Golang aetest.NewContext函数代码示例

func TestPayFwd(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	pay, err := bcy.CreatePayFwd(c, PayFwd{Destination: keys1.Address})
	if err != nil {
		t.Error("CreatePayFwd error encountered: ", err)
	}
	t.Logf("%+v\n", pay)
	pay, err = bcy.GetPayFwd(c, pay.ID)
	if err != nil {
		t.Error("GetPayFwd error encountered: ", err)
	}
	t.Logf("%+v\n", pay)
	if err = bcy.DeletePayFwd(c, pay.ID); err != nil {
		t.Error("DeletePayFwd error encountered: ", err)
	}
	pays, err := bcy.ListPayFwds(c)
	if err != nil {
		t.Error("ListPayFwds error encountered: ", err)
	}
	//Should be empty
	t.Logf("%+v\n", pays)
	return
}

func (t *testSuite) TestGame() {
	c, err := aetest.NewContext(nil)
	if c != nil {
		defer c.Close()
	}
	if err != nil {
		t.Error("Could not start aetest - %v", err)
		return
	}
	g := goon.FromContext(c)
	game := NewGame(4)
	game.Dealer = 0
	game.Players[1] = createAI()
	game.Players[1].SetHand(g, c, game, Hand{KD, QD, JD, JD, ND, TC, KC, QC, KH, NH, QS, NS}, 0, 1)
	game.Players[2] = createAI()
	game.Players[2].SetHand(g, c, game, Hand{AD, AD, KD, ND, NC, NC, TH, JH, AS, JS, JS, NS}, 0, 2)
	game.Players[3] = createAI()
	game.Players[3].SetHand(g, c, game, Hand{AC, AC, KC, JC, JC, TH, QH, QH, JH, AS, TS, KS}, 0, 3)
	game.Players[0] = createAI()
	game.Players[0].SetHand(g, c, game, Hand{TD, TD, QD, TC, QC, AH, AH, KH, NH, TS, KS, QS}, 0, 0)
	game.Meld = make([]uint8, len(game.Players)/2)
	game.CountMeld = make([]bool, len(game.Players)/2)
	game.Counters = make([]uint8, len(game.Players)/2)
	game.HighBid = 20
	game.HighPlayer = game.Dealer
	game.State = StateBid
	game.Next = game.Dealer
	//oright = game.Players[0].(*AI).HT
	//Log(oright.Owner, "Start of game hands")
	//oright.Debug()
	game.inc() // so dealer's not the first to bid

	game.processAction(g, c, nil, game.Players[game.Next].Tell(nil, nil, game, CreateBid(0, game.Next)))
	t.True(true) // just getting to the end successfully counts!
}

func TestLoadStoreTokens(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatalf("Couldn't start local datastore: %s", err)
	}
	defer c.Close()

	tok, err := NewToken(userID, path, now)
	if err != nil {
		t.Fatalf("Error creating token: %s", err)
	}
	if err := tok.Store(c); err != nil {
		t.Fatalf("Error storing token: %s", err)
	}
	tok1, err := TokenForRequest(c, userID, path)
	if err != nil {
		t.Fatalf("Error looking up token: %s", err)
	}
	if !reflect.DeepEqual(tok, tok1) {
		t.Errorf("Tokens don't match; %v instead of %v", tok1, tok)
	}
	tok.Delete(c)
	_, err = TokenForRequest(c, userID, path)
	if err != ErrTokenNotFound {
		t.Errorf("Should not have found token on second lookup")
	}
}

func TestPlayerSaveNoSeason(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	name := "Player Name"
	email := "[email protected]"
	faction := "Skorne"
	err = SavePlayer(c, nil, name, email, faction)
	if err != nil {
		t.Fatalf("Error saving player: %v", err)
	}
	p := LoadPlayer(c, nil, email)
	if p == nil {
		t.Fatal("Loading player gave us a nil player")
	}
	if p.Name != name {
		t.Errorf("Expected player name to be '%s' not '%s'", name, p.Name)
	}
	if p.Email != email {
		t.Errorf("Expected player email to be '%s' instead it was '%s'", email, p.Email)
	}
	if p.Faction != faction {
		t.Errorf("Expected player faction to be '%s' instead it was '%s'", faction, p.Faction)
	}
}

func TestAppEngine(t *testing.T) {
	ctx, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer ctx.Close()

	cache := New(ctx)

	key := "testKey"
	_, ok := cache.Get(key)
	if ok {
		t.Fatal("retrieved key before adding it")
	}

	val := []byte("some bytes")
	cache.Set(key, val)

	retVal, ok := cache.Get(key)
	if !ok {
		t.Fatal("could not retrieve an element we just added")
	}
	if !bytes.Equal(retVal, val) {
		t.Fatal("retrieved a different value than what we put in")
	}

	cache.Delete(key)

	_, ok = cache.Get(key)
	if ok {
		t.Fatal("deleted key still present")
	}
}

