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) 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) TestReadMessageWithTerminateJSON(c *check.C) {
cmd, err := commandmocker.Add("sudo", "service nginx reload")
c.Assert(err, check.IsNil)
defer commandmocker.Remove(cmd)
// Setup instance file
u := Config.Upstreams[0]
instance := &ec2.Instance{InstanceId: s.instance_ids[0], PrivateDNSName: "test.internal"}
if err := addInstance(u, instance); err != nil {
c.Error(err)
}
payload := `{"TopicArn":"arn:test","Message":
"{\"AutoScalingGroupARN\":\"arn:asg-test\",\"Event\":\"autoscaling:EC2_INSTANCE_TERMINATE\",\"EC2InstanceId\":\"%s\"}"}`
b := strings.NewReader(fmt.Sprintf(payload, s.instance_ids[0]))
recorder, request := newRequest("POST", "/", b, c)
readMessage(recorder, request)
body := readBody(recorder.Body, c)
c.Assert(body, check.Equals, fmt.Sprintf(`Removed instance "%s".`, s.instance_ids[0]))
c.Assert(recorder.Code, check.Equals, 200)
// Check upstreams file
content, err := ioutil.ReadFile(u.File)
c.Assert(err, check.IsNil)
c.Assert(string(content), check.Equals, fmt.Sprintf("upstream %s {\n}\n", u.Name))
// Check run NGINX reload
c.Assert(commandmocker.Ran(cmd), check.Equals, true)
}
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 *S) TestReadMessageWithLaunchJSON(c *check.C) {
cmd, err := commandmocker.Add("sudo", "service nginx reload")
c.Assert(err, check.IsNil)
defer commandmocker.Remove(cmd)
payload := `{"TopicArn":"arn:test","Message":` +
`"{\"AutoScalingGroupARN\":\"arn:asg-test\",\"Event\":\"autoscaling:EC2_INSTANCE_LAUNCH\",` +
`\"EC2InstanceId\":\"%s\"}"}`
b := strings.NewReader(fmt.Sprintf(payload, s.instance_ids[0]))
recorder, request := newRequest("POST", "/", b, c)
readMessage(recorder, request)
body := readBody(recorder.Body, c)
c.Assert(body, check.Equals, fmt.Sprintf(`Added instance "%s".`, s.instance_ids[0]))
c.Assert(recorder.Code, check.Equals, 200)
// Check upstreams file
upstream := Config.Upstreams[0]
content, err := ioutil.ReadFile(upstream.File)
c.Assert(err, check.IsNil)
serverLine := fmt.Sprintf("server %s.internal.invalid:80 max_fails=3 fail_timeout=60s; # %s\n", s.instance_ids[0], s.instance_ids[0])
c.Assert(string(content), check.Equals, fmt.Sprintf("upstream %s {\n %s}\n", upstream.Name, serverLine))
// Check run NGINX reload
c.Assert(commandmocker.Ran(cmd), check.Equals, true)
}
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) TestGrantAccessShouldAddUserToListOfRepositories(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
r, err := New("proj1", []string{"someuser"}, true)
c.Assert(err, gocheck.IsNil)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
defer conn.Repository().RemoveId(r.Name)
r2, err := New("proj2", []string{"otheruser"}, true)
c.Assert(err, gocheck.IsNil)
defer conn.Repository().RemoveId(r2.Name)
u := struct {
Name string `bson:"_id"`
}{Name: "lolcat"}
err = conn.User().Insert(&u)
c.Assert(err, gocheck.IsNil)
defer conn.User().RemoveId(u.Name)
err = GrantAccess([]string{r.Name, r2.Name}, []string{u.Name})
c.Assert(err, gocheck.IsNil)
err = conn.Repository().FindId(r.Name).One(&r)
c.Assert(err, gocheck.IsNil)
err = conn.Repository().FindId(r2.Name).One(&r2)
c.Assert(err, gocheck.IsNil)
c.Assert(r.Users, gocheck.DeepEquals, []string{"someuser", u.Name})
c.Assert(r2.Users, gocheck.DeepEquals, []string{"otheruser", u.Name})
}
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) 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")
s.tmpdir, err = commandmocker.Add("git", "")
c.Assert(err, gocheck.IsNil)
}
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 *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) TestCollectStatusInvalidYAML(c *gocheck.C) {
tmpdir, err := commandmocker.Add("juju", "local: somewhere::")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
p := JujuProvisioner{}
_, err = p.CollectStatus()
c.Assert(err, gocheck.NotNil)
pErr, ok := err.(*provision.Error)
c.Assert(ok, gocheck.Equals, true)
c.Assert(pErr.Reason, gocheck.Equals, `"juju status" returned invalid data: local: somewhere::`)
c.Assert(pErr.Err, gocheck.ErrorMatches, `^YAML error:.*$`)
}
func (s *S) TestExecuteWithoutArgs(c *gocheck.C) {
tmpdir, err := commandmocker.Add("ls", "ok")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
var e OsExecutor
var b bytes.Buffer
err = e.Execute("ls", nil, nil, &b, &b)
c.Assert(err, gocheck.IsNil)
c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true)
c.Assert(commandmocker.Parameters(tmpdir), gocheck.IsNil)
c.Assert(b.String(), gocheck.Equals, "ok")
}
func (s *S) TestCollectStatusDirtyOutput(c *gocheck.C) {
server, url := badGatewayServer()
defer server.Close()
tmpdir, err := commandmocker.Add("juju", generateDirtyOutput(url))
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
expected := []provision.Unit{
{
Name: "as_i_rise/0",
AppName: "as_i_rise",
Type: "django",
Machine: 105,
InstanceId: "i-00000439",
Ip: url,
Status: provision.StatusUnreachable,
},
{
Name: "the_infanta/1",
AppName: "the_infanta",
Type: "gunicorn",
Machine: 107,
InstanceId: "i-0000043e",
Ip: url,
Status: provision.StatusBuilding,
},
}
p := JujuProvisioner{}
units, err := p.CollectStatus()
c.Assert(err, gocheck.IsNil)
cp := make([]provision.Unit, len(units))
copy(cp, units)
if cp[0].Type == "gunicorn" {
cp[0], cp[1] = cp[1], cp[0]
}
c.Assert(cp, gocheck.DeepEquals, expected)
c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true)
var wg sync.WaitGroup
wg.Add(1)
collection := p.unitsCollection()
defer collection.Close()
go func() {
q := bson.M{"_id": bson.M{"$in": []string{"as_i_rise/0", "the_infanta/1"}}}
for {
if n, _ := collection.Find(q).Count(); n == 2 {
break
}
runtime.Gosched()
}
collection.Remove(q)
wg.Done()
}()
wg.Wait()
}
func (s *S) TestNewShouldCreateNewGitBareRepository(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
_, err = New("myRepo", []string{"pumpkin"}, true)
c.Assert(err, gocheck.IsNil)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
defer conn.Repository().Remove(bson.M{"_id": "myRepo"})
c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true)
}
func (s *S) TestConflictingRepositoryNameShouldReturnExplicitError(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
_, err = New("someRepo", []string{"gollum"}, true)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
defer conn.Repository().Remove(bson.M{"_id": "someRepo"})
c.Assert(err, gocheck.IsNil)
_, err = New("someRepo", []string{"gollum"}, true)
c.Assert(err, gocheck.ErrorMatches, "A repository with this name already exists.")
}
func (s *S) TestExecute(c *gocheck.C) {
tmpdir, err := commandmocker.Add("ls", "ok")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
var e OsExecutor
var b bytes.Buffer
err = e.Execute("ls", []string{"-lsa"}, nil, &b, &b)
c.Assert(err, gocheck.IsNil)
c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true)
expected := []string{"-lsa"}
c.Assert(commandmocker.Parameters(tmpdir), gocheck.DeepEquals, expected)
c.Assert(b.String(), gocheck.Equals, "ok")
}
func (s *S) TestNewBareShouldNotPassTemplateOptionWhenItsNotSetInConfig(c *gocheck.C) {
config.Unset("git:bare:template")
bareLocation, err := config.GetString("git:bare:location")
c.Assert(err, gocheck.IsNil)
barePath := path.Join(bareLocation, "foo.git")
dir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(dir)
err = newBare("foo")
c.Assert(err, gocheck.IsNil)
c.Assert(commandmocker.Ran(dir), gocheck.Equals, true)
expected := fmt.Sprintf("init %s --bare", barePath)
c.Assert(commandmocker.Output(dir), gocheck.Equals, expected)
}
func (s *S) TestRemoveShouldRemoveBareRepositoryFromFileSystem(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
rfs := &fstesting.RecordingFs{FileContent: "foo"}
fs.Fsystem = rfs
defer func() { fs.Fsystem = nil }()
r, err := New("myRepo", []string{"pumpkin"}, false)
c.Assert(err, gocheck.IsNil)
err = Remove(r.Name)
c.Assert(err, gocheck.IsNil)
action := "removeall " + path.Join(bareLocation(), "myRepo.git")
c.Assert(rfs.HasAction(action), gocheck.Equals, true)
}
func (s *S) TestNewShouldCreateANewRepository(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
users := []string{"smeagol", "saruman"}
r, err := New("myRepo", users, false)
c.Assert(err, gocheck.IsNil)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
defer conn.Repository().Remove(bson.M{"_id": "myRepo"})
c.Assert(r.Name, gocheck.Equals, "myRepo")
c.Assert(r.Users, gocheck.DeepEquals, users)
c.Assert(r.IsPublic, gocheck.Equals, false)
}
func (s *S) TestExecuteActionShouldNotCallSSH_ORIGINAL_COMMANDWhenRepositoryDoesNotExists(c *gocheck.C) {
dir, err := commandmocker.Add("git-receive-pack", "$*")
c.Check(err, gocheck.IsNil)
defer commandmocker.Remove(dir)
os.Args = []string{"gandalf", s.user.Name}
os.Setenv("SSH_ORIGINAL_COMMAND", "git-receive-pack 'ghostapp.git'")
defer func() {
os.Args = []string{}
os.Setenv("SSH_ORIGINAL_COMMAND", "")
}()
stdout := &bytes.Buffer{}
errorMsg := "You don't have access to write in this repository."
executeAction(hasWritePermission, errorMsg, stdout)
c.Assert(commandmocker.Ran(dir), gocheck.Equals, false)
}
func (s *S) TestNewBareShouldPassTemplateOptionWhenItExistsOnConfig(c *check.C) {
bareTemplate := "/var/templates"
bareLocation, err := config.GetString("git:bare:location")
config.Set("git:bare:template", bareTemplate)
defer config.Unset("git:bare:template")
barePath := path.Join(bareLocation, "foo.git")
dir, err := commandmocker.Add("git", "$*")
c.Assert(err, check.IsNil)
defer commandmocker.Remove(dir)
err = newBare("foo")
c.Assert(err, check.IsNil)
c.Assert(commandmocker.Ran(dir), check.Equals, true)
expected := fmt.Sprintf("init %s --bare --template=%s", barePath, bareTemplate)
c.Assert(commandmocker.Output(dir), check.Equals, expected)
}
func (s *S) TestInstanceMachineHealWhenEverythingIsOk(c *gocheck.C) {
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
jujuTmpdir, err := commandmocker.Add("juju", collectOutput)
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(jujuTmpdir)
h := instanceMachineHealer{}
err = h.Heal()
c.Assert(err, gocheck.IsNil)
args := []string{
"status", // for juju status that gets the output
}
c.Assert(commandmocker.Ran(jujuTmpdir), gocheck.Equals, true)
c.Assert(commandmocker.Parameters(jujuTmpdir), gocheck.DeepEquals, args)
}
func (s *S) TestDeploy(c *gocheck.C) {
tmpdir, err := commandmocker.Add("juju", "")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
config.Set("git:unit-repo", "test/dir")
defer func() {
config.Unset("git:unit-repo")
}()
app := testing.NewFakeApp("cribcaged", "python", 1)
w := &bytes.Buffer{}
p := JujuProvisioner{}
err = p.Deploy(app, "f83ac40", w)
c.Assert(err, gocheck.IsNil)
expected := []string{"set", app.GetName(), "app-version=f83ac40"}
c.Assert(commandmocker.Parameters(tmpdir)[:3], gocheck.DeepEquals, expected)
}
func (s *S) TestNewShouldRecordItOnDatabase(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
r, err := New("someRepo", []string{"smeagol"}, false)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
defer conn.Repository().Remove(bson.M{"_id": "someRepo"})
c.Assert(err, gocheck.IsNil)
err = conn.Repository().Find(bson.M{"_id": "someRepo"}).One(&r)
c.Assert(err, gocheck.IsNil)
c.Assert(r.Name, gocheck.Equals, "someRepo")
c.Assert(r.Users, gocheck.DeepEquals, []string{"smeagol"})
c.Assert(r.IsPublic, gocheck.Equals, false)
}
func (s *ELBSuite) TestAddUnitsWithELB(c *gocheck.C) {
tmpdir, err := commandmocker.Add("juju", addUnitsOutput)
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
app := testing.NewFakeApp("resist", "rush", 0)
p := JujuProvisioner{}
_, err = p.AddUnits(app, 4)
c.Assert(err, gocheck.IsNil)
expected := []string{
"resist", "resist/3", "resist/4",
"resist/5", "resist/6",
}
msg, err := getQueue(queueName).Get(1e9)
c.Assert(err, gocheck.IsNil)
c.Assert(msg.Action, gocheck.Equals, addUnitToLoadBalancer)
c.Assert(msg.Args, gocheck.DeepEquals, expected)
}
func (s *S) TestExecuteWithoutArgs(c *gocheck.C) {
tmpdir, err := commandmocker.Add("ls", "ok")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
var e OsExecutor
var b bytes.Buffer
opts := ExecuteOptions{
Cmd: "ls",
Stdout: &b,
Stderr: &b,
}
err = e.Execute(opts)
c.Assert(err, gocheck.IsNil)
c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true)
c.Assert(commandmocker.Parameters(tmpdir), gocheck.IsNil)
c.Assert(b.String(), gocheck.Equals, "ok")
}
func (s *S) TestCollectStatusShouldNotAddBootstraTwice(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{}
_, err = p.CollectStatus()
c.Assert(err, gocheck.IsNil)
_, err = p.CollectStatus()
c.Assert(err, gocheck.IsNil)
collection := p.bootstrapCollection()
defer collection.Close()
l, err := collection.Find(nil).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(l, gocheck.Equals, 1)
}
func (s *S) TestRemoveShouldRemoveRepositoryFromDatabase(c *gocheck.C) {
tmpdir, err := commandmocker.Add("git", "$*")
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
rfs := &fstesting.RecordingFs{FileContent: "foo"}
fs.Fsystem = rfs
defer func() { fs.Fsystem = nil }()
r, err := New("myRepo", []string{"pumpkin"}, false)
c.Assert(err, gocheck.IsNil)
err = Remove(r.Name)
c.Assert(err, gocheck.IsNil)
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
err = conn.Repository().Find(bson.M{"_id": r.Name}).One(&r)
c.Assert(err, gocheck.ErrorMatches, "^not found$")
}
func (s *S) TestExecuteActionShouldExecuteGitReceivePackWhenUserHasWritePermission(c *gocheck.C) {
dir, err := commandmocker.Add("git-receive-pack", "$*")
c.Check(err, gocheck.IsNil)
defer commandmocker.Remove(dir)
os.Args = []string{"gandalf", s.user.Name}
os.Setenv("SSH_ORIGINAL_COMMAND", "git-receive-pack 'myapp.git'")
defer func() {
os.Args = []string{}
os.Setenv("SSH_ORIGINAL_COMMAND", "")
}()
stdout := &bytes.Buffer{}
executeAction(hasWritePermission, "You don't have access to write in this repository.", stdout)
c.Assert(commandmocker.Ran(dir), gocheck.Equals, true)
p, err := config.GetString("git:bare:location")
c.Assert(err, gocheck.IsNil)
expected := path.Join(p, "myapp.git")
c.Assert(stdout.String(), gocheck.Equals, expected)
}