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)
}
func TestInjector_Call(t *testing.T) {
container := injector.NewInjector()
container.SetLogger(test.NewTestLogger(t))
container.RegisterValue(10)
container.RegisterValue("foo")
var result1 string
err := container.Call(func(a int, b string) string {
return fmt.Sprint(a, b)
}, &result1)
test.Fatal(t, err, nil)
test.Fatal(t, result1, "10foo")
}
func getDocumentManager(t *testing.T) (dm mongo.DocumentManager, done func()) {
dm = mongo.NewDocumentManager(getDB(t))
err := dm.GetDB().DropDatabase()
test.Fatal(t, err, nil)
if debug == true || verbose == true {
dm.SetLogger(test.NewTestLogger(t))
}
done = func() {
dm.GetDB().DropDatabase()
dm.GetDB().Session.Close()
}
return
}
func TestInjector_Resolve_Parent(t *testing.T) {
type Person struct{ Name string }
container := injector.NewInjector()
container.SetLogger(test.NewTestLogger(t))
container.RegisterValue("foo")
childContainer := container.CreateChild()
err := childContainer.RegisterFactory(func(name string) (Person, error) {
return Person{name}, nil
})
test.Fatal(t, err, nil)
person := &Person{}
err = childContainer.Resolve(person)
test.Fatal(t, err, nil)
test.Fatal(t, person.Name, "foo")
}
func TestInjector_Resolve_Factory(t *testing.T) {
container := injector.NewInjector()
container.SetLogger(test.NewTestLogger(t))
err := container.RegisterFactory(func(a int, b string) (string, error) {
return fmt.Sprint(a, b), nil
}, "service")
test.Fatal(t, err, nil)
container.RegisterValue(5)
container.RegisterValue("bar")
var result string
err = container.Resolve(&result, "service")
test.Fatal(t, err, nil)
test.Fatal(t, result, "5bar")
}
func TestInjector_Populate(t *testing.T) {
type Target struct {
ID int `injector:"id"`
Name string `injector:"name"`
}
var target Target
container := injector.NewInjector()
container.SetLogger(test.NewTestLogger(t))
container.RegisterValue(10, "id")
container.RegisterValue(20)
container.RegisterValue("john doe", "name")
container.RegisterValue("jane doe")
err := container.Populate(&target)
test.Fatal(t, err, nil)
test.Fatal(t, target.ID, 10)
test.Fatal(t, target.Name, "john doe")
}
func TestInjector_RegisterValue(t *testing.T) {
var s string
type id string
container := injector.NewInjector()
container.RegisterValue("foo")
err := container.Resolve(&s)
test.Fatal(t, err, nil)
test.Fatal(t, s, "foo")
container = injector.NewInjector()
container.RegisterValue("bar", "bar")
err = container.Resolve(&s)
test.Fatal(t, err, injector.ErrorServiceNotFound)
container = injector.NewInjector()
container.SetLogger(test.NewTestLogger(t))
container.RegisterValue(id("some_id"))
err = container.Resolve(&s)
test.Fatal(t, err, injector.ErrorServiceNotFound)
var i id
err = container.Resolve(&i)
test.Fatal(t, err, nil)
test.Fatal(t, i, id("some_id"))
}
func Example() {
type Author struct {
// ID is the mongo id, needs to be set explicitly
ID bson.ObjectId `bson:"_id,omitempty"`
// Name is the author's name
// unfortunatly mgo driver lowercases mongo keys by default
// so always explicitely set the key name to the field name
//
// index(unique:true) creates an unix index on key Name, so
// there is no duplicates for that key
Name string `bson:"Name" odm:"index(unique:true)"`
}
type Tag struct {
ID bson.ObjectId `bson:"_id,omitempty"`
Name string `bson:"Name" odm:"index"`
}
type Article struct {
ID bson.ObjectId `bson:"_id,omitempty"`
// The title of the blog post
Title string `bson:"Title"`
// The author of the post, the owning side of the Article/Author relationship
Author *Author `odm:"referenceOne(targetDocument:Author)"`
// Article references many tags.
// cascade tells the document manager to automatically persist related Tags when Article is persisted,
// it will also automatically remove related tags as well.
Tags []*Tag `odm:"referenceMany(targetDocument:Tag,cascade:all)"`
}
// create a mongodb connection
session, err := mgo.Dial(os.Getenv("MONGODB_TEST_SERVER"))
if err != nil {
log.Println("error connecting to the db", err)
return
}
// select a database
db := session.DB(os.Getenv("MONGODB_TEST_DB"))
defer cleanUp(db)
// create a document manager
documentManager := mongo.NewDocumentManager(db)
if debug == true {
documentManager.SetLogger(test.NewTestLogger(&test.ExampleTester{log.New(os.Stderr, "", log.LstdFlags)}))
}
// register the types into the document manager
if err = documentManager.RegisterMany(map[string]interface{}{
"Article": new(Article),
"Author": new(Author),
"Tag": new(Tag),
}); err != nil {
log.Println("error registering types", err)
return
}
// create some documents
author := &Author{Name: "John Doe"}
programmingTag := &Tag{Name: "programming"}
article1 := &Article{Title: "Go tiger!", Author: author, Tags: []*Tag{{Name: "go"}, programmingTag}}
article2 := &Article{Title: "MongoDB", Author: author, Tags: []*Tag{programmingTag}}
// plan for saving
// we don't need to explicitly persist Tags since
// Article type cascade persists tags
documentManager.Persist(author)
documentManager.Persist(article1)
documentManager.Persist(article2)
// do commit changes
if err = documentManager.Flush(); err != nil {
log.Println("error saving documents", err)
return
}
// query the database
author = new(Author)
if err = documentManager.FindOne(bson.M{"Name": "John Doe"}, author); err != nil {
log.Println("error fetching author", err)
return
}
fmt.Println("author's name :", author.Name)
// query a document by ID
authorID := author.ID
author = new(Author)
if err = documentManager.FindID(authorID, author); err != nil {
log.Println("error fetching author by id", err)
return
}
// fetch all documents
articles := []*Article{}
if err = documentManager.FindAll(&articles); err != nil {
log.Println("error fetching articles", err)
return
}
fmt.Println("articles length :", len(articles))
// or query specific documents
articles = []*Article{}
if err = documentManager.FindBy(bson.M{"Title": "MongoDB"}, &articles); err != nil {
log.Println("error fetching articles by title", err)
return
}
fmt.Println("articles length :", len(articles))
// remove a document
documentManager.Remove(articles[0])
if err = documentManager.Flush(); err != nil {
log.Println("error removing article", err)
return
}
// since removing an article remove the related tags, 'programming' tag
// should not exist in the db
tag := new(Tag)
if err = documentManager.FindOne(bson.M{"Name": "programming"}, tag); err != mgo.ErrNotFound {
log.Printf("%+v\n", tag)
log.Println("the error should be : mgo.ErrNotFound, got ", err)
return
}
// use complex queries
author = new(Author)
// query one document
query := documentManager.CreateQuery().
Find(bson.M{"Name": "John Doe"}).Select(bson.M{"Name": 1})
if err = query.One(author); err != nil {
log.Println("Error querying one author", err)
return
}
fmt.Println("name:", author.Name)
authors := []*Author{}
// query multiple documents
query = documentManager.CreateQuery().
Find(bson.M{"Name": bson.M{"$ne": "Jane Doe"}}).
Select(bson.M{"ID": 1, "Name": 1}).
Skip(0).Limit(50).Sort("Name")
if err = query.All(&authors); err != nil {
log.Println("Error querying authors", err)
return
}
fmt.Println("authors:", len(authors))
// Output:
// author's name : John Doe
// articles length : 2
// articles length : 1
// name: John Doe
// authors: 1
}