sendico/api/ledger/storage/mongo/store/accounts_test.go

package store

import (
	"context"
	"errors"
	"testing"

	"github.com/tech/sendico/ledger/storage"
	"github.com/tech/sendico/ledger/storage/model"
	"github.com/tech/sendico/pkg/db/repository"
	"github.com/tech/sendico/pkg/db/repository/builder"
	rd "github.com/tech/sendico/pkg/db/repository/decoder"
	"github.com/tech/sendico/pkg/db/storable"
	"github.com/tech/sendico/pkg/merrors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.uber.org/zap"
)

func TestAccountsStore_Create(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()

	t.Run("Success", func(t *testing.T) {
		var insertedAccount *model.Account
		stub := &repositoryStub{
			InsertFunc: func(ctx context.Context, object storable.Storable, _ builder.Query) error {
				insertedAccount = object.(*model.Account)
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		account := &model.Account{
			AccountCode:   "1000",
			Currency:      "USD",
			AccountType:   model.AccountTypeAsset,
			Status:        model.AccountStatusActive,
			AllowNegative: false,
		}

		err := store.Create(ctx, account)

		require.NoError(t, err)
		assert.NotNil(t, insertedAccount)
		assert.Equal(t, "1000", insertedAccount.AccountCode)
		assert.Equal(t, "USD", insertedAccount.Currency)
	})

	t.Run("NilAccount", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		err := store.Create(ctx, nil)

		require.Error(t, err)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("DuplicateAccountCode", func(t *testing.T) {
		stub := &repositoryStub{
			InsertFunc: func(ctx context.Context, object storable.Storable, _ builder.Query) error {
				return mongo.WriteException{
					WriteErrors: []mongo.WriteError{
						{Code: 11000}, // Duplicate key error
					},
				}
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		account := &model.Account{
			AccountCode: "1000",
			Currency:    "USD",
		}

		err := store.Create(ctx, account)

		require.Error(t, err)
		assert.True(t, errors.Is(err, merrors.ErrDataConflict))
	})

	t.Run("InsertError", func(t *testing.T) {
		expectedErr := errors.New("database error")
		stub := &repositoryStub{
			InsertFunc: func(ctx context.Context, object storable.Storable, _ builder.Query) error {
				return expectedErr
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		account := &model.Account{AccountCode: "1000", Currency: "USD"}

		err := store.Create(ctx, account)

		require.Error(t, err)
		assert.Equal(t, expectedErr, err)
	})
}

func TestAccountsStore_Get(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()

	t.Run("Success", func(t *testing.T) {
		accountRef := primitive.NewObjectID()
		stub := &repositoryStub{
			GetFunc: func(ctx context.Context, id primitive.ObjectID, result storable.Storable) error {
				account := result.(*model.Account)
				account.SetID(accountRef)
				account.AccountCode = "1000"
				account.Currency = "USD"
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.Get(ctx, accountRef)

		require.NoError(t, err)
		assert.NotNil(t, result)
		assert.Equal(t, "1000", result.AccountCode)
		assert.Equal(t, "USD", result.Currency)
	})

	t.Run("ZeroID", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		result, err := store.Get(ctx, primitive.NilObjectID)

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("NotFound", func(t *testing.T) {
		accountRef := primitive.NewObjectID()
		stub := &repositoryStub{
			GetFunc: func(ctx context.Context, id primitive.ObjectID, result storable.Storable) error {
				return merrors.ErrNoData
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.Get(ctx, accountRef)

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, storage.ErrAccountNotFound))
	})

	t.Run("GetError", func(t *testing.T) {
		accountRef := primitive.NewObjectID()
		expectedErr := errors.New("database error")
		stub := &repositoryStub{
			GetFunc: func(ctx context.Context, id primitive.ObjectID, result storable.Storable) error {
				return expectedErr
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.Get(ctx, accountRef)

		require.Error(t, err)
		assert.Nil(t, result)
		assert.Equal(t, expectedErr, err)
	})
}

func TestAccountsStore_GetByAccountCode(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()
	orgRef := primitive.NewObjectID()

	t.Run("Success", func(t *testing.T) {
		stub := &repositoryStub{
			FindOneByFilterFunc: func(ctx context.Context, _ builder.Query, result storable.Storable) error {
				account := result.(*model.Account)
				account.AccountCode = "1000"
				account.Currency = "USD"
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.GetByAccountCode(ctx, orgRef, "1000", "USD")

		require.NoError(t, err)
		assert.NotNil(t, result)
		assert.Equal(t, "1000", result.AccountCode)
		assert.Equal(t, "USD", result.Currency)
	})

	t.Run("ZeroOrganizationID", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		result, err := store.GetByAccountCode(ctx, primitive.NilObjectID, "1000", "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("EmptyAccountCode", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		result, err := store.GetByAccountCode(ctx, orgRef, "", "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("EmptyCurrency", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		result, err := store.GetByAccountCode(ctx, orgRef, "1000", "")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("NotFound", func(t *testing.T) {
		stub := &repositoryStub{
			FindOneByFilterFunc: func(ctx context.Context, _ builder.Query, result storable.Storable) error {
				return merrors.ErrNoData
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.GetByAccountCode(ctx, orgRef, "9999", "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, storage.ErrAccountNotFound))
	})
}

func TestAccountsStore_GetDefaultSettlement(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()
	orgRef := primitive.NewObjectID()

	t.Run("Success", func(t *testing.T) {
		stub := &repositoryStub{
			FindOneByFilterFunc: func(ctx context.Context, _ builder.Query, result storable.Storable) error {
				account := result.(*model.Account)
				account.SetID(primitive.NewObjectID())
				account.Currency = "USD"
				account.IsSettlement = true
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.GetDefaultSettlement(ctx, orgRef, "USD")

		require.NoError(t, err)
		assert.NotNil(t, result)
		assert.True(t, result.IsSettlement)
		assert.Equal(t, "USD", result.Currency)
	})

	t.Run("ZeroOrganizationID", func(t *testing.T) {
		store := &accountsStore{logger: logger, repo: &repositoryStub{}}
		result, err := store.GetDefaultSettlement(ctx, primitive.NilObjectID, "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("EmptyCurrency", func(t *testing.T) {
		store := &accountsStore{logger: logger, repo: &repositoryStub{}}
		result, err := store.GetDefaultSettlement(ctx, orgRef, "")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("NotFound", func(t *testing.T) {
		stub := &repositoryStub{
			FindOneByFilterFunc: func(ctx context.Context, _ builder.Query, result storable.Storable) error {
				return merrors.ErrNoData
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.GetDefaultSettlement(ctx, orgRef, "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.True(t, errors.Is(err, storage.ErrAccountNotFound))
	})

	t.Run("FindError", func(t *testing.T) {
		expectedErr := errors.New("database error")
		stub := &repositoryStub{
			FindOneByFilterFunc: func(ctx context.Context, _ builder.Query, result storable.Storable) error {
				return expectedErr
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		result, err := store.GetDefaultSettlement(ctx, orgRef, "USD")

		require.Error(t, err)
		assert.Nil(t, result)
		assert.Equal(t, expectedErr, err)
	})
}

func TestAccountsStore_ListByOrganization(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()
	orgRef := primitive.NewObjectID()

	t.Run("Success", func(t *testing.T) {
		var calledWithQuery bool
		stub := &repositoryStub{
			FindManyByFilterFunc: func(ctx context.Context, _ builder.Query, decoder rd.DecodingFunc) error {
				calledWithQuery = true
				// In unit tests, we just verify the method is called correctly
				// Integration tests would test the actual iteration logic
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		results, err := store.ListByOrganization(ctx, orgRef, 10, 0)

		require.NoError(t, err)
		assert.True(t, calledWithQuery, "FindManyByFilter should have been called")
		assert.NotNil(t, results)
	})

	t.Run("ZeroOrganizationID", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		results, err := store.ListByOrganization(ctx, primitive.NilObjectID, 10, 0)

		require.Error(t, err)
		assert.Nil(t, results)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("EmptyResult", func(t *testing.T) {
		stub := &repositoryStub{
			FindManyByFilterFunc: func(ctx context.Context, _ builder.Query, decoder rd.DecodingFunc) error {
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		results, err := store.ListByOrganization(ctx, orgRef, 10, 0)

		require.NoError(t, err)
		assert.Len(t, results, 0)
	})

	t.Run("FindError", func(t *testing.T) {
		expectedErr := errors.New("database error")
		stub := &repositoryStub{
			FindManyByFilterFunc: func(ctx context.Context, _ builder.Query, decoder rd.DecodingFunc) error {
				return expectedErr
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		results, err := store.ListByOrganization(ctx, orgRef, 10, 0)

		require.Error(t, err)
		assert.Nil(t, results)
		assert.Equal(t, expectedErr, err)
	})
}

func TestAccountsStore_UpdateStatus(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()
	accountRef := primitive.NewObjectID()

	t.Run("Success", func(t *testing.T) {
		var patchedID primitive.ObjectID
		var patchedStatus model.AccountStatus
		stub := &repositoryStub{
			PatchFunc: func(ctx context.Context, id primitive.ObjectID, _ repository.PatchDoc) error {
				patchedID = id
				// In real test, we'd inspect patch builder but this is sufficient for stub
				patchedStatus = model.AccountStatusFrozen
				return nil
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		err := store.UpdateStatus(ctx, accountRef, model.AccountStatusFrozen)

		require.NoError(t, err)
		assert.Equal(t, accountRef, patchedID)
		assert.Equal(t, model.AccountStatusFrozen, patchedStatus)
	})

	t.Run("ZeroID", func(t *testing.T) {
		stub := &repositoryStub{}
		store := &accountsStore{logger: logger, repo: stub}

		err := store.UpdateStatus(ctx, primitive.NilObjectID, model.AccountStatusFrozen)

		require.Error(t, err)
		assert.True(t, errors.Is(err, merrors.ErrInvalidArg))
	})

	t.Run("PatchError", func(t *testing.T) {
		expectedErr := errors.New("database error")
		stub := &repositoryStub{
			PatchFunc: func(ctx context.Context, id primitive.ObjectID, _ repository.PatchDoc) error {
				return expectedErr
			},
		}

		store := &accountsStore{logger: logger, repo: stub}
		err := store.UpdateStatus(ctx, accountRef, model.AccountStatusFrozen)

		require.Error(t, err)
		assert.Equal(t, expectedErr, err)
	})
}