func (s *S) TestProvisionerProvision(c *gocheck.C) { config.Set("local:authorized-key-path", "somepath") rfs := &fstesting.RecordingFs{} fsystem = rfs defer func() { fsystem = nil }() f, _ := os.Open("testdata/dnsmasq.leases") data, err := ioutil.ReadAll(f) c.Assert(err, gocheck.IsNil) file, err := rfs.Create("/var/lib/misc/dnsmasq.leases") c.Assert(err, gocheck.IsNil) _, err = file.Write(data) c.Assert(err, gocheck.IsNil) tmpdir, err := commandmocker.Add("sudo", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) sshTempDir, err := commandmocker.Add("ssh", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(sshTempDir) scpTempDir, err := commandmocker.Add("scp", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(scpTempDir) var p LocalProvisioner app := testing.NewFakeApp("myapp", "python", 0) defer p.collection().Remove(bson.M{"name": "myapp"}) c.Assert(p.Provision(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { for { coll := s.conn.Collection(s.collName) ct, err := coll.Find(bson.M{"name": "myapp", "status": provision.StatusStarted}).Count() if err != nil { c.Fatal(err) } if ct > 0 { ok <- true return } time.Sleep(1e3) } }() select { case <-ok: case <-time.After(10e9): c.Fatal("Timed out waiting for the container to be provisioned (10 seconds)") } c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected := "lxc-create -t ubuntu -n myapp -- -S somepath" expected += "lxc-start --daemon -n myapp" expected += "service nginx restart" c.Assert(commandmocker.Output(tmpdir), gocheck.Equals, expected) var unit provision.Unit err = s.conn.Collection(s.collName).Find(bson.M{"name": "myapp"}).One(&unit) c.Assert(err, gocheck.IsNil) c.Assert(unit.Ip, gocheck.Equals, "10.10.10.15") }
func (s *ELBSuite) TestRemoveUnitWithELB(c *gocheck.C) { instIds := make([]string, 4) units := make([]provision.Unit, len(instIds)) for i := 0; i < len(instIds); i++ { id := s.server.NewInstance() defer s.server.RemoveInstance(id) instIds[i] = id units[i] = provision.Unit{ Name: "radio/" + strconv.Itoa(i), InstanceId: id, } } tmpdir, err := commandmocker.Add("juju", "unit removed") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) app := testing.NewFakeApp("radio", "rush", 4) manager := ELBManager{} manager.e = s.client err = manager.Create(app) c.Assert(err, gocheck.IsNil) defer manager.Destroy(app) err = manager.Register(app, units...) c.Assert(err, gocheck.IsNil) p := JujuProvisioner{} fUnit := testing.FakeUnit{Name: units[0].Name, InstanceId: units[0].InstanceId} err = p.removeUnit(app, &fUnit) c.Assert(err, gocheck.IsNil) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) c.Assert(resp.LoadBalancerDescriptions[0].Instances, gocheck.HasLen, len(units)-1) instance := resp.LoadBalancerDescriptions[0].Instances[0] c.Assert(instance.InstanceId, gocheck.Equals, instIds[1]) }
func (s *ELBSuite) TestDestroyWithELB(c *gocheck.C) { config.Set("juju:charms-path", "/home/charms") defer config.Unset("juju:charms-path") tmpdir, err := commandmocker.Add("juju", "deployed") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) app := testing.NewFakeApp("jimmy", "who", 0) p := JujuProvisioner{} err = p.Provision(app) c.Assert(err, gocheck.IsNil) err = p.Destroy(app) c.Assert(err, gocheck.IsNil) lb := p.LoadBalancer() defer lb.Destroy(app) // sanity addr, err := lb.Addr(app) c.Assert(addr, gocheck.Equals, "") c.Assert(err, gocheck.NotNil) c.Assert(err.Error(), gocheck.Equals, "not found") q := getQueue(queueName) msg, err := q.Get(1e9) c.Assert(err, gocheck.IsNil) if msg.Action == addUnitToLoadBalancer && msg.Args[0] == "jimmy" { msg.Delete() } else { q.Release(msg, 0) } }
func (s *ELBSuite) TestHandleMessagesWithPendingUnits(c *gocheck.C) { id := s.server.NewInstance() defer s.server.RemoveInstance(id) app := testing.NewFakeApp("2112", "python", 1) router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(app.GetName()) defer router.RemoveBackend(app.GetName()) output := strings.Replace(collectOutputNoInstanceID, "i-00004444", id, 1) tmpdir, err := commandmocker.Add("juju", output) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) handle(&queue.Message{ Action: addUnitToLoadBalancer, Args: []string{"2112", "2112/0", "2112/1"}, }) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 1) c.Assert(instances[0].InstanceId, gocheck.Equals, id) msg, err := getQueue(queueName).Get(5e9) c.Assert(err, gocheck.IsNil) c.Assert(msg.Action, gocheck.Equals, addUnitToLoadBalancer) c.Assert(msg.Args, gocheck.DeepEquals, []string{"2112", "2112/1"}) }
func (s *S) TestRemoveUnit(c *gocheck.C) { tmpdir, err := commandmocker.Add("juju", "removed") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) app := testing.NewFakeApp("two", "rush", 3) p := JujuProvisioner{} conn, collection := p.unitsCollection() defer conn.Close() err = collection.Insert(instance{UnitName: "two/2", InstanceId: "i-00000439"}) c.Assert(err, gocheck.IsNil) err = p.RemoveUnit(app, "two/2") c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected := []string{"remove-unit", "two/2", "terminate-machine", "3"} ran := make(chan bool, 1) go func() { for { if reflect.DeepEqual(commandmocker.Parameters(tmpdir), expected) { ran <- true } time.Sleep(1e3) } }() n, err := collection.Find(bson.M{"_id": "two/2"}).Count() c.Assert(err, gocheck.IsNil) c.Assert(n, gocheck.Equals, 0) select { case <-ran: case <-time.After(2e9): c.Errorf("Did not run terminate-machine command after 2 seconds.") } }
func (s *S) TestAddRoute(c *gocheck.C) { tmpdir, err := commandmocker.Add("sudo", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) config.Set("nginx:domain", "andrewzito.com") config.Set("nginx:routes-path", "testdata") rfs := &testing.RecordingFs{} fsystem = rfs defer func() { fsystem = nil }() var r NginxRouter err = r.AddRoute("name", "127.0.0.1") c.Assert(err, gocheck.IsNil) file, err := rfs.Open("testdata/name") c.Assert(err, gocheck.IsNil) data, err := ioutil.ReadAll(file) c.Assert(err, gocheck.IsNil) expected := `server { listen 80; server_name name.andrewzito.com; location / { proxy_pass http://127.0.0.1; } }` c.Assert(string(data), gocheck.Equals, expected) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected = "service nginx restart" c.Assert(commandmocker.Output(tmpdir), gocheck.Equals, expected) }
func (s *S) TestCollectStatusIDChangeDisabledELB(c *gocheck.C) { tmpdir, err := commandmocker.Add("juju", collectOutput) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) p := JujuProvisioner{} conn, collection := p.unitsCollection() defer conn.Close() err = collection.Insert(instance{UnitName: "as_i_rise/0", InstanceId: "i-00000239"}) c.Assert(err, gocheck.IsNil) defer collection.Remove(bson.M{"_id": bson.M{"$in": []string{"as_i_rise/0", "the_infanta/0"}}}) _, err = p.CollectStatus() c.Assert(err, gocheck.IsNil) done := make(chan int8) go func() { for { q := bson.M{"_id": "as_i_rise/0", "instanceid": "i-00000439"} ct, err := collection.Find(q).Count() c.Assert(err, gocheck.IsNil) if ct == 1 { done <- 1 return } time.Sleep(1e3) } }() select { case <-done: case <-time.After(5e9): c.Fatal("Did not update the unit after 5 seconds.") } }
func (s *S) TestGrantAccessShouldAddUserToListOfRepositories(c *C) { tmpdir, err := commandmocker.Add("git", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) r, err := New("proj1", []string{"someuser"}, true) c.Assert(err, IsNil) defer db.Session.Repository().RemoveId(r.Name) r2, err := New("proj2", []string{"otheruser"}, true) c.Assert(err, IsNil) defer db.Session.Repository().RemoveId(r2.Name) u := struct { Name string `bson:"_id"` }{Name: "lolcat"} err = db.Session.User().Insert(&u) c.Assert(err, IsNil) defer db.Session.User().RemoveId(u.Name) err = GrantAccess([]string{r.Name, r2.Name}, []string{u.Name}) c.Assert(err, IsNil) err = db.Session.Repository().FindId(r.Name).One(&r) c.Assert(err, IsNil) err = db.Session.Repository().FindId(r2.Name).One(&r2) c.Assert(err, IsNil) c.Assert(r.Users, DeepEquals, []string{"someuser", u.Name}) c.Assert(r2.Users, DeepEquals, []string{"otheruser", u.Name}) }
func (s *S) TestCollectStatusDirtyOutput(c *C) { tmpdir, err := commandmocker.Add("juju", dirtyCollectOutput) c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) expected := []provision.Unit{ { Name: "as_i_rise/0", AppName: "as_i_rise", Type: "django", Machine: 105, Ip: "10.10.10.163", Status: provision.StatusStarted, }, { Name: "the_infanta/1", AppName: "the_infanta", Type: "gunicorn", Machine: 107, Ip: "10.10.10.168", Status: provision.StatusInstalling, }, } p := JujuProvisioner{} units, err := p.CollectStatus() c.Assert(err, IsNil) if units[0].Type == "gunicorn" { units[0], units[1] = units[1], units[0] } c.Assert(units, DeepEquals, expected) c.Assert(commandmocker.Ran(tmpdir), Equals, true) }
func (s *S) TestDestroy(c *C) { tmpdir, err := commandmocker.Add("juju", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) app := NewFakeApp("cribcaged", "python", 3) p := JujuProvisioner{} err = p.Destroy(app) c.Assert(err, IsNil) c.Assert(commandmocker.Ran(tmpdir), Equals, true) expected := []string{ "destroy-service", "cribcaged", "terminate-machine", "1", "terminate-machine", "2", "terminate-machine", "3", } ran := make(chan bool, 1) go func() { for { if reflect.DeepEqual(commandmocker.Parameters(tmpdir), expected) { ran <- true } } }() select { case <-ran: case <-time.After(2e9): c.Errorf("Did not run terminate-machine commands after 2 seconds.") } c.Assert(commandmocker.Parameters(tmpdir), DeepEquals, expected) }
func (s *S) TestBootstrapProvisionHealerHeal(c *gocheck.C) { p := JujuProvisioner{} m := machine{ AgentState: "not-started", IpAddress: "localhost", InstanceId: "i-00000376", InstanceState: "running", } p.saveBootstrapMachine(m) conn, collection := p.bootstrapCollection() defer conn.Close() defer collection.Remove(m) sshTmpdir, err := commandmocker.Add("ssh", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(sshTmpdir) sshOutput := []string{ "-o", "StrictHostKeyChecking no", "-q", "-l", "ubuntu", "localhost", "sudo", "start", "juju-provision-agent", } h := bootstrapProvisionHealer{} err = h.Heal() c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(sshTmpdir), gocheck.Equals, true) c.Assert(commandmocker.Parameters(sshTmpdir), gocheck.DeepEquals, sshOutput) }
func (s *S) TestExecuteCommandUnitDown(c *C) { var buf bytes.Buffer tmpdir, err := commandmocker.Add("juju", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) app := NewFakeApp("almah", "static", 3) app.units[1].(*FakeUnit).status = provision.StatusDown p := JujuProvisioner{} err = p.ExecuteCommand(&buf, &buf, app, "ls", "-lha") c.Assert(err, IsNil) cmdOutput := "ssh -o StrictHostKeyChecking no -q 1 ls -lha" cmdOutput += "ssh -o StrictHostKeyChecking no -q 3 ls -lha" bufOutput := `Output from unit "almah/0": ssh -o StrictHostKeyChecking no -q 1 ls -lha Output from unit "almah/1": Unit state is "down", it must be "started" for running commands. Output from unit "almah/2": ssh -o StrictHostKeyChecking no -q 3 ls -lha ` c.Assert(commandmocker.Ran(tmpdir), Equals, true) c.Assert(commandmocker.Output(tmpdir), Equals, cmdOutput) c.Assert(buf.String(), Equals, bufOutput) }
func (s *S) TestBootstrapMachineHealerDontNeedsHeal(c *gocheck.C) { tmpdir, err := commandmocker.Add("juju", collectOutput) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) h := bootstrapMachineHealer{} c.Assert(h.needsHeal(), gocheck.Equals, false) }
func (s *S) TestRemoveUnits(c *C) { tmpdir, err := commandmocker.Add("juju", "removed") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) app := NewFakeApp("xanadu", "rush", 4) p := JujuProvisioner{} units, err := p.RemoveUnits(app, 3) c.Assert(err, IsNil) expected := []string{ "remove-unit", "xanadu/0", "xanadu/1", "xanadu/2", "terminate-machine", "1", "terminate-machine", "2", "terminate-machine", "3", } ran := make(chan bool, 1) go func() { for { if reflect.DeepEqual(commandmocker.Parameters(tmpdir), expected) { ran <- true } } }() select { case <-ran: case <-time.After(2e9): params := commandmocker.Parameters(tmpdir) c.Fatalf("Did not run terminate-machine commands after 2 seconds. Parameters: %#v", params) } c.Assert(units, DeepEquals, []int{0, 1, 2}) }
func (s *ELBSuite) TestHandleMessageWithoutUnits(c *gocheck.C) { instIds := make([]string, 3) for i := 0; i < len(instIds); i++ { id := s.server.NewInstance() defer s.server.RemoveInstance(id) instIds[i] = id } replace := []string{"i-00004444", "i-00004445", "i-00004450"} output := simpleCollectOutput for i, r := range replace { output = strings.Replace(output, r, instIds[i], 1) } tmpdir, err := commandmocker.Add("juju", output) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) app := testing.NewFakeApp("symfonia", "python", 1) router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(app.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(app.GetName()) handle(&queue.Message{ Action: addUnitToLoadBalancer, Args: []string{"symfonia"}, }) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 3) ids := []string{instances[0].InstanceId, instances[1].InstanceId, instances[2].InstanceId} sort.Strings(ids) sort.Strings(instIds) c.Assert(ids, gocheck.DeepEquals, instIds) }
func (s *ELBSuite) TestHandleMessageWithUnits(c *gocheck.C) { id1 := s.server.NewInstance() id2 := s.server.NewInstance() defer s.server.RemoveInstance(id1) defer s.server.RemoveInstance(id2) app := testing.NewFakeApp("symfonia", "python", 1) router, err := Router() c.Assert(err, gocheck.IsNil) router.AddBackend(app.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(app.GetName()) output := strings.Replace(simpleCollectOutput, "i-00004444", id1, -1) output = strings.Replace(output, "i-00004445", id2, -1) tmpdir, err := commandmocker.Add("juju", output) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) msg := queue.Message{ Action: addUnitToLoadBalancer, Args: []string{"symfonia", "symfonia/0", "symfonia/1"}, } handle(&msg) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 2) ids := []string{instances[0].InstanceId, instances[1].InstanceId} sort.Strings(ids) want := []string{id1, id2} sort.Strings(want) c.Assert(ids, gocheck.DeepEquals, want) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) }
func (s *S) TestCollectStatusIDChangeFromPending(c *gocheck.C) { server, url := badGatewayServer() defer server.Close() tmpdir, err := commandmocker.Add("juju", generateOutput(url)) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) p := JujuProvisioner{} collection := p.unitsCollection() defer collection.Close() err = collection.Insert(instance{UnitName: "as_i_rise/0", InstanceID: "pending"}) c.Assert(err, gocheck.IsNil) defer collection.Remove(bson.M{"_id": bson.M{"$in": []string{"as_i_rise/0", "the_infanta/0"}}}) _, err = p.CollectStatus() c.Assert(err, gocheck.IsNil) done := make(chan int8) go func() { for { q := bson.M{"_id": "as_i_rise/0", "instanceid": "i-00000439"} ct, err := collection.Find(q).Count() c.Assert(err, gocheck.IsNil) if ct == 1 { done <- 1 return } runtime.Gosched() } }() select { case <-done: case <-time.After(5e9): c.Fatal("Did not update the unit after 5 seconds.") } }
func (s *ELBSuite) TestHandleMessagesAllPendingUnits(c *gocheck.C) { app := testing.NewFakeApp("2112", "python", 1) router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(app.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(app.GetName()) tmpdir, err := commandmocker.Add("juju", collectOutputAllPending) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) msg := queue.Message{ Action: addUnitToLoadBalancer, Args: []string{"2112", "2112/0", "2112/1"}, } handle(&msg) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 0) got, err := getQueue(queueName).Get(1e6) c.Assert(err, gocheck.IsNil) c.Assert(*got, gocheck.DeepEquals, msg) got.Delete() }
func (s *S) TestNewBareShouldCreateADir(c *gocheck.C) { dir, err := commandmocker.Add("git", "$*") c.Check(err, gocheck.IsNil) defer commandmocker.Remove(dir) err = newBare("myBare") c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(dir), gocheck.Equals, true) }
func (s *S) TestInstanceMachineHealWhenEverythingIsOk(c *gocheck.C) { jujuTmpdir, err := commandmocker.Add("juju", collectOutput) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(jujuTmpdir) sshTmpdir, err := commandmocker.Add("ssh", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(sshTmpdir) jujuOutput := []string{ "status", // for juju status that gets the output } h := instanceMachineHealer{} err = h.Heal() c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(jujuTmpdir), gocheck.Equals, true) c.Assert(commandmocker.Parameters(jujuTmpdir), gocheck.DeepEquals, jujuOutput) c.Assert(commandmocker.Ran(sshTmpdir), gocheck.Equals, false) }
func (s *S) TestRestartRouter(c *gocheck.C) { tmpdir, err := commandmocker.Add("sudo", "$*") c.Assert(err, gocheck.IsNil) err = RestartRouter() c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected := "service nginx restart" c.Assert(commandmocker.Output(tmpdir), gocheck.Equals, expected) }
func (s *ELBSuite) TestCollectStatusWithELBAndIDChange(c *gocheck.C) { a := testing.NewFakeApp("symfonia", "symfonia", 0) p := JujuProvisioner{} router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(a.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(a.GetName()) id1 := s.server.NewInstance() defer s.server.RemoveInstance(id1) id2 := s.server.NewInstance() defer s.server.RemoveInstance(id2) id3 := s.server.NewInstance() defer s.server.RemoveInstance(id3) collection := p.unitsCollection() defer collection.Close() err = collection.Insert(instance{UnitName: "symfonia/0", InstanceID: id3}) c.Assert(err, gocheck.IsNil) err = router.AddRoute(a.GetName(), id3) c.Assert(err, gocheck.IsNil) err = router.AddRoute(a.GetName(), id2) c.Assert(err, gocheck.IsNil) q := bson.M{"_id": bson.M{"$in": []string{"symfonia/0", "symfonia/1", "symfonia/2", "raise/0"}}} defer collection.Remove(q) output := strings.Replace(simpleCollectOutput, "i-00004444", id1, 1) output = strings.Replace(output, "i-00004445", id2, 1) tmpdir, err := commandmocker.Add("juju", output) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) _, err = p.CollectStatus() c.Assert(err, gocheck.IsNil) done := make(chan int8) go func() { for { q := bson.M{"_id": "symfonia/0", "instanceid": id1} ct, err := collection.Find(q).Count() c.Assert(err, gocheck.IsNil) if ct == 1 { done <- 1 return } runtime.Gosched() } }() select { case <-done: case <-time.After(5e9): c.Fatal("Did not save the unit after 5 seconds.") } resp, err := s.client.DescribeLoadBalancers(a.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 2) c.Assert(instances[0].InstanceId, gocheck.Equals, id2) c.Assert(instances[1].InstanceId, gocheck.Equals, id1) }
func (s *S) SetUpSuite(c *gocheck.C) { err := config.ReadConfigFile("../etc/gandalf.conf") c.Assert(err, gocheck.IsNil) config.Set("database:url", "127.0.0.1:27017") config.Set("database:name", "gandalf_api_tests") db.Connect() s.tmpdir, err = commandmocker.Add("git", "") c.Assert(err, gocheck.IsNil) }
func (s *S) TestNewShouldCreateNewGitBareRepository(c *C) { tmpdir, err := commandmocker.Add("git", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) _, err = New("myRepo", []string{"pumpkin"}, true) c.Assert(err, IsNil) defer db.Session.Repository().Remove(bson.M{"_id": "myRepo"}) c.Assert(commandmocker.Ran(tmpdir), Equals, true) }
func (s *S) TestConflictingRepositoryNameShouldReturnExplicitError(c *C) { tmpdir, err := commandmocker.Add("git", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) _, err = New("someRepo", []string{"gollum"}, true) defer db.Session.Repository().Remove(bson.M{"_id": "someRepo"}) c.Assert(err, IsNil) _, err = New("someRepo", []string{"gollum"}, true) c.Assert(err, ErrorMatches, "A repository with this name already exists.") }
func (s *S) TestNewContainer(c *gocheck.C) { id := "945132e7b4c9" tmpdir, err := commandmocker.Add("docker", id) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) app := testing.NewFakeApp("app-name", "python", 1) container, _ := newContainer(app, deployContainerCmd) c.Assert(container.name, gocheck.Equals, "app-name") c.Assert(container.id, gocheck.Equals, id) }
func (s *S) TestImageCommitReturnsImageId(c *gocheck.C) { tmpdir, err := commandmocker.Add("docker", "945132e7b4c9\n") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) img := image{Name: "app-name", Id: "image-id"} id, err := img.commit("container-id") defer img.remove() c.Assert(err, gocheck.IsNil) c.Assert(id, gocheck.Equals, "945132e7b4c9") }
func (s *S) TestProvision(c *C) { tmpdir, err := commandmocker.Add("juju", "$*") c.Assert(err, IsNil) defer commandmocker.Remove(tmpdir) app := NewFakeApp("trace", "python", 0) p := JujuProvisioner{} err = p.Provision(app) c.Assert(err, IsNil) c.Assert(commandmocker.Ran(tmpdir), Equals, true) c.Assert(commandmocker.Output(tmpdir), Equals, "deploy --repository /home/charms local:python trace") }
func (s *S) TestLXCDestroy(c *gocheck.C) { tmpdir, err := commandmocker.Add("sudo", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) container := container{name: "container"} err = container.destroy() c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected := "lxc-destroy -n container" c.Assert(commandmocker.Output(tmpdir), gocheck.Equals, expected) }
func (s *S) TestProvisionSetup(c *gocheck.C) { tmpdir, err := commandmocker.Add("scp", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) sshTempDir, err := commandmocker.Add("ssh", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(sshTempDir) p := LocalProvisioner{} formulasPath := "/home/ubuntu/formulas" config.Set("local:formulas-path", formulasPath) err = p.setup("10.10.10.10", "static") c.Assert(err, gocheck.IsNil) c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) cmds := []string{ "-q", "-o", "StrictHostKeyChecking no", "-r", formulasPath + "/static/hooks", "[email protected]:/var/lib/tsuru", } c.Assert(commandmocker.Parameters(tmpdir), gocheck.DeepEquals, cmds) c.Assert(commandmocker.Ran(sshTempDir), gocheck.Equals, true) cmds = []string{ "-q", "-o", "StrictHostKeyChecking no", "-l", "ubuntu", "10.10.10.10", "sudo mkdir -p /var/lib/tsuru/hooks", "-q", "-o", "StrictHostKeyChecking no", "-l", "ubuntu", "10.10.10.10", "sudo chown -R ubuntu /var/lib/tsuru/hooks", } c.Assert(commandmocker.Parameters(sshTempDir), gocheck.DeepEquals, cmds) }