Create & Init Project...

app/service/openplatform/abtest/http/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "group_test.go",
+        "http_test.go",
+        "stra_bench_test.go",
+        "stra_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/openplatform/abtest/conf:go_default_library",
+        "//app/service/openplatform/abtest/service:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "group.go",
+        "http.go",
+        "stra.go",
+    ],
+    importpath = "go-common/app/service/openplatform/abtest/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/openplatform/abtest/conf:go_default_library",
+        "//app/service/openplatform/abtest/model:go_default_library",
+        "//app/service/openplatform/abtest/model/validator:go_default_library",
+        "//app/service/openplatform/abtest/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/openplatform/abtest/http/group.go

@@ -0,0 +1,48 @@
+package http
+
+import (
+	"go-common/app/service/openplatform/abtest/model"
+	"go-common/app/service/openplatform/abtest/model/validator"
+	bm "go-common/library/net/http/blademaster"
+)
+
+//add group
+func addGroup(c *bm.Context) {
+	params := new(validator.AddGroupParams)
+	if err := c.Bind(params); err != nil {
+		return
+	}
+	g := model.Group{
+		Name: params.Name,
+		Desc: params.Desc,
+	}
+	c.JSON(abSvr.AddGroup(c, g))
+}
+
+//list group
+func listGroup(c *bm.Context) {
+	c.JSON(abSvr.ListGroup(c))
+}
+
+//update group
+func updateGroup(c *bm.Context) {
+	params := new(validator.UpdateGroupParams)
+	if err := c.Bind(params); err != nil {
+		return
+	}
+	g := model.Group{
+		ID:   params.ID,
+		Name: params.Name,
+		Desc: params.Desc,
+	}
+	c.JSON(abSvr.UpdateGroup(c, g))
+}
+
+//delete group
+func deleteGroup(c *bm.Context) {
+	params := new(validator.DeleteGroupParams)
+	if err := c.Bind(params); err != nil {
+		return
+	}
+	c.JSON(abSvr.DeleteGroup(c, params.ID))
+}

app/service/openplatform/abtest/http/group_test.go

