initial commit

2025-12-09 00:50:59 +13:00 · 2018-10-19 15:31:41 -04:00
commit e2dd29259f
203 changed files with 44839 additions and 0 deletions
--- a/core/model/account_test.go
+++ b/core/model/account_test.go
@@ -0,0 +1,330 @@
+package model
+
+import (
+	"errors"
+	"github.com/openaccounting/oa-server/core/model/db"
+	"github.com/openaccounting/oa-server/core/model/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"testing"
+	"time"
+)
+
+type TdAccount struct {
+	db.Datastore
+	mock.Mock
+}
+
+func (td *TdAccount) GetPermissionedAccountIds(userId string, orgId string, tokenId string) ([]string, error) {
+	// User has permission to only "Assets" account
+	return []string{"2"}, nil
+}
+
+func (td *TdAccount) GetAccountsByOrgId(orgId string) ([]*types.Account, error) {
+	args := td.Called(orgId)
+	return args.Get(0).([]*types.Account), args.Error(1)
+}
+
+func (td *TdAccount) InsertAccount(account *types.Account) error {
+	return nil
+}
+
+func (td *TdAccount) UpdateAccount(account *types.Account) error {
+	return nil
+}
+
+func (td *TdAccount) AddBalance(account *types.Account, date time.Time) error {
+	return nil
+}
+
+func (td *TdAccount) AddNativeBalanceNearestInTime(account *types.Account, date time.Time) error {
+	return nil
+}
+
+func (td *TdAccount) AddNativeBalanceCost(account *types.Account, date time.Time) error {
+	return nil
+}
+
+func (td *TdAccount) AddBalances(accounts []*types.Account, date time.Time) error {
+	balance := int64(1000)
+	for _, account := range accounts {
+		account.Balance = &balance
+	}
+
+	return nil
+}
+
+func (td *TdAccount) AddNativeBalancesNearestInTime(accounts []*types.Account, date time.Time) error {
+	balance := int64(1000)
+	for _, account := range accounts {
+		account.NativeBalance = &balance
+	}
+
+	return nil
+}
+
+func (td *TdAccount) AddNativeBalancesCost(accounts []*types.Account, date time.Time) error {
+	balance := int64(1000)
+	for _, account := range accounts {
+		account.NativeBalance = &balance
+	}
+
+	return nil
+}
+
+func (td *TdAccount) GetSplitCountByAccountId(id string) (int64, error) {
+	args := td.Called(id)
+	return args.Get(0).(int64), args.Error(1)
+}
+
+func (td *TdAccount) GetChildCountByAccountId(id string) (int64, error) {
+	args := td.Called(id)
+	return args.Get(0).(int64), args.Error(1)
+}
+
+func (td *TdAccount) DeleteAccount(id string) error {
+	return nil
+}
+
+func (td *TdAccount) GetOrgUserIds(id string) ([]string, error) {
+	return []string{"1"}, nil
+}
+
+func (td *TdAccount) GetAccount(id string) (*types.Account, error) {
+	return &types.Account{}, nil
+}
+
+func getTestAccounts() []*types.Account {
+	return []*types.Account{
+		&types.Account{
+			Id:           "2",
+			OrgId:        "1",
+			Name:         "Assets",
+			Parent:       "1",
+			Currency:     "USD",
+			Precision:    2,
+			DebitBalance: true,
+		},
+		&types.Account{
+			Id:           "3",
+			OrgId:        "1",
+			Name:         "Current Assets",
+			Parent:       "2",
+			Currency:     "USD",
+			Precision:    2,
+			DebitBalance: true,
+		},
+		&types.Account{
+			Id:           "1",
+			OrgId:        "1",
+			Name:         "Root",
+			Parent:       "",
+			Currency:     "USD",
+			Precision:    2,
+			DebitBalance: true,
+		},
+	}
+}
+
+func TestCreateAccount(t *testing.T) {
+	tests := map[string]struct {
+		err     error
+		account *types.Account
+	}{
+		"success": {
+			err: nil,
+			account: &types.Account{
+				Id:           "1",
+				OrgId:        "1",
+				Name:         "Cash",
+				Parent:       "3",
+				Currency:     "USD",
+				Precision:    2,
+				DebitBalance: true,
+			},
+		},
+		"permission error": {
+			err: errors.New("user does not have permission to access account 1"),
+			account: &types.Account{
+				Id:           "1",
+				OrgId:        "1",
+				Name:         "Cash",
+				Parent:       "1",
+				Currency:     "USD",
+				Precision:    2,
+				DebitBalance: true,
+			},
+		},
+	}
+
+	for name, test := range tests {
+		t.Logf("Running test case: %s", name)
+
+		td := &TdAccount{}
+		td.On("GetAccountsByOrgId", "1").Return(getTestAccounts(), nil)
+
+		model := NewModel(td, nil, types.Config{})
+
+		err := model.CreateAccount(test.account, "1")
+		assert.Equal(t, test.err, err)
+	}
+}
+
+func TestUpdateAccount(t *testing.T) {
+	tests := map[string]struct {
+		err     error
+		account *types.Account
+	}{
+		"success": {
+			err: nil,
+			account: &types.Account{
+				Id:           "3",
+				OrgId:        "1",
+				Name:         "Current Assets2",
+				Parent:       "2",
+				Currency:     "USD",
+				Precision:    2,
+				DebitBalance: true,
+			},
+		},
+		"error": {
+			err: errors.New("account cannot be its own parent"),
+			account: &types.Account{
+				Id:           "3",
+				OrgId:        "1",
+				Name:         "Current Assets",
+				Parent:       "3",
+				Currency:     "USD",
+				Precision:    2,
+				DebitBalance: true,
+			},
+		},
+	}
+
+	for name, test := range tests {
+		t.Logf("Running test case: %s", name)
+
+		td := &TdAccount{}
+		td.On("GetAccountsByOrgId", "1").Return(getTestAccounts(), nil)
+
+		model := NewModel(td, nil, types.Config{})
+
+		err := model.UpdateAccount(test.account, "1")
+		assert.Equal(t, test.err, err)
+
+		if err == nil {
+			td.AssertExpectations(t)
+		}
+	}
+}
+
+func TestDeleteAccount(t *testing.T) {
+	tests := map[string]struct {
+		err       error
+		accountId string
+		count     int64
+	}{
+		"success": {
+			err:       nil,
+			accountId: "3",
+			count:     0,
+		},
+		"error": {
+			err:       errors.New("Cannot delete an account that has transactions"),
+			accountId: "3",
+			count:     1,
+		},
+	}
+
+	for name, test := range tests {
+		t.Logf("Running test case: %s", name)
+
+		td := &TdAccount{}
+		td.On("GetAccountsByOrgId", "1").Return(getTestAccounts(), nil)
+		td.On("GetSplitCountByAccountId", test.accountId).Return(test.count, nil)
+		td.On("GetChildCountByAccountId", test.accountId).Return(test.count, nil)
+
+		model := NewModel(td, nil, types.Config{})
+
+		err := model.DeleteAccount(test.accountId, "1", "1")
+		assert.Equal(t, test.err, err)
+
+		if err == nil {
+			td.AssertExpectations(t)
+		}
+	}
+}
+
+func TestGetAccounts(t *testing.T) {
+	tests := map[string]struct {
+		err error
+	}{
+		"success": {
+			err: nil,
+		},
+		// "error": {
+		// 	err: errors.New("db error"),
+		// },
+	}
+
+	for name, test := range tests {
+		t.Logf("Running test case: %s", name)
+
+		td := &TdAccount{}
+		td.On("GetAccountsByOrgId", "1").Return(getTestAccounts(), test.err)
+
+		model := NewModel(td, nil, types.Config{})
+
+		accounts, err := model.GetAccounts("1", "1", "")
+
+		assert.Equal(t, test.err, err)
+
+		if err == nil {
+			td.AssertExpectations(t)
+			assert.Equal(t, 3, len(accounts))
+			assert.Equal(t, false, accounts[0].ReadOnly)
+			assert.Equal(t, false, accounts[1].ReadOnly)
+			assert.Equal(t, true, accounts[2].ReadOnly)
+		}
+	}
+}
+
+func TestGetAccountsWithBalances(t *testing.T) {
+	tests := map[string]struct {
+		err error
+	}{
+		"success": {
+			err: nil,
+		},
+		"error": {
+			err: errors.New("db error"),
+		},
+	}
+
+	for name, test := range tests {
+		t.Logf("Running test case: %s", name)
+
+		td := &TdAccount{}
+		td.On("GetAccountsByOrgId", "1").Return(getTestAccounts(), test.err)
+
+		model := NewModel(td, nil, types.Config{})
+
+		accounts, err := model.GetAccountsWithBalances("1", "1", "", time.Now())
+
+		assert.Equal(t, test.err, err)
+
+		if err == nil {
+			td.AssertExpectations(t)
+			assert.Equal(t, 3, len(accounts))
+			assert.Equal(t, false, accounts[0].ReadOnly)
+			assert.Equal(t, false, accounts[1].ReadOnly)
+			assert.Equal(t, true, accounts[2].ReadOnly)
+
+			assert.Equal(t, int64(1000), *accounts[0].Balance)
+			assert.Equal(t, int64(1000), *accounts[1].Balance)
+
+			assert.Equal(t, int64(1000), *accounts[0].NativeBalance)
+			assert.Equal(t, int64(1000), *accounts[1].NativeBalance)
+		}
+	}
+}