Golang test.Fatal函數代碼示例

func TestDeleteWithoutAlias(t *testing.T) {
	connection := NewTestConnection(t)
	qb := db.NewQueryBuilder(connection)
	qb.Delete("users")
	test.Fatal(t, db.Delete, qb.GetType())
	test.Fatal(t, "DELETE FROM users", qb.String())
}

func TestDocumentManager_Register_StoreIdAnnotation(t *testing.T) {
	type Person struct {
		ID   bson.ObjectId `bson:"_id"`
		Name string        `bson:"Name"`
	}
	type Family struct {
		ID        bson.ObjectId   `bson:"_id"`
		Name      string          `bson:"Name"`
		Members   []*Person       `odm:"referenceMany(targetDocument:Person,storeId:MemberIDs,cascade:all)"`
		MemberIDs []bson.ObjectId `bson:"MemberIDs"`
	}
	dm, done := getDocumentManager(t)
	defer done()
	err := dm.RegisterMany(map[string]interface{}{
		"Person": new(Person),
		"Family": new(Family),
	})
	test.Fatal(t, err, nil)
	family := &Family{Name: "Doe", Members: []*Person{{Name: "John"}, {Name: "Jane"}, {Name: "Jack"}}}
	dm.Persist(family)
	err = dm.Flush()
	test.Fatal(t, err, nil)
	family = new(Family)
	err = dm.FindOne(bson.M{"Name": "Doe"}, family)
	test.Fatal(t, err, nil)
	test.Fatal(t, len(family.MemberIDs), 3)
}

func TestSetFirstResult(t *testing.T) {
	connection := NewTestConnection(t)
	qb := db.NewQueryBuilder(connection)
	qb.SetFirstResult(10)
	test.Fatal(t, qb.GetState(), db.Dirty)
	test.Fatal(t, qb.GetFirstResult(), 10)
}

func TestParser(t *testing.T) {
	testLogger := logger.NewTestLogger(t)

	for _, fixture := range []struct {
		String      string
		Length      int
		Definitions []*tag.Definition
	}{
		{`field:foo;complex_field(name:param,name2:param2,name_3:3);field:1;last_field`,
			4,
			[]*tag.Definition{
				{Name: "field", Value: "foo"},
				{Name: "complex_field", Parameters: []tag.Parameter{{Key: "name", Value: "param"}, {Key: "name2", Value: "param2"}, {Key: "name_3", Value: "3"}}},
				{Name: "field", Value: "1"},
				{Name: "last_field"},
			},
		},
	} {
		parser := tag.NewParser(strings.NewReader(fixture.String))
		parser.SetLogger(testLogger)
		definitions, err := parser.Parse()
		test.Fatal(t, err, nil)
		test.Fatal(t, len(definitions), fixture.Length)
		test.Fatal(t, reflect.DeepEqual(definitions, fixture.Definitions), true)
	}

}

func TestMongo(t *testing.T) {

	type Test struct {
		ID bson.ObjectId `bson:"_id,omitempty"`
		Name,
		Description string
	}

	session, err := mgo.Dial(os.Getenv("MONGODB_TEST_SERVER"))
	test.Fatal(t, err, nil)
	defer session.Close()
	defer session.DB(os.Getenv("MONGODB_TEST_DB")).C("mongo_tests").DropCollection()

	// Optional. Switch the session to a monotonic behavior.
	session.SetMode(mgo.Monotonic, true)
	collection := session.DB(os.Getenv("MONGODB_TEST_DB")).C("mongo_tests")
	test1 := &Test{Name: "Initial", Description: "A simple test"}
	err = collection.Insert(test1)
	test.Fatal(t, err, nil)
	result := new(Test)
	err = collection.Find(bson.M{"name": test1.Name}).One(result)
	test.Error(t, err, nil)
	test.Error(t, result.Description, test1.Description)
	result1 := new(Test)
	err = collection.FindId(result.ID).One(result1)
	test.Error(t, err, nil)
	test.Error(t, result1.ID, result.ID)
}

func TestConnectionPrepare(t *testing.T) {
	connection := GetConnection(t)
	defer connection.Close()
	result, err := connection.Prepare("SELECT * from users").Exec()
	test.Fatal(t, err, nil)
	test.Fatal(t, result != nil, true)
}

func TestConnectionArray(t *testing.T) {
	connection := GetConnection(t)
	LoadFixtures(connection)
	var users []*AppUser
	err := connection.Query("SELECT * FROM users WHERE name IN (?,?)", []interface{}{"John Doe", "Jane Doe"}...).GetResults(&users)
	test.Fatal(t, err, nil)
	test.Fatal(t, len(users), 2)
}