@@ -0,0 +1,118 @@
+package http
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+const (
+	_getGroupListURL = "http://localhost:8801/openplatform/admin/abtest/group/list"
+	_AddGroupURL     = "http://localhost:8801/openplatform/admin/abtest/group/add"
+	_DelGroupURL     = "http://localhost:8801/openplatform/admin/abtest/group/delete"
+	_UpdateGroupURL  = "http://localhost:8801/openplatform/admin/abtest/group/update"
+)
+
+var agcs = []TestCase{
+	TestCase{tag: "TestAddGroup: valid parameters", testData: TestData{"name": "test", "desc": "test add"}, should: Shoulds{0}},
+	TestCase{tag: "TestAddGroup: empty parameters", testData: TestData{"name": "", "desc": ""}, should: Shoulds{-400}},
+	TestCase{tag: "TestAddGroup: no parameters", testData: TestData{}, should: Shoulds{-400}},
+}
+
+func TestAddGroup(t *testing.T) {
+	for _, td := range agcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _AddGroupURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+				Data int `json:"data"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+			if res.Code == 0 {
+				testID = res.Data
+			}
+		})
+	}
+}
+
+func TestUpdateGroup(t *testing.T) {
+	var ugcs = []TestCase{
+		TestCase{tag: "TestUpdateGroup: valid parameters", testData: TestData{"id": strconv.Itoa(testID), "name": "test", "desc": "test update"}, should: Shoulds{0}},
+		TestCase{tag: "TestUpdateGroup: empty parameters", testData: TestData{"id": "0", "name": "", "desc": ""}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateGroup: no parameters", testData: TestData{}, should: Shoulds{-400}},
+	}
+
+	for _, td := range ugcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _UpdateGroupURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+func TestDeleteGroup(t *testing.T) {
+	var dgcs = []TestCase{
+		TestCase{tag: "TestDeleteGroup: valid parameters", testData: TestData{"id": strconv.Itoa(testID), "name": "test", "desc": "test delete"}, should: Shoulds{0}},
+		TestCase{tag: "TestDeleteGroup: empty parameters", testData: TestData{"id": "0", "name": "", "desc": ""}, should: Shoulds{-400}},
+		TestCase{tag: "TestDeleteGroup: no parameters", testData: TestData{}, should: Shoulds{-400}},
+	}
+
+	for _, td := range dgcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _DelGroupURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+func TestListGroup(t *testing.T) {
+	Convey("TestListGroup: ", t, func() {
+		params := url.Values{}
+		req, _ := client.NewRequest("GET", _getGroupListURL, "127.0.0.1", params)
+		var res struct {
+			Code int `json:"code"`
+		}
+
+		if err := client.Do(context.TODO(), req, &res); err != nil {
+			t.Errorf("client.Do() error(%v)", err)
+			t.FailNow()
+		}
+		So(res.Code, ShouldEqual, 0)
+	})
+}

app/service/openplatform/abtest/http/http.go

@@ -0,0 +1,80 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/openplatform/abtest/conf"
+	"go-common/app/service/openplatform/abtest/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	abSvr *service.Service
+)
+
+// Init init account service.
+func Init(c *conf.Config, s *service.Service) {
+	abSvr = s
+	engineInner := bm.DefaultServer(c.BM.Inner)
+	innerRouter(engineInner)
+	// init Inner serve
+	if err := engineInner.Start(); err != nil {
+		log.Error("bm.DefaultServer error(%v)", err)
+		panic(err)
+	}
+	engineOuter := bm.DefaultServer(c.BM.Outer)
+	outerRouter(engineOuter)
+	// init Outer serve
+	if err := engineOuter.Start(); err != nil {
+		log.Error("bm.DefaultServer error(%v)", err)
+		panic(err)
+	}
+}
+
+// innerRouter init inner router api path.
+func innerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	group := e.Group("/openplatform/internal/abtest")
+	{
+		//common
+		group.GET("/versionid", versionID)
+		group.GET("/version", version)
+	}
+
+	group = e.Group("/openplatform/admin/abtest")
+	{
+		//mng abtest
+		group.GET("/list", listAb)
+		group.GET("/add", addAb)
+		group.GET("/update", updateAb)
+		group.GET("/status", updateStatus)
+		group.GET("/delete", deleteAb)
+	}
+
+	group = e.Group("/openplatform/admin/abtest/group")
+	{
+		//mng group
+		group.GET("/add", addGroup)
+		group.GET("/list", listGroup)
+		group.GET("/update", updateGroup)
+		group.GET("/delete", deleteGroup)
+	}
+
+	group = e.Group("/openplatform/admin/abtest/stat")
+	{
+		group.GET("/total", total)
+	}
+}
+
+// outerRouter init outer router.
+func outerRouter(e *bm.Engine) {
+}
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	if err := abSvr.Ping(c); err != nil {
+		log.Error("open-abtest http service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/service/openplatform/abtest/http/http_test.go

@@ -0,0 +1,24 @@
+package http
+
+import (
+	"flag"
+	"fmt"
+
+	"go-common/app/service/openplatform/abtest/conf"
+	"go-common/app/service/openplatform/abtest/service"
+	httpx "go-common/library/net/http/blademaster"
+
+	_ "github.com/smartystreets/goconvey/convey"
+)
+
+var client *httpx.Client
+
+func init() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(fmt.Errorf("conf.Init() error(%v)", err))
+	}
+	svr := service.New(conf.Conf)
+	client = httpx.NewClient(conf.Conf.HTTPClient.Read)
+	Init(conf.Conf, svr)
+}

app/service/openplatform/abtest/http/stra.go

@@ -0,0 +1,197 @@
+package http
+
+import (
+	"encoding/json"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/service/openplatform/abtest/model"
+	"go-common/app/service/openplatform/abtest/model/validator"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func versionID(c *bm.Context) {
+	params := new(validator.VerionParams)
+	if err := c.Bind(params); err != nil {
+		return
+	}
+	c.JSON(abSvr.VersionID(c, params.Group))
+}
+
+func version(c *bm.Context) {
+	var (
+		key      = c.Request.Form.Get("key")
+		verStr   = c.Request.Form.Get("version")
+		ver      = &model.Version{}
+		groupStr = c.Request.Form.Get("group")
+		appKey   = c.Request.Form.Get("appkey")
+		group    int
+		err      error
+	)
+	if verStr != "" {
+		if err = json.Unmarshal([]byte(verStr), ver); err != nil {
+			log.Warn("[http.stra|version] json.Unmarshal(%s) err: %v", verStr, err)
+		}
+	}
+	if groupStr != "" {
+		if group, err = strconv.Atoi(groupStr); err != nil {
+			log.Warn("[http.stra|version] strconv.Atoi(group:%s) err: %v", groupStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	c.JSON(abSvr.Version(c, group, key, ver, appKey))
+}
+
+func listAb(c *bm.Context) {
+	var (
+		params = new(validator.ListParams)
+		data   []*model.AB
+		total  int
+		err    error
+	)
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	if err = checkStatus(params.Mstatus); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if data, total, err = abSvr.ListAb(c, params.Pn, params.Ps, params.Mstatus, params.Group); err != nil {
+		log.Error("[http.stra|version] abSvr.ListAb(%d,%d) err: %v", params.Pn, params.Ps, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"result": data,
+		"total":  total,
+	}, nil)
+}
+
+func addAb(c *bm.Context) {
+	var (
+		params = new(validator.AddAbParams)
+		ab     = &model.AB{}
+		err    error
+	)
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	// params
+	if err = json.Unmarshal([]byte(params.Data), ab); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ab.Group == 0 {
+		ab.Group = params.Group
+	}
+	if ab.Group == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if params.Group != 0 && ab.Group != params.Group {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if !ab.Stra.Check() {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	rand.Seed(time.Now().Unix())
+	c.JSON(abSvr.AddAb(c, ab))
+}
+
+func updateAb(c *bm.Context) {
+	var (
+		err   error
+		ab    *model.AB
+		srcAb model.AB
+	)
+	params := new(validator.UpdateAbParams)
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	if ab, err = abSvr.Ab(c, params.ID, params.Group); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if params.Group != 0 && ab.Group != params.Group {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	srcAb = *ab
+	if err = json.Unmarshal([]byte(params.Data), ab); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if !ab.Stra.Check() {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ab.Version = srcAb.Version
+	ab.Status = srcAb.Status
+	ab.Group = srcAb.Group
+	c.JSON(abSvr.UpdateAb(c, params.ID, ab))
+}
+
+func updateStatus(c *bm.Context) {
+	var (
+		ab  *model.AB
+		err error
+	)
+	params := new(validator.UpdateStatusAbParams)
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	if params.Status > 3 || params.Status < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ab, err = abSvr.Ab(c, params.ID, params.Group); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if params.Group != 0 && ab.Group != params.Group {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvr.UpdateStatus(c, params.ID, params.Status, params.Modifier, ab.Group))
+}
+
+func deleteAb(c *bm.Context) {
+	var (
+		ab  *model.AB
+		err error
+	)
+	params := new(validator.DelAbParams)
+	if err = c.Bind(params); err != nil {
+		return
+	}
+	if ab, err = abSvr.Ab(c, params.ID, params.Group); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if params.Group != 0 && ab.Group != params.Group {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvr.DeleteAb(c, params.ID))
+}
+
+func checkStatus(s string) (err error) {
+	strs := strings.Split(s, ",")
+	for _, a := range strs {
+		if _, err = strconv.Atoi(a); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func total(c *bm.Context) {
+	c.JSON(abSvr.Total(c))
+}

app/service/openplatform/abtest/http/stra_bench_test.go

@@ -0,0 +1,29 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"testing"
+)
+
+func BenchmarkVersion(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		params := url.Values{}
+		for k, v := range guscs[0].testData {
+			params.Set(k, v)
+		}
+		req, _ := client.NewRequest("GET", _getVersionURL, "127.0.0.1", params)
+		var res struct {
+			Code int `json:"code"`
+			Data struct {
+				V int         `json:"v"`
+				D interface{} `json:"d"`
+			} `json:"data"`
+		}
+
+		if err := client.Do(context.TODO(), req, &res); err != nil {
+			fmt.Println(err)
+		}
+	}
+}

app/service/openplatform/abtest/http/stra_test.go

@@ -0,0 +1,246 @@
+package http
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+const (
+	_getListURL      = "http://localhost:8801/openplatform/admin/abtest/list"
+	_getVersionIDURL = "http://localhost:8801/openplatform/internal/abtest/versionid"
+	_getVersionURL   = "http://localhost:8801/openplatform/internal/abtest/version"
+	_AddURL          = "http://localhost:8801/openplatform/admin/abtest/add"
+	_DelURL          = "http://localhost:8801/openplatform/admin/abtest/delete"
+	_UpdateURL       = "http://localhost:8801/openplatform/admin/abtest/update"
+	_UpdateStatusURL = "http://localhost:8801/openplatform/admin/abtest/status"
+)
+
+type TestData map[string]string
+type Shoulds []interface{}
+
+type TestCase struct {
+	tag      string
+	testData TestData
+	should   Shoulds
+}
+
+var gvcs = []TestCase{
+	TestCase{tag: "TestGetVersionID: valid parameters", testData: TestData{"group": "1"}, should: Shoulds{0}},
+	TestCase{tag: "TestGetVersionID: empty parameters", testData: TestData{"group": ""}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetVersionID: invalid parameters", testData: TestData{"group": "asd"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetVersionID: no parameters", testData: TestData{}, should: Shoulds{-400}},
+}
+
+func TestGetVersionID(t *testing.T) {
+	for _, td := range gvcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _getVersionIDURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+var guscs = []TestCase{
+	TestCase{tag: "TestGetVersion: valid parameters", testData: TestData{"group": "1", "key": "23232", "version": "{}"}, should: Shoulds{0}},
+	TestCase{tag: "TestGetVersion: no version", testData: TestData{"group": "1", "key": ""}, should: Shoulds{0}},
+	TestCase{tag: "TestGetVersion: no key", testData: TestData{"group": "1", "version": "{}"}, should: Shoulds{0}},
+	TestCase{tag: "TestGetVersion: no group", testData: TestData{"group": "1", "version": "{}"}, should: Shoulds{0}},
+}
+
+func TestGetVersion(t *testing.T) {
+	for _, td := range guscs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _getVersionURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+				Data struct {
+					V int         `json:"v"`
+					D interface{} `json:"d"`
+				} `json:"data"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+var glcs = []TestCase{
+	TestCase{tag: "TestGetListAb: valid parameters", testData: TestData{"pn": "1", "ps": "20", "mstatus": "1,2,0"}, should: Shoulds{0}},
+	TestCase{tag: "TestGetListAb: no pn", testData: TestData{"ps": "1", "mstatus": "1,2,0"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetListAb: no ps", testData: TestData{"pn": "1", "mstatus": "1,2,0"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetListAb: no mstatus", testData: TestData{"pn": "1", "ps": "10"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetListAb: invalid pn", testData: TestData{"pn": "a", "ps": "20", "mstatus": "1,2,0"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetListAb: invalid ps", testData: TestData{"pn": "1", "ps": "a", "mstatus": "1,2,0"}, should: Shoulds{-400}},
+	TestCase{tag: "TestGetListAb: invalid mstatus", testData: TestData{"pn": "1", "ps": "20", "mstatus": "a"}, should: Shoulds{-400}},
+}
+
+func TestGetListAb(t *testing.T) {
+	for _, td := range glcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _getListURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+				Data struct {
+					Result interface{} `json:"result"`
+					Total  interface{} `json:"total"`
+				} `json:"data"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+var testID int
+var adcs = []TestCase{
+	TestCase{tag: "TestAddAb: valid json", testData: TestData{"data": `{"name":"test1","desc":"test","stra":{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`}, should: Shoulds{0}},
+	TestCase{tag: "TestAddAb: no permission", testData: TestData{"data": `{"name":"test1","desc":"test","stra":{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`, "group": "2"}, should: Shoulds{-400}},
+	TestCase{tag: "TestAddAb: not json", testData: TestData{"data": `{"name":"test2","desc""test""stra":"{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`}, should: Shoulds{-400}},
+	TestCase{tag: "TestAddAb: invalid stra", testData: TestData{"data": `{"name":"test3","desc":"test","stra":{"precision":100,"ratio":[20,70]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`}, should: Shoulds{-400}},
+	TestCase{tag: "TestAddAb: no data", testData: TestData{}, should: Shoulds{-400}},
+}
+
+func TestAddAb(t *testing.T) {
+	for _, td := range adcs {
+		Convey(td.tag, t, func() {
+			var res struct {
+				Code int `json:"code"`
+				Data struct {
+					Newid int `json:"newid"`
+				} `json:"data"`
+			}
+
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _AddURL, "127.0.0.1", params)
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+
+			So(res.Code, ShouldEqual, td.should[0])
+			if res.Code == 0 {
+				testID = res.Data.Newid
+			}
+		})
+	}
+}
+
+func TestUpdateAb(t *testing.T) {
+	var upcs = []TestCase{
+		TestCase{tag: "TestUpdateAb: valid params", testData: TestData{"id": strconv.Itoa(testID), "data": `{"name":"test","desc":"update","stra":{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`}, should: Shoulds{0}},
+		TestCase{tag: "TestUpdateAb: no permission", testData: TestData{"id": strconv.Itoa(testID), "data": `{"name":"test1","desc":"test","stra":{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":2,"author":"test","modifer":"test"}`, "group": "2"}, should: Shoulds{-500}},
+		TestCase{tag: "TestUpdateAb: invalid params", testData: TestData{}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateAb: invalid id", testData: TestData{"id": "11111", "data": "aa"}, should: Shoulds{-500}},
+		TestCase{tag: "TestUpdateAb: invalid data", testData: TestData{"id": strconv.Itoa(testID), "data": "aa"}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateAb: valid stra", testData: TestData{"id": strconv.Itoa(testID), "data": `{"name":"test","desc":"update","stra":{"precision":100,"ratio":[20,81]},"result":1,"status":0,"group":1,"author":"test","modifer":"test"}`}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateAb: valid params group 0", testData: TestData{"id": strconv.Itoa(testID), "data": `{"name":"test","desc":"update2","stra":{"precision":100,"ratio":[20,80]},"result":1,"status":0,"group":0,"author":"test","modifer":"test"}`}, should: Shoulds{0}},
+	}
+	for _, td := range upcs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _UpdateURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+func TestUpdateStatusAb(t *testing.T) {
+	var upscs = []TestCase{
+		TestCase{tag: "TestUpdateStatusAb: valid params", testData: TestData{"id": strconv.Itoa(testID), "status": "1", "modifier": "test2"}, should: Shoulds{0}},
+		TestCase{tag: "TestUpdateStatusAb: no permission", testData: TestData{"id": strconv.Itoa(testID), "status": "1", "modifier": "test2", "group": "2"}, should: Shoulds{-500}},
+		TestCase{tag: "TestUpdateStatusAb: invalid params", testData: TestData{}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateStatusAb: invalid id", testData: TestData{"id": "11111", "data": "aa"}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateStatusAb: invalid status", testData: TestData{"id": strconv.Itoa(testID), "status": "4", "modifier": "test2"}, should: Shoulds{-400}},
+		TestCase{tag: "TestUpdateStatusAb: valid params", testData: TestData{"id": strconv.Itoa(testID), "status": "3", "modifier": "test2"}, should: Shoulds{0}},
+	}
+	for _, td := range upscs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _UpdateStatusURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}
+
+func TestDelAb(t *testing.T) {
+	var dacs = []TestCase{
+		TestCase{tag: "TestDelAb: no permission", testData: TestData{"id": strconv.Itoa(testID), "group": "2"}, should: Shoulds{-500}},
+		TestCase{tag: "TestDelAb: valid id", testData: TestData{"id": strconv.Itoa(testID)}, should: Shoulds{0}},
+		TestCase{tag: "TestDelAb: invalid id", testData: TestData{"id": "x"}, should: Shoulds{-400}},
+	}
+	for _, td := range dacs {
+		Convey(td.tag, t, func() {
+			params := url.Values{}
+			for k, v := range td.testData {
+				params.Set(k, v)
+			}
+			req, _ := client.NewRequest("GET", _DelURL, "127.0.0.1", params)
+			var res struct {
+				Code int `json:"code"`
+			}
+
+			if err := client.Do(context.TODO(), req, &res); err != nil {
+				t.Errorf("client.Do() error(%v)", err)
+				t.FailNow()
+			}
+			So(res.Code, ShouldEqual, td.should[0])
+		})
+	}
+}