func TestToJSON(t *testing.T) {
s, err := store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
)
assert.NoError(t, err)
var buf bytes.Buffer
assert.NoError(t, s.ToJSON(&buf))
tsd := TestToJSONStore{}
assert.NoError(t, json.Unmarshal(buf.Bytes(), &tsd))
want := TestToJSONStore{Code: "de", GroupID: 1, IsActive: true, Name: "Germany", SortOrder: 10, StoreID: 1, WebsiteID: 1}
assert.Equal(t, want, tsd)
var ds store.TableStore
assert.NoError(t, json.NewDecoder(&buf).Decode(&ds))
assert.Equal(t, "de", ds.Code.String)
assert.Equal(t, "Germany", ds.Name)
assert.Equal(t, int64(1), ds.WebsiteID)
}
func TestNewWebsiteStoreIDError(t *testing.T) {
w, err := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
)
assert.NoError(t, err)
assert.Exactly(t, scope.UnavailableStoreID, w.StoreID())
}
func TestStoreCodeFromClaimFullToken(t *testing.T) {
s := store.MustNewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
)
token := jwt.New(jwt.SigningMethodHS256)
s.AddClaim(token.Claims)
so, err := store.CodeFromClaim(token.Claims)
assert.NoError(t, err)
assert.EqualValues(t, "de", so.StoreCode())
so, err = store.CodeFromClaim(nil)
assert.EqualError(t, store.ErrStoreNotFound, err.Error())
assert.Nil(t, so.Website)
assert.Nil(t, so.Group)
assert.Nil(t, so.Store)
token2 := jwt.New(jwt.SigningMethodHS256)
token2.Claims[store.ParamName] = "Invalid Cod€"
so, err = store.CodeFromClaim(token2.Claims)
assert.EqualError(t, store.ErrStoreCodeInvalid, err.Error())
assert.Nil(t, so.Website)
assert.Nil(t, so.Group)
assert.Nil(t, so.Store)
}
func TestNewServiceGroups(t *testing.T) {
serviceGroups := storemock.MustNewService(scope.Option{}, func(ms *storemock.Storage) {
ms.MockGroupSlice = func() (store.GroupSlice, error) {
return store.GroupSlice{}, nil
}
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
)
}
})
// call it twice to test internal caching
ss, err := serviceGroups.Groups()
assert.NotNil(t, ss)
assert.NoError(t, err)
assert.Len(t, ss, 0)
ss, err = serviceGroups.Groups()
assert.NotNil(t, ss)
assert.NoError(t, err)
assert.Len(t, ss, 0)
assert.False(t, serviceGroups.IsCacheEmpty())
serviceGroups.ClearCache()
assert.True(t, serviceGroups.IsCacheEmpty())
}
func TestNewStoreErrorIncorrectWebsite(t *testing.T) {
s, err := store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "UK Group", RootCategoryID: 2, DefaultStoreID: 4},
)
assert.Nil(t, s)
assert.EqualError(t, store.ErrStoreIncorrectWebsite, err.Error())
}
func TestNewGroupSetStores(t *testing.T) {
g, err := store.NewGroup(
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
nil, // this is just for to confuse the NewGroup ApplyOption function
store.SetGroupStores(
store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("uk"), WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NewNullString("at"), WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NewNullString("ch"), WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
),
)
assert.NoError(t, err)
assert.NotNil(t, g.Stores)
assert.EqualValues(t, utils.StringSlice{"de", "at", "ch"}, g.Stores.Codes())
gDefaultStore, err := g.DefaultStore()
assert.NoError(t, err)
assert.EqualValues(t, "euro", gDefaultStore.Website.Data.Code.String)
assert.EqualValues(t, "DACH Group", gDefaultStore.Group.Data.Name)
assert.EqualValues(t, "at", gDefaultStore.Data.Code.String)
}
func TestMarshalJSON(t *testing.T) {
s := store.MustNewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
)
jdata, err := json.Marshal(s)
assert.NoError(t, err)
have := []byte(`{"StoreID":1,"Code":"de","WebsiteID":1,"GroupID":1,"Name":"Germany","SortOrder":10,"IsActive":true}`)
assert.Equal(t, have, jdata, "Have: %s\nWant: %s", have, jdata)
}
func TestNewGroupSetStoresErrorWebsiteIncorrect(t *testing.T) {
g, err := store.NewGroup(
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
store.SetGroupStores(
store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
},
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
),
)
assert.Nil(t, g)
assert.EqualError(t, store.ErrGroupWebsiteIntegrityFailed, err.Error())
}
func TestNewWebsiteSetGroupsStores(t *testing.T) {
w, err := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
store.SetWebsiteGroupsStores(
store.TableGroupSlice{
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
&store.TableGroup{GroupID: 0, WebsiteID: 0, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
&store.TableGroup{GroupID: 2, WebsiteID: 1, Name: "UK Group", RootCategoryID: 2, DefaultStoreID: 4},
},
store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("uk"), WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NewNullString("at"), WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NewNullString("ch"), WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
),
)
assert.NoError(t, err)
dg, err := w.DefaultGroup()
assert.NotNil(t, dg)
assert.EqualValues(t, "DACH Group", dg.Data.Name, "get default group: %#v", dg)
assert.NoError(t, err)
ds, err := w.DefaultStore()
assert.NotNil(t, ds)
assert.EqualValues(t, "at", ds.Data.Code.String, "get default store: %#v", ds)
assert.NoError(t, err)
assert.NotNil(t, dg.Stores)
assert.EqualValues(t, utils.StringSlice{"de", "at", "ch"}, dg.Stores.Codes())
for _, st := range dg.Stores {
assert.EqualValues(t, "DACH Group", st.Group.Data.Name)
assert.EqualValues(t, "Europe", st.Website.Data.Name.String)
}
assert.NotNil(t, w.Stores)
assert.EqualValues(t, utils.StringSlice{"de", "uk", "at", "ch"}, w.Stores.Codes())
assert.NotNil(t, w.Groups)
assert.EqualValues(t, utils.Int64Slice{1, 2}, w.Groups.IDs())
assert.Exactly(t, int64(2), w.StoreID())
assert.Exactly(t, int64(1), w.GroupID())
assert.Equal(t, "euro", w.WebsiteCode())
}
func TestNewWebsite(t *testing.T) {
w, err := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
)
assert.NoError(t, err)
assert.Equal(t, "euro", w.Data.Code.String)
dg, err := w.DefaultGroup()
assert.Nil(t, dg)
assert.EqualError(t, store.ErrWebsiteDefaultGroupNotFound, err.Error())
ds, err := w.DefaultStore()
assert.Nil(t, ds)
assert.EqualError(t, store.ErrWebsiteDefaultGroupNotFound, err.Error())
assert.Nil(t, w.Stores)
assert.Nil(t, w.Groups)
}
func TestNewGroupPanicWebsiteIncorrect(t *testing.T) {
ng, err := store.NewGroup(
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
store.SetGroupWebsite(&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)}),
)
assert.Nil(t, ng)
assert.EqualError(t, store.ErrGroupWebsiteNotFound, err.Error())
}
func TestNewServiceWebsite(t *testing.T) {
var serviceWebsite = storemock.MustNewService(scope.Option{}, func(ms *storemock.Storage) {
ms.MockWebsite = func() (*store.Website, error) {
return store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
)
}
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
)
}
})
tests := []struct {
m *store.Service
have scope.WebsiteIDer
wantErr error
wantWebsiteCode string
}{
{serviceWebsite, scope.MockID(1), nil, "euro"},
{serviceWebsite, scope.MockID(1), nil, "euro"},
{serviceWebsite, scope.MockCode("notImportant"), nil, "euro"},
{serviceWebsite, scope.MockCode("notImportant"), nil, "euro"},
}
for _, test := range tests {
haveW, haveErr := test.m.Website(test.have)
if test.wantErr != nil {
assert.Error(t, haveErr, "%#v", test)
assert.Nil(t, haveW, "%#v", test)
} else {
assert.NoError(t, haveErr, "%#v", test)
assert.NotNil(t, haveW, "%#v", test)
assert.Equal(t, test.wantWebsiteCode, haveW.Data.Code.String)
}
}
assert.False(t, serviceWebsite.IsCacheEmpty())
serviceWebsite.ClearCache()
assert.True(t, serviceWebsite.IsCacheEmpty())
}
func TestNewServiceGroup(t *testing.T) {
var serviceGroupSimpleTest = storemock.MustNewService(scope.Option{}, func(ms *storemock.Storage) {
ms.MockGroup = func() (*store.Group, error) {
return store.NewGroup(
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
store.SetGroupWebsite(&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)}),
)
}
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
)
}
})
tests := []struct {
m *store.Service
have scope.GroupIDer
wantErr error
wantGroupName string
wantWebsiteCode string
}{
{serviceGroupSimpleTest, scope.MockID(20), nil, "DACH Group", "euro"},
{serviceGroupSimpleTest, scope.MockID(1), nil, "DACH Group", "euro"},
{serviceGroupSimpleTest, scope.MockID(1), nil, "DACH Group", "euro"},
}
for i, test := range tests {
g, err := test.m.Group(test.have)
if test.wantErr != nil {
assert.Nil(t, g, "Index %d", i)
assert.EqualError(t, test.wantErr, err.Error(), "test %#v", test)
} else {
assert.NotNil(t, g, "test %#v", test)
assert.NoError(t, err, "test %#v", test)
assert.Equal(t, test.wantGroupName, g.Data.Name)
assert.Equal(t, test.wantWebsiteCode, g.Website.Data.Code.String)
}
}
assert.False(t, serviceGroupSimpleTest.IsCacheEmpty())
serviceGroupSimpleTest.ClearCache()
assert.True(t, serviceGroupSimpleTest.IsCacheEmpty())
}
func TestStorageGroupNoWebsite(t *testing.T) {
var tst = store.MustNewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
store.SetStorageStores(
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
),
)
g, err := tst.Group(scope.MockID(3))
assert.Nil(t, g)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
gs, err := tst.Groups()
assert.Nil(t, gs)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
}
func TestTableWebsiteSlice(t *testing.T) {
websites := store.TableWebsiteSlice{
&store.TableWebsite{WebsiteID: 0, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
nil,
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
}
assert.True(t, websites.Len() == 4)
w1, err := websites.FindByWebsiteID(999)
assert.Nil(t, w1)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
w2, err := websites.FindByWebsiteID(2)
assert.NotNil(t, w2)
assert.NoError(t, err)
assert.Equal(t, int64(2), w2.WebsiteID)
w3, err := websites.FindByCode("euro")
assert.NotNil(t, w3)
assert.NoError(t, err)
assert.Equal(t, "euro", w3.Code.String)
w4, err := websites.FindByCode("corestore")
assert.Nil(t, w4)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
wf1 := websites.Filter(func(w *store.TableWebsite) bool {
return w != nil && w.WebsiteID == 1
})
assert.EqualValues(t, "Europe", wf1[0].Name.String)
}
func TestStoreSlice(t *testing.T) {
storeSlice := store.StoreSlice{
store.MustNewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
),
nil,
store.MustNewStore(
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
}
assert.True(t, storeSlice.Len() == 3)
assert.EqualValues(t, utils.Int64Slice{1, 5}, storeSlice.IDs())
assert.EqualValues(t, utils.StringSlice{"de", "au"}, storeSlice.Codes())
assert.EqualValues(t, 5, storeSlice.LastItem().Data.StoreID)
assert.Nil(t, (store.StoreSlice{}).LastItem())
storeSlice2 := storeSlice.Filter(func(s *store.Store) bool {
return s.Website.Data.WebsiteID == 2
})
assert.True(t, storeSlice2.Len() == 1)
assert.Equal(t, "au", storeSlice2[0].Data.Code.String)
assert.EqualValues(t, utils.Int64Slice{5}, storeSlice2.IDs())
assert.EqualValues(t, utils.StringSlice{"au"}, storeSlice2.Codes())
assert.Nil(t, (store.StoreSlice{}).IDs())
assert.Nil(t, (store.StoreSlice{}).Codes())
}
func TestDefaultStoreView(t *testing.T) {
st, err := testStorage.DefaultStoreView()
assert.NoError(t, err)
assert.EqualValues(t, "at", st.Data.Code.String)
var tst = store.MustNewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
),
)
dSt, err := tst.DefaultStoreView()
assert.Nil(t, dSt)
assert.EqualError(t, store.ErrStoreNotFound, err.Error())
var tst2 = store.MustNewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(true)},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 33, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
store.SetStorageStores(),
)
dSt2, err := tst2.DefaultStoreView()
assert.Nil(t, dSt2)
assert.EqualError(t, store.ErrIDNotFoundTableGroupSlice, err.Error())
}
func TestNewStore(t *testing.T) {
tests := []struct {
w *store.TableWebsite
g *store.TableGroup
s *store.TableStore
}{
{
w: &store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
g: &store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
s: &store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
},
{
w: &store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
g: &store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
s: &store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
},
}
for _, test := range tests {
s, err := store.NewStore(test.s, test.w, test.g)
assert.NoError(t, err)
assert.NotNil(t, s)
assert.EqualValues(t, test.w.WebsiteID, s.Website.Data.WebsiteID)
assert.EqualValues(t, test.g.GroupID, s.Group.Data.GroupID)
assert.EqualValues(t, test.s.Code, s.Data.Code)
assert.NotNil(t, s.Group.Website)
assert.NotEmpty(t, s.Group.Website.WebsiteID())
assert.Nil(t, s.Group.Stores)
assert.EqualValues(t, test.s.StoreID, s.StoreID())
assert.EqualValues(t, test.s.GroupID, s.GroupID())
assert.EqualValues(t, test.s.WebsiteID, s.WebsiteID())
}
}
func TestContextReaderSuccess(t *testing.T) {
ctx := storemock.NewContextService(scope.Option{},
func(ms *storemock.Storage) {
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 6},
)
}
},
)
haveMr, s, err := store.FromContextReader(ctx)
assert.NoError(t, err)
assert.Exactly(t, int64(6), s.StoreID())
s2, err2 := haveMr.Store()
assert.NoError(t, err2)
assert.Exactly(t, int64(6), s2.StoreID())
}
func TestNewGroupSetStoresErrorWebsiteIsNil(t *testing.T) {
g, err := store.NewGroup(
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
nil,
store.SetGroupStores(
store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
},
nil,
),
)
assert.Nil(t, g)
assert.EqualError(t, store.ErrGroupWebsiteNotFound, err.Error())
}
func init() {
middlewareConfigReader = config.NewMockReader(
config.WithMockValues(config.MockPV{
config.MockPathScopeDefault(store.PathRedirectToBase): 1,
config.MockPathScopeStore(1, store.PathSecureInFrontend): true,
config.MockPathScopeStore(1, store.PathUnsecureBaseURL): "http://www.corestore.io/",
config.MockPathScopeStore(1, store.PathSecureBaseURL): "https://www.corestore.io/",
}),
)
middlewareCtxStoreService = storemock.NewContextService(
scope.Option{},
func(ms *storemock.Storage) {
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
store.SetStoreConfig(middlewareConfigReader),
)
}
},
)
}
func init() {
middlewareConfigReader = config.NewMockGetter(
config.WithMockValues(config.MockPV{
scope.StrDefault.FQPathInt64(0, backend.Backend.WebURLRedirectToBase.String()): 1,
scope.StrStores.FQPathInt64(1, backend.Backend.WebSecureUseInFrontend.String()): true,
scope.StrStores.FQPathInt64(1, backend.Backend.WebUnsecureBaseURL.String()): "http://www.corestore.io/",
scope.StrStores.FQPathInt64(1, backend.Backend.WebSecureBaseURL.String()): "https://www.corestore.io/",
}),
)
middlewareCtxStoreService = storemock.WithContextMustService(
scope.Option{},
func(ms *storemock.Storage) {
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
store.WithStoreConfig(middlewareConfigReader),
)
}
},
)
}
func TestNewServiceWebsites(t *testing.T) {
serviceWebsites := storemock.MustNewService(scope.Option{}, func(ms *storemock.Storage) {
ms.MockWebsiteSlice = func() (store.WebsiteSlice, error) {
return store.WebsiteSlice{}, nil
}
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
)
}
})
tests := []struct {
m *store.Service
wantErr error
wantNil bool
}{
{serviceWebsites, nil, false},
{serviceWebsites, nil, false},
{storemock.MustNewService(scope.Option{}, func(ms *storemock.Storage) {
ms.MockWebsiteSlice = func() (store.WebsiteSlice, error) {
return nil, nil
}
ms.MockStore = func() (*store.Store, error) {
return store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
)
}
}), nil, true},
}
for _, test := range tests {
haveWS, haveErr := test.m.Websites()
if test.wantErr != nil {
assert.Error(t, haveErr, "%#v", test)
assert.Nil(t, haveWS, "%#v", test)
} else {
assert.NoError(t, haveErr, "%#v", test)
if test.wantNil {
assert.Nil(t, haveWS, "%#v", test)
} else {
assert.NotNil(t, haveWS, "%#v", test)
}
}
}
assert.False(t, serviceWebsites.IsCacheEmpty())
serviceWebsites.ClearCache()
assert.True(t, serviceWebsites.IsCacheEmpty())
}
func TestNewWebsiteSetGroupsStoresError1(t *testing.T) {
w, err := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
store.SetWebsiteGroupsStores(
store.TableGroupSlice{
&store.TableGroup{GroupID: 0, WebsiteID: 0, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
},
store.TableStoreSlice{
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("uk"), WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NewNullString("at"), WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NewNullString("ch"), WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
),
)
assert.Nil(t, w)
assert.Contains(t, err.Error(), "Integrity error")
}
func TestColumnComment(t *testing.T) {
c := column{
Column: csdb.Column{
Field: dbr.NewNullString("entity_id"),
Type: dbr.NewNullString("varchar"),
Null: dbr.NewNullString("YES"),
Key: dbr.NewNullString("PRI"),
Default: dbr.NewNullString("0"),
Extra: dbr.NewNullString("unsigned"),
},
}
assert.Equal(t, "// entity_id varchar NULL PRI DEFAULT '0' unsigned", c.Comment())
}
func TestStorageStoreErrors(t *testing.T) {
var nsw = store.MustNewStorage(
store.SetStorageWebsites(),
store.SetStorageGroups(),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
),
)
stw, err := nsw.Store(scope.MockCode("nz"))
assert.Nil(t, stw)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
stws, err := nsw.Stores()
assert.Nil(t, stws)
assert.EqualError(t, store.ErrIDNotFoundTableWebsiteSlice, err.Error())
var nsg = store.MustNewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 13, WebsiteID: 12, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 4},
),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
),
)
stg, err := nsg.Store(scope.MockCode("nz"))
assert.Nil(t, stg)
assert.EqualError(t, store.ErrIDNotFoundTableGroupSlice, err.Error())
stgs, err := nsg.Stores()
assert.Nil(t, stgs)
assert.EqualError(t, store.ErrIDNotFoundTableGroupSlice, err.Error())
}
func TestStoreBaseURLandPath(t *testing.T) {
s, err := store.NewStore(
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "Default", RootCategoryID: 0, DefaultStoreID: 1},
)
assert.NoError(t, err)
if s == nil {
t.Fail()
}
tests := []struct {
haveR config.Reader
haveUT config.URLType
haveIsSecure bool
wantBaseUrl string
wantPath string
}{
{
config.NewMockReader(config.WithMockString(
func(path string) (string, error) {
switch path {
case config.MockPathScopeDefault(store.PathSecureBaseURL):
return "https://corestore.io", nil
case config.MockPathScopeDefault(store.PathUnsecureBaseURL):
return "http://corestore.io", nil
}
return "", config.ErrKeyNotFound
},
)),
config.URLTypeWeb, true, "https://corestore.io/", "/",
},
{
config.NewMockReader(config.WithMockString(
func(path string) (string, error) {
switch path {
case config.MockPathScopeDefault(store.PathSecureBaseURL):
return "https://myplatform.io/customer1", nil
case config.MockPathScopeDefault(store.PathUnsecureBaseURL):
return "http://myplatform.io/customer1", nil
}
return "", config.ErrKeyNotFound
},
)),
config.URLTypeWeb, false, "http://myplatform.io/customer1/", "/customer1/",
},
{
config.NewMockReader(config.WithMockString(
func(path string) (string, error) {
switch path {
case config.MockPathScopeDefault(store.PathSecureBaseURL):
return store.PlaceholderBaseURL, nil
case config.MockPathScopeDefault(store.PathUnsecureBaseURL):
return store.PlaceholderBaseURL, nil
case config.MockPathScopeDefault(config.PathCSBaseURL):
return config.CSBaseURL, nil
}
return "", config.ErrKeyNotFound
},
)),
config.URLTypeWeb, false, config.CSBaseURL, "/",
},
}
for i, test := range tests {
s.ApplyOptions(store.SetStoreConfig(test.haveR))
assert.NotNil(t, s.Config, "Index %d", i)
baseURL, err := s.BaseURL(test.haveUT, test.haveIsSecure)
assert.NoError(t, err)
assert.EqualValues(t, test.wantBaseUrl, baseURL.String())
assert.EqualValues(t, test.wantPath, s.Path())
_, err = s.BaseURL(config.URLTypeAbsent, false)
assert.EqualError(t, err, config.ErrURLCacheCleared.Error())
}
}
assert.Nil(t, (store.StoreSlice{}).LastItem())
storeSlice2 := storeSlice.Filter(func(s *store.Store) bool {
return s.Website.Data.WebsiteID == 2
})
assert.True(t, storeSlice2.Len() == 1)
assert.Equal(t, "au", storeSlice2[0].Data.Code.String)
assert.EqualValues(t, utils.Int64Slice{5}, storeSlice2.IDs())
assert.EqualValues(t, utils.StringSlice{"au"}, storeSlice2.Codes())
assert.Nil(t, (store.StoreSlice{}).IDs())
assert.Nil(t, (store.StoreSlice{}).Codes())
}
var testStores = store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
nil,
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("uk"), WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NewNullString("at"), WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NewNullString("ch"), WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
nil,
}
func TestTableStoreSliceLoad(t *testing.T) {
dbc := csdb.MustConnectTest()
defer func() { assert.NoError(t, dbc.Close()) }()
dbrSess := dbc.NewSession()
import (
"testing"
"github.com/corestoreio/csfw/storage/csdb"
"github.com/corestoreio/csfw/storage/dbr"
"github.com/corestoreio/csfw/store"
"github.com/corestoreio/csfw/store/scope"
"github.com/corestoreio/csfw/util"
"github.com/stretchr/testify/assert"
)
// todo inspect the high allocs
var testStorage = store.MustNewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 0, Code: dbr.NewNullString("admin"), Name: dbr.NewNullString("Admin"), SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NewNullBool(false)},
&store.TableWebsite{WebsiteID: 1, Code: dbr.NewNullString("euro"), Name: dbr.NewNullString("Europe"), SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NewNullBool(true)},
&store.TableWebsite{WebsiteID: 2, Code: dbr.NewNullString("oz"), Name: dbr.NewNullString("OZ"), SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NewNullBool(false)},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
&store.TableGroup{GroupID: 0, WebsiteID: 0, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
&store.TableGroup{GroupID: 2, WebsiteID: 1, Name: "UK Group", RootCategoryID: 2, DefaultStoreID: 4},
),
store.SetStorageStores(
&store.TableStore{StoreID: 0, Code: dbr.NewNullString("admin"), WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
&store.TableStore{StoreID: 5, Code: dbr.NewNullString("au"), WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NewNullString("de"), WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NewNullString("uk"), WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NewNullString("at"), WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
func TestGetGoPrimitive(t *testing.T) {
tests := []struct {
c csdb.Column
useNullType bool
want string
}{
{
csdb.Column{
Field: dbr.NewNullString(`category_id131`, true),
Type: dbr.NewNullString(`int(10) unsigned`, true),
Null: dbr.NewNullString(`NO`, true),
Key: dbr.NewNullString(`PRI`, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
false,
"int64",
},
{
csdb.Column{
Field: dbr.NewNullString(`category_id143`, true),
Type: dbr.NewNullString(`int(10) unsigned`, true),
Null: dbr.NewNullString(`YES`, true),
Key: dbr.NewNullString(`PRI`, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
false,
"int64",
},
{
csdb.Column{
Field: dbr.NewNullString(`category_id155`, true),
Type: dbr.NewNullString(`int(10) unsigned`, true),
Null: dbr.NewNullString(`YES`, true),
Key: dbr.NewNullString(`PRI`, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
true,
"dbr.NullInt64",
},
{
csdb.Column{
Field: dbr.NewNullString(`is_root_category155`, true),
Type: dbr.NewNullString(`smallint(2) unsigned`, true),
Null: dbr.NewNullString(`YES`, true),
Key: dbr.NewNullString(``, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
false,
"bool",
},
{
csdb.Column{
Field: dbr.NewNullString(`is_root_category180`, true),
Type: dbr.NewNullString(`smallint(2) unsigned`, true),
Null: dbr.NewNullString(`YES`, true),
Key: dbr.NewNullString(``, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
true,
"dbr.NullBool",
},
{
csdb.Column{
Field: dbr.NewNullString(`product_name193`, true),
Type: dbr.NewNullString(`varchar(255)`, true),
Null: dbr.NewNullString(`YES`, true),
Key: dbr.NewNullString(``, true),
Default: dbr.NewNullString(`0`, true),
Extra: dbr.NewNullString(``, true),
},
true,
"dbr.NullString",
},
{
csdb.Column{
Field: dbr.NewNullString(`product_name193`, true),
Type: dbr.NewNullString(`varchar(255)`, true),
Null: dbr.NewNullString(`YES`, true),
},
false,
"string",
},
{
csdb.Column{
Field: dbr.NewNullString(`price`, true),
Type: dbr.NewNullString(`decimal(12,4)`, true),
Null: dbr.NewNullString(`YES`, true),
},
false,
"money.Currency",
},
{
csdb.Column{
Field: dbr.NewNullString(`shipping_adjustment_230`, true),
Type: dbr.NewNullString(`decimal(12,4)`, true),
Null: dbr.NewNullString(`YES`, true),
},
true,
"money.Currency",
},
{
csdb.Column{
Field: dbr.NewNullString(`grand_absolut_233`, true),
Type: dbr.NewNullString(`decimal(12,4)`, true),
Null: dbr.NewNullString(`YES`, true),
},
true,
"money.Currency",
},
{
csdb.Column{
Field: dbr.NewNullString(`some_currencies_242`, true),
Type: dbr.NewNullString(`decimal(12,4)`, true),
Null: dbr.NewNullString(`NO`, true),
Default: dbr.NewNullString(`0.0000`, true),
},
true,
"money.Currency",
},
{
csdb.Column{
Field: dbr.NewNullString(`weight_252`, true),
Type: dbr.NewNullString(`decimal(10,4)`, true),
Null: dbr.NewNullString(`YES`, true),
Default: dbr.NewNullString(`0.0000`, true),
},
true,
"dbr.NullFloat64",
},
{
csdb.Column{
Field: dbr.NewNullString(`weight_263`, true),
Type: dbr.NewNullString(`double(10,4)`, true),
Null: dbr.NewNullString(`YES`, true),
Default: dbr.NewNullString(`0.0000`, true),
},
false,
"float64",
},
{
csdb.Column{
Field: dbr.NewNullString(`created_at_274`, true),
Type: dbr.NewNullString(`date`, true),
Null: dbr.NewNullString(`YES`, true),
Default: dbr.NewNullString(`0000-00-00`, true),
},
false,
"time.Time",
},
{
csdb.Column{
Field: dbr.NewNullString(`created_at_274`, true),
Type: dbr.NewNullString(`date`, true),
Null: dbr.NewNullString(`YES`, true),
Default: dbr.NewNullString(`0000-00-00`, true),
},
true,
"dbr.NullTime",
},
}
for _, test := range tests {
have := test.c.GetGoPrimitive(test.useNullType)
assert.Equal(t, test.want, have, "Test: %#v", test)
}
}