func SubTestDocumentManager_FindOne(dm mongo.DocumentManager, t *testing.T) bson.ObjectId {
	user := new(User)
	err := dm.FindOne(bson.M{"Name": "John"}, user)
	test.Fatal(t, err, nil)
	test.Fatal(t, user.Role != nil, true)
	test.Fatal(t, user.Role.Title, "Editor")
	return user.ID
}

func SubTestDocumentManager_FindAll(dm mongo.DocumentManager, t *testing.T) {
	users := []*User{}
	err := dm.FindAll(&users)
	test.Fatal(t, err, nil)
	test.Fatal(t, len(users), 1)
	test.Fatal(t, len(users[0].Posts), 1)
	test.Fatal(t, users[0].Posts[0].Title, "First Post Title")
	test.Fatal(t, users[0].Role != nil, true)
}

func TestUpdate(t *testing.T) {
	connection := NewTestConnection(t)
	qb := db.NewQueryBuilder(connection)
	qb.Update("users", "u").
		Set("u.foo", "?").
		Set("u.bar", "?")
	test.Fatal(t, qb.GetType(), db.Update)
	test.Fatal(t, qb.String(), "UPDATE users u SET u.foo = ?, u.bar = ?")
}

func TestGetState(t *testing.T) {
	connection := NewTestConnection(t)
	qb := db.NewQueryBuilder(connection)
	test.Fatal(t, qb.GetState(), db.Clean)
	qb.Select("u.*").From("users", "u")
	test.Fatal(t, qb.GetState(), db.Dirty)
	qb.String()
	test.Fatal(t, qb.GetState(), db.Clean)
}

func TestSQLTagBuilder(t *testing.T) {
	tag := "column:nick_name"
	sqlTag := db.SQLStructTagBuilder{logger.NewTestLogger(t)}.BuildFromString(tag)
	test.Fatal(t, sqlTag.ColumnName, "nick_name")
	test.Fatal(t, sqlTag.PersistZeroValue, false)
	tag = "column:email_address,persistzerovalue"
	sqlTag = db.SQLStructTagBuilder{logger.NewTestLogger(t)}.BuildFromString(tag)
	test.Fatal(t, sqlTag.ColumnName, "email_address")
	test.Fatal(t, sqlTag.PersistZeroValue, true)
}

func TestInsertValuesSetValue(t *testing.T) {
	connection := NewTestConnection(t)

	qb := db.NewQueryBuilder(connection)
	qb.Insert("users").
		SetValue("foo", "?").
		SetValue("bar", "?")
	test.Fatal(t, db.Insert, qb.GetType())
	test.Fatal(t, "INSERT INTO users (foo, bar) VALUES(?, ?)", qb.String())
}

func TestDocumentManager_CreateQuery_Select(t *testing.T) {
	t.Log("QueryBuilder.Select should also affect which relations are resolved")
	dm, done := getDocumentManager(t)
	defer done()
	err := dm.RegisterMany(map[string]interface{}{
		"Client":   new(Client),
		"Employee": new(Employee),
		"Project":  new(Project),
	})
	test.Fatal(t, err, nil)
	client := &Client{Name: "Example"}
	employee := &Employee{Name: "John Doe"}
	project := &Project{Title: "Project", Employee: employee}
	client.Projects = append(client.Projects, project)
	dm.Persist(client)
	dm.Persist(employee)
	dm.Persist(project)
	err = dm.Flush()
	test.Fatal(t, err, nil)
	projects := []*Project{}
	err = dm.CreateQuery().Select(bson.M{"Client": 1}).All(&projects)
	test.Fatal(t, err, nil)
	test.Fatal(t, projects[0].Employee == nil, true)
	test.Fatal(t, projects[0].Client.Name, "Example")
	client = new(Client)
	err = dm.CreateQuery().Select(bson.M{"Name": 1}).One(client)
	test.Fatal(t, err, nil)
	test.Fatal(t, len(client.Projects), 0)
	err = dm.FindID(client.ID, client)
	test.Fatal(t, err, nil)
	test.Fatal(t, len(client.Projects), 1)
}

func TestInjector_Resolve_CircularDependency(t *testing.T) {
	container := injector.NewInjector()
	container.SetLogger(test.NewTestLogger(t))
	err := container.RegisterFactory(func(i int) (int, error) {
		return i, nil
	})
	test.Fatal(t, err, nil)
	var i int
	err = container.Resolve(&i)
	test.Fatal(t, err, injector.ErrorCircularDependency)
}