func TestPager_Basic(t *testing.T) {
total := rand.Intn(10000) + 1
offset := rand.Intn(10000) + 1
limit := rand.Intn(10000) + 1
p1 := store.NewPager()
p1.SetTotal(total)
p1.SetLimit(limit, offset)
data, err := json.Marshal(p1)
if err != nil {
t.Errorf("marshal error: %#v", err.Error())
}
p2 := store.NewPager()
err = json.Unmarshal(data, &p2)
if err != nil {
t.Errorf("unmarshal error: %#v", err.Error())
}
if want, have := total, p2.GetTotal(); want != have {
t.Errorf("total want: %#v, got: %#v", want, have)
}
limit2, offset2 := p2.GetLimit()
if want, have := limit, limit2; want != have {
t.Errorf("limit want: %#v, got: %#v", want, have)
}
if want, have := offset, offset2; want != have {
t.Errorf("offset want: %#v, got: %#v", want, have)
}
}
func TestPager_Partial(t *testing.T) {
p1 := store.NewPager().SetTotal(rand.Intn(10000) + 1)
if err := testPagerHasOnly(p1, "total"); err != nil {
t.Error(err)
}
p2 := store.NewPager().SetLimit(
rand.Intn(10000)+1, rand.Intn(10000)+1)
if err := testPagerHasOnly(p2, "limit", "offset"); err != nil {
t.Error(err)
}
}
// UserStoreEndpoints return CURD endpoints for UserStore
func UserStoreEndpoints(noun, nounp string) (endpoints map[string]endpoint.Endpoint) {
// variables to use later
allocEntityList := func() *[]User { return &[]User{} }
storeKey := KeyUser
getStore := func(ctx context.Context) (s *UserStore, err error) {
raw, err := store.Get(ctx, storeKey)
if err != nil {
return
}
s, ok := raw.(*UserStore)
if !ok {
err = fmt.Errorf("store.Get(\"UserStore\") does not return *UserStore")
return
}
return
}
// store endpoints here
// TODO: may have new struct to store
endpoints = make(map[string]endpoint.Endpoint)
endpoints["create"] = func(ctx context.Context, e interface{}) (res interface{}, err error) {
// get context information
r := gourdctx.HTTPRequest(ctx)
if r == nil {
serr := store.ErrorInternal
serr.ServerMsg = "missing request in context"
err = serr
return
}
// get store
s, err := getStore(ctx)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error obtaining %s store (%s)", storeKey, err)
err = serr
return
}
defer s.Close()
// create entity
err = s.Create(nil, e)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf(
"error creating %s: %#v, entity: %#v", noun, err.Error(), e)
err = serr
return
}
// encode response
res = map[string]interface{}{
nounp: &[]User{*e.(*User)},
}
return
}
endpoints["retrieve"] = func(ctx context.Context, request interface{}) (res interface{}, err error) {
sReq := request.(*httpservice.Request)
q := sReq.Query
// get context information
r := gourdctx.HTTPRequest(ctx)
if r == nil {
serr := store.ErrorInternal
serr.ServerMsg = "missing request in context"
err = serr
return
}
// get store
s, err := getStore(ctx)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error obtaining %s store (%s)", storeKey, err)
err = serr
return
}
defer s.Close()
// allocate memory for variables
el := allocEntityList()
// retrieve
err = s.Search(q).All(el)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error searching %s: %s",
noun, err)
err = serr
return
}
// encode response
if s.Len(el) == 0 {
err = store.ErrorNotFound
return
}
res = map[string]interface{}{
nounp: el,
}
return
}
endpoints["list"] = func(ctx context.Context, request interface{}) (res interface{}, err error) {
sReq := request.(*httpservice.Request)
q := sReq.Query
// get context information
r := gourdctx.HTTPRequest(ctx)
if r == nil {
serr := store.ErrorInternal
serr.ServerMsg = "missing request in context"
err = serr
return
}
// get store
s, err := getStore(ctx)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error obtaining %s store (%s)", storeKey, err)
err = serr
return
}
defer s.Close()
// allocate memory for variables
el := allocEntityList()
results := s.Search(q)
count, err := results.Count()
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error counting %s: %s",
noun, err)
err = serr
return
}
err = results.All(el)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error searching %s: %s",
noun, err)
err = serr
return
}
// TODO: need to fix overflow error of pager variables
res = map[string]interface{}{
nounp: el,
"paging": store.NewPager().
SetTotal(int(count)).
SetLimit(int(q.GetLimit()), int(q.GetOffset())),
}
return
}
endpoints["update"] = func(ctx context.Context, request interface{}) (res interface{}, err error) {
sReq := request.(*httpservice.Request)
q := sReq.Query
e := sReq.Payload
cond := q.GetConds()
// get context information
r := gourdctx.HTTPRequest(ctx)
if r == nil {
serr := store.ErrorInternal
serr.ServerMsg = "missing request in context"
err = serr
return
}
// get store
s, err := getStore(ctx)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error obtaining %s store (%s)", storeKey, err)
err = serr
return
}
defer s.Close()
// update entity
if err = s.Update(cond, e); err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf(
"error encoding %s list: %s",
noun, err)
err = serr
return
}
res = map[string]interface{}{
nounp: &[]User{*e.(*User)},
}
return
}
endpoints["delete"] = func(ctx context.Context, request interface{}) (res interface{}, err error) {
// allocate memory for variables
el := allocEntityList()
// store query of id
sReq := request.(*httpservice.Request)
q := sReq.Query
cond := q.GetConds()
// get context information
r := gourdctx.HTTPRequest(ctx)
if r == nil {
serr := store.ErrorInternal
serr.ServerMsg = "missing request in context"
err = serr
return
}
// get store
s, err := getStore(ctx)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error obtaining %s store (%s)", storeKey, err)
err = serr
return
}
defer s.Close()
// find the content of the id
err = s.Search(q).All(el)
if err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf("error searching %s: %s",
noun, err)
err = serr
return
}
// delete entity
if err = s.Delete(cond); err != nil {
serr := store.ErrorInternal
serr.ServerMsg = fmt.Sprintf(
"error encoding %s list: %s",
noun, err)
err = serr
return
}
res = map[string]interface{}{
nounp: el,
}
return
}
return
}
