From fb6a5e8254a50242202ce0fc83dc9c687fd13e9f Mon Sep 17 00:00:00 2001 From: "shota.silagadze" Date: Tue, 12 Nov 2024 14:04:34 +0400 Subject: [PATCH] refactor(ARCO-282): Separate callbacker #642 --- .../callbacker_api_client_mock.go | 145 ++++++++++++++++++ internal/callbacker/callbacker_mocks.go | 2 + pkg/callbacker/callbacker_test.go | 76 +++++++++ 3 files changed, 223 insertions(+) create mode 100644 internal/callbacker/callbacker_api/callbacker_api_client_mock.go create mode 100644 pkg/callbacker/callbacker_test.go diff --git a/internal/callbacker/callbacker_api/callbacker_api_client_mock.go b/internal/callbacker/callbacker_api/callbacker_api_client_mock.go new file mode 100644 index 000000000..67f4390f8 --- /dev/null +++ b/internal/callbacker/callbacker_api/callbacker_api_client_mock.go @@ -0,0 +1,145 @@ +// Code generated by moq; DO NOT EDIT. +// github.com/matryer/moq + +package callbacker_api + +import ( + context "context" + grpc "google.golang.org/grpc" + emptypb "google.golang.org/protobuf/types/known/emptypb" + sync "sync" +) + +// Ensure, that CallbackerAPIClientMock does implement CallbackerAPIClient. +// If this is not the case, regenerate this file with moq. +var _ CallbackerAPIClient = &CallbackerAPIClientMock{} + +// CallbackerAPIClientMock is a mock implementation of CallbackerAPIClient. +// +// func TestSomethingThatUsesCallbackerAPIClient(t *testing.T) { +// +// // make and configure a mocked CallbackerAPIClient +// mockedCallbackerAPIClient := &CallbackerAPIClientMock{ +// HealthFunc: func(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthResponse, error) { +// panic("mock out the Health method") +// }, +// SendCallbackFunc: func(ctx context.Context, in *SendCallbackRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { +// panic("mock out the SendCallback method") +// }, +// } +// +// // use mockedCallbackerAPIClient in code that requires CallbackerAPIClient +// // and then make assertions. +// +// } +type CallbackerAPIClientMock struct { + // HealthFunc mocks the Health method. + HealthFunc func(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthResponse, error) + + // SendCallbackFunc mocks the SendCallback method. + SendCallbackFunc func(ctx context.Context, in *SendCallbackRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + + // calls tracks calls to the methods. + calls struct { + // Health holds details about calls to the Health method. + Health []struct { + // Ctx is the ctx argument value. + Ctx context.Context + // In is the in argument value. + In *emptypb.Empty + // Opts is the opts argument value. + Opts []grpc.CallOption + } + // SendCallback holds details about calls to the SendCallback method. + SendCallback []struct { + // Ctx is the ctx argument value. + Ctx context.Context + // In is the in argument value. + In *SendCallbackRequest + // Opts is the opts argument value. + Opts []grpc.CallOption + } + } + lockHealth sync.RWMutex + lockSendCallback sync.RWMutex +} + +// Health calls HealthFunc. +func (mock *CallbackerAPIClientMock) Health(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthResponse, error) { + if mock.HealthFunc == nil { + panic("CallbackerAPIClientMock.HealthFunc: method is nil but CallbackerAPIClient.Health was just called") + } + callInfo := struct { + Ctx context.Context + In *emptypb.Empty + Opts []grpc.CallOption + }{ + Ctx: ctx, + In: in, + Opts: opts, + } + mock.lockHealth.Lock() + mock.calls.Health = append(mock.calls.Health, callInfo) + mock.lockHealth.Unlock() + return mock.HealthFunc(ctx, in, opts...) +} + +// HealthCalls gets all the calls that were made to Health. +// Check the length with: +// +// len(mockedCallbackerAPIClient.HealthCalls()) +func (mock *CallbackerAPIClientMock) HealthCalls() []struct { + Ctx context.Context + In *emptypb.Empty + Opts []grpc.CallOption +} { + var calls []struct { + Ctx context.Context + In *emptypb.Empty + Opts []grpc.CallOption + } + mock.lockHealth.RLock() + calls = mock.calls.Health + mock.lockHealth.RUnlock() + return calls +} + +// SendCallback calls SendCallbackFunc. +func (mock *CallbackerAPIClientMock) SendCallback(ctx context.Context, in *SendCallbackRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + if mock.SendCallbackFunc == nil { + panic("CallbackerAPIClientMock.SendCallbackFunc: method is nil but CallbackerAPIClient.SendCallback was just called") + } + callInfo := struct { + Ctx context.Context + In *SendCallbackRequest + Opts []grpc.CallOption + }{ + Ctx: ctx, + In: in, + Opts: opts, + } + mock.lockSendCallback.Lock() + mock.calls.SendCallback = append(mock.calls.SendCallback, callInfo) + mock.lockSendCallback.Unlock() + return mock.SendCallbackFunc(ctx, in, opts...) +} + +// SendCallbackCalls gets all the calls that were made to SendCallback. +// Check the length with: +// +// len(mockedCallbackerAPIClient.SendCallbackCalls()) +func (mock *CallbackerAPIClientMock) SendCallbackCalls() []struct { + Ctx context.Context + In *SendCallbackRequest + Opts []grpc.CallOption +} { + var calls []struct { + Ctx context.Context + In *SendCallbackRequest + Opts []grpc.CallOption + } + mock.lockSendCallback.RLock() + calls = mock.calls.SendCallback + mock.lockSendCallback.RUnlock() + return calls +} diff --git a/internal/callbacker/callbacker_mocks.go b/internal/callbacker/callbacker_mocks.go index 333b73c4a..f3b2d6ce1 100644 --- a/internal/callbacker/callbacker_mocks.go +++ b/internal/callbacker/callbacker_mocks.go @@ -2,3 +2,5 @@ package callbacker // from callbacker.go //go:generate moq -out ./callbacker_mock.go ./ SenderI + +//go:generate moq -out ./callbacker_api/callbacker_api_client_mock.go ./callbacker_api/ CallbackerAPIClient diff --git a/pkg/callbacker/callbacker_test.go b/pkg/callbacker/callbacker_test.go new file mode 100644 index 000000000..3b6fa6db9 --- /dev/null +++ b/pkg/callbacker/callbacker_test.go @@ -0,0 +1,76 @@ +package callbacker + +import ( + "context" + "log/slog" + "os" + "testing" + + "github.com/bitcoin-sv/arc/internal/callbacker/callbacker_api" + "github.com/bitcoin-sv/arc/internal/metamorph/metamorph_api" + "github.com/bitcoin-sv/arc/internal/metamorph/store" + "github.com/libsv/go-p2p/chaincfg/chainhash" + "github.com/stretchr/testify/require" + "google.golang.org/grpc" + "google.golang.org/protobuf/types/known/emptypb" +) + +func TestSendCallback(t *testing.T) { + tt := []struct { + name string + expectedCalls int + err error + data *store.Data + }{ + { + name: "empty callbacks", + expectedCalls: 0, + data: &store.Data{ + Status: metamorph_api.Status_UNKNOWN, + Hash: &chainhash.Hash{}, + Callbacks: []store.Callback{}, + }, + }, + { + name: "empty url", + expectedCalls: 0, + + data: &store.Data{ + Status: metamorph_api.Status_UNKNOWN, + Hash: &chainhash.Hash{}, + Callbacks: []store.Callback{ + { + CallbackURL: "", + }, + }, + }, + }, + { + name: "expected call", + expectedCalls: 1, + data: &store.Data{ + Status: metamorph_api.Status_UNKNOWN, + Hash: &chainhash.Hash{}, + Callbacks: []store.Callback{ + { + CallbackURL: "http://someurl.comg", + }, + }, + }, + }, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + apiClient := &callbacker_api.CallbackerAPIClientMock{ + SendCallbackFunc: func(_ context.Context, in *callbacker_api.SendCallbackRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + return nil, nil + }, + } + grpcCallbacker := NewGrpcCallbacker(apiClient, slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))) + grpcCallbacker.SendCallback(context.Background(), tc.data) + require.Equal(t, tc.expectedCalls, len(apiClient.SendCallbackCalls())) + }) + } + +}