// Should return the user with the given username, or throw an Entity not found error func TestGetUser(t *testing.T) { ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() key := datastore.NewKey(ctx, "User", "testertim", 0, nil) if _, err := datastore.Put(ctx, key, &models.User{FirstName: "Tim"}); err != nil { t.Fatal(err) } user := &models.User{Username: "******"} if err = repositories.GetUser(ctx, user); err == nil || err.Error() != "datastore: no such entity" { t.Errorf("Error: %v; want datastore: no such entity", err) } user.Username = "******" err = repositories.GetUser(ctx, user) if err != nil { t.Fatal(err) } if firstName, want := user.FirstName, "Tim"; firstName != want { t.Errorf("User First Name %d, want %d", firstName, want) } if username, want := user.Username, "testertim"; username != want { t.Errorf("Username %d, want %d", username, want) } }
// Should store the given user, after encrypting its password func TestStoreUser(t *testing.T) { ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() user := &models.User{Username: "******", FirstName: "Tim", Email: "*****@*****.**", Password: []byte("I <3 golang")} err = repositories.StoreUser(ctx, user) if err != nil { t.Fatal(err) } key := datastore.NewKey(ctx, "User", "testertim", 0, nil) var storedUser models.User err = datastore.Get(ctx, key, &storedUser) if err != nil { t.Fatal(err) } if storedUser.FirstName != user.FirstName { t.Errorf("FirstName %d, want %d", storedUser.FirstName, user.FirstName) } if storedUser.Username != "" { t.Errorf("Username %d should be derived from the key, not stored", storedUser.Username) } if string(storedUser.Password) == "I <3 golang" { t.Errorf("Password %d should be hashed and not %d", string(storedUser.Password), "I <3 golang") } }
func TestHasRole(t *testing.T) { ctx, done, _ := aetest.NewContext() defer done() ctx = test.WithConfig(ctx, map[string]interface{}{"AuthSecret": "foo"}) w := httptest.NewRecorder() r, _ := http.NewRequest("GET", "/", nil) r.Header.Set("Authorization", "wrong") // Make up a fake user acct, _ := account.New(ctx, "*****@*****.**", "foobar") acct.Roles = append(acct.Roles, "tyrant") account.Save(ctx, acct) // Unretrievable user, because middleware hasn't been run. if err := HasRole("foo")(ctx, w, r); err != ErrCannotGetAccount { t.Errorf("Unexpected error, wanted ErrCannotGetAccount, got %s", err) } // User's set, but claimset isn't for some reason. ctx2 := context.WithValue(ctx, internal.AuthContextKey, &account.Nobody) if err := HasRole("foo")(ctx2, w, r); err != ErrCannotGetClaimSet { t.Errorf("Unexpected error, wanted ErrCannotGetClaimSet, got %s", err) } // Account doesn't have the role. r.Header.Set("Authorization", test.JWT(&jws.ClaimSet{Sub: "*****@*****.**", Scope: AllScope}, "foo")) ctx2 = Middleware(ctx, w, r) if err := HasRole("foo")(ctx2, w, r); err != ErrRoleMissing { t.Errorf("Unexpected error, wanted ErrRoleMissing, got %s", err) } // Token doesn't have the role in scope. r.Header.Set("Authorization", test.JWT(&jws.ClaimSet{Sub: "*****@*****.**", Scope: "somethingelse"}, "foo")) ctx2 = Middleware(ctx, w, r) if err := HasRole("tyrant")(ctx2, w, r); err != ErrRoleNotInScope { t.Errorf("Unexpected error, wanted ErrRoleNotInScope, got %s", err) } // Token is consumable, but hasn't been used yet. consumableToken := test.ConsumableJWT(&jws.ClaimSet{Sub: "*****@*****.**", Scope: "tyrant"}, "foo", 1) r.Header.Set("Authorization", consumableToken) ctx2 = Middleware(ctx, w, r) if err := HasRole("tyrant")(ctx2, w, r); err != nil { t.Errorf("Unexpected error, wanted nil, got %s", err) } // We used this token once already. Should be used up. ctx2 = Middleware(ctx, w, r) if err := HasRole("tyrant")(ctx2, w, r); err != ErrClaimSetUsedUp { t.Errorf("Unexpected error, wanted ErrClaimSetUsedUp, got %s", err) } }
func TestIndexHandler(t *testing.T) { _, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() inst, err := aetest.NewInstance(nil) if err != nil { t.Errorf("Failed to create instance: %v", err) } defer inst.Close() request, err := inst.NewRequest("GET", "/", nil) if err != nil { t.Errorf("Error creating new instance %v", err) } response := httptest.NewRecorder() IndexHandler(response, request) if response.Code != http.StatusFound { t.Errorf("Did not get StatusFound(302) got %v", response.Code) } if response.Header().Get("Location") != "/index.html" { t.Errorf("Expected Location: /index.html but instead got %v", response.Header().Get("Location")) } }
func TestProcess(t *testing.T) { ctx, done, _ := aetest.NewContext() defer done() smallTest := strings.NewReader(`{ "User/jsmith": { "Name": "John Smith", "LotteryNumbers": [1,2,3,4,5], "CreatedAt": { "Type": "time", "Value": "1993-05-01T12:31:00.000Z" } }, "User/jdoe": { "Name": "Jane Doe", "LotteryNumbers": [2,4,6,8,10], "CreatedAt": { "Type": "time", "Value": "1992-01-30T08:01:00.000Z" } } }`) if err := Process(ctx, smallTest); err != nil { t.Errorf("Unexpected error %s", err) } key1 := datastore.NewKey(ctx, "User", "jdoe", 0, nil) key2 := datastore.NewKey(ctx, "User", "jsmith", 0, nil) value1 := fakeUser{} value2 := fakeUser{} if err := nds.Get(ctx, key1, &value1); err != nil { t.Errorf("Unexpected error %s retrieving value1", err) } else if err := nds.Get(ctx, key2, &value2); err != nil { t.Errorf("Unexpected error %s retrieving value2", err) } value1.CreatedAt = value1.CreatedAt.UTC() value2.CreatedAt = value2.CreatedAt.UTC() if !reflect.DeepEqual(value1, fakeUser{ Name: "Jane Doe", LotteryNumbers: []int64{2, 4, 6, 8, 10}, CreatedAt: time.Date(1992, 1, 30, 8, 1, 0, 0, time.UTC), }) { t.Errorf("Unexpected value in value1: %+v", value1) } if !reflect.DeepEqual(value2, fakeUser{ Name: "John Smith", LotteryNumbers: []int64{1, 2, 3, 4, 5}, CreatedAt: time.Date(1993, 5, 1, 12, 31, 0, 0, time.UTC), }) { t.Errorf("Unexpected value in value2: %+v", value1) } }
func TestParseWormhole2(t *testing.T) { c, err := aetest.NewContext(nil) if err != nil { t.Fatal(err) } defer c.Close() wh, rpl := parseWormhole(`[[.Moke もけ]]`) if wh == nil { t.Errorf("wh is nil") } if !reflect.DeepEqual(*wh, Wormhole{ "Moke", "もけ", true, PROPERTY, }) { t.Errorf("illegal wh: %#v\n", wh) } if rpl != `{{index .Properties "Moke"}}` { t.Errorf("illegal rpl: %s\n", rpl) } }
//func parseWormhole(s string) (*Wormhole, string) { func TestParseWormhole1(t *testing.T) { c, err := aetest.NewContext(nil) if err != nil { t.Fatal(err) } defer c.Close() wh, rpl := parseWormhole(`[[hoge]]`) if wh == nil { t.Errorf("wh is nil") } if !reflect.DeepEqual(*wh, Wormhole{ "hoge", "", false, AREA, }) { t.Errorf("illegal wh: %#v\n", wh) } if rpl != `{{index .Areas "hoge"}}` { t.Errorf("illegal rpl: %s\n", rpl) } }
func TestEndToEndTest(t *testing.T) { if testing.Short() { t.Skip() } c, clean, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer clean() err = createSampleEntities(c, 3) if err != nil { t.Fatal(err) } w := new(bytes.Buffer) err = Dump(c, w, &Options{Kind: "User", GetAfterPut: true}) if err != nil { t.Fatal(err) } t.Log("Dump output: ", w) err = Load(c, w, &Options{ GetAfterPut: true, BatchSize: 50, }) if err != nil { t.Fatal(err) } }
func TestBasicUsage1(t *testing.T) { c, closer, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer closer() src := &a.Sample{"Foo!"} index := a.NewSampleSearch() _, err = index.Put(c, src) if err != nil { t.Fatal(err) } index.Foo.Match("Foo") index.Opts().Limit(3) iter, err := index.Search(c) if err != nil { t.Fatal(err) } for { _, doc, err := iter.Next(c) if err == search.Done { break } t.Logf("%#v", doc) } }
func TestReadAfterWrite(t *testing.T) { ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } dueDate := time.Date(2016, 2, 29, 13, 0, 0, 0, time.UTC) itemId := writeTodoItem(ctx, "finish writing these tests", dueDate, false, &testUser, false) switch (*itemId).(type) { case TodoID: theTodo := readTodoItem(ctx, (*itemId).(TodoID)) switch (*theTodo).(type) { case TodoItem: theItem := (*theTodo).(TodoItem) assertEquals(t, theItem.Description, "finish writing these tests") assertEquals(t, theItem.DueDate.String(), dueDate.Local().String()) case E, TodoID: t.Fatal("Expected read to return a todo item, got ", *theTodo) } case E, TodoItem: t.Fatal("Expected write to return a todo ID, got something else") } defer done() }
func TestUpdate(t *testing.T) { ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } dueDate := time.Date(2016, 2, 29, 13, 0, 0, 0, time.UTC) id := writeTodoItem(ctx, "phone up my friend", dueDate, false, &testUser, false) switch (*id).(type) { case TodoID: id1 := ((datastore.Key)((*id).(TodoID))) result := updateTodoItem(ctx, testUser.Email, "phone up my friend", dueDate, true, id1.IntID()) switch (*result).(type) { case Ok: case Matches, E, TodoID, TodoItem: t.Fatal("Non-OK result from updateTodoItem") } item := readTodoItem(ctx, TodoID(id1)) switch (*item).(type) { case TodoItem: item1 := (*item).(TodoItem) assert(t, item1.Description == "phone up my friend", "wrong description") assert(t, item1.DueDate == dueDate, fmt.Sprintf("wrong date: expected %s, found %s [%s] {%s}", dueDate, item1.DueDate, dueDate.Sub(item1.DueDate), dueDate == item1.DueDate)) assert(t, item1.State == "completed", "expected to be completed, saw incompleted") case E, TodoID, Matches: t.Fatal("Didn't get a TodoItem result from readTodoItem") } case E, TodoItem, Matches: t.Fatal("Didn't get a TodoID result from writeTodoItem") } defer done() }
// write 1 todo item // list todo items: should be 1 item // write another todo item // list todo items again: should be 2 items func TestListWriteList(t *testing.T) { ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } dueDate := time.Date(2016, 2, 29, 13, 0, 0, 0, time.UTC) writeTodoItem(ctx, "phone up my friend", dueDate, false, &testUser, false) listResults := listTodoItems(ctx, &testUser) switch (*listResults).(type) { case Matches: items := ([]Match)((*listResults).(Matches)) assert(t, len(items) == 1, fmt.Sprintf("wrong number of todo items: expected 1, saw %d", len(items))) writeTodoItem(ctx, "buy a new phone", dueDate, false, &testUser, false) listResults1 := listTodoItems(ctx, &testUser) switch (*listResults1).(type) { case Matches: items1 := ([]Match)((*listResults1).(Matches)) assert(t, len(items1) == 2, fmt.Sprintf("wrong number of todo items: expected 2, saw %d", len(items1))) default: t.Fatal(fmt.Sprintf("weird result from second listTodoItems: %s", *listResults1)) } default: t.Fatal("weird result from listTodoItems") } defer done() }
func TestBatchSizeOnDump(t *testing.T) { c, clean, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer clean() for _, i := range []int{10, 20, 50, 99, 100, 101} { t.Logf("Testing %d entities ...", i) if err := createSampleEntities(c, i); err != nil { t.Fatal(err) } w := new(bytes.Buffer) err := Dump(c, w, &Options{Kind: "User", PrettyPrint: false}) if err != nil { t.Fatal(err) } count := strings.Count(w.String(), "__key__") if count != i { t.Errorf("Unexpected number of __key__'s %d: expected %d", count, i) } // t.Logf(w.String()) // Check if we have all keys for id := 1; id <= i; id++ { sep := fmt.Sprintf(`["User",%d]`, id) occ := strings.Count(w.String(), sep) if occ != 1 { t.Errorf("Unexpected ocorrences of entity id %d: %d, expected 1", id, occ) } } } }
func TestIndexPage(t *testing.T) { inst, err := aetest.NewInstance(nil) if err != nil { t.Fatalf("Failed to create instance: %v", err) } defer inst.Close() req, err := inst.NewRequest("GET", "/", nil) if err != nil { t.Fatalf("Failed to create request: %v", err) } w := httptest.NewRecorder() var vars map[string]string var settings Settings file, err := ioutil.ReadFile("./settings_test.json") if err == nil { json.Unmarshal(file, &settings) } ctx, _, _ := aetest.NewContext() index(&Context{ AE: ctx, Request: req, Response: w, Settings: &settings, Vars: vars, }) if w.Code != 200 { t.Errorf("Index did not return 200. Returned type was %d", w.Code) } }
func TestUsecaseSample(t *testing.T) { c, closer, err := aetest.NewContext() if err != nil { t.Fatal(err.Error()) } defer closer() sample := &Sample{ A: []int64{1, 2, 3}, } index := NewSampleSearch() _, err = index.Put(c, sample) if err != nil { t.Fatal(err.Error()) } index = NewSampleSearch() index.A.Match("3") iter, err := index.Search(c) if err != nil { t.Fatal(err) } for { docID, s, err := iter.Next(c) if err == search.Done { break } if err != nil { t.Fatal(err.Error()) } t.Logf("%s %#v", docID, s) } }
func TestBasicUsage2(t *testing.T) { c, closer, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer closer() src := &a.Sample{"Foo!"} key := datastore.NewIncompleteKey(c, "Sample", nil) _, err = datastore.Put(c, key, src) if err != nil { t.Fatal(err) } builder := a.NewSampleQueryBuilder() builder.Foo.GreaterThan("Foo").KeysOnly().Limit(3) iter := builder.Query().Run(c) for { key, err = iter.Next(nil) if err == datastore.Done { break } else if err != nil { t.Fatal(err) } src := &a.Sample{} err = datastore.Get(c, key, src) if err != nil { t.Fatal(err) } t.Logf("key: %#v, entity: %#v", key, src) } }
func TestNone(t *testing.T) { c, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() tests := []struct { name string count int contiguous bool canQuery bool ranges []NamespaceRange }{ {"testSplitWithNoNamespacesInDatastore", 10, false, true, []NamespaceRange{}}, } for _, test := range tests { results, _ := namespaceSplit(c, test.count, test.contiguous, test.canQuery) if len(results) != len(test.ranges) { t.Fatalf("%s expected %d ranges got %d", test.name, len(test.ranges), len(results)) } for i, r := range results { if r.Start != test.ranges[i].Start || r.End != test.ranges[i].End { t.Fatalf("%s expected range %d %s-%s got %s-%s", test.name, i, test.ranges[i].Start, test.ranges[i].End, r.Start, r.End) } } } }
func SetupEnv(t *testing.T) TestContext { c, clean, err := aetest.NewContext() if err != nil { t.Fatal(err) } err = aetools.Load(c, strings.NewReader(SampleEntities), aetools.LoadSync) if err != nil { defer clean() t.Fatal(err) } s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { b, _ := httputil.DumpRequest(r, true) log.Printf("Received request:\n%s\n", string(b)) enc := json.NewEncoder(w) err := enc.Encode(&bigquery.TableDataInsertAllResponse{}) log.Printf("Error writing response: %v\n", err) })) // TODO(ronoaldo): enable parallel testing. bigquerysync.InsertAllURL = fmt.Sprintf("%s/%%s/%%s/%%s", s.URL) bigquerysync.NewClient = func(c context.Context) (*http.Client, error) { return &http.Client{}, nil } tc := &testContext{ Context: c, clean: clean, server: s, } return tc }
func NewContext(t *testing.T) (context.Context, func()) { c, closeFunc, err := aetest.NewContext() if err != nil { t.Fatal(err) } return c, closeFunc }
func TestInferTableSchema(t *testing.T) { c, clean, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer clean() err = aetools.LoadJSON(c, datastoreStats, aetools.LoadSync) s, err := bigquerysync.SchemaForKind(c, "Account") if err != nil { t.Fatal(err) } j, _ := json.Marshal(s) t.Logf("Decoded schema: '%s'", string(j)) if len(s.Fields) != 4 { t.Errorf("Unexpected field len: %d, expected 4", len(s.Fields)) } for i, f := range s.Fields { if f.Name == "" { t.Errorf("Name of field %d is empty", i) } if f.Type == "" { t.Errorf("Type of field %d is empty", i) } } }
func TestSearchResultSorted(t *testing.T) { c, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() // Put multiple packages into the search index and the search result // should be sorted properly. id := "1" for i := 2; i < 6; i++ { id += strconv.Itoa(i) pdoc.Synopsis = id if err := PutIndex(c, pdoc, id, math.Pow(0.9, float64(i)), 10*i); err != nil { t.Fatal(err) } } got, err := Search(c, "test") if err != nil { t.Fatal(err) } wanted := []string{"123", "12", "1234", "12345"} for i, p := range got { if p.Synopsis != wanted[i] { t.Errorf("Search got %v, want %v", p.Synopsis, wanted[i]) } } }
func TestSessionStore(t *testing.T) { ctx, done, _ := aetest.NewContext() defer done() store := NewSessionStore(ctx) wcg.SessionStoreTest(store, t) }
func TestEncodeEntities(t *testing.T) { c, clean, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer clean() parent := datastore.NewKey(c, "Parent", "parent-1", 0, nil) entities := make([]Entity, 0, 10) for i := 0; i < 10; i++ { id := i + 1 k := datastore.NewKey(c, "Test", "", int64(id), nil) if i%2 == 0 { k = datastore.NewKey(c, "Test", "", int64(id), parent) } e := Entity{Key: k} e.Add(datastore.Property{ Name: "name", Value: fmt.Sprintf("Test Entity #%d", id), }) for j := 0; j < 3; j++ { e.Add(datastore.Property{ Name: "tags", Value: fmt.Sprintf("tag%d", j), Multiple: true, }) } e.Add(datastore.Property{ Name: "active", Value: i%2 == 0, }) e.Add(datastore.Property{ Name: "height", Value: i * 10, }) entities = append(entities, e) } p := encodeKey(entities[0].Key) t.Logf("encodeKey: from %s to %#v", entities[0].Key, p) w := new(bytes.Buffer) err = EncodeEntities(entities, w) if err != nil { t.Fatal(err) } json := w.String() t.Logf("JSON encoded entities: %s", json) attrs := []string{"name", "tags", "active", "height"} for _, a := range attrs { if !strings.Contains(json, a) { t.Errorf("Invalid JSON string: missing attribute %s.", a) } } }
func TestMain(m *testing.M) { ctx, done, _ = aetest.NewContext() result := m.Run() done() os.Exit(result) }
func TestCreateUserWithAnonymous(t *testing.T) { c, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() _ = NewStore(c) _ = user.Current(c) }
func TestPutIndexCreateNilDoc(t *testing.T) { c, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() if err := PutIndex(c, nil, "12345", -1, 2); err == nil { t.Errorf("PutIndex succeeded unexpectedly") } }
func TestImport(t *testing.T) { c, done, err := aetest.NewContext() //ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() testTimeParse(t, c) //testDaysParse(t, c) }
func TestPutIndexWithEmptyId(t *testing.T) { c, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() if err := PutIndex(c, nil, "", 0, 0); err == nil { t.Errorf("PutIndex succeeded unexpectedly") } }
func TestList(t *testing.T) { c, done, _ := aetest.NewContext() defer done() ds := service.FromContext(c) //geo.LoadPolygonFromFile(ds) //time.Sleep(10000) t.Log("calling") resp := geo.PointInPolygon(ds, 13.477646709852323, 80.18274600000001) t.Log("exiting") t.Log(resp) }
func TestRapDemo(t *testing.T) { _, done, err := aetest.NewContext() //ctx, done, err := aetest.NewContext() if err != nil { t.Fatal(err) } defer done() //test that the base pages come back basePageTester(t, "index", "map", "calendar") }