// Store creates a new Store which contains the the store, its group and website
// according to the interface definition.
func (st *Storage) Store(r scope.StoreIDer) (*Store, error) {
s, err := st.store(r)
if err != nil {
return nil, errgo.Mask(err)
}
w, err := st.website(scope.MockID(s.WebsiteID))
if err != nil {
return nil, errgo.Mask(err)
}
g, err := st.group(scope.MockID(s.GroupID))
if err != nil {
return nil, errgo.Mask(err)
}
ns, err := NewStore(s, w, g, WithStoreConfig(st.cr))
if err != nil {
return nil, errgo.Mask(err)
}
if _, err := ns.Website.ApplyOptions(SetWebsiteGroupsStores(st.groups, st.stores)); err != nil {
return nil, errgo.Mask(err)
}
if _, err := ns.Group.ApplyOptions(SetGroupStores(st.stores, w)); err != nil {
return nil, errgo.Mask(err)
}
return ns, nil
}
// DefaultStoreView traverses through the websites to find the default website and gets
// the default group which has the default store id assigned to. Only one website can be the default one.
func (st *Storage) DefaultStoreView() (*Store, error) {
for _, website := range st.websites {
if website.IsDefault.Bool && website.IsDefault.Valid {
g, err := st.group(scope.MockID(website.DefaultGroupID))
if err != nil {
return nil, errgo.Mask(err)
}
return st.Store(scope.MockID(g.DefaultStoreID))
}
}
return nil, ErrStoreNotFound
}
func TestNewServiceRequestedStore_ScopeGroup(t *testing.T) {
initScope := scope.Option{Group: scope.MockID(1)}
sm := getInitializedStoreService(initScope)
if haveStore, haveErr := sm.RequestedStore(initScope); haveErr != nil {
t.Fatal(haveErr)
} else {
assert.NoError(t, haveErr)
assert.Exactly(t, int64(2), haveStore.StoreID())
}
if s, err := sm.Store(); err == nil {
assert.EqualValues(t, "at", s.Data.Code.String)
} else {
assert.EqualError(t, err, store.ErrStoreNotFound.Error())
t.Fail()
}
if g, err := sm.Group(); err == nil {
assert.EqualValues(t, 1, g.Data.GroupID)
} else {
assert.EqualError(t, err, store.ErrStoreNotFound.Error())
t.Fail()
}
// // we're testing here against Group ID = 1
tests := []testNewServiceRequestedStore{
{scope.Option{Group: scope.MockID(232)}, "", store.ErrIDNotFoundTableGroupSlice},
{scope.Option{Store: scope.MockID(232)}, "", store.ErrIDNotFoundTableStoreSlice},
{scope.Option{Store: scope.MockCode("\U0001f631")}, "", store.ErrIDNotFoundTableStoreSlice},
{scope.Option{Store: scope.MockID(6)}, "nz", store.ErrStoreChangeNotAllowed},
{scope.Option{Store: scope.MockCode("ch")}, "", store.ErrStoreNotActive},
{scope.Option{Store: scope.MockCode("de")}, "de", nil},
{scope.Option{Store: scope.MockID(2)}, "at", nil},
{scope.Option{Store: scope.MockID(2)}, "at", nil},
{scope.Option{Store: scope.MockCode("au")}, "au", store.ErrStoreChangeNotAllowed},
{scope.Option{Store: scope.MockCode("ch")}, "", store.ErrStoreNotActive},
{scope.Option{Group: scope.MockCode("ch")}, "", store.ErrIDNotFoundTableGroupSlice},
{scope.Option{Group: scope.MockID(2)}, "", store.ErrStoreChangeNotAllowed},
{scope.Option{Group: scope.MockID(1)}, "at", nil},
{scope.Option{Website: scope.MockCode("xxxx")}, "", store.ErrIDNotFoundTableWebsiteSlice},
{scope.Option{Website: scope.MockID(2)}, "", store.ErrStoreChangeNotAllowed},
{scope.Option{Website: scope.MockID(1)}, "at", nil},
}
runTestsRequestedStore(t, sm, tests)
}
func TestApplyID(t *testing.T) {
tests := []struct {
wantWebsiteID scope.WebsiteIDer
wantGroupID scope.GroupIDer
wantStoreID scope.StoreIDer
haveID int64
s scope.Scope
err error
}{
{scope.MockID(1), nil, nil, 1, scope.WebsiteID, nil},
{nil, scope.MockID(3), nil, 3, scope.GroupID, nil},
{nil, nil, scope.MockID(2), 2, scope.StoreID, nil},
{nil, nil, nil, 4, scope.AbsentID, scope.ErrUnsupportedScopeID},
}
for _, test := range tests {
so, err := scope.SetByID(test.haveID, test.s)
assert.NotNil(t, so)
if test.err != nil {
assert.EqualError(t, err, test.err.Error())
assert.Nil(t, so.Website)
assert.Nil(t, so.Group)
assert.Nil(t, so.Store)
} else {
assert.NoError(t, err)
assert.Equal(t, test.s, so.Scope())
assert.Equal(t, "", so.StoreCode())
assert.Equal(t, "", so.WebsiteCode())
if test.wantWebsiteID != nil {
assert.Equal(t, test.wantWebsiteID.WebsiteID(), so.Website.WebsiteID())
} else {
assert.Nil(t, test.wantWebsiteID)
}
if test.wantGroupID != nil {
assert.Equal(t, test.wantGroupID.GroupID(), so.Group.GroupID())
} else {
assert.Nil(t, test.wantGroupID)
}
if test.wantStoreID != nil {
assert.Equal(t, test.wantStoreID.StoreID(), so.Store.StoreID())
} else {
assert.Nil(t, test.wantStoreID)
}
}
}
}
func TestMustNewService(t *testing.T) {
defer func() {
if r := recover(); r != nil {
assert.EqualError(t, r.(error), store.ErrStoreNotFound.Error())
} else {
t.Fatal("Expecting a Panic")
}
}()
tests := []struct {
have scope.StoreIDer
wantErr error
}{
{scope.MockCode("nilSlices"), store.ErrStoreNotFound},
{scope.MockID(2), store.ErrStoreNotFound},
{nil, store.ErrStoreNotFound},
}
serviceEmpty := storemock.MustNewService(scope.Option{})
for _, test := range tests {
s, err := serviceEmpty.Store(test.have)
assert.Nil(t, s)
assert.EqualError(t, test.wantErr, err.Error())
}
assert.True(t, serviceStoreSimpleTest.IsCacheEmpty())
}
func TestApplyStore(t *testing.T) {
so := scope.Option{Store: scope.MockID(3)}
assert.NotNil(t, so)
assert.Equal(t, int64(3), so.Store.StoreID())
assert.Nil(t, so.Website)
assert.Nil(t, so.Group)
assert.Exactly(t, scope.StoreID.String(), so.String())
}
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 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())
}
// Stores creates a new store slice. Can return an error when the website or
// the group cannot be found.
func (st *Storage) Stores() (StoreSlice, error) {
stores := make(StoreSlice, len(st.stores), len(st.stores))
for i, s := range st.stores {
var err error
if stores[i], err = st.Store(scope.MockID(s.StoreID)); err != nil {
return nil, errgo.Mask(err)
}
}
return stores, nil
}
func TestNewServiceReInit(t *testing.T) {
t.Skip(TODO_Better_Test_Data)
// quick implement, use mock of dbr.SessionRunner and remove connection
dbc := csdb.MustConnectTest()
defer func() { assert.NoError(t, dbc.Close()) }()
dbrSess := dbc.NewSession()
storeService := store.MustNewService(scope.Option{}, store.MustNewStorage(nil /* trick it*/))
if err := storeService.ReInit(dbrSess); err != nil {
t.Fatal(err)
}
tests := []struct {
have scope.StoreIDer
wantErr error
}{
{scope.MockCode("dede"), nil},
{scope.MockCode("czcz"), store.ErrIDNotFoundTableStoreSlice},
{scope.MockID(1), nil},
{scope.MockID(100), store.ErrStoreNotFound},
{mockIDCode{1, "dede"}, nil},
{mockIDCode{2, "czfr"}, store.ErrStoreNotFound},
{mockIDCode{2, ""}, nil},
}
for _, test := range tests {
s, err := storeService.Store(test.have)
if test.wantErr == nil {
assert.NoError(t, err, "No Err; for test: %#v", test)
assert.NotNil(t, s)
// assert.NotEmpty(t, s.Data.Code.String, "%#v", s.Data)
} else {
assert.Error(t, err, "Err for test: %#v", test)
assert.EqualError(t, test.wantErr, err.Error(), "EqualErr for test: %#v", test)
assert.Nil(t, s)
}
}
assert.False(t, storeService.IsCacheEmpty())
storeService.ClearCache()
assert.True(t, storeService.IsCacheEmpty())
}
func TestWithInitStoreByToken(t *testing.T) {
var newReq = func(i int) *http.Request {
req, err := http.NewRequest(httputil.MethodGet, fmt.Sprintf("https://corestore.io/store/list/%d", i), nil)
if err != nil {
t.Fatal(err)
}
return req
}
tests := []struct {
ctx context.Context
wantStoreCode string
wantErr error
}{
{store.WithContextReader(context.Background(), nil), "de", store.ErrContextServiceNotFound},
{store.WithContextReader(context.Background(), getInitializedStoreService(scope.Option{Store: scope.MockCode("de")})), "de", ctxjwt.ErrContextJWTNotFound},
{newStoreServiceWithTokenCtx(scope.Option{Store: scope.MockCode("de")}, "de"), "de", nil},
{newStoreServiceWithTokenCtx(scope.Option{Store: scope.MockCode("at")}, "ch"), "at", store.ErrStoreNotActive},
{newStoreServiceWithTokenCtx(scope.Option{Store: scope.MockCode("de")}, "at"), "at", nil},
{newStoreServiceWithTokenCtx(scope.Option{Store: scope.MockCode("de")}, "a$t"), "de", store.ErrStoreCodeInvalid},
{newStoreServiceWithTokenCtx(scope.Option{Store: scope.MockCode("at")}, ""), "at", store.ErrStoreCodeInvalid},
{newStoreServiceWithTokenCtx(scope.Option{Group: scope.MockID(1)}, "de"), "de", nil},
{newStoreServiceWithTokenCtx(scope.Option{Group: scope.MockID(1)}, "ch"), "at", store.ErrStoreNotActive},
{newStoreServiceWithTokenCtx(scope.Option{Group: scope.MockID(1)}, " ch"), "at", store.ErrStoreCodeInvalid},
{newStoreServiceWithTokenCtx(scope.Option{Group: scope.MockID(1)}, "uk"), "at", store.ErrStoreChangeNotAllowed},
{newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, "uk"), "au", store.ErrStoreChangeNotAllowed},
{newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, "nz"), "nz", nil},
{newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, "n z"), "au", store.ErrStoreCodeInvalid},
{newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, "au"), "au", nil},
{newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, ""), "au", store.ErrStoreCodeInvalid},
}
for i, test := range tests {
mw := store.WithInitStoreByToken()(finalInitStoreHandler(t, test.wantStoreCode))
rec := httptest.NewRecorder()
surfErr := mw.ServeHTTPContext(test.ctx, rec, newReq(i))
if test.wantErr != nil {
assert.EqualError(t, surfErr, test.wantErr.Error(), "Index %d", i)
continue
}
assert.NoError(t, surfErr, "Index %d", i)
}
}
func TestStorageStore(t *testing.T) {
tests := []struct {
have scope.StoreIDer
err error
wantCode string
}{
{nil, store.ErrStoreNotFound, ""},
{scope.MockID(2015), store.ErrIDNotFoundTableStoreSlice, ""},
{scope.MockID(1), nil, "de"},
{scope.MockCode("asia"), store.ErrIDNotFoundTableStoreSlice, ""},
{scope.MockCode("nz"), nil, "nz"},
{mockIDCode{4, "nz"}, nil, "nz"},
{mockIDCode{4, "auuuuu"}, store.ErrIDNotFoundTableStoreSlice, ""},
}
for i, test := range tests {
s, err := testStorage.Store(test.have)
if test.err != nil {
assert.Nil(t, s, "%#v", test)
assert.EqualError(t, err, test.err.Error(), "Index: %d", i)
} else {
assert.NotNil(t, s, "%#v", test)
assert.NoError(t, err, "%#v", test)
assert.Equal(t, test.wantCode, s.Data.Code.String)
}
}
s, err := testStorage.Store(scope.MockCode("at"))
assert.NoError(t, err)
assert.NotNil(t, s)
assert.EqualValues(t, "DACH Group", s.Group.Data.Name)
assert.EqualValues(t, "euro", s.Website.Data.Code.String)
wg, err := s.Website.DefaultGroup()
assert.NotNil(t, wg)
assert.EqualValues(t, "DACH Group", wg.Data.Name)
wgs, err := wg.DefaultStore()
assert.NoError(t, err)
assert.EqualValues(t, "at", wgs.Data.Code.String)
}
func TestStorageWebsite(t *testing.T) {
tests := []struct {
have scope.WebsiteIDer
err error
wantWCode string
}{
{nil, store.ErrWebsiteNotFound, ""},
{scope.MockID(2015), store.ErrIDNotFoundTableWebsiteSlice, ""},
{scope.MockID(1), nil, "euro"},
{scope.MockCode("asia"), store.ErrIDNotFoundTableWebsiteSlice, ""},
{scope.MockCode("oz"), nil, "oz"},
{mockIDCode{1, "oz"}, nil, "oz"},
{mockIDCode{1, "ozzz"}, store.ErrIDNotFoundTableWebsiteSlice, ""},
}
for _, test := range tests {
w, err := testStorage.Website(test.have)
if test.err != nil {
assert.Nil(t, w)
assert.EqualError(t, test.err, err.Error())
} else {
assert.NotNil(t, w, "Test: %#v", test)
assert.NoError(t, err, "Test: %#v", test)
assert.Equal(t, test.wantWCode, w.Data.Code.String, "Test: %#v", test)
}
}
w, err := testStorage.Website(scope.MockCode("euro"))
assert.NoError(t, err)
assert.NotNil(t, w)
dGroup, err := w.DefaultGroup()
assert.NoError(t, err)
assert.EqualValues(t, "DACH Group", dGroup.Data.Name)
assert.NotNil(t, w.Groups)
assert.EqualValues(t, util.Int64Slice{1, 2}, w.Groups.IDs())
assert.NotNil(t, w.Stores)
assert.EqualValues(t, util.StringSlice{"de", "uk", "at", "ch"}, w.Stores.Codes())
}
// MBA mid 2012 CPU: Intel Core i5-3427U CPU @ 1.80GHz
// BenchmarkStorageGroupGetDefaultStore 1000000 1916 ns/op 464 B/op 14 allocs/op
// BenchmarkStorageGroupGetDefaultStore-4 300000 5387 ns/op 2880 B/op 64 allocs/op
func BenchmarkStorageGroupGetDefaultStore(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
var err error
benchmarkStorageGroup, err = testStorage.Group(scope.MockID(3))
if err != nil {
b.Error(err)
}
benchmarkStorageGroupDefaultStore, err = benchmarkStorageGroup.DefaultStore()
if err != nil {
b.Error(err)
}
}
}
// Group creates a new Group which contains all related stores and its website according to the
// interface definition.
func (st *Storage) Group(id scope.GroupIDer) (*Group, error) {
g, err := st.group(id)
if err != nil {
return nil, errgo.Mask(err)
}
w, err := st.website(scope.MockID(g.WebsiteID))
if err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("store.Storage.Group.website", "err", err, "websiteID", g.WebsiteID, "groupID", id.GroupID())
}
return nil, errgo.Mask(err)
}
return NewGroup(g, SetGroupConfig(st.cr), SetGroupWebsite(w), SetGroupStores(st.stores, nil))
}
func TestStorageGroup(t *testing.T) {
tests := []struct {
id scope.GroupIDer
err error
wantName string
}{
{nil, store.ErrGroupNotFound, ""},
{scope.MockID(2015), store.ErrIDNotFoundTableGroupSlice, ""},
{scope.MockID(1), nil, "DACH Group"},
}
for _, test := range tests {
g, err := testStorage.Group(test.id)
if test.err != nil {
assert.Nil(t, g)
assert.EqualError(t, err, test.err.Error())
} else {
assert.NotNil(t, g)
assert.NoError(t, err)
assert.Equal(t, test.wantName, g.Data.Name)
}
}
g, err := testStorage.Group(scope.MockID(3))
assert.NoError(t, err)
assert.NotNil(t, g)
dStore, err := g.DefaultStore()
assert.NoError(t, err)
assert.EqualValues(t, "au", dStore.Data.Code.String)
assert.EqualValues(t, "oz", g.Website.Data.Code.String)
assert.NotNil(t, g.Stores)
assert.EqualValues(t, util.StringSlice{"au", "nz"}, g.Stores.Codes())
}
func TestWithInitStoreByToken_EqualPointers(t *testing.T) {
// this Test is related to Benchmark_WithInitStoreByToken
// The returned pointers from store.FromContextReader must be the
// same for each request with the same request pattern.
ctx := newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, "nz")
rec := httptest.NewRecorder()
req, err := http.NewRequest(httputil.MethodGet, "https://corestore.io/store/list", nil)
if err != nil {
t.Fatal(err)
}
var equalStorePointer *store.Store
mw := store.WithInitStoreByToken()(ctxhttp.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
_, haveReqStore, err := store.FromContextReader(ctx)
if err != nil {
return err
}
if equalStorePointer == nil {
equalStorePointer = haveReqStore
}
if "nz" != haveReqStore.StoreCode() {
t.Errorf("Have: %s\nWant: nz", haveReqStore.StoreCode())
}
wantP := reflect.ValueOf(equalStorePointer)
haveP := reflect.ValueOf(haveReqStore)
if wantP.Pointer() != haveP.Pointer() {
t.Errorf("Expecting equal pointers for each request.\nWant: %p\nHave: %p", equalStorePointer, haveReqStore)
}
return nil
}))
for i := 0; i < 10; i++ {
if err := mw.ServeHTTPContext(ctx, rec, req); err != nil {
t.Error(err)
}
}
}
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())
}
// Groups creates a new group slice containing its website all related stores.
// May panic when a website pointer is nil.
func (st *Storage) Groups() (GroupSlice, error) {
groups := make(GroupSlice, len(st.groups), len(st.groups))
for i, g := range st.groups {
w, err := st.website(scope.MockID(g.WebsiteID))
if err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("store.Storage.Groups.website", "err", err, "g", g, "websiteID", g.WebsiteID)
}
return nil, errgo.Mask(err)
}
groups[i], err = NewGroup(g, SetGroupConfig(st.cr), SetGroupWebsite(w), SetGroupStores(st.stores, nil))
if err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("store.Storage.Groups.NewGroup", "err", err, "g", g, "websiteID", g.WebsiteID)
}
return nil, errgo.Mask(err)
}
}
return groups, nil
}
// Benchmark_WithInitStoreByToken-4 100000 17297 ns/op 9112 B/op 203 allocs/op => old bug
// Benchmark_WithInitStoreByToken-4 2000000 810 ns/op 128 B/op 5 allocs/op => new
func Benchmark_WithInitStoreByToken(b *testing.B) {
// see TestWithInitStoreByToken_Alloc_Investigations_TEMP
b.ReportAllocs()
wantStoreCode := "nz"
ctx := newStoreServiceWithTokenCtx(scope.Option{Website: scope.MockID(2)}, wantStoreCode)
mw := store.WithInitStoreByToken()(benchValidationHandler(b, wantStoreCode))
rec := httptest.NewRecorder()
req, err := http.NewRequest(httputil.MethodGet, "https://corestore.io/store/list/", nil)
if err != nil {
b.Fatal(err)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
if err := mw.ServeHTTPContext(ctx, rec, req); err != nil {
b.Error(err)
}
}
}
func TestNewServiceRequestedStore_ScopeStore(t *testing.T) {
initScope := scope.Option{Store: scope.MockID(1)}
sm := getInitializedStoreService(initScope)
if haveStore, haveErr := sm.RequestedStore(initScope); haveErr != nil {
t.Fatal(haveErr)
} else {
assert.NoError(t, haveErr)
assert.Exactly(t, int64(1), haveStore.StoreID())
}
if s, err := sm.Store(); err == nil {
assert.EqualValues(t, "de", s.Data.Code.String)
} else {
assert.EqualError(t, err, store.ErrStoreNotFound.Error())
t.Fail()
}
if s, err := sm.Store(scope.MockID(123)); err == nil {
assert.Error(t, err)
t.Fail()
} else {
assert.Nil(t, s)
assert.EqualError(t, err, store.ErrIDNotFoundTableStoreSlice.Error())
}
tests := []testNewServiceRequestedStore{
{scope.Option{Store: scope.MockID(232)}, "", store.ErrIDNotFoundTableStoreSlice},
{scope.Option{}, "de", scope.ErrUnsupportedScopeID},
{scope.Option{Store: scope.MockCode("\U0001f631")}, "", store.ErrIDNotFoundTableStoreSlice},
{scope.Option{Store: scope.MockID(6)}, "nz", nil},
{scope.Option{Store: scope.MockCode("ch")}, "", store.ErrStoreNotActive},
{scope.Option{Store: scope.MockCode("nz")}, "nz", nil},
{scope.Option{Store: scope.MockCode("de")}, "de", nil},
{scope.Option{Store: scope.MockID(2)}, "at", nil},
{scope.Option{Store: scope.MockID(2)}, "at", nil},
{scope.Option{Store: scope.MockCode("au")}, "au", nil},
{scope.Option{Store: scope.MockCode("ch")}, "", store.ErrStoreNotActive},
}
runTestsRequestedStore(t, sm, tests)
}
func initStore() {
store.PkgLog = log.NewStdLogger(
log.SetStdDebug(&testDebugLogBuf, "testErr: ", std.Lshortfile),
)
store.PkgLog.SetLevel(log.StdLevelDebug)
testStoreService = store.MustNewService(
scope.Option{
Website: scope.MockID(1), // bound to website ID 1 = Europe
},
store.MustNewStorage(
// Storage gets usually loaded from the database tables containing
// website, group and store. For the sake of this example the storage
// is hard coded.
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},
&store.TableStore{StoreID: 6, Code: dbr.NewNullString("nz"), WebsiteID: 2, GroupID: 3, Name: "Kiwi", SortOrder: 30, IsActive: true},
&store.TableStore{IsActive: false, StoreID: 3, Code: dbr.NewNullString("ch"), WebsiteID: 1, GroupID: 1, Name: "Schweiz", SortOrder: 30},
),
),
)
}
func TestMockID(t *testing.T) {
var e int64 = 29
assert.Equal(t, e, scope.MockID(29).StoreID())
assert.Equal(t, e, scope.MockID(29).GroupID())
assert.Equal(t, e, scope.MockID(29).WebsiteID())
}
assert.Exactly(t, wantStoreCode, haveReqStore.StoreCode())
return nil
}
}
var testsMWInitByFormCookie = []struct {
req *http.Request
haveSO scope.Option
wantStoreCode string // this is the default store in a scope, lookup in getInitializedStoreService
wantErr error
wantCookie string // the newly set cookie
wantLog string
}{
{
getMWTestRequest("GET", "http://cs.io", &http.Cookie{Name: store.ParamName, Value: "uk"}),
scope.Option{Store: scope.MockID(1)}, "uk", nil, store.ParamName + "=uk;", store.ErrStoreCodeInvalid.Error(),
},
{
getMWTestRequest("GET", "http://cs.io/?"+store.HTTPRequestParamStore+"=uk", nil),
scope.Option{Store: scope.MockID(1)}, "uk", nil, store.ParamName + "=uk;", "", // generates a new 1year valid cookie
},
{
getMWTestRequest("GET", "http://cs.io/?"+store.HTTPRequestParamStore+"=%20uk", nil),
scope.Option{Store: scope.MockID(1)}, "de", nil, "", store.ErrStoreCodeInvalid.Error(),
},
{
getMWTestRequest("GET", "http://cs.io", &http.Cookie{Name: store.ParamName, Value: "de"}),
scope.Option{Group: scope.MockID(1)}, "de", nil, store.ParamName + "=de;", store.ErrStoreCodeInvalid.Error(),
},
{
getMWTestRequest("GET", "http://cs.io", nil),
// Benchmark_WithInitStoreByFormCookie-4 3000 481881 ns/op 189103 B/op 232 allocs/op => with debug enabled
// Benchmark_WithInitStoreByFormCookie-4 300000 4797 ns/op 1016 B/op 16 allocs/op => debug disabled
func Benchmark_WithInitStoreByFormCookie(b *testing.B) {
store.PkgLog.SetLevel(log.StdLevelInfo)
b.ReportAllocs()
wantStoreCode := "nz"
ctx := store.WithContextReader(context.Background(), getInitializedStoreService(scope.Option{Website: scope.MockID(2)}))
mw := store.WithInitStoreByFormCookie()(benchValidationHandler(b, wantStoreCode))
rec := httptest.NewRecorder()
req, err := http.NewRequest(httputil.MethodGet, "https://corestore.io/store/list/", nil)
if err != nil {
b.Fatal(err)
}
req.AddCookie(&http.Cookie{
Name: store.ParamName,
Value: wantStoreCode,
})
b.ResetTimer()
for i := 0; i < b.N; i++ {
if err := mw.ServeHTTPContext(ctx, rec, req); err != nil {
b.Error(err)
}
}
}