func TestDefaultStoreView(t *testing.T) {
st, err := testStorage.DefaultStoreView()
assert.NoError(t, err)
assert.EqualValues(t, "at", st.Data.Code.String)
var tst = store.NewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NullString{NullString: sql.NullString{String: "oz", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "OZ", Valid: true}}, SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: false, Valid: true}}},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NullString{NullString: sql.NullString{String: "au", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, 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},
),
)
dSt, err := tst.DefaultStoreView()
assert.Nil(t, dSt)
assert.EqualError(t, store.ErrStoreNotFound, err.Error())
var tst2 = store.NewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NullString{NullString: sql.NullString{String: "oz", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "OZ", Valid: true}}, SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: true, Valid: 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 TestStorageReInitError(t *testing.T) {
nsg, err := store.NewStorage(store.WithDatabaseInit(nil))
assert.Nil(t, nsg)
if assert.Error(t, err) {
assert.Contains(t, err.Error(), "dbr.SessionRunner is nil\n")
}
}
func getInitializedStoreService(so scope.Option) *store.Service {
return store.MustNewService(so,
store.NewStorage(
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 TestStorageReInit(t *testing.T) {
// quick implement, use mock of dbr.SessionRunner and remove connection
dbc := csdb.MustConnectTest()
defer func() { assert.NoError(t, dbc.Close()) }()
nsg := store.NewStorage(nil, nil, nil)
assert.NoError(t, nsg.ReInit(dbc.NewSession()))
stores, err := nsg.Stores()
assert.NoError(t, err)
assert.True(t, stores.Len() > 0, "Expecting at least one store loaded from DB")
for _, s := range stores {
assert.NotEmpty(t, s.Data.Code.String, "Store: %#v", s.Data)
}
groups, err := nsg.Groups()
assert.True(t, groups.Len() > 0, "Expecting at least one group loaded from DB")
assert.NoError(t, err)
for _, g := range groups {
assert.NotEmpty(t, g.Data.Name, "Group: %#v", g.Data)
}
websites, err := nsg.Websites()
assert.True(t, websites.Len() > 0, "Expecting at least one website loaded from DB")
assert.NoError(t, err)
for _, w := range websites {
assert.NotEmpty(t, w.Data.Code.String, "Website: %#v", w.Data)
}
}
func TestStorageStoreErrors(t *testing.T) {
var nsw = store.NewStorage(
store.SetStorageWebsites(),
store.SetStorageGroups(),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NullString{NullString: sql.NullString{String: "au", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, 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},
),
)
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.NewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 2, Code: dbr.NullString{NullString: sql.NullString{String: "oz", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "OZ", Valid: true}}, SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: false, Valid: true}}},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 13, WebsiteID: 12, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 4},
),
store.SetStorageStores(
&store.TableStore{StoreID: 4, Code: dbr.NullString{NullString: sql.NullString{String: "au", Valid: true}}, WebsiteID: 2, GroupID: 3, Name: "Australia", SortOrder: 10, 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},
),
)
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 TestNewManagerReInit(t *testing.T) {
t.Skip(TODO_Better_Test_Data)
// quick implement, use mock of dbr.SessionRunner and remove connection
dbc := csdb.MustConnectTest()
defer dbc.Close()
dbrSess := dbc.NewSession()
storeManager := store.NewManager(store.NewStorage(nil /* trick it*/))
if err := storeManager.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},
{nil, store.ErrAppStoreNotSet}, // if set returns default store
}
for _, test := range tests {
s, err := storeManager.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, storeManager.IsCacheEmpty())
storeManager.ClearCache()
assert.True(t, storeManager.IsCacheEmpty())
}
func TestStorageGroupNoWebsite(t *testing.T) {
var tst = store.NewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 21, Code: dbr.NullString{NullString: sql.NullString{String: "oz", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "OZ", Valid: true}}, SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: false, Valid: true}}},
),
store.SetStorageGroups(
&store.TableGroup{GroupID: 3, WebsiteID: 2, Name: "Australia", RootCategoryID: 2, DefaultStoreID: 5},
),
store.SetStorageStores(
&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: 6, Code: dbr.NullString{NullString: sql.NullString{String: "nz", Valid: true}}, 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 TestStorageReInit(t *testing.T) {
numCPU := runtime.NumCPU()
prevCPU := runtime.GOMAXPROCS(numCPU)
t.Logf("GOMAXPROCS was: %d now: %d", prevCPU, numCPU)
defer runtime.GOMAXPROCS(prevCPU)
// quick implement, use mock of dbr.SessionRunner and remove connection
db := csdb.MustConnectTest()
defer db.Close()
dbrConn := dbr.NewConnection(db, nil)
nsg := store.NewStorage(nil, nil, nil)
if err := nsg.ReInit(dbrConn.NewSession(nil)); err != nil {
t.Error(err)
}
stores, err := nsg.Stores()
assert.NoError(t, err)
assert.True(t, stores.Len() > 0, "Expecting at least one store loaded from DB")
for _, s := range stores {
assert.NotEmpty(t, s.Data().Code.String, "Store: %#v", s.Data())
}
groups, err := nsg.Groups()
assert.True(t, groups.Len() > 0, "Expecting at least one group loaded from DB")
assert.NoError(t, err)
for _, g := range groups {
assert.NotEmpty(t, g.Data().Name, "Group: %#v", g.Data())
}
websites, err := nsg.Websites()
assert.True(t, websites.Len() > 0, "Expecting at least one website loaded from DB")
assert.NoError(t, err)
for _, w := range websites {
assert.NotEmpty(t, w.Data().Code.String, "Website: %#v", w.Data())
}
}
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.NewStorage(
// 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},
),
),
)
}
"github.com/corestoreio/csfw/store"
"github.com/corestoreio/csfw/utils"
"github.com/stretchr/testify/assert"
)
var testStorage = store.NewStorage(
store.SetStorageWebsites(
&store.TableWebsite{WebsiteID: 0, Code: dbr.NullString{NullString: sql.NullString{String: "admin", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "Admin", Valid: true}}, SortOrder: 0, DefaultGroupID: 0, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: false, Valid: true}}},
&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}}},
&store.TableWebsite{WebsiteID: 2, Code: dbr.NullString{NullString: sql.NullString{String: "oz", Valid: true}}, Name: dbr.NullString{NullString: sql.NullString{String: "OZ", Valid: true}}, SortOrder: 20, DefaultGroupID: 3, IsDefault: dbr.NullBool{NullBool: sql.NullBool{Bool: false, Valid: true}}},
),
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.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},
),
)
func TestStorageWebsite(t *testing.T) {
tests := []struct {
have scope.WebsiteIDer