synapsecns/sanguine

package dbcommon_test

import (
    "context"
    "database/sql/driver"
    "fmt"
    "github.com/Flaque/filet"
    "github.com/ipfs/go-log"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/core/dbcommon"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "os"
    "testing"
)

var testDBLogger = log.Logger("dbcommon")

// TestEnum tests the default providers for an enum type.
func (s DbSuite) TestEnum() {
    res, err := RunEnumExample(s.GetTestContext(), fmt.Sprintf("%s/sql.db", filet.TmpDir(s.T(), "")))
    Nil(s.T(), err)

    for i, fruit := range AllFruits {
        Equal(s.T(), fruit.Int(), res[i].Fruit.Int())
    }

    Equal(s.T(), len(res), len(AllFruits))
}

// ExampleEnum demonstrates example use of the enum interface.
// this implementation can be confusing, so there's an example below.
func ExampleEnum() {
    res, err := RunEnumExample(context.Background(), fmt.Sprintf("%s/sql.db", os.TempDir()))
    if err != nil {
        panic(err)
    }

    for _, res := range res {
        fmt.Printf("got result %s \n", res.Fruit.String())
    }
}

// RunEnumExample is used to separate out tests from the example.
func RunEnumExample(ctx context.Context, dbDir string) (res []InventoryModel, err error) {
    gdb, err := gorm.Open(sqlite.Open(dbDir), &gorm.Config{
        Logger: dbcommon.GetGormLogger(testDBLogger),
    })
    if err != nil {
        return res, fmt.Errorf("could not open db: %w", err)
    }

    // migrate the inventory model
    err = gdb.WithContext(ctx).AutoMigrate(&InventoryModel{})
    if err != nil {
        return res, fmt.Errorf("could not migrate db: %w", err)
    }

    for _, fruit := range AllFruits {
        tx := gdb.WithContext(ctx).Create(&InventoryModel{
            Fruit: fruit,
        })

        if tx.Error != nil {
            return res, fmt.Errorf("could not insert fruit: %w", err)
        }
    }

    tx := gdb.WithContext(ctx).Find(&res)
    if tx.Error != nil {
        return res, fmt.Errorf("could not query db: %w", err)
    }

    return res, nil
}

// InventoryModel is an example model for of an inventory table for fruit.
type InventoryModel struct {
    gorm.Model
    // fruit is the fruit we're storing
    Fruit Fruit
}

// you should use ints rather than iota's when interacting with the database.
const (
    // Apple is an example implementing enum.
    Apple Fruit = 0
    // Pear is a n example implementing enum.
    Pear Fruit = 1
)

var AllFruits = []Fruit{Apple, Pear}

type Fruit uint8

// String gets a string of the enum
// in a production setting, generater should be used.
// see: https://pkg.go.dev/golang.org/x/tools/cmd/stringer for details
func (f Fruit) String() string {
    switch f {
    case Apple:
        return "Apple"
    case Pear:
        return "Pear"
    }
    return ""
}

// Int get the integer value of the fruit.
func (f Fruit) Int() uint8 {
    return uint8(f)
}

// GormDataType is the gorm data type.
func (f Fruit) GormDataType() string {
    return dbcommon.EnumDataType
}

// Scan will scan the fruit into the db.
func (f *Fruit) Scan(src interface{}) error {
    res, err := dbcommon.EnumScan(src)
    if err != nil {
        return fmt.Errorf("could not scan: %w", err)
    }
    newFruit := Fruit(res)
    *f = newFruit
    return nil
}

// nolint: wrapcheck
func (f *Fruit) Value() (driver.Value, error) {
    return dbcommon.EnumValue(f)
}

var _ dbcommon.EnumInter = (*Fruit)(nil)

type testEnum uint8

func (t testEnum) Int() uint8 {
    return uint8(t)
}

const (
    testEnumValue1 testEnum = 1
    testEnumValue2 testEnum = 2
)

func TestEnumValue(t *testing.T) {
    tests := []struct {
        name    string
        enum    dbcommon.EnumInter
        want    int64
        wantErr error
    }{
        {
            name: "Valid enum value",
            enum: testEnumValue1,
            want: 1,
        },
        {
            name: "Valid enum value",
            enum: testEnumValue2,
            want: 2,
        },
    }

    for i := range tests {
        tt := tests[i]
        t.Run(tt.name, func(t *testing.T) {
            got, err := dbcommon.EnumValue(tt.enum)
            if tt.wantErr != nil {
                ErrorIs(t, err, tt.wantErr)
            } else {
                Nil(t, err)
                Equal(t, tt.want, got)
            }
        })
    }
}

func TestEnumScan(t *testing.T) {
    tests := []struct {
        name    string
        src     interface{}
        want    uint8
        wantErr string
    }{
        {
            name: "Valid int64 value",
            src:  int64(1),
            want: 1,
        },
        {
            name: "Valid int32 value",
            src:  int32(2),
            want: 2,
        },
        {
            name:    "Invalid type",
            src:     "invalid",
            want:    0,
            wantErr: "could not scan enum: converting driver.Value type string (\"invalid\") to a int32: invalid syntax",
        },
    }

    for i := range tests {
        tt := tests[i]
        t.Run(tt.name, func(t *testing.T) {
            got, err := dbcommon.EnumScan(tt.src)
            if tt.wantErr != "" {
                Error(t, err)
                EqualError(t, err, tt.wantErr)
            } else {
                NoError(t, err)
                Equal(t, tt.want, got)
            }
        })
    }
}