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 TestNewWebsiteSetGroupsStoresPanic(t *testing.T) {
defer func() {
if r := recover(); r != nil {
if str, ok := r.(string); ok {
assert.Contains(t, str, "Integrity error")
} else {
t.Errorf("Failed to convert to type error: %#v", str)
}
} else {
t.Error("Cannot find panic")
}
}()
w := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
)
w.SetGroupsStores(
store.TableGroupSlice{
&store.TableGroup{GroupID: 0, WebsiteID: 0, Name: "Default", RootCategoryID: 0, DefaultStoreID: 0},
},
store.TableStoreSlice{
&store.TableStore{StoreID: 5, Code: dbr.NullString{NullString: sql.NullString{String: "au", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "de", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NullString{NullString: sql.NullString{String: "uk", Valid: true}}, WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NullString{NullString: sql.NullString{String: "at", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NullString{NullString: sql.NullString{String: "nz", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NullString{NullString: sql.NullString{String: "ch", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
)
}
func TestNewManagerWebsiteInit(t *testing.T) {
err := getTestManager(func(ms *mockStorage) {
ms.w = func() (*store.Website, error) {
return store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
), nil
}
}).Init(config.ScopeCode("euro"), config.ScopeWebsiteID)
assert.EqualError(t, store.ErrWebsiteDefaultGroupNotFound, err.Error())
managerWebsite := getTestManager(func(ms *mockStorage) {
ms.w = func() (*store.Website, error) {
return store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
).SetGroupsStores(
store.TableGroupSlice{
&store.TableGroup{GroupID: 1, WebsiteID: 1, Name: "DACH Group", RootCategoryID: 2, DefaultStoreID: 2},
},
store.TableStoreSlice{
&store.TableStore{StoreID: 0, Code: dbr.NullString{NullString: sql.NullString{String: "admin", Valid: true}}, WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "de", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NullString{NullString: sql.NullString{String: "at", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NullString{NullString: sql.NullString{String: "ch", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
), nil
}
})
w1, err := managerWebsite.Website()
assert.EqualError(t, store.ErrAppStoreNotSet, err.Error())
assert.Nil(t, w1)
err = managerWebsite.Init(config.ScopeCode("euro"), config.ScopeWebsiteID)
assert.NoError(t, err)
w2, err := managerWebsite.Website()
assert.NoError(t, err)
assert.EqualValues(t, "euro", w2.Data.Code.String)
err3 := getTestManager(func(ms *mockStorage) {}).Init(config.ScopeCode("euronen"), config.ScopeWebsiteID)
assert.Error(t, err3, "config.ScopeCode(euro), config.ScopeWebsite: %#v => %s", err3, err3)
assert.EqualError(t, store.ErrWebsiteNotFound, err3.Error())
}
func TestNewWebsiteSetGroupsStores(t *testing.T) {
w := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
)
w.SetGroupsStores(
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.NullString{NullString: sql.NullString{String: "admin", Valid: true}}, WebsiteID: 0, GroupID: 0, Name: "Admin", SortOrder: 0, IsActive: true},
&store.TableStore{StoreID: 5, Code: dbr.NullString{NullString: sql.NullString{String: "au", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "de", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Germany", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 4, Code: dbr.NullString{NullString: sql.NullString{String: "uk", Valid: true}}, WebsiteID: 1, GroupID: 2, Name: "UK", SortOrder: 10, IsActive: true},
&store.TableStore{StoreID: 2, Code: dbr.NullString{NullString: sql.NullString{String: "at", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Österreich", SortOrder: 20, IsActive: true},
&store.TableStore{StoreID: 6, Code: dbr.NullString{NullString: sql.NullString{String: "nz", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{StoreID: 3, Code: dbr.NullString{NullString: sql.NullString{String: "ch", Valid: true}}, WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30, IsActive: true},
},
)
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)
dgStores, err := dg.Stores()
assert.NoError(t, err)
assert.EqualValues(t, utils.StringSlice{"de", "at", "ch"}, dgStores.Codes())
for _, st := range dgStores {
assert.EqualValues(t, "DACH Group", st.Group().Data().Name)
assert.EqualValues(t, "Europe", st.Website().Data().Name.String)
}
stores, err := w.Stores()
assert.NoError(t, err)
assert.NotNil(t, stores)
assert.EqualValues(t, utils.StringSlice{"de", "uk", "at", "ch"}, stores.Codes())
groups, err := w.Groups()
assert.NoError(t, err)
assert.NotNil(t, groups)
assert.EqualValues(t, utils.Int64Slice{1, 2}, groups.IDs())
}
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 TestNewWebsite(t *testing.T) {
w := store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
)
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 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 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 TestNewManagerWebsite(t *testing.T) {
var managerWebsite = getTestManager(func(ms *mockStorage) {
ms.w = func() (*store.Website, error) {
return store.NewWebsite(
&store.TableWebsite{WebsiteID: 1, Code: dbr.NullString{NullString: sql.NullString{String: "euro", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Europe", Valid: true}}, SortOrder: 0, DefaultGroupID: 1, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: true}}},
), nil
}
})
tests := []struct {
m *store.Manager
have config.ScopeIDer
wantErr error
wantWebsiteCode string
}{
{managerWebsite, nil, store.ErrAppStoreNotSet, ""},
{getTestManager(), config.ScopeID(20), store.ErrGroupNotFound, ""},
{managerWebsite, config.ScopeID(1), nil, "euro"},
{managerWebsite, config.ScopeID(1), nil, "euro"},
{managerWebsite, config.ScopeCode("notImportant"), nil, "euro"},
{managerWebsite, config.ScopeCode("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, managerWebsite.IsCacheEmpty())
managerWebsite.ClearCache()
assert.True(t, managerWebsite.IsCacheEmpty())
}