You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
893 lines
23 KiB
893 lines
23 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"go-common/app/interface/main/esports/model" |
|
arcmdl "go-common/app/service/main/archive/api" |
|
"testing" |
|
|
|
"github.com/smartystreets/goconvey/convey" |
|
) |
|
|
|
func TestDaokeyCale(t *testing.T) { |
|
convey.Convey("keyCale", t, func(ctx convey.C) { |
|
var ( |
|
stime = "" |
|
etime = "" |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyCale(stime, etime) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyCont(t *testing.T) { |
|
convey.Convey("keyCont", t, func(ctx convey.C) { |
|
var ( |
|
ps = int(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyCont(ps) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyVideo(t *testing.T) { |
|
convey.Convey("keyVideo", t, func(ctx convey.C) { |
|
var ( |
|
ps = int(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyVideo(ps) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyContID(t *testing.T) { |
|
convey.Convey("keyContID", t, func(ctx convey.C) { |
|
var ( |
|
cid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyContID(cid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyCoFav(t *testing.T) { |
|
convey.Convey("keyCoFav", t, func(ctx convey.C) { |
|
var ( |
|
mid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyCoFav(mid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyCoAppFav(t *testing.T) { |
|
convey.Convey("keyCoAppFav", t, func(ctx convey.C) { |
|
var ( |
|
mid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyCoAppFav(mid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeySID(t *testing.T) { |
|
convey.Convey("keySID", t, func(ctx convey.C) { |
|
var ( |
|
sid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keySID(sid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyMatchAct(t *testing.T) { |
|
convey.Convey("keyMatchAct", t, func(ctx convey.C) { |
|
var ( |
|
aid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyMatchAct(aid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyMatchModule(t *testing.T) { |
|
convey.Convey("keyMatchModule", t, func(ctx convey.C) { |
|
var ( |
|
mmid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyMatchModule(mmid) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyKnock(t *testing.T) { |
|
convey.Convey("keyKnock", t, func(ctx convey.C) { |
|
var ( |
|
mdID = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyKnock(mdID) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyTop(t *testing.T) { |
|
convey.Convey("keyTop", t, func(ctx convey.C) { |
|
var ( |
|
aid = int64(1) |
|
ps = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyTop(aid, ps) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaokeyPoint(t *testing.T) { |
|
convey.Convey("keyPoint", t, func(ctx convey.C) { |
|
var ( |
|
aid = int64(1) |
|
mdID = int64(1) |
|
ps = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := keyPoint(aid, mdID, ps) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoFMatCache(t *testing.T) { |
|
convey.Convey("FMatCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.FMatCache(c) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoFVideoCache(t *testing.T) { |
|
convey.Convey("FVideoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.FVideoCache(c) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaofilterCache(t *testing.T) { |
|
convey.Convey("filterCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "1" |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.filterCache(c, key) |
|
ctx.Convey("Then err should be nil.rs should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetFMatCache(t *testing.T) { |
|
convey.Convey("SetFMatCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
fs map[string][]*model.Filter |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetFMatCache(c, fs) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetFVideoCache(t *testing.T) { |
|
convey.Convey("SetFVideoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
fs map[string][]*model.Filter |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetFVideoCache(c, fs) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaosetFilterCache(t *testing.T) { |
|
convey.Convey("setFilterCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "" |
|
fs map[string][]*model.Filter |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.setFilterCache(c, key, fs) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoContestCache(t *testing.T) { |
|
convey.Convey("ContestCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ps = int(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.ContestCache(c, ps) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoFavCoCache(t *testing.T) { |
|
convey.Convey("FavCoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.FavCoCache(c, mid) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoFavCoAppCache(t *testing.T) { |
|
convey.Convey("FavCoAppCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.FavCoAppCache(c, mid) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaocosCache(t *testing.T) { |
|
convey.Convey("cosCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "1" |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.cosCache(c, key) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetContestCache(t *testing.T) { |
|
convey.Convey("SetContestCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ps = int(1) |
|
con = &model.Contest{} |
|
contests = []*model.Contest{con} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetContestCache(c, ps, contests, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetFavCoCache(t *testing.T) { |
|
convey.Convey("SetFavCoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mid = int64(0) |
|
con = &model.Contest{} |
|
contests = []*model.Contest{con} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetFavCoCache(c, mid, contests, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetAppFavCoCache(t *testing.T) { |
|
convey.Convey("SetAppFavCoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mid = int64(0) |
|
con = &model.Contest{} |
|
contests = []*model.Contest{con} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetAppFavCoCache(c, mid, contests, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoDelFavCoCache(t *testing.T) { |
|
convey.Convey("DelFavCoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mid = int64(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.DelFavCoCache(c, mid) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaosetCosCache(t *testing.T) { |
|
convey.Convey("setCosCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "" |
|
con = &model.Contest{} |
|
contests = []*model.Contest{con} |
|
total = int(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.setCosCache(c, key, contests, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoCalendarCache(t *testing.T) { |
|
convey.Convey("CalendarCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
p = &model.ParamFilter{} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.CalendarCache(c, p) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetCalendarCache(t *testing.T) { |
|
convey.Convey("SetCalendarCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
p = &model.ParamFilter{} |
|
cal = &model.Calendar{} |
|
cales = []*model.Calendar{cal} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetCalendarCache(c, p, cales) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoVideoCache(t *testing.T) { |
|
convey.Convey("VideoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ps = int(1) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.VideoCache(c, ps) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetVideoCache(t *testing.T) { |
|
convey.Convey("SetVideoCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ps = int(0) |
|
arc = &arcmdl.Arc{} |
|
videos = []*arcmdl.Arc{arc} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetVideoCache(c, ps, videos, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoseasonsCache(t *testing.T) { |
|
convey.Convey("seasonsCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "1" |
|
start = int(0) |
|
end = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.seasonsCache(c, key, start, end) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaosetSeasonsCache(t *testing.T) { |
|
convey.Convey("setSeasonsCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
key = "1" |
|
seasons = []*model.Season{} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.setSeasonsCache(c, key, seasons, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSeasonCache(t *testing.T) { |
|
convey.Convey("SeasonCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
start = int(0) |
|
end = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.SeasonCache(c, start, end) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetSeasonCache(t *testing.T) { |
|
convey.Convey("SetSeasonCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
seasons = []*model.Season{} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetSeasonCache(c, seasons, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSeasonMCache(t *testing.T) { |
|
convey.Convey("SeasonMCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
start = int(0) |
|
end = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.SeasonMCache(c, start, end) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoSetSeasonMCache(t *testing.T) { |
|
convey.Convey("SetSeasonMCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
seasons = []*model.Season{} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.SetSeasonMCache(c, seasons, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaofrom(t *testing.T) { |
|
convey.Convey("from", t, func(ctx convey.C) { |
|
var ( |
|
i = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := from(i) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaocombine(t *testing.T) { |
|
convey.Convey("combine", t, func(ctx convey.C) { |
|
var ( |
|
sort = int64(0) |
|
count = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
p1 := combine(sort, count) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoCacheEpContests(t *testing.T) { |
|
convey.Convey("CacheEpContests", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ids = []int64{1} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
res, err := d.CacheEpContests(c, ids) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(res, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddCacheEpContests(t *testing.T) { |
|
convey.Convey("AddCacheEpContests", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
data map[int64]*model.Contest |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddCacheEpContests(c, data) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoCacheEpSeasons(t *testing.T) { |
|
convey.Convey("CacheEpSeasons", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
ids = []int64{1} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
res, err := d.CacheEpSeasons(c, ids) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(res, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddCacheEpSeasons(t *testing.T) { |
|
convey.Convey("AddCacheEpSeasons", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
data map[int64]*model.Season |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddCacheEpSeasons(c, data) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetActPageCache(t *testing.T) { |
|
convey.Convey("GetActPageCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
id = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.GetActPageCache(c, id) |
|
ctx.Convey("Then err should be nil.act should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddActPageCache(t *testing.T) { |
|
convey.Convey("AddActPageCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(0) |
|
act = &model.ActivePage{} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddActPageCache(c, aid, act) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetActModuleCache(t *testing.T) { |
|
convey.Convey("GetActModuleCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mmid = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.GetActModuleCache(c, mmid) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddActModuleCache(t *testing.T) { |
|
convey.Convey("AddActModuleCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mmid = int64(0) |
|
module []*arcmdl.Arc |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddActModuleCache(c, mmid, module) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetActTopCache(t *testing.T) { |
|
convey.Convey("GetActTopCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(0) |
|
ps = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.GetActTopCache(c, aid, ps) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddActTopCache(t *testing.T) { |
|
convey.Convey("AddActTopCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(0) |
|
ps = int64(0) |
|
con = &model.Contest{} |
|
tops = []*model.Contest{con} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddActTopCache(c, aid, ps, tops, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetActPointsCache(t *testing.T) { |
|
convey.Convey("GetActPointsCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(0) |
|
mdID = int64(0) |
|
ps = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, total, err := d.GetActPointsCache(c, aid, mdID, ps) |
|
ctx.Convey("Then err should be nil.res,total should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(total, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddActPointsCache(t *testing.T) { |
|
convey.Convey("AddActPointsCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(0) |
|
mdID = int64(0) |
|
ps = int64(0) |
|
con = &model.Contest{} |
|
points = []*model.Contest{con} |
|
total = int(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddActPointsCache(c, aid, mdID, ps, points, total) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetActKnockoutCache(t *testing.T) { |
|
convey.Convey("GetActKnockoutCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mdID = int64(0) |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
_, err := d.GetActKnockoutCache(c, mdID) |
|
ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddActKnockoutCache(t *testing.T) { |
|
convey.Convey("AddActKnockoutCache", t, func(ctx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mdID = int64(0) |
|
knock = [][]*model.TreeList{} |
|
) |
|
ctx.Convey("When everything goes positive", func(ctx convey.C) { |
|
err := d.AddActKnockoutCache(c, mdID, knock) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
func TestDaoAddActKnockCacheTime(t *testing.T) { |
|
convey.Convey("AddActKnockCacheTime", t, func(convCtx convey.C) { |
|
var ( |
|
c = context.Background() |
|
mdID = int64(1) |
|
) |
|
convCtx.Convey("When everything goes positive", func(convCtx convey.C) { |
|
err := d.AddActKnockCacheTime(c, mdID) |
|
convCtx.Convey("Then err should be nil.", func(convCtx convey.C) { |
|
convCtx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoGetMActCache(t *testing.T) { |
|
convey.Convey("GetMActCache", t, func(convCtx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(1) |
|
) |
|
convCtx.Convey("When everything goes positive", func(convCtx convey.C) { |
|
res, err := d.GetMActCache(c, aid) |
|
convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) { |
|
convCtx.So(err, convey.ShouldBeNil) |
|
println(res) |
|
}) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDaoAddMActCache(t *testing.T) { |
|
convey.Convey("AddMActCache", t, func(convCtx convey.C) { |
|
var ( |
|
c = context.Background() |
|
aid = int64(1) |
|
act = &model.Active{} |
|
) |
|
convCtx.Convey("When everything goes positive", func(convCtx convey.C) { |
|
err := d.AddMActCache(c, aid, act) |
|
convCtx.Convey("Then err should be nil.", func(convCtx convey.C) { |
|
convCtx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
}) |
|
}
|
|
|