datastore/internal/dal/impl_test.go

package dal

import (
	"database/sql"
	"database/sql/driver"
	"reflect"
	"testing"
	"time"

	"git.rosemyrtle.work/personal-finance/server/internal/entity"
	"github.com/DATA-DOG/go-sqlmock"
	"github.com/shopspring/decimal"
)

func TestDalImpl_Transaction(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatal(err)
	}
	date := time.Now()

	type fields struct {
		Db *sql.DB
	}
	type args struct {
		transactionId int64
		rows          [][]driver.Value
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    *entity.Transaction
		wantErr bool
	}{
		{"notfound", fields{db}, args{2, nil}, nil, false},
		{
			"found",
			fields{db},
			args{
				1,
				[][]driver.Value{
					{1, date, "income", 1000},
				}},
			&entity.Transaction{Id: 1, Date: date, Description: "income", Value: decimal.NewFromInt(1000)},
			false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			d := &DalImpl{
				Db: tt.fields.Db,
			}

			mock.
				ExpectQuery("^SELECT .* FROM .*transactions t WHERE t.id = \\$1$").
				WithArgs(tt.args.transactionId).
				WillReturnRows(
					mock.
						NewRows([]string{"id", "date", "description", "amount"}).
						AddRows(tt.args.rows...),
				)

			got, err := d.Transaction(tt.args.transactionId)
			if (err != nil) != tt.wantErr {
				t.Errorf("DalImpl.Transaction() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DalImpl.Transaction() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDalImpl_Transactions(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatal(err)
	}
	date := time.Now()

	type fields struct {
		Db *sql.DB
	}
	type args struct {
		rows [][]driver.Value
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    entity.Transactions
		wantErr bool
	}{
		{"empty", fields{db}, args{}, nil, false},
		{
			"without category",
			fields{db},
			args{[][]driver.Value{
				{1, date, "income", 1000},
				{2, date, "expense", -10.50},
			}},
			entity.Transactions{
				{Id: 1, Date: date, Description: "income", Value: decimal.NewFromInt(1000)},
				{Id: 2, Date: date, Description: "expense", Value: decimal.NewFromFloat(-10.50)},
			},
			false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dal := &DalImpl{
				Db: tt.fields.Db,
			}

			mock.
				// ExpectQuery("^SELECT .* FROM .*transactions t LEFT JOIN .*transactions_categorized tc ON t.id = tc.id$").
				ExpectQuery("^SELECT .* FROM .*transactions t$").
				WithoutArgs().
				WillReturnRows(
					mock.
						// NewRows([]string{"category", "date", "description", "id", "amount"}).
						NewRows([]string{"id", "date", "description", "amount"}).
						AddRows(tt.args.rows...),
				)

			got, err := dal.Transactions()
			if (err != nil) != tt.wantErr {
				t.Errorf("DalImpl.Transactions() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DalImpl.Transactions() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDalImpl_Bank(t *testing.T) {
	type fields struct {
		Db *sql.DB
	}
	tests := []struct {
		name    string
		fields  fields
		want    entity.Bank
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			d := &DalImpl{
				Db: tt.fields.Db,
			}
			got, err := d.Bank()
			if (err != nil) != tt.wantErr {
				t.Errorf("DalImpl.Bank() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DalImpl.Bank() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDalImpl_Banks(t *testing.T) {
	type fields struct {
		Db *sql.DB
	}
	tests := []struct {
		name    string
		fields  fields
		want    entity.Banks
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			d := &DalImpl{
				Db: tt.fields.Db,
			}
			got, err := d.Banks()
			if (err != nil) != tt.wantErr {
				t.Errorf("DalImpl.Banks() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DalImpl.Banks() = %v, want %v", got, tt.want)
			}
		})
	}
}