func TestHandlers(t *testing.T) {
	_, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	resp := httptest.NewRecorder()
	uri := "/api/tasks/"
	var testjson1 = `{"summary" : "task1",
                "content" : ["taskcontent1"],
    "done": false}`
	instance, err := aetest.NewInstance(nil)
	if err != nil {
		t.Fatal(err)
	}
	req, err := instance.NewRequest("POST", uri, ioutil.NopCloser(strings.NewReader(testjson1)))
	http.DefaultServeMux.ServeHTTP(resp, req)
	if p, err := ioutil.ReadAll(resp.Body); err != nil {
		t.Fail()

	} else {
		if strings.Contains(string(p), "Error") {
			t.Errorf("header response shouldn't return error: %s: ", p)
		}
		if !strings.Contains(string(p), "task1") {
			t.Errorf("header response doesn't match: \n%s", p)
		}
	}

	getreq, err := instance.NewRequest("GET", uri, nil)
	if err != nil {
		t.Fatal(err)
	}
	http.DefaultServeMux.ServeHTTP(resp, getreq)
	if p, err := ioutil.ReadAll(resp.Body); err != nil {
		t.Fail()
	} else {
		if strings.Contains(string(p), "Error") {
			t.Errorf("header response shouldn't return erros: %s: ", p)
		}
		if !strings.Contains(string(p), "task1") {
			t.Errorf("header response doesn't match: \n%s", p)
		}
		if !strings.Contains(string(p), "taskcontent1") {
			t.Errorf("header reponse doesn't match: \n%s", p)
		}
	}
	uri = "/api/task/5629499534213120"
	delreq, err := instance.NewRequest("DELETE", uri, nil)
	if err != nil {
		t.Fatal(err)
	}
	http.DefaultServeMux.ServeHTTP(resp, delreq)
	if p, err := ioutil.ReadAll(resp.Body); err != nil {
		t.Fail()
	} else {
		if strings.Contains(string(p), "Error") {
			t.Errorf("header response shouldn't return error: %s: ", p)
		}
	}
}

func TestMicro(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	result, err := bcy.SendMicro(c, MicroTX{Priv: keys2.Private, ToAddr: keys1.Address, Value: 25000})
	if err != nil {
		t.Error("Error encountered: ", err)
	}
	t.Logf("%+v\n", result)
	//Test public key signing method
	micpub, err := bcy.SendMicro(c, MicroTX{Pubkey: keys2.Public, ToAddr: keys1.Address, Value: 15000})
	if err != nil {
		t.Error("Error encountered: ", err)
	}
	t.Logf("First MicroTX Pubkey call: %+v\n", micpub)
	//Sign resultpub
	err = micpub.Sign(keys2.Private)
	if err != nil {
		t.Error("Error encountered: ", err)
	}
	t.Logf("Signed MicroTX: %+v\n", micpub)
	//Send signed resultpub
	resultpub, err := bcy.SendMicro(c, micpub)
	if err != nil {
		t.Error("Error encountered: ", err)
	}
	t.Logf("Final MicroTX Pubkey call: %+v\n", resultpub)
	return
}

func TestKeyAndSaveAndList(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	t1 := Task{Summary: "some summary", Id: 123}
	t2 := Task{Summary: "second summary", Id: 222}
	if _, err := t1.save(c); err != nil {
		t.Fatal(err)
	}
	if _, err := t2.save(c); err != nil {
		t.Fatal(err)
	}
	k1 := t1.key(c)
	k1id := k1.IntID()
	if k1id != 123 {
		t.Error("Expected 123, got: ", k1id)
	}
	k2 := t2.key(c)
	k2id := k2.IntID()
	if k2id != 222 {
		t.Error("Expected 222, got: ", k2id)
	}
	tasks, err := listTasks(c)
	if err != nil {
		t.Fatal(err)
	}
	if tasks[0].Id != 123 {
		t.Error("Expected 123, got: ", tasks[0].Id)
	}
	if tasks[1].Id != 222 {
		t.Error("Expected 222, got: ", tasks[1].Id)
	}
}

func TestOpHandler_AddSucess(t *testing.T) {
	c, err := aetest.NewContext(&aetest.Options{StronglyConsistentDatastore: true})
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	// The test has two operations. One is added at investment creation and the other is added via handler.
	firstOp, _ := NewOperationFromString(typeStr, valueStr, firstOpDateStr)
	secondOp, _ := NewOperationFromString(typeStr, valueStr, dateStr)
	// Adding investment along with first operation.
	inv := &Investment{Name: "testInv", Ops: Operations{firstOp}}
	if err := PutInvestment(c, inv); err != nil {
		t.Fatal(err)
	}
	// This should add an operation that is exactly like second operation.
	form := url.Values{OpsParamInv: {inv.Key}, OpsParamType: {typeStr}, OpsParamValue: {valueStr}, OpsParamDate: {dateStr}}
	if err := handleOp(c, &http.Request{Form: form}); err != nil {
		t.Fatalf("handleOp want nil got:%q", err)
	}
	gotInv, err := GetInvestment(c, inv.Key)
	if err != nil {
		t.Errorf("getInvestment returned an error: %q", err)
	}
	// Even though firstOp happened latter, operations must be chronologically sorted.
	if !reflect.DeepEqual(firstOp, gotInv.Ops[0]) { // There is already one operation inserted.
		t.Errorf("want:%v got:%v", firstOp, gotInv.Ops[0])
	}
	if !reflect.DeepEqual(secondOp, gotInv.Ops[1]) { // There is already one operation inserted.
		t.Errorf("want:%v got:%v", secondOp, gotInv.Ops[1])
	}
}

func initFileSystems() (fss []fsi.FileSystem, c aetest.Context) {

	var err error
	c, err = aetest.NewContext(nil)
	if err != nil {
		log.Fatal(err)
	}

	// defer c.Close()
	// Not here, but instead at the start of the test-funcs

	// We cant make variadic options generic,
	// since they need the concrete filesystem type.
	fs1 := dsfs.New(
		dsfs.MountName(dsfs.MountPointLast()),
		dsfs.AeContext(c),
	)

	fs3 := osfs.New()

	fs4 := memfs.New(
		memfs.Ident("m"),
	)

	fss = []fsi.FileSystem{fs1, fs3, fs4}

	return fss, c
}

func (s *S) Test(c *C) {
	ctx, err := aetest.NewContext(nil)
	if err != nil {
		c.Fatal(err)
	}
	defer ctx.Close()

	cache := New(ctx)

	key := "testKey"
	_, ok := cache.Get(key)

	c.Assert(ok, Equals, false)

	val := []byte("some bytes")
	cache.Set(key, val)

	retVal, ok := cache.Get(key)
	c.Assert(ok, Equals, true)
	c.Assert(bytes.Equal(retVal, val), Equals, true)

	cache.Delete(key)

	_, ok = cache.Get(key)
	c.Assert(ok, Equals, false)
}

func TestPlayerSaveNoSeason(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	name := "Player Name"
	faction := "Skorne"
	player := Player{
		Name:    name,
		Faction: faction,
	}
	players := make([]Player, 1)
	players[0] = player
	SavePlayers(c, nil, players)
	p := LoadPlayer(c, nil, name)
	if p == nil {
		t.Fatal("Loading player gave us a nil player")
	}
	if p.Name != name {
		t.Errorf("Expected player name to be '%s' not '%s'", name, p.Name)
	}
	if p.Faction != faction {
		t.Errorf("Expected player faction to be '%s' instead it was '%s'", faction, p.Faction)
	}
}

func TestEditTask(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	key := datastore.NewKey(c, "Task", "", 123456789, defaultTaskList(c))
	id, _ := strconv.ParseInt("123456789", 10, 64)
	if id != 123456789 {
		t.Fatal(err)
	}
	if _, err := datastore.Put(c, key, &Task{Summary: "some summary"}); err != nil {
		t.Fatal(err)
	}
	task1ret := Task{}
	newkey := keyForID(c, id)
	if err := datastore.Get(c, newkey, &task1ret); err != nil {
		t.Fatal(err)
	}
	tid := newkey.IntID()
	if task1ret.Summary != "some summary" {
		t.Error("Expected <some summary>, got: ", task1ret.Summary)
	}
	if tid != 123456789 {
		t.Error("Expected id 123456789, got: ", tid)
	}

}

// TestSuccessCodeAndInfoForComplexMessage sends out a complex message to the pubnub channel
// The response is parsed and should match the 'sent' status.
// _publishSuccessMessage and customstruct is defined in the common.go file
func TestSuccessCodeAndInfoForComplexMessage(t *testing.T) {
	context, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer context.Close()
	uuid := ""
	w, req := InitAppEngineContext(t)

	pubnubInstance := messaging.New(context, uuid, w, req, PubKey, SubKey, "", "", false)

	//pubnubInstance := messaging.NewPubnub(PubKey, SubKey, "", "", false, "", "", false)
	channel := "testChannel"

	customStruct := CustomStruct{
		Foo: "hi!",
		Bar: []int{1, 2, 3, 4, 5},
	}

	returnChannel := make(chan []byte)
	errorChannel := make(chan []byte)
	responseChannel := make(chan string)
	waitChannel := make(chan string)

	//go pubnubInstance.Publish(channel, customStruct, returnChannel, errorChannel)
	go pubnubInstance.Publish(context, w, req, channel, customStruct, returnChannel, errorChannel)
	go ParsePublishResponse(returnChannel, channel, publishSuccessMessage, "SuccessCodeAndInfoForComplexMessage", responseChannel)

	go ParseErrorResponse(errorChannel, responseChannel)
	go WaitForCompletion(responseChannel, waitChannel)
	ParseWaitResponse(waitChannel, t, "SuccessCodeAndInfoForComplexMessage")
	time.Sleep(2 * time.Second)
}

func TestListTasks(t *testing.T) {
	c, err := aetest.NewContext(nil)
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	assert := assert.New(t)
	t1 := Task{Summary: "task1", Done: true}
	t2 := Task{Summary: "task2", Done: false}
	t1n, err := t1.save(c)
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t1n.Done, true)
	t2n, err := t2.save(c)
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t2n.Done, false)
	tasklist, err := listTasks(c)
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(tasklist[0].Summary, "task2")
	assert.Equal(tasklist[1].Done, true)
}