func TestDelChannelApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) // prepare d := NewTvChannelDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) ent1 := &tv.TvChannel{"c1", "s1", "foo", "bar"} ent2 := &tv.TvChannel{"c2", "s2", "hoge", "piyo"} d.Put(d.NewKey(ent1.Key(), 0, nil), ent1) d.Put(d.NewKey(ent2.Key(), 0, nil), ent2) err := util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 2 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm TvChannel entities has been stored within a timeout window.") p := app.Api.Path("/channels/c1/s1.json") req := ts.Delete(p) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) err = util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "DELETE %s Confirm TvChannel entities has been deleted via API within a timeout window.", p) // Confirm cache invalidation mc := memcache.NewDriver(ts.Context, wcg.NewLogger(nil)) assert.Ok(!mc.Exists(MC_KEY_CHANNELS), "DELETE %s should invalidate the cache", p) }) }
func TestRedirect(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) GAEServer.Routes().Get("/l/", Redirect) res := ts.Get("/l/").RouteTo(GAEServer.Routes()) assert.HttpStatus(404, res) res = ts.Get("/l/?u=foobar").RouteTo(GAEServer.Routes()) assert.HttpStatus(404, res) res = ts. Get(fmt.Sprintf("/l/?u=%s", url.QueryEscape("http://foobar.example.com/"))). RouteTo(GAEServer.Routes()) assert.HttpStatus(302, res) assert.HttpHeader("http://foobar.example.com/", res, "Location") res = ts. Get(fmt.Sprintf("/l/?u=%s", url.QueryEscape("http://foobar.example.com/?foobar"))). RouteTo(GAEServer.Routes()) assert.HttpStatus(302, res) assert.HttpHeader("http://foobar.example.com/?foobar", res, "Location") res = ts. Get(fmt.Sprintf("/l/?u=%s", url.QueryEscape("http://foobar.example.com/?var=val&hoge=fuga"))). RouteTo(GAEServer.Routes()) assert.HttpStatus(302, res) assert.HttpHeader("http://foobar.example.com/?var=val&hoge=fuga", res, "Location") res = ts. Get(fmt.Sprintf("/l/?u=%s", url.QueryEscape("http://foobar.example.com/?var=val&hoge=fuga#hashhoge"))). RouteTo(GAEServer.Routes()) assert.HttpStatus(302, res) assert.HttpHeader("http://foobar.example.com/?var=val&hoge=fuga#hashhoge", res, "Location") }) }
func TestSave(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.App, ts) // TODO: fixture // prepare p := &blog.Post{ Title: "test post", Content: "test content", Tags: []string{}, IsDraft: false, IsHidden: false, PublishAt: time.Now(), } d := NewPostDriver(appCtx) _, err := d.Save(p) assert.Nil(err, "Save() should not return an error on creating a new post") assert.Ok(len(p.Id) > 0, "post Id should be set after Save().") lastUpdate := p.UpdatedAt _, err = d.Save(p) assert.Nil(err, "Save() should not return an error on updating an exising post") assert.Ok(p.UpdatedAt.After(lastUpdate), "UpdatedAt should be updated afeter Save()") }) }
func TestAddKeywordApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) p := app.Api.Path("/keywords/") req := ts.PostForm(p, url.Values{ "keyword": []string{"モーニング娘。'15"}, "category": []string{"モーニング娘。"}, "scope": []string{"1"}, }) lib.SetApiTokenForTest(req, lib.Admin) var got map[string]interface{} res := req.RouteTo(app.Routes()) res.Json(&got) assert.HttpStatus(201, res) assert.EqStr( "http://localhost:8080/api/pt/keywords/モーニング娘。'15.json", got["location"].(string), "POST %s location", p, ) // Confirm cache invalidation mc := memcache.NewDriver(ts.Context, wcg.NewLogger(nil)) assert.Ok(!mc.Exists(MC_KEY_KEYWORDS), "POST %s should invalidate the cache", p) }) }
func TestChannel_AddAndDelCrawlerConfig(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := wcg.NewAssert(t) // prepare d := NewCrawlerConfigDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) d.Add(&tv.CrawlerConfig{ Keyword: "キーワード1", Category: "カテゴリー1", Scope: 1, }) d.Add(&tv.CrawlerConfig{ Keyword: "キーワード2", Category: "カテゴリー2", Scope: 1, }) err := util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 2 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm CrawlerConfig entities has been stored within a timeout window.") d.Delete("キーワード1") err = util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm CrawlerConfig entities has been deleted within a timeout window.") err = d.Delete("Not Exists") assert.Nil(err, "Delete should not return even trying to delete the unexising keyword.") }) }
func TestAddChannelApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) p := app.Api.Path("/channels/") req := ts.PostForm(p, url.Values{ "cid": []string{"c1"}, "sid": []string{"s1"}, "name": []string{"foo"}, "iepg_station_id": []string{"bar"}, }) lib.SetApiTokenForTest(req, lib.Admin) var got map[string]interface{} res := req.RouteTo(app.Routes()) res.Json(&got) assert.HttpStatus(201, res) assert.EqStr( "http://localhost:8080/api/pt/channels/c1/s1.json", got["location"].(string), "POST %s location", p, ) // Confirm cache invalidation mc := memcache.NewDriver(ts.Context, wcg.NewLogger(nil)) assert.Ok(!mc.Exists(MC_KEY_CHANNELS), "POST %s should invalidate the cache", p) }) }
func TestApiUpdateEvent(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.TestApp().App, ts) test.DatastoreFixture(ts.Context, "./fixtures/TestApiUpdateEvent.json", nil) d := NewEventDriver(appCtx) var e event.Event p := app.TestApp().Api.Path("/events/event1.json") req := ts.PutForm(p, url.Values{ "title": []string{"Updated Title"}, "link": []string{"http://www.up.example.com/"}, "image_link": []string{"http://www.up.example.com/img.png"}, }) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(200, res) err := util.WaitFor(func() bool { d.Load("event1", &e) return e.Title == "Updated Title" }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm the show has been inserted within timeout window.") assert.EqStr("Updated Title", e.Title, "Title") assert.EqStr("http://www.up.example.com/", e.Link, "Link") assert.EqStr("http://www.up.example.com/img.png", e.ImageLink, "ImageLink") }) }
func TestApiCreateEvent_201(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.TestApp().App, ts) d := NewEventDriver(appCtx) var respJson map[string]interface{} var e event.Event p := app.TestApp().Api.Path("/events/") req := ts.PostForm(p, url.Values{ "title": []string{"test tour title"}, "link": []string{"http://www.example.com/"}, "image_link": []string{"http://www.example.com/img.png"}, }) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(201, res) err := util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm the show has been inserted within timeout window.") res.Json(&respJson) d.Load(respJson["id"].(string), &e) assert.EqStr("test tour title", e.Title, "Title") assert.EqStr("http://www.example.com/", e.Link, "Link") assert.EqStr("http://www.example.com/img.png", e.ImageLink, "ImageLink") }) }
func TestApiCreateEvent_400(t *testing.T) { var genParams = func(omitName string) url.Values { params := url.Values{ "title": []string{"test tour title"}, "link": []string{"http://www.example.com/"}, "image_link": []string{"http://www.example.com/img.png"}, } params.Del(omitName) return params } test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) test.DatastoreFixture(ts.Context, "./fixtures/TestApiCreateEventShow.json", nil) p := app.TestApp().Api.Path("/events/") var testOmitParams = []string{ "title", "link", "image_link", } for _, paramName := range testOmitParams { req := ts.PostForm(p, genParams(paramName)) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(400, res) } }) }
func TestApiCreateEventShow_400(t *testing.T) { var genParams = func(omitName string) url.Values { params := url.Values{ "open_at": []string{"2015-01-02T06:00:00Z"}, "start_at": []string{"2015-01-02T07:00:00Z"}, "latitude": []string{"37.39"}, "longitude": []string{"140.38"}, "venue_id": []string{"153237058036933"}, "venue_name": []string{"郡山市民文化センター"}, "pia_link": []string{"http://pia.jp/link"}, "ya_keyword": []string{"郡山"}, } params.Del(omitName) return params } test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) test.DatastoreFixture(ts.Context, "./fixtures/TestApiCreateEventShow.json", nil) p := app.TestApp().Api.Path("/events/event1/shows") var testOmitParams = []string{ "open_at", "start_at", "latitude", "longitude", "venue_id", "venue_name", // "pia_link", "ya_keyword", } for _, paramName := range testOmitParams { req := ts.PostForm(p, genParams(paramName)) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(400, res) } }) }
func TestDeleteAmebloContents(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.TestApp().App, ts) // prepare amUrl := "http://ameblo.jp/eriko--imai/entry-11980960390.html" d := NewAmebloEntryDriver(appCtx) t1 := time.Now() ent := &ameblo.AmebloEntry{ Title: "切り替え〜る", Owner: "今井絵理子", Url: amUrl, UpdatedAt: t1, CrawledAt: time.Time{}, Content: "", AmLikes: 5, AmComments: 10, } err := updateIndexes(appCtx, []*ameblo.AmebloEntry{ent}) assert.Nil(err, "UpdateIndexes() should not return an error on creating an ameblo entry") p := app.TestApp().Api.Path("/ameblo/contents/今井絵理子.json") req := ts.Delete(p) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(200, res) // confirm the content updated. var ent1 ameblo.AmebloEntry err = d.Get(d.NewKey(amUrl, 0, nil), &ent1) assert.Ok(ent1.CrawledAt.Equal(time.Time{}), "DELETE %s should delete the cralwing timestamp.", p) }) }
func TestUpdateApiToken(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app, ts) // prepare d := lib.NewApiTokenDriver(appCtx) tok, _ := d.Issue("token1") d.Issue("token2") util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 2 }, util.DefaultWaitForTimeout) var tokUrl = fmt.Sprintf("/api/admin/api_tokens/%s/", tok.Key()) // Case 400 req := ts.PutForm(tokUrl, url.Values{ "desc": []string{"updated"}, "alert_on": []string{"-20"}, }) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.Routes()) assert.HttpStatus(400, res) // Case 200 req = ts.PutForm(tokUrl, url.Values{ "desc": []string{"updated"}, "alert_on": []string{"30"}, }) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(200, res) }) }
func TestCreateAndDeleteEvent(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.TestApp().App, ts) d := NewEventDriver(appCtx) t, err := d.Save(&event.Event{ Title: "Test Tour", Link: "http://example.com", ImageLink: "http://example.com/foo.jpg", }) assert.Nil(err, "TourDriver#Save should not return an error.") assert.Ok(t.Id != "", "TourDriver#Save should set Id for the given tour object.") err = util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm the tour has been inserted within timeout window.") err = d.Delete(t.Id) assert.Nil(err, "TourDriver#Delete should not return an error.") err = util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm the tour has been deleted within timeout window.") }) }
func TestGetOverlaps(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { var found []*tv.TvRecord const timeForm = "2006/01/02 15:04:05" assert := wcg.NewAssert(t) d := NewTvRecordDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) base := genTestRecord() base.StartAt, _ = time.Parse(timeForm, "2014/01/01 12:00:00") base.EndAt, _ = time.Parse(timeForm, "2014/01/01 13:00:00") d.Save(base) err := util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm TvRecord entities has been stored within a timeout window.") // case1: no overlaps r := genTestRecord() r.StartAt, _ = time.Parse(timeForm, "2014/01/01 10:50:00") r.EndAt, _ = time.Parse(timeForm, "2014/01/01 11:10:00") found, err = d.GetOverlaps(r) assert.Nil(err, "TvRecordDriver#GetOverlaps should not return an error (case1)") assert.EqInt(0, len(found), "TvRecordDriver#GetOverlaps should return empty array (case1)") // case 2: base.end < r.start r = genTestRecord() r.StartAt, _ = time.Parse(timeForm, "2014/01/01 13:50:00") r.EndAt, _ = time.Parse(timeForm, "2014/01/01 14:10:00") found, err = d.GetOverlaps(r) assert.Nil(err, "TvRecordDriver#GetOverlaps should not return an error (case2)") assert.EqInt(0, len(found), "TvRecordDriver#GetOverlaps should return empty array (case2)") // case 3: base.start < r.start < base.end r = genTestRecord() r.StartAt, _ = time.Parse(timeForm, "2014/01/01 11:50:00") r.EndAt, _ = time.Parse(timeForm, "2014/01/01 12:10:00") found, err = d.GetOverlaps(r) assert.Nil(err, "TvRecordDriver#GetOverlaps should not return an error (case3)") assert.EqInt(1, len(found), "TvRecordDriver#GetOverlaps should return an array with an entity (case3)") // case 4: r.start < base.end < r.end r = genTestRecord() r.StartAt, _ = time.Parse(timeForm, "2014/01/01 12:50:00") r.EndAt, _ = time.Parse(timeForm, "2014/01/01 13:10:00") found, err = d.GetOverlaps(r) assert.Nil(err, "TvRecordDriver#GetOverlaps should not return an error (case4)") assert.EqInt(1, len(found), "TvRecordDriver#GetOverlaps should return an array with an entity (case4)") // case 5: r.start < base.start < base.end < r.end r = genTestRecord() r.StartAt, _ = time.Parse(timeForm, "2014/01/01 12:10:00") r.EndAt, _ = time.Parse(timeForm, "2014/01/01 12:50:00") found, err = d.GetOverlaps(r) assert.Nil(err, "TvRecordDriver#GetOverlaps should not return an error (case4)") assert.EqInt(1, len(found), "TvRecordDriver#GetOverlaps should return an array with an entity (case4)") }) }
func Test_updateIndexes(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.TestApp().App, ts) d := NewAmebloEntryDriver(appCtx) amUrl := "http://ameblo.jp/foo/bar.html" key := d.NewKey(amUrl, 0, nil) t1 := time.Now() ent := &ameblo.AmebloEntry{ Title: "Test Title", Owner: "Myblog", Url: amUrl, UpdatedAt: t1, CrawledAt: t1, Content: "crawled content", AmLikes: 5, AmComments: 10, } err := updateIndexes(appCtx, []*ameblo.AmebloEntry{ent}) assert.Nil(err, "UpdateIndexes() should not return an error on creating an ameblo entry") err = util.WaitFor(func() bool { var ent ameblo.AmebloEntry d.Get(key, &ent) return ent.Url == amUrl }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm entry has been inserted within timeout window.") // test confirm not to update content and crawled at t2 := time.Now() newent := &ameblo.AmebloEntry{ Title: "(Updated) Test Title", Owner: "(Updated) Myblog", Url: "http://ameblo.jp/foo/bar.html", UpdatedAt: t2, CrawledAt: t2, Content: "", AmLikes: 10, AmComments: 15, } err = updateIndexes(appCtx, []*ameblo.AmebloEntry{newent}) assert.Nil(err, "UpdateIndexes() should not return an error on creating an ameblo entry") err = util.WaitFor(func() bool { var updatedent ameblo.AmebloEntry d.Get(key, &updatedent) return updatedent.AmLikes == 10 && updatedent.AmComments == 15 }, util.DefaultWaitForTimeout) var updatedent ameblo.AmebloEntry d.Get(key, &updatedent) assert.Nil(err, "AmLikes and AmComments should be updated after UpdateIndexes() without timeout") assert.EqStr("crawled content", updatedent.Content, "Content should not be updated after UpdateIndexes()") assert.Ok(t1.Unix() == updatedent.CrawledAt.Unix(), "CrawledAt should not be updated UpdateIndexes") }) }
func TestGetVersion(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { var got interface{} assert := test.NewAssert(t) req := ts.Get("/api/admin/version/") lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.Routes()) res.Json(&got) assert.HttpStatus(200, res) }) }
func TestUpdate(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) app := NewApp("default", "TestApp") d := NewApiTokenDriver(NewAppContextFromTestServer(app, ts)) token, err := d.Issue("New Api Token") assert.Nil(err, "ApiTokenDriver#Issue should not return an error") err = d.Update(token.Token, "Updated Api Token", 3*time.Second) assert.Nil(err, "ApiTokenDriver#Update should not return an error") }) }
func TestApiCreateEventShow_404(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) test.DatastoreFixture(ts.Context, "./fixtures/TestApiCreateEventShow.json", nil) p := app.TestApp().Api.Path("/events/notexit/shows") req := ts.PostForm(p, url.Values{}) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(404, res) }) }
func TestGetPost(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.App, ts) // TODO: fixture // prepare d := NewPostDriver(appCtx) post1, _ := d.Save(&blog.Post{ Title: "test post1", Content: "test content", Tags: []string{}, IsDraft: false, IsHidden: false, PublishAt: time.Now(), }) post2, _ := d.Save(&blog.Post{ Title: "test post2", Content: "test content", Tags: []string{}, IsDraft: true, IsHidden: false, PublishAt: time.Now(), }) util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) // test post1 : public post var got *blog.Post p := app.Api.Path(fmt.Sprintf("/posts/%s.json", post1.Id)) req := ts.Get(p) res := req.RouteTo(app.Routes()) res.Json(&got) assert.HttpStatus(200, res) assert.EqStr("test post1", got.Title, "post1.Title") // test post2 : draft post, only visible by admins. p = app.Api.Path(fmt.Sprintf("/posts/%s.json", post2.Id)) req = ts.Get(p) res = req.RouteTo(app.Routes()) assert.HttpStatus(404, res) req = ts.Get(p) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) res.Json(&got) assert.HttpStatus(200, res) assert.EqStr("test post2", got.Title, "post2.Title") }) }
func TestApp(t *testing.T) { assert := test.NewAssert(t) test.RunTestServer(func(ts *test.TestServer) { app := NewApp("default", "TestApp") app.Routes().Get("/", func(res *wcg.Response, req *wcg.Request) { res.WriteString("OK") }) req := ts.Get("/") res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) }) }
func TestIssue(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) app := NewApp("default", "TestApp") d := NewApiTokenDriver(NewAppContextFromTestServer(app, ts)) token, err := d.Issue("New Api Token") assert.Nil(err, "ApiTokenDriver#Issue should not return an error") assert.NotNil(token, "ApiTokenDriver#Issue should issue the token wit") assert.EqStr("New Api Token", token.Description, "ApiTokenDriver#Issue should issue the token with given description") assert.GtInt(0, len(token.Token), "ApiTokenDriver#Issue should issue the valid token") }) }
func TestDeleteRecordApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) d := NewRecordCacheDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) // create an empty cache var got []tv.TvRecord p := app.Api.Path("/records/") req := ts.Get(p) res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) res.Json(&got) assert.EqInt(0, len(got), "GET %s should return 2 TvRecord entities.") assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "GET %s should create RecordCacheTypeTvRecord cache", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should create RecordCacheTypeIEpg cache", p) // prepare in_window := genTestRecord() in_window.StartAt = d.today.Add(1 * time.Hour) in_window.EndAt = d.today.Add(2 * time.Hour) d.TvRecord.Save(in_window) future := genTestRecord() future.StartAt = d.today.Add(RECORD_TIME_WINDOW + 1*time.Hour) future.EndAt = future.StartAt.Add(1 * time.Hour) d.TvRecord.Save(future) err := util.WaitFor(func() bool { records, _ := d.TvRecord.NewQuery().Count() return records == 2 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm TvRecord entities has been stored within a timeout window.") // case 1: future p = fmt.Sprintf("%s%s.json", app.Api.Path("/records/"), future.Key()) req = ts.Delete(p) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(200, res) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "POST %s should not invalidate RecordCacheTypeTvRecord cache (future record)", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should not invalidate RecordCacheTypeIEpg cache (future record)", p) // case 2: in recording window p = fmt.Sprintf("%s%s.json", app.Api.Path("/records/"), in_window.Key()) req = ts.Delete(p) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(200, res) assert.Ok(!d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "POST %s should invalidate RecordCacheTypeTvRecord cache (in_window record)", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should not invalidate RecordCacheTypeIEpg cache (in_window record)", p) }) }
func TestUpdatePost(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) appCtx := apptest.NewAppContextFromTestServer(app.App, ts) // TODO: fixture // prepare d := NewPostDriver(appCtx) post1, _ := d.Save(&blog.Post{ Title: "test post1", Content: "test content", Tags: []string{}, IsDraft: false, IsHidden: false, PublishAt: time.Now(), }) util.WaitFor(func() bool { c, _ := d.NewQuery().Count() return c == 1 }, util.DefaultWaitForTimeout) // test p := app.Api.Path(fmt.Sprintf("/posts/%s.json", post1.Id)) req := ts.PutForm(p, url.Values{ "title": []string{"updated: test post1"}, "content": []string{"updated: test content"}, "publish_at": []string{"2015-01-01T12:04:05Z"}, // ISO8601 format }) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) assert.Nil(util.WaitFor(func() bool { var p blog.Post key := d.NewKey(post1.Id, 0, nil) d.Get(key, &p) return "updated: test post1" == p.Title }, util.DefaultWaitForTimeout), "Confirm update") // case 404 not found p = app.Api.Path(fmt.Sprintf("/api/default/posts/%s.json", "not-found")) req = ts.PutForm(p, url.Values{ "title": []string{"updated: test post1"}, "content": []string{"updated: test content"}, "publish_at": []string{"2015-01-01T12:04:05Z"}, // ISO8601 format }) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(404, res) }) }
func TestRecordCache_GetRecords_and_Invalidate(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := wcg.NewAssert(t) d := NewRecordCacheDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) // prepare in_window := genTestRecord() in_window.StartAt = d.today.Add(1 * time.Hour) in_window.EndAt = d.today.Add(2 * time.Hour) d.TvRecord.Save(in_window) future := genTestRecord() future.StartAt = d.today.Add(RECORD_TIME_WINDOW + 1*time.Hour) future.EndAt = future.StartAt.Add(1 * time.Hour) d.TvRecord.Save(future) past := genTestRecord() past.StartAt = d.today.Add(-RECORD_TIME_WINDOW - 1*time.Hour) past.EndAt = past.StartAt.Add(30 * time.Minute) d.TvRecord.Save(past) in_window_iepg := genTestIEpg() in_window.StartAt = d.today.Add(4 * time.Hour) in_window.EndAt = d.today.Add(5 * time.Hour) d.IEpg.Save(in_window_iepg) err := util.WaitFor(func() bool { records, _ := d.TvRecord.NewQuery().Count() iepgs, _ := d.IEpg.NewQuery().Count() return records+iepgs == 4 }, util.DefaultWaitForTimeout) assert.Nil(err, "Confirm TvRecord/IEpg entities has been stored within a timeout window.") list, err := d.GetRecords(false) assert.Nil(err, "RecordCache#GetRecords should not return an error") assert.EqInt(2, len(list), "RecordCache#GetRecords should return 2 records in a time window") // cache check assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "RecordCache#GetRecords should create RecordCacheTypeTvRecord on memcache.") assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "RecordCache#GetRecords should create RecordCacheTypeIEpg on memcache.") // invalidate the keys assert.Ok(!d.Invalidate(future), "RecordCache#Invalidate should not return true if the passed record is out of window (future)") assert.Ok(!d.Invalidate(past), "RecordCache#Invalidate should not return true if the passed record is out of window (future)") assert.Ok(d.Invalidate(in_window), "RecordCache#Invalidate should return true if the passed record is in window") assert.Ok(!d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "RecordCache#GetRecords should invalidate RecordCacheTypeTvRecord on memcache.") assert.Ok(d.Invalidate(in_window_iepg), "RecordCache#Invalidate should return true if the passed record is in window (iepg)") assert.Ok(!d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "RecordCache#GetRecords should invalidate RecordCacheTypeIEpg on memcache.") }) }
func TestAmebloIndexApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) var got map[string][]string p := app.TestApp().Api.Path("/ameblo/indexes/") req := ts.Get(p) lib.SetApiTokenForTest(req, lib.Admin) res := req.RouteTo(app.TestApp().Routes()) res.Json(&got) assert.HttpStatus(200, res) assert.EqInt(2, len(got), "GET %s should return the list of crawled results.", p) assert.EqInt(20, len(got["今井絵理子"]), "GET %s return 20 entries for '今井絵理子'.", p) }) }
func TestAhAuthHandler(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) app := NewApp("default", "TestApp") app.Routes().Get("/_ah/foo", func(res *wcg.Response, req *wcg.Request) { assert.EqStr("api:x-appengine-ah", req.User.Id(), "User Id") res.WriteString("OK") }) req := ts.Get("/_ah/foo") res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) }) }
func TestRevoke(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) app := NewApp("default", "TestApp") d := NewApiTokenDriver(NewAppContextFromTestServer(app, ts)) token, err := d.Issue("New Api Token") assert.Nil(err, "ApiTokenDriver#Issue should not return an error") err = d.Revoke(token.Token) assert.Nil(err, "ApiTokenDriver#Revoke should not return an error") err = d.Revoke("non-existing") assert.Nil(err, "ApiTokenDriver#Revoke should not return an error even non-existing token is passed") }) }
func TestCreateRecordApi(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) d := NewRecordCacheDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil)) // create an empty cache var got []tv.TvRecord p := app.Api.Path("/records/") req := ts.Get(p) res := req.RouteTo(app.Routes()) assert.HttpStatus(200, res) res.Json(&got) assert.EqInt(0, len(got), "GET %s should return 2 TvRecord entities.") assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "GET %s should create RecordCacheTypeTvRecord cache", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should create RecordCacheTypeIEpg cache", p) now := time.Now() // case 1: future req = ts.PostForm(p, url.Values{ "title": []string{"Title"}, "category": []string{"Category"}, "cid": []string{"27"}, "sid": []string{"hd"}, "start_at": []string{util.FormatDateTime(now.Add(RECORD_TIME_WINDOW + 24*time.Hour))}, "end_at": []string{util.FormatDateTime(now.Add(RECORD_TIME_WINDOW + 25*time.Hour))}, }) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(201, res) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "POST %s should not invalidate RecordCacheTypeTvRecord cache (future record)", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should not invalidate RecordCacheTypeIEpg cache (future record)", p) // case 2: in recording window req = ts.PostForm(p, url.Values{ "title": []string{"Title"}, "category": []string{"Category"}, "cid": []string{"27"}, "sid": []string{"hd"}, "start_at": []string{util.FormatDateTime(now)}, "end_at": []string{util.FormatDateTime(now.Add(1 * time.Hour))}, }) lib.SetApiTokenForTest(req, lib.Admin) res = req.RouteTo(app.Routes()) assert.HttpStatus(201, res) assert.Ok(!d.Cache.Exists(d.GetMcKey(RecordCacheTypeTvRecord)), "POST %s should invalidate RecordCacheTypeTvRecord cache (in window)", p) assert.Ok(d.Cache.Exists(d.GetMcKey(RecordCacheTypeIEpg)), "GET %s should not invalidate RecordCacheTypeIEpg cache (in window)", p) }) }
func TestApiListEventShow(t *testing.T) { test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) test.DatastoreFixture(ts.Context, "./fixtures/TestApiListEventShow.json", nil) var respJson []event.Show p := app.TestApp().Api.Path("/events/event1/shows") req := ts.Get(p) res := req.RouteTo(app.TestApp().Routes()) assert.HttpStatus(200, res) res.Json(&respJson) assert.EqInt(1, len(respJson), "shows should return 1 element") assert.EqStr("event1-show1", respJson[0].Id, "Id") assert.EqStr("event1", respJson[0].EventId, "EventId") }) }
func Test_registerJsonpProxyHandlers(t *testing.T) { routes := GAEServer.Routes() registerJsonpProxyHandlers(routes) test.RunTestServer(func(ts *test.TestServer) { assert := test.NewAssert(t) res := ts.Get("/jsonp").RouteTo(routes) assert.HttpStatus(400, res) res = ts.Get("/jsonp?target=ftp://www.example.com").RouteTo(routes) assert.HttpStatus(400, res) res = ts.Get("/jsonp?target=http://localhost/jsonp").RouteTo(routes) assert.HttpStatus(400, res) }) }