✅ [channel/test,backend/eth/channel] Generic adjudicator test

Signed-off-by: Matthias Geihs <[email protected]>

Author: matthiasgeihs

backend/ethereum/channel/adjudicator_test.go

@@ -16,6 +16,7 @@ package channel_test
 
 import (
 	"context"
+	"math/rand"
 	"testing"
 	"time"
 
@@ -33,6 +34,128 @@ import (
 	pkgtest "perun.network/go-perun/pkg/test"
 )
 
+// TestAdjudicator tests the adjudicator.
+func TestAdjudicator(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+
+	rng := pkgtest.Prng(t)
+	numParts := 2 + rng.Intn(maxNumParts-2)
+	s := test.NewSetup(t, rng, numParts, blockInterval)
+	a := newAdjudicatorSetup(s)
+	channeltest.TestAdjudicator(ctx, t, a)
+}
+
+type adjudicatorSetup struct {
+	setup *test.Setup
+}
+
+func newAdjudicatorSetup(setup *test.Setup) *adjudicatorSetup {
+	return &adjudicatorSetup{
+		setup: setup,
+	}
+}
+
+type testAdjudicator struct {
+	*test.SimAdjudicator
+}
+
+// Progress is a no-op because app channels are not supported yet.
+func (a *testAdjudicator) Progress(ctx context.Context, req channel.ProgressReq) error {
+	return nil
+}
+
+func (a *adjudicatorSetup) Adjudicator() channel.Adjudicator {
+	return &testAdjudicator{a.setup.Adjs[0]}
+}
+
+func (a *adjudicatorSetup) NewRegisterReq(ctx context.Context, rng *rand.Rand) (*channel.AdjudicatorReq, []channel.SignedState) {
+	req := a.newAdjudicatorReq(ctx, rng, channeltest.WithIsFinal(false))
+	return req, nil
+}
+
+func (a *adjudicatorSetup) newAdjudicatorReq(ctx context.Context, rng *rand.Rand, opts ...channeltest.RandomOpt) *channel.AdjudicatorReq {
+	params, state := a.newRandomParamsAndState(rng, opts...)
+
+	// Fund the channel.
+	numParts := len(params.Parts)
+	errs := make(chan error, numParts)
+	for i, funder := range a.setup.Funders {
+		req := channel.NewFundingReq(params, state, channel.Index(i), state.Balances)
+		go func(funder channel.Funder, req channel.FundingReq) {
+			errs <- funder.Fund(ctx, req)
+		}(funder, *req)
+	}
+	for range a.setup.Funders {
+		select {
+		case err := <-errs:
+			if err != nil {
+				panic(err)
+			}
+		case <-ctx.Done():
+			panic(ctx.Err())
+		}
+	}
+
+	tx, err := signState(a.setup.Accs, state)
+	if err != nil {
+		panic(err)
+	}
+	return &channel.AdjudicatorReq{
+		Acc:    a.setup.Accs[0],
+		Idx:    0,
+		Params: params,
+		Tx:     tx,
+	}
+}
+
+func (a *adjudicatorSetup) newRandomParamsAndState(rng *rand.Rand, opts ...channeltest.RandomOpt) (*channel.Params, *channel.State) {
+	_opts := a.defaultOpts()
+	_opts = append(_opts, opts...)
+	return channeltest.NewRandomParamsAndState(rng, _opts...)
+}
+
+func (a *adjudicatorSetup) defaultOpts() []channeltest.RandomOpt {
+	return []channeltest.RandomOpt{
+		channeltest.WithChallengeDuration(100),
+		channeltest.WithParts(a.setup.Parts...),
+		channeltest.WithAssets((*ethchannel.Asset)(&a.setup.Asset)),
+		channeltest.WithLedgerChannel(true),
+		channeltest.WithVirtualChannel(false),
+		channeltest.WithNumLocked(0),
+	}
+}
+
+func (a *adjudicatorSetup) NewProgressReq(context.Context, *rand.Rand) *channel.ProgressReq {
+	return &channel.ProgressReq{} // Progression test is not implemented.
+}
+
+func (a *adjudicatorSetup) NewWithdrawReq(ctx context.Context, rng *rand.Rand) (*channel.AdjudicatorReq, channel.StateMap) {
+	adj := a.Adjudicator()
+	req := a.newAdjudicatorReq(ctx, rng, channeltest.WithoutApp())
+	subChannels := []channel.SignedState{}
+
+	if !req.Tx.IsFinal {
+		// Register.
+		err := adj.Register(ctx, *req, subChannels)
+		if err != nil {
+			panic(err)
+		}
+
+		// Wait until concludable.
+		sub, err := adj.Subscribe(ctx, req.Params.ID())
+		if err != nil {
+			panic(err)
+		}
+		err = sub.Next().Timeout().Wait(ctx)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	return req, channeltest.MakeStateMapFromSignedStates(subChannels...)
+}
+
 const defaultTxTimeout = 2 * time.Second
 
 func testSignState(t *testing.T, accounts []*keystore.Account, state *channel.State) channel.Transaction {

channel/test/adjudicator.go

@@ -0,0 +1,74 @@
+//  Copyright 2021 - See NOTICE file for copyright holders.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+package test
+
+import (
+	"context"
+	"math/rand"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"perun.network/go-perun/channel"
+	pkgtest "perun.network/go-perun/pkg/test"
+)
+
+// Adjudicator represents an adjudicator test setup.
+//
+// Adjudicator should return the adjudicator instance used for testing.
+// NewRegisterReq should return the inputs to a successful register call.
+// NewProgressReq should return the inputs to a successful progress call.
+// NewWithdrawReq should return the inputs to a successful withdraw call.
+type Adjudicator interface {
+	Adjudicator() channel.Adjudicator
+	NewRegisterReq(context.Context, *rand.Rand) (*channel.AdjudicatorReq, []channel.SignedState)
+	NewProgressReq(context.Context, *rand.Rand) *channel.ProgressReq
+	NewWithdrawReq(context.Context, *rand.Rand) (*channel.AdjudicatorReq, channel.StateMap)
+}
+
+// TestAdjudicator tests the given adjudicator.
+func TestAdjudicator(ctx context.Context, t *testing.T, a Adjudicator) {
+	rng := pkgtest.Prng(t)
+
+	adj := a.Adjudicator()
+
+	t.Run("register and subscribe", func(t *testing.T) {
+		req, subChannels := a.NewRegisterReq(ctx, rng)
+		err := adj.Register(ctx, *req, subChannels)
+		require.NoError(t, err, "registering")
+
+		_, err = adj.Subscribe(ctx, req.Params.ID())
+		require.NoError(t, err, "subscribing")
+	})
+
+	t.Run("progress", func(t *testing.T) {
+		req := a.NewProgressReq(ctx, rng)
+		err := adj.Progress(ctx, *req)
+		require.NoError(t, err, "progressing")
+	})
+
+	t.Run("withdraw", func(t *testing.T) {
+		req, subChannels := a.NewWithdrawReq(ctx, rng)
+		err := adj.Withdraw(ctx, *req, subChannels)
+		require.NoError(t, err, "withdrawing")
+	})
+}
+
+func MakeStateMapFromSignedStates(channels ...channel.SignedState) channel.StateMap {
+	m := channel.MakeStateMap()
+	for _, c := range channels {
+		m.Add(c.State)
+	}
+	return m
+}