package main import ( "context" "crypto/ecdsa" "errors" "testing" "github.com/nspcc-dev/neofs-api-go/v2/accounting" accountingGRPC "github.com/nspcc-dev/neofs-api-go/v2/accounting/grpc" "github.com/nspcc-dev/neofs-api-go/v2/refs" "github.com/nspcc-dev/neofs-api-go/v2/service" "github.com/nspcc-dev/neofs-api-go/v2/signature" "github.com/nspcc-dev/neofs-crypto/test" "github.com/stretchr/testify/require" "google.golang.org/grpc" ) type testGRPCClient struct { server *testGRPCServer } type testGRPCServer struct { key *ecdsa.PrivateKey resp *accounting.BalanceResponse err error } func (s *testGRPCClient) Balance(ctx context.Context, in *accountingGRPC.BalanceRequest, opts ...grpc.CallOption) (*accountingGRPC.BalanceResponse, error) { return s.server.Balance(ctx, in) } func (s *testGRPCServer) Balance(_ context.Context, req *accountingGRPC.BalanceRequest) (*accountingGRPC.BalanceResponse, error) { if s.err != nil { return nil, s.err } // verify request structure if err := signature.VerifyServiceMessage( accounting.BalanceRequestFromGRPCMessage(req), ); err != nil { return nil, err } // sign response structure if err := signature.SignServiceMessage(s.key, s.resp); err != nil { return nil, err } return accounting.BalanceResponseToGRPCMessage(s.resp), nil } func testRequest() *accounting.BalanceRequest { ownerID := new(refs.OwnerID) ownerID.SetValue([]byte{1, 2, 3}) body := new(accounting.BalanceRequestBody) body.SetOwnerID(ownerID) meta := new(service.RequestMetaHeader) meta.SetTTL(1) req := new(accounting.BalanceRequest) req.SetBody(body) req.SetMetaHeader(meta) return req } func testResponse() *accounting.BalanceResponse { dec := new(accounting.Decimal) dec.SetValue(10) body := new(accounting.BalanceResponseBody) body.SetBalance(dec) meta := new(service.ResponseMetaHeader) meta.SetTTL(1) resp := new(accounting.BalanceResponse) resp.SetBody(body) resp.SetMetaHeader(meta) return resp } func TestGRPCClient(t *testing.T) { ctx := context.TODO() cliKey := test.DecodeKey(0) srvKey := test.DecodeKey(1) t.Run("gRPC server error", func(t *testing.T) { srvErr := errors.New("test server error") srv := &testGRPCServer{ err: srvErr, } cli := &testGRPCClient{ server: srv, } c, err := accounting.New(accounting.WithGRPCServiceClient(cli)) require.NoError(t, err) resp, err := c.Balance(ctx, new(accounting.BalanceRequest)) require.True(t, errors.Is(err, srvErr)) require.Nil(t, resp) }) t.Run("invalid request structure", func(t *testing.T) { req := testRequest() require.Error(t, signature.VerifyServiceMessage(req)) c, err := accounting.New( accounting.WithGRPCServiceClient( &testGRPCClient{ server: new(testGRPCServer), }, ), ) require.NoError(t, err) resp, err := c.Balance(ctx, req) require.Error(t, err) require.Nil(t, resp) }) t.Run("correct response", func(t *testing.T) { req := testRequest() require.NoError(t, signature.SignServiceMessage(cliKey, req)) resp := testResponse() { // w/o this require.Equal fails due to nil and []T{} difference meta := new(service.ResponseMetaHeader) meta.SetXHeaders([]*service.XHeader{}) resp.SetMetaHeader(meta) } c, err := accounting.New( accounting.WithGRPCServiceClient( &testGRPCClient{ server: &testGRPCServer{ key: srvKey, resp: resp, }, }, ), ) require.NoError(t, err) r, err := c.Balance(ctx, req) require.NoError(t, err) require.NoError(t, signature.VerifyServiceMessage(r)) require.Equal(t, resp.GetBody(), r.GetBody()) require.Equal(t, resp.GetMetaHeader(), r.GetMetaHeader()) }) }