checkin

Author: Lei Pi

.gitignore

@@ -2,3 +2,4 @@ build
 testBuild
 db/*.db
 .vscode
+.idea

service/api_impl.go

@@ -20,16 +20,20 @@ func newNotes(pn *hlcmsg.Pagenote) *hlcmsg.IdList {
 func getNotes(pn *hlcmsg.Pagenote) *hlcmsg.Pagenote {
 	if pn.Uid > 0 {
 		return storage.QueryPagenote(pn.Uid, pn.Pageid)
-	} else {
-		util.Log("error, empty uid not supported")
-		return nil
 	}
+	util.Log("error, empty uid not supported")
+	return nil
 }
 
 func parseNewNotesRequest(r *http.Request) *hlcmsg.Pagenote {
 	pn := &hlcmsg.Pagenote{}
 	payload, err := readRequestPayload(r)
 	if err != nil {
+		util.Debug("error loading payload", err)
+		return nil
+	}
+	if payload == nil || len(payload) == 0 {
+		util.Debug("empty payload", err)
 		return nil
 	}
 	if err = proto.Unmarshal(payload, pn); err != nil {

service/api_impl_test.go

@@ -1,6 +1,44 @@
 package service
 
 import "testing"
+import "github.com/lpimem/hlcsrv/hlcmsg"
+import "github.com/lpimem/hlcsrv/storage"
+
+func testGetPagenote(t *testing.T, uid uint32, pid uint32, count uint32) {
+	storage.ResetTestDb()
+	req := &hlcmsg.Pagenote{
+		Uid:    uid,
+		Pageid: pid,
+	}
+	note := getNotes(req)
+	if count == 0 {
+		if note != nil {
+			t.Error("expecting nil, got", note)
+			t.Fail()
+		}
+		return
+	}
+	if note == nil {
+		t.Error("note should be not nil")
+		t.Fail()
+		return
+	}
+	if len(note.Highlights) != int(count) {
+		t.Error("note should contain", count, "highlights")
+		t.Fail()
+		return
+	}
+}
+
+func TestGetNote(t *testing.T) {
+	for _, tc := range [][]uint32{
+		[]uint32{1, 0, 1},
+		[]uint32{1, 1, 1},
+		[]uint32{2, 1, 0},
+	} {
+		testGetPagenote(t, tc[0], tc[1], tc[2])
+	}
+}
 
 func TestCleanUrl(t *testing.T) {
 	tcs := [][]string{

service/api_test.go

@@ -0,0 +1,117 @@
+package service
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"net/http"
+
+	"io/ioutil"
+
+	"bytes"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/lpimem/hlcsrv/hlcmsg"
+	"github.com/lpimem/hlcsrv/storage"
+)
+
+func TestNewPagenote(t *testing.T) {
+	const url = "/pagenote/new"
+	var w *httptest.ResponseRecorder
+	// post only
+	get := httptest.NewRequest("GET", url, nil)
+	w = httptest.NewRecorder()
+	savePagenote(w, get)
+	if w.Code != http.StatusBadRequest {
+		t.Error("Expecting", http.StatusBadRequest, "got", w.Code, w.Body.String())
+	}
+
+	// post empty
+	var post *http.Request
+	post = httptest.NewRequest("POST", url, nil)
+	w = httptest.NewRecorder()
+	savePagenote(w, post)
+	if w.Code == http.StatusOK {
+		t.Error("null request body shouldn't get accepted")
+		t.Fail()
+	}
+	// post normal
+	reqPn := &hlcmsg.Pagenote{
+		Uid:    1,
+		Pageid: 1,
+		Url:    "http://example.com",
+		Highlights: []*hlcmsg.RangeMeta{
+			&hlcmsg.RangeMeta{
+				Anchor:      "/",
+				Start:       "/1",
+				StartOffset: 0,
+				End:         "/2",
+				EndOffset:   3,
+			},
+		},
+	}
+	buf, _ := proto.Marshal(reqPn)
+	reader := bytes.NewReader(buf)
+	post = httptest.NewRequest("POST", url, reader)
+	w = httptest.NewRecorder()
+	savePagenote(w, post)
+	if w.Code != http.StatusOK {
+		t.Error("valid new pn request failed", w.Body.String())
+		t.Fail()
+		return
+	}
+	respBody := w.Body.Bytes()
+	pnResp := &hlcmsg.HlcResp{}
+	err := proto.Unmarshal(respBody, pnResp)
+	if err != nil {
+		t.Error("cannot parse response body")
+		t.Fail()
+	}
+	if pnResp.Code != hlcmsg.HlcResp_SUC {
+		t.Error("valid new pn request failed", pnResp.Msg)
+		t.Fail()
+	}
+	if pnResp.IdList == nil || len(pnResp.IdList.Arr) != 1 {
+		t.Error("Failed to get ", 1, "created id")
+		t.Fail()
+	}
+}
+
+func TestGetPageNote(t *testing.T) {
+	req := httptest.NewRequest("GET", "/pagenote?uid=1", nil)
+	recorder := httptest.NewRecorder()
+	getPagenote(recorder, req)
+	httpResp := recorder.Result()
+	if httpResp.StatusCode != http.StatusOK {
+		t.Error("response code should be ", http.StatusOK, "got", httpResp.StatusCode, httpResp.Status)
+		t.Fail()
+	}
+	if recorder.Body == nil {
+		t.Error("response body shouldn't be nil ")
+		t.Fail()
+	}
+	buf, err := ioutil.ReadAll(httpResp.Body)
+	if err != nil {
+		t.Error("cannot read resp body", err)
+		t.Fail()
+		return
+	}
+	if len(buf) < 1 {
+		t.Error("response body buf shouldn't be empty ")
+		t.Fail()
+	}
+	resp := &hlcmsg.HlcResp{}
+	proto.Unmarshal(buf, resp)
+	if resp.Code != hlcmsg.HlcResp_SUC {
+		t.Error("response code should be ", hlcmsg.HlcResp_SUC, "got", resp.Code)
+		t.Fail()
+	}
+	if len(resp.PagenoteList) < 1 || len(resp.PagenoteList[0].Highlights) < 1 {
+		t.Error("parsed response page list should contain 1 range meta")
+		t.Fail()
+	}
+}
+
+func init() {
+	storage.ResetTestDb()
+}

service/checker.go

@@ -2,15 +2,17 @@ package service
 
 import "net/http"
 
-type ReqCookieCheckerBuilder []string
+type ReqCookieCheckerBuilder struct {
+	headers []string
+}
 
-func (builder ReqCookieCheckerBuilder) Require(key string) {
-	builder = append(builder, key)
+func (builder *ReqCookieCheckerBuilder) Require(key string) {
+	builder.headers = append(builder.headers, key)
 }
 
 func (builder ReqCookieCheckerBuilder) Build() RequestInterceptor {
 	return func(req *http.Request) error {
-		for _, expect := range builder {
+		for _, expect := range builder.headers {
 			if _, err := req.Cookie(expect); err != nil {
 				return err
 			}
@@ -22,8 +24,7 @@ func (builder ReqCookieCheckerBuilder) Build() RequestInterceptor {
 func RequirePost(w http.ResponseWriter, r *http.Request) bool {
 	if r.Method == http.MethodPost {
 		return true
-	} else {
-		http.Error(w, "only post accepted", http.StatusBadRequest)
-		return false
 	}
+	http.Error(w, "only post accepted", http.StatusBadRequest)
+	return false
 }

storage/pagenote_dict.go

@@ -35,7 +35,7 @@ func (d *PagenoteDict) AddPagenote(uid uint32, note *hlcmsg.Pagenote) {
 func (d *PagenoteDict) GetPagenote(uid uint32, pid uint32) *hlcmsg.Pagenote {
 	notes := d.getOrCreatePagenoteList(uid)
 	for _, n := range notes {
-		if n.Pageid == pid {
+		if pid == 0 || n.Pageid == pid {
 			return n
 		}
 	}

storage/storage.go

@@ -8,6 +8,10 @@ import (
 var storage *SqliteStorage = nil
 
 func InitStorage(path string) {
+	if storage != nil {
+		util.Log("WARN:", path, "is not inited as storage as storage was already registered at ", storage.path)
+		return
+	}
 	storage = NewSqliteStorage(path)
 }
 

storage/storage_impl_test.go

@@ -5,21 +5,20 @@ import (
 
 	"github.com/golang/protobuf/proto"
 	"github.com/lpimem/hlcsrv/hlcmsg"
-	"github.com/lpimem/hlcsrv/util"
 )
 
 func TestQueryNotesByUID(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	testQueryNotes(1, 0, "uid", t)
 }
 
 func TestQueryNotesByPid(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	testQueryNotes(0, 1, "pid", t)
 }
 
 func TestQueryNotesByUidAndPid(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	testQueryNotes(1, 1, "uid and pid", t)
 }
 
@@ -57,7 +56,7 @@ func testQueryNotes(uid, pid uint32, msg string, t *testing.T) (notes []*hlcmsg.
 }
 
 func TestNewRangeMeta(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	var err error
 	metas := storage.QueryMetaList(1, 1)
 	if len(metas) < 1 {
@@ -89,7 +88,7 @@ func TestNewRangeMeta(t *testing.T) {
 }
 
 func TestDeleteRangeMeta(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	metas := storage.QueryMetaList(1, 1)
 	count := len(metas)
 	if count < 1 {
@@ -112,7 +111,7 @@ func TestDeleteRangeMeta(t *testing.T) {
 }
 
 func TestQueryPageId(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	pid := storage.QueryPageId("example.com")
 	if pid != 1 {
 		t.Error("Should get 1 for page id, but got", pid)
@@ -126,7 +125,7 @@ func TestQueryPageId(t *testing.T) {
 }
 
 func TestNewPage(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	url := "http://new.example.com"
 	pid := storage.NewPage("test", url)
 	if pid < 1 {
@@ -141,7 +140,7 @@ func TestNewPage(t *testing.T) {
 }
 
 func TestQueryUser(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	uname := "Bob"
 	uemail := "[email protected]"
 	passwd := "unsafe"
@@ -158,7 +157,7 @@ func TestQueryUser(t *testing.T) {
 }
 
 func TestNewUser(t *testing.T) {
-	resetDb()
+	ResetTestDb()
 	uname := "Alice"
 	email := "[email protected]"
 	passwd := "unsafe"
@@ -179,47 +178,6 @@ func TestNewUser(t *testing.T) {
 	}
 }
 
-func InitTestDb() {
-	InitStorage(util.GetAbsRunDirPath() + "/db/test.db")
-	err := CleanDb()
-	if err != nil {
-		panic(err)
-	}
-	err = SeedTestDb()
-	if err != nil {
-		panic(err)
-	}
-}
-
-func CleanDb() error {
-	_, err := storage.DB.Exec(`
-	delete from hlc_range;
-	delete from hlc_user;
-	delete from hlc_page;
-	delete from hlc_comments;
-	`)
-	return err
-}
-
-func SeedTestDb() error {
-	_, err := storage.DB.Exec(`
-	insert into hlc_user(id, name, email, password, _slt) 
-		values (1, "Bob", "[email protected]", "unsafe", "unsafe");
-
-	insert into hlc_page(id, title, url)
-		values (1, "example", "example.com");
-
-	insert into hlc_range(id, anchor, start, startOffset, end, endOffset, text, page, author)
-		values (1, "#c", "#c/1", 0, "#c/12", 32, "This is the selected text", 1, 1);
-	`)
-	return err
-}
-
-func resetDb() {
-	CleanDb()
-	SeedTestDb()
-}
-
 func init() {
-	InitTestDb()
+	ResetTestDb()
 }