ipfs-force-community · LinZexiao · Nov 21, 2022 · Nov 14, 2022 · Nov 14, 2022 · Nov 16, 2022
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -0,0 +1,41 @@
+version: 2.1
+
+orbs:
+  go: venus/[email protected]
+jobs:
+  test_all:
+    executor:
+      name: go/default
+      tag: "cimg/go:1.18.1"
+    steps:
+      - go/setup_env:
+          install_ffi: true
+      - go/test:
+          display-name: integrate_test
+          suite: "integrate_test"
+          target: "./integrate_test/..."
+      - go/test:
+          display-name: proofevent_uint_test
+          suite: "proofevent"
+          target: "./proofevent/..."
+      - go/test:
+          display-name: walletevent_uint_test
+          suite: "walletevent"
+          target: "./walletevent/..."
+      - go/test:
+          display-name: marketevent_uint_test
+          suite: "marketevent"
+          target: "./marketevent/..."
+      - go/test:
+          display-name: validator_unit_test
+          suite: "validator_unit_test"
+          target: "./validator/..."
+      - go/test:
+          display-name: baseevent_unit_test
+          suite: "baseevent_unit_test"
+          target: "./types/..."
+
+workflows:
+  ci:
+    jobs:
+      - test_all
diff --git a/.golangci.yml b/.golangci.yml
@@ -9,9 +9,6 @@ linters:
     - errcheck
     - unconvert
     - staticcheck
-    - varcheck
-    - structcheck
-    - deadcode
     - unused
     - stylecheck
     - gosimple

diff --git a/integrate_test/marketapi_test.go b/integrate_test/marketapi_test.go
@@ -1,3 +1,4 @@
+// stm: #integration
 package integrate
 
 import (
@@ -51,6 +52,7 @@ func TestMarketAPI(t *testing.T) {
 
 		handler := testhelper.NewMarketHandler(t)
 		proofEvent := marketevent.NewMarketEventClient(walletEventClient, mAddr, handler, logging.Logger("test").With())
+		// stm: @VENUSGATEWAY_MARKET_EVENT_LISTEN_MARKET_EVENT_001
 		go proofEvent.ListenMarketRequest(ctx)
 		proofEvent.WaitReady(ctx)
 
@@ -64,6 +66,7 @@ func TestMarketAPI(t *testing.T) {
 		size := abi.PaddedPieceSize(100)
 		offset := sharedTypes.PaddedByteIndex(100)
 		handler.SetCheckIsUnsealExpect(sectorRef, offset, size, false)
+		// stm: @VENUSGATEWAY_API_IS_UNSEALED_001, @VENUSGATEWAY_MARKET_EVENT_IS_UNSEALED_001
 		isUnseal, err := sAPi.IsUnsealed(ctx, mAddr, cid.Undef, sectorRef, offset, size)
 		require.NoError(t, err)
 		require.True(t, isUnseal)
@@ -106,6 +109,7 @@ func TestMarketAPI(t *testing.T) {
 		pieceCid, err := cid.Decode("bafy2bzaced2kktxdkqw5pey5of3wtahz5imm7ta4ymegah466dsc5fonj73u2")
 		require.NoError(t, err)
 		handler.SetSectorsUnsealPieceExpect(pieceCid, sectorRef, offset, size, dest, false)
+		// stm: @VENUSGATEWAY_API_SECTOR_UNSEAL_PRICE_001
 		err = sAPi.SectorsUnsealPiece(ctx, mAddr, pieceCid, sectorRef, offset, size, dest)
 		require.NoError(t, err)
 
@@ -136,6 +140,7 @@ func TestMarketAPI(t *testing.T) {
 		go marketEventClient.ListenMarketRequest(ctx)
 		marketEventClient.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_API_LIST_MARKET_CONNECTIONS_STATE_001
 		connectsState, err := sAPi.ListMarketConnectionsState(ctx)
 		require.NoError(t, err)
 		require.Len(t, connectsState, 1)

diff --git a/integrate_test/proofapi_test.go b/integrate_test/proofapi_test.go
@@ -1,3 +1,4 @@
+// stm: #integration
 package integrate
 
 import (
@@ -74,6 +75,7 @@ func TestProofAPI(t *testing.T) {
 		go proofEvent.ListenProofRequest(ctx)
 		proofEvent.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_API_COMPUTE_PROOF_001
 		proof, err := sAPi.ComputeProof(ctx, mAddr, expectInfo, expectRand, expectEpoch, expectVersion)
 		require.NoError(t, err)
 		require.Equal(t, expectProof, proof)
@@ -167,10 +169,12 @@ func TestProofAPI(t *testing.T) {
 		go proofEvent3.ListenProofRequest(ctx)
 		proofEvent3.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_API_LIST_CONNECTED_MINERS_001
 		miners, err := sAPi.ListConnectedMiners(ctx)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(miners))
 
+		// stm: @VENUSGATEWAY_API_LIST_MINER_CONNECTION_001
 		minerConnections, err := sAPi.ListMinerConnection(ctx, mAddr)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(minerConnections.Connections))

diff --git a/integrate_test/walletapi_test.go b/integrate_test/walletapi_test.go
@@ -1,3 +1,4 @@
+// stm: #integration
 package integrate
 
 import (
@@ -83,6 +84,7 @@ func TestWalletAPI(t *testing.T) {
 		err = walletEvent.AddNewAddress(ctx, []address.Address{toAddAddr1, toAddAddr2})
 		require.NoError(t, err)
 
+		// stm: @VENUSGATEWAY_API_LIST_WALLET_INFO_BY_WALLET_001
 		walletDetail, err := sAPi.ListWalletInfoByWallet(ctx, "defaultLocalToken")
 		require.NoError(t, err)
 		require.Contains(t, walletDetail.ConnectStates[0].Addrs, toAddAddr1)
@@ -184,6 +186,7 @@ func TestWalletAPI(t *testing.T) {
 		go walletEvent2.ListenWalletRequest(ctx)
 		walletEvent2.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_API_WALLET_SIGN_001
 		walletInfo, err := sAPi.ListWalletInfo(ctx)
 		require.NoError(t, err)
 		require.Len(t, walletInfo, 1)
@@ -221,6 +224,7 @@ func TestWalletAPI(t *testing.T) {
 		err = walletEvent.SupportAccount(ctx, "123")
 		require.NoError(t, err)
 
+		// stm: @VENUSGATEWAY_API_WALLET_HAS_001
 		has, err := sAPi.WalletHas(ctx, "123", addr1)
 		require.NoError(t, err)
 		require.True(t, has)
@@ -260,6 +264,7 @@ func TestWalletAPI(t *testing.T) {
 			var msg [32]byte
 			_, err = rand.Read(msg[:])
 			require.NoError(t, err)
+			// stm: @VENUSGATEWAY_API_WALLET_SIGN_001
 			sig, err := sAPi.WalletSign(ctx, "123", addr1, msg[:], types2.MsgMeta{})
 			require.NoError(t, err)
 			err = wallet.Verify(ctx, addr1, sig, msg[:])

diff --git a/marketevent/market_event_test.go b/marketevent/market_event_test.go
@@ -1,3 +1,4 @@
+// stm: #unit
 package marketevent
 
 import (
@@ -42,6 +43,7 @@ func TestListenMarketEvent(t *testing.T) {
 
 		marketEvent := setupMarketEvent(t, supportAccount, minerAddr)
 		client := NewMarketEventClient(marketEvent, addrGetter(), nil, log.With())
+		// stm: @VENUSGATEWAY_MARKET_EVENT_LISTEN_MARKET_EVENT_002
 		err := client.listenMarketRequestOnce(jwtclient.CtxWithName(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"), supportAccount))
 		require.Contains(t, err.Error(), "not exists")
 	})
@@ -54,6 +56,7 @@ func TestListenMarketEvent(t *testing.T) {
 		//register
 		marketEvent := setupMarketEvent(t, supportAccount, minerAddr)
 		client := NewMarketEventClient(marketEvent, minerAddr, nil, log.With())
+		// stm: @VENUSGATEWAY_MARKET_EVENT_LISTEN_MARKET_EVENT_003
 		err := client.listenMarketRequestOnce(jwtclient.CtxWithName(ctx, supportAccount))
 		require.Contains(t, err.Error(), "ip not exist")
 	})
@@ -70,6 +73,7 @@ func TestIsUnsealed(t *testing.T) {
 		marketEvent := setupMarketEvent(t, supportAccount, minerAddr)
 		handler := testhelper.NewMarketHandler(t)
 		client := NewMarketEventClient(marketEvent, minerAddr, handler, log.With())
+		// stm: @VENUSGATEWAY_MARKET_EVENT_RESPONSE_MARKET_EVENT_001
 		go client.ListenMarketRequest(jwtclient.CtxWithName(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"), supportAccount))
 		client.WaitReady(ctx)
 
@@ -83,6 +87,7 @@ func TestIsUnsealed(t *testing.T) {
 		size := abi.PaddedPieceSize(100)
 		offset := sharedTypes.PaddedByteIndex(100)
 		handler.SetCheckIsUnsealExpect(sectorRef, offset, size, false)
+		// stm: @VENUSGATEWAY_MARKET_EVENT_IS_UNSEALED_001
 		isUnsealed, err := marketEvent.IsUnsealed(ctx, minerAddr, cid.Undef, sectorRef, offset, size)
 		require.NoError(t, err)
 		require.True(t, isUnsealed)
@@ -107,6 +112,7 @@ func TestIsUnsealed(t *testing.T) {
 		size := abi.PaddedPieceSize(100)
 		offset := sharedTypes.PaddedByteIndex(100)
 		handler.SetCheckIsUnsealExpect(sectorRef, offset, size, false)
+		// stm: @VENUSGATEWAY_MARKET_EVENT_IS_UNSEALED_003
 		_, err := marketEvent.IsUnsealed(ctx, addrGetter(), cid.Undef, sectorRef, offset, size)
 		require.Contains(t, err.Error(), "no connections for this miner")
 	})
@@ -162,6 +168,7 @@ func TestUnsealed(t *testing.T) {
 		pieceCid, err := cid.Decode("bafy2bzaced2kktxdkqw5pey5of3wtahz5imm7ta4ymegah466dsc5fonj73u2")
 		require.NoError(t, err)
 		handler.SetSectorsUnsealPieceExpect(pieceCid, sectorRef, offset, size, dest, false)
+		// stm: @VENUSGATEWAY_MARKET_EVENT_SECTORS_UNSEAL_PIECE_001
 		err = marketEvent.SectorsUnsealPiece(ctx, minerAddr, pieceCid, sectorRef, offset, size, dest)
 		require.NoError(t, err)
 	})
@@ -188,6 +195,7 @@ func TestUnsealed(t *testing.T) {
 		pieceCid, err := cid.Decode("bafy2bzaced2kktxdkqw5pey5of3wtahz5imm7ta4ymegah466dsc5fonj73u2")
 		require.NoError(t, err)
 		handler.SetSectorsUnsealPieceExpect(pieceCid, sectorRef, offset, size, dest, false)
+		// stm: @VENUSGATEWAY_MARKET_EVENT_SECTORS_UNSEAL_PIECE_003
 		err = marketEvent.SectorsUnsealPiece(ctx, addrGetter(), pieceCid, sectorRef, offset, size, dest)
 		require.Contains(t, err.Error(), "no connections for this miner")
 	})
@@ -231,6 +239,7 @@ func TestListMarketConnectionsState(t *testing.T) {
 	go client.ListenMarketRequest(jwtclient.CtxWithName(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"), walletAccount))
 	client.WaitReady(ctx)
 
+	// stm: @VENUSGATEWAY_MARKET_EVENT_LIST_MARKET_CONNECTIONS_STATE_001
 	marketState, err := marketEvent.ListMarketConnectionsState(ctx)
 	require.NoError(t, err)
 	require.Len(t, marketState, 1)

diff --git a/proofevent/proof_event.go b/proofevent/proof_event.go
@@ -154,6 +154,7 @@ func (e *ProofEventStream) ComputeProof(ctx context.Context, miner address.Addre
 		metrics.ComputeProof.M(metrics.SinceInMilliseconds(start)))
 	if err == nil {
 		return result, nil
+
 	}
 	return nil, err
 }

diff --git a/proofevent/proof_event_test.go b/proofevent/proof_event_test.go
@@ -1,3 +1,4 @@
+// stm: #unit
 package proofevent
 
 import (
@@ -33,6 +34,7 @@ func TestListenProofEvent(t *testing.T) {
 		proof := setupProofEvent(t, []address.Address{addr1})
 		ctx, cancel := context.WithCancel(context.Background())
 		ctx = jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1")
+		// stm: @VENUSGATEWAY_PROOF_EVENT_LISTEN_PROOF_EVENT_001
 		requestCh, err := proof.ListenProofEvent(ctx, &types.ProofRegisterPolicy{
 			MinerAddress: addr1,
 		})
@@ -64,6 +66,7 @@ func TestListenProofEvent(t *testing.T) {
 		proof := setupProofEvent(t, []address.Address{addr1})
 		ctx, cancel := context.WithCancel(context.Background())
 		proofClient := NewProofEvent(proof, addr1, testhelper.NewTimeoutProofHandler(time.Second), log.With())
+		// stm:
 		go proofClient.ListenProofRequest(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"))
 		proofClient.WaitReady(ctx)
 
@@ -99,6 +102,7 @@ func TestListenProofEvent(t *testing.T) {
 		defer cancel()
 		ctx = jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1")
 
+		// stm: @VENUSGATEWAY_PROOF_EVENT_LISTEN_PROOF_EVENT_003
 		_, err := proof.ListenProofEvent(ctx, &types.ProofRegisterPolicy{
 			MinerAddress: addr2,
 		})
@@ -109,6 +113,7 @@ func TestListenProofEvent(t *testing.T) {
 		proof := setupProofEvent(t, []address.Address{addr1})
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
+		// stm: @VENUSGATEWAY_PROOF_EVENT_LISTEN_PROOF_EVENT_002
 		_, err := proof.ListenProofEvent(ctx, &types.ProofRegisterPolicy{
 			MinerAddress: addr2,
 		})
@@ -146,6 +151,7 @@ func TestComputeProofEvent(t *testing.T) {
 		go proofClient.ListenProofRequest(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"))
 		proofClient.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_PROOF_EVENT_COMPUTE_PROOF_001
 		result, err := proof.ComputeProof(ctx, addr, expectInfo, expectRand, expectEpoch, expectVersion)
 		require.NoError(t, err)
 		require.Equal(t, expectProof, result)
@@ -184,6 +190,7 @@ func TestComputeProofEvent(t *testing.T) {
 			channels, err := proof.getChannels(addr)
 			require.NoError(t, err)
 			var result []builtin.PoStProof
+			// stm: @VENUSGATEWAY_PROOF_EVENT_COMPUTE_PROOF_002
 			err = proof.SendRequest(ctx, channels, "ComputeProof", []byte{1, 3, 5, 1, 3}, &result)
 			require.Contains(t, err.Error(), "invalid character")
 		}
@@ -210,13 +217,19 @@ func TestComputeProofEvent(t *testing.T) {
 		go proofClient.ListenProofRequest(jwtclient.CtxWithTokenLocation(ctx, "127.1.1.1"))
 		proofClient.WaitReady(ctx)
 
+		// stm: @VENUSGATEWAY_PROOF_EVENT_COMPUTE_PROOF_004
 		result, err := proof.ComputeProof(ctx, addr, expectInfo, expectRand, expectEpoch, expectVersion)
 		require.EqualError(t, err, "mock error")
 		require.Nil(t, result)
 
+		// stm: @VENUSGATEWAY_PROOF_EVENT_COMPUTE_PROOF_003
+		addr3 := addrGetter()
+		_, err = proof.ComputeProof(ctx, addr3, expectInfo, expectRand, expectEpoch, expectVersion)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "no connections for this miner")
 	})
 
-	t.Run("uncorrect result  error", func(t *testing.T) {
+	t.Run("incorrect result  error", func(t *testing.T) {
 		proof := setupProofEvent(t, []address.Address{addr})
 		{
 			ctx := jwtclient.CtxWithTokenLocation(context.Background(), "127.1.1.1")
@@ -313,6 +326,8 @@ func TestListMinerConnection(t *testing.T) {
 		proofClient.WaitReady(ctx)
 	}
 
+	// todo: should change 'LISTEN' to 'LIST', it maybe a spell mistake.
+	// stm: @VENUSGATEWAY_PROOF_EVENT_LISTEN_CONNECTED_MINERS_001
 	connetions, err := proof.ListMinerConnection(ctx, addr1)
 	require.NoError(t, err)
 	require.Equal(t, connetions.ConnectionCount, 2)

diff --git a/types/base_event_test.go b/types/base_event_test.go
@@ -1,3 +1,4 @@
+// stm: #unit
 package types
 
 import (
@@ -32,6 +33,7 @@ func TestSendRequest(t *testing.T) {
 
 		var clients []*mockClient
 		client := setupClient(t, eventSteam, "127.1.1.1")
+		// stm: @VENUSGATEWAY_TYPES_RESPONSE_EVENT_001
 		go client.start(ctx)
 		clients = append(clients, client)
 		var getConns = func() []*ChannelInfo {
@@ -41,8 +43,14 @@ func TestSendRequest(t *testing.T) {
 			}
 			return channels
 		}
+
+		// stm: @VENUSGATEWAY_TYPES_SEND_REQUEST_001
 		err = eventSteam.SendRequest(ctx, getConns(), "mock_method", parms, result)
 		require.NoError(t, err)
+
+		// stm: @VENUSGATEWAY_TYPES_SEND_REQUEST_002
+		err = eventSteam.SendRequest(ctx, nil, "mock_method", parms, result)
+		require.Error(t, err)
 	})
 
 	//test for bug https://github.com/filecoin-project/venus/issues/4992
@@ -245,6 +253,11 @@ func TestSendRequest(t *testing.T) {
 		defer cancel()
 		eventSteam := NewBaseEventStream(ctx, DefaultConfig())
 
+		// expect id not exists error
+		// stm: @VENUSGATEWAY_TYPES_RESPONSE_EVENT_002
+		err := eventSteam.ResponseEvent(ctx, &types.ResponseEvent{ID: sharedTypes.NewUUID()})
+		require.Error(t, err)
+
 		parms, err := json.Marshal(mockParams{A: "mock arg"})
 		require.NoError(t, err)
 		result := &mockResult{}