func (s *S) TestDeployLogsActions(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
provisioner := testing.NewFakeProvisioner()
provisioner.PrepareOutput([]byte(""))
provisioner.PrepareOutput([]byte("updated"))
app := testing.NewFakeApp("cribcaged", "python", 1)
provisioner.Provision(app)
w := &bytes.Buffer{}
err := Git(provisioner, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7", w)
c.Assert(err, gocheck.IsNil)
logs := w.String()
expected := `
---> tsuru receiving push
---> Replicating the application repository across units
---> Installing dependencies
---> Restarting application
Restarting app...
---> Deploy done!
`
c.Assert(logs, gocheck.Equals, expected)
}
func (s *ELBSuite) TestDestroyWithELB(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
config.Set("juju:charms-path", "/home/charms")
defer config.Unset("juju:charms-path")
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
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)
router, err := Router()
c.Assert(err, gocheck.IsNil)
defer router.RemoveBackend(app.GetName())
addr, err := router.Addr(app.GetName())
c.Assert(addr, gocheck.Equals, "")
c.Assert(err, gocheck.NotNil)
c.Assert(err, gocheck.ErrorMatches, "not found")
q := getQueue(queueName)
msg, err := q.Get(1e9)
c.Assert(err, gocheck.IsNil)
if msg.Action != addUnitToLoadBalancer {
q.Put(msg, 0)
}
}
func (s *S) TestDestroyShouldUnbindAppFromInstance(c *gocheck.C) {
h := testHandler{}
tsg := testing.StartGandalfTestServer(&h)
defer tsg.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNoContent)
}))
defer ts.Close()
srvc := service.Service{Name: "my", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.Services().Remove(bson.M{"_id": srvc.Name})
instance := service.ServiceInstance{Name: "MyInstance", Apps: []string{"whichapp"}, ServiceName: srvc.Name}
err = instance.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.ServiceInstances().Remove(bson.M{"_id": instance.Name})
a := App{
Name: "whichapp",
Platform: "python",
Teams: []string{},
}
err = CreateApp(&a, s.user)
c.Assert(err, gocheck.IsNil)
app, err := GetByName(a.Name)
c.Assert(err, gocheck.IsNil)
err = Delete(app)
c.Assert(err, gocheck.IsNil)
n, err := s.conn.ServiceInstances().Find(bson.M{"apps": bson.M{"$in": []string{a.Name}}}).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(n, gocheck.Equals, 0)
}
func (s *S) SetUpTest(c *gocheck.C) {
s.conn, _ = db.Conn()
s.reqs = make([]*http.Request, 0)
s.bodies = make([]string, 0)
s.rsps = make(map[string]string)
s.testHandler = tsuruTesting.TestHandler{}
s.gandalf = tsuruTesting.StartGandalfTestServer(&s.testHandler)
}
func (s *S) SetUpSuite(c *gocheck.C) {
config.Set("git:api-server", "http://*****:*****@git.tsuru.io:foobar.git"}`
s.h = &tsrTesting.TestHandler{Content: content}
s.ts = tsrTesting.StartGandalfTestServer(s.h)
}
func (s *S) TestDeployRemoveContainersEvenWhenTheyreNotInTheAppsCollection(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(3)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
cont1, err := s.newContainer(nil)
defer s.removeTestContainer(cont1)
c.Assert(err, gocheck.IsNil)
cont2, err := s.newContainer(nil)
defer s.removeTestContainer(cont2)
c.Assert(err, gocheck.IsNil)
defer rtesting.FakeRouter.RemoveBackend(cont1.AppName)
var p dockerProvisioner
a := app.App{
Name: "otherapp",
Platform: "python",
Units: []app.Unit{{Name: "i-0800", State: "started"}},
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
var w bytes.Buffer
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: &w,
})
c.Assert(err, gocheck.IsNil)
time.Sleep(1e9)
defer p.Destroy(&a)
q, err := getQueue()
c.Assert(err, gocheck.IsNil)
for _, u := range a.ProvisionedUnits() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.GetName())
}
coll := collection()
defer coll.Close()
n, err := coll.Find(bson.M{"appname": cont1.AppName}).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(n, gocheck.Equals, 2)
}
func (s *S) TestAddrWithoutUnits(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
app := testing.NewFakeApp("squeeze", "who", 0)
p := JujuProvisioner{}
addr, err := p.Addr(app)
c.Assert(addr, gocheck.Equals, "")
c.Assert(err, gocheck.NotNil)
c.Assert(err.Error(), gocheck.Equals, `App "squeeze" has no units.`)
}
func (s *S) TestCreateRepositoryBackward(c *gocheck.C) {
h := testHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
app := App{Name: "someapp"}
ctx := action.BWContext{FWResult: &app, Params: []interface{}{app}}
createRepository.Backward(ctx)
c.Assert(h.url[0], gocheck.Equals, "/repository/someapp")
c.Assert(h.method[0], gocheck.Equals, "DELETE")
c.Assert(string(h.body[0]), gocheck.Equals, "null")
}
func (s *S) TestListKeysGandalfAPIError(c *gocheck.C) {
h := testBadHandler{content: "some terrible error"}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
u := User{Email: "*****@*****.**", Password: "******"}
err := u.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.Users().Remove(bson.M{"email": u.Email})
keys, err := u.ListKeys()
c.Assert(keys, gocheck.DeepEquals, map[string]string(nil))
c.Assert(err.Error(), gocheck.Equals, "some terrible error\n")
}
func (s *S) TestGetDiffInDeploysWithOneCommit(c *gocheck.C) {
s.conn.Deploys().RemoveAll(nil)
lastDeploy := deploy{App: "g1", Timestamp: time.Now(), Commit: "1b970b076bbb30d708e262b402d4e31910e1dc10"}
s.conn.Deploys().Insert(lastDeploy)
defer s.conn.Deploys().RemoveAll(nil)
expected := "test_diff"
h := testHandler{content: expected}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
_, err := GetDiffInDeploys(&lastDeploy)
c.Assert(err.Error(), gocheck.Equals, "The deployment must have at least two commits for the diff.")
}
func (s *S) TestCreateUserOnGandalf(c *gocheck.C) {
h := testing.TestHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
u := &User{Email: "*****@*****.**"}
err := u.CreateOnGandalf()
c.Assert(err, gocheck.IsNil)
c.Assert(h.Url, gocheck.Equals, "/user")
expected := `{"name":"*****@*****.**","keys":{}}`
c.Assert(string(h.Body), gocheck.Equals, expected)
c.Assert(h.Method, gocheck.Equals, "POST")
}
func (s *S) TestContainerDeploy(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
app := testing.NewFakeApp("myapp", "python", 1)
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
var buf bytes.Buffer
_, err = deploy(app, "ff13e", &buf)
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestAddKeyInGandalfShouldCallGandalfAPI(c *gocheck.C) {
h := testing.TestHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
u := &User{Email: "*****@*****.**"}
err := u.Create()
c.Assert(err, gocheck.IsNil)
defer u.Delete()
key := Key{Content: "my-ssh-key", Name: "key1"}
err = u.AddKeyGandalf(&key)
c.Assert(err, gocheck.IsNil)
c.Assert(h.Url, gocheck.Equals, "/user/[email protected]/key")
}
func (s *ActionsSuite) TestAddKeyInGandalfActionBackward(c *gocheck.C) {
h := testHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
key := &auth.Key{Name: "mysshkey", Content: "my-ssh-key"}
u := &auth.User{Email: "*****@*****.**", Password: "******"}
ctx := action.BWContext{
Params: []interface{}{key, u},
}
addKeyInGandalfAction.Backward(ctx)
c.Assert(len(h.url), gocheck.Equals, 1)
expected := fmt.Sprintf("/user/%s/key/%s", u.Email, key.Name)
c.Assert(h.url[0], gocheck.Equals, expected)
}
func (s *S) TestCloneRepository(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("something"))
app := testing.NewFakeApp("your", "python", 1)
out, err := clone(p, app)
c.Assert(err, gocheck.IsNil)
c.Assert(string(out), gocheck.Equals, "something")
url := repository.ReadOnlyURL(app.GetName())
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("git clone %s %s --depth 1", url, path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
func (s *S) TestListKeysShouldCallGandalfAPI(c *gocheck.C) {
h := testHandler{content: `{"mypckey":"ssh-rsa keystuff keycomment"}`}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
u := User{Email: "*****@*****.**", Password: "******"}
err := u.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.Users().Remove(bson.M{"email": u.Email})
keys, err := u.ListKeys()
c.Assert(err, gocheck.IsNil)
expected := map[string]string{"mypckey": "ssh-rsa keystuff keycomment"}
c.Assert(expected, gocheck.DeepEquals, keys)
c.Assert(h.url[0], gocheck.Equals, "/user/[email protected]/keys")
c.Assert(h.method[0], gocheck.Equals, "GET")
}
func (s *S) TestRestartFailure(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
tmpdir, err := commandmocker.Error("juju", "juju failed to run command", 25)
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
app := testing.NewFakeApp("cribcaged", "python", 1)
p := JujuProvisioner{}
err = p.Restart(app)
c.Assert(err, gocheck.NotNil)
pErr, ok := err.(*provision.Error)
c.Assert(ok, gocheck.Equals, true)
c.Assert(pErr.Reason, gocheck.Equals, "juju failed to run command\n")
c.Assert(pErr.Err.Error(), gocheck.Equals, "exit status 25")
}
func (s *ActionsSuite) TestAddKeyInGandalfActionForward(c *gocheck.C) {
h := testHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
key := &auth.Key{Name: "mysshkey", Content: "my-ssh-key"}
u := &auth.User{Email: "*****@*****.**", Password: "******"}
ctx := action.FWContext{
Params: []interface{}{key, u},
}
result, err := addKeyInGandalfAction.Forward(ctx)
c.Assert(err, gocheck.IsNil)
c.Assert(result, gocheck.IsNil) // we're not gonna need the result
c.Assert(len(h.url), gocheck.Equals, 1)
expected := fmt.Sprintf("/user/%s/key", u.Email)
c.Assert(h.url[0], gocheck.Equals, expected)
}
func (s *ActionsSuite) TestAddUserToTeamInGandalfActionBackward(c *gocheck.C) {
h := testHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
u := &auth.User{Email: "*****@*****.**", Password: "******"}
err := u.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.Users().Remove(bson.M{"email": u.Email})
t := &auth.Team{Name: "myteam"}
ctx := action.BWContext{
Params: []interface{}{u, t},
}
addUserToTeamInGandalfAction.Backward(ctx)
c.Assert(len(h.url), gocheck.Equals, 1)
c.Assert(h.url[0], gocheck.Equals, "/repository/revoke")
}
func (s *S) TestCreateRepositoryForwardAppPointer(c *gocheck.C) {
h := testHandler{}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
app := App{Name: "someapp", Teams: []string{s.team.Name}}
ctx := action.FWContext{Params: []interface{}{&app}}
result, err := createRepository.Forward(ctx)
a, ok := result.(*App)
c.Assert(ok, gocheck.Equals, true)
c.Assert(a.Name, gocheck.Equals, app.Name)
c.Assert(err, gocheck.IsNil)
c.Assert(h.url[0], gocheck.Equals, "/repository")
c.Assert(h.method[0], gocheck.Equals, "POST")
expected := fmt.Sprintf(`{"name":"someapp","users":["%s"],"ispublic":false}`, s.user.Email)
c.Assert(string(h.body[0]), gocheck.Equals, expected)
}
func (s *S) TestGetDiffInDeploys(c *gocheck.C) {
s.conn.Deploys().RemoveAll(nil)
lastDeploy := deploy{App: "g1", Timestamp: time.Now(), Commit: "1b970b076bbb30d708e262b402d4e31910e1dc10"}
previousDeploy := deploy{App: "g1", Timestamp: time.Now().Add(-3600 * time.Second), Commit: "545b1904af34458704e2aa06ff1aaffad5289f8f"}
otherAppDeploy := deploy{App: "ge", Timestamp: time.Now(), Commit: "hwed834hf8y34h8fhn8rnr823nr238runh23x"}
s.conn.Deploys().Insert(previousDeploy)
s.conn.Deploys().Insert(lastDeploy)
s.conn.Deploys().Insert(otherAppDeploy)
defer s.conn.Deploys().RemoveAll(nil)
expected := "test_diff"
h := testHandler{content: expected}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
diffOutput, err := GetDiffInDeploys(&lastDeploy)
c.Assert(err, gocheck.IsNil)
c.Assert(diffOutput, gocheck.DeepEquals, expected)
}
func (s *S) TestDeployRemoveContainersEvenWhenTheyreNotInTheAppsCollection(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(3)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
cont1, err := s.newContainer(nil)
defer s.removeTestContainer(cont1)
c.Assert(err, gocheck.IsNil)
cont2, err := s.newContainer(nil)
defer s.removeTestContainer(cont2)
c.Assert(err, gocheck.IsNil)
defer rtesting.FakeRouter.RemoveBackend(cont1.AppName)
var p dockerProvisioner
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
var w bytes.Buffer
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: &w,
})
c.Assert(err, gocheck.IsNil)
defer p.Destroy(&a)
coll := collection()
defer coll.Close()
n, err := coll.Find(bson.M{"appname": cont1.AppName}).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(n, gocheck.Equals, 2)
}
func (s *S) TestDeploy(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
p := dockerProvisioner{}
app.Provisioner = &p
a := app.App{
Name: "otherapp",
Platform: "python",
Units: []app.Unit{{Name: "i-0800", State: "started"}},
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
w := writer{b: make([]byte, 2048)}
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: &w,
})
c.Assert(err, gocheck.IsNil)
w.b = nil
time.Sleep(6e9)
q, err := getQueue()
for _, u := range a.ProvisionedUnits() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.GetName())
}
}
func (s *S) TestDeployCmds(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
app := testing.NewFakeApp("app-name", "python", 1)
env := bind.EnvVar{
Name: "http_proxy",
Value: "[http://theirproxy.com:3128/, http://teste.com:3111]",
Public: true,
}
app.SetEnv(env)
deployCmd, err := config.GetString("docker:deploy-cmd")
c.Assert(err, gocheck.IsNil)
version := "version"
appRepo := repository.ReadOnlyURL(app.GetName())
expected := []string{deployCmd, appRepo, version, `http_proxy=[http://theirproxy.com:3128/,http://teste.com:3111] `}
cmds, err := deployCmds(app, version)
c.Assert(err, gocheck.IsNil)
c.Assert(cmds, gocheck.DeepEquals, expected)
}
func (s *S) TestDeploy(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
setExecut(&etesting.FakeExecutor{})
defer setExecut(nil)
p := dockerProvisioner{}
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
w := safe.NewBuffer(make([]byte, 2048))
var serviceBodies []string
rollback := s.addServiceInstance(c, a.Name, func(w http.ResponseWriter, r *http.Request) {
data, _ := ioutil.ReadAll(r.Body)
serviceBodies = append(serviceBodies, string(data))
w.WriteHeader(http.StatusOK)
})
defer rollback()
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: w,
})
c.Assert(err, gocheck.IsNil)
units := a.Units()
c.Assert(units, gocheck.HasLen, 1)
c.Assert(serviceBodies, gocheck.HasLen, 1)
c.Assert(serviceBodies[0], gocheck.Matches, ".*unit-host="+units[0].Ip)
}
func (s *S) TestDeployEnqueuesBindService(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
setExecut(&etesting.FakeExecutor{})
defer setExecut(nil)
p := dockerProvisioner{}
app.Provisioner = &p
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
w := safe.NewBuffer(make([]byte, 2048))
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: w,
})
c.Assert(err, gocheck.IsNil)
defer p.Destroy(&a)
q, err := getQueue()
c.Assert(err, gocheck.IsNil)
for _, u := range a.Units() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.Name)
}
}
func (s *S) TestDeploy(c *gocheck.C) {
content := `{"git_url": "git://tsuruhost.com/cribcaged.git"}`
h := &testing.TestHandler{Content: content}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
provisioner := testing.NewFakeProvisioner()
provisioner.PrepareOutput([]byte("cloned"))
provisioner.PrepareOutput([]byte("updated"))
app := testing.NewFakeApp("cribcaged", "python", 1)
provisioner.Provision(app)
w := &bytes.Buffer{}
err := Git(provisioner, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7", w)
c.Assert(err, gocheck.IsNil)
c.Assert(app.Commands, gocheck.DeepEquals, []string{"restart"})
c.Assert(provisioner.InstalledDeps(app), gocheck.Equals, 1)
cloneCommand := "git clone git://tsuruhost.com/cribcaged.git test/dir --depth 1"
c.Assert(provisioner.GetCmds(cloneCommand, app), gocheck.HasLen, 1)
path, _ := repository.GetPath()
checkoutCommand := fmt.Sprintf("cd %s && git checkout 5734f0042844fdeb5bbc1b72b18f2dc1779cade7", path)
c.Assert(provisioner.GetCmds(checkoutCommand, app), gocheck.HasLen, 1)
}
func (s *DeploySuite) TestDeployInfo(c *gocheck.C) {
var result map[string]interface{}
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
request, err := http.NewRequest("GET", "/deploys/deploy?:deploy=53e143cb874ccb1f68000001", nil)
c.Assert(err, gocheck.IsNil)
recorder := httptest.NewRecorder()
depId := bson.ObjectIdHex("53e143cb874ccb1f68000001")
otherDepId := bson.ObjectIdHex("53e143cb874ccb1f68000002")
timestamp := time.Now()
duration := time.Duration(10e9)
lastDeploy := Deploy{ID: depId, App: "g1", Timestamp: timestamp, Duration: duration, Commit: "e82nn93nd93mm12o2ueh83dhbd3iu112", Error: ""}
err = s.conn.Deploys().Insert(lastDeploy)
c.Assert(err, gocheck.IsNil)
previousDeploy := Deploy{ID: otherDepId, App: "g1", Timestamp: timestamp.Add(-3600 * time.Second), Duration: duration, Commit: "e293e3e3me03ejm3puejmp3ej3iejop32", Error: ""}
err = s.conn.Deploys().Insert(previousDeploy)
c.Assert(err, gocheck.IsNil)
defer s.conn.Deploys().RemoveAll(nil)
expected := "test_diff"
h := testHandler{content: expected}
ts := testing.StartGandalfTestServer(&h)
defer ts.Close()
err = deployInfo(recorder, request, s.token)
c.Assert(err, gocheck.IsNil)
body, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, gocheck.IsNil)
err = json.Unmarshal(body, &result)
c.Assert(err, gocheck.IsNil)
expected_deploy := map[string]interface{}{
"Id": depId.Hex(),
"App": "g1",
"Timestamp": timestamp.Format(time.RFC3339),
"Duration": 10e9,
"Commit": "e82nn93nd93mm12o2ueh83dhbd3iu112",
"Error": "",
"Diff": expected,
}
c.Assert(result, gocheck.DeepEquals, expected_deploy)
}
func (s *S) TestGitDeployRollsbackAfterErrorOnAttach(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
app := testing.NewFakeApp("myapp", "python", 1)
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
var buf errBuffer
_, err = gitDeploy(app, "ff13e", &buf)
c.Assert(err, gocheck.NotNil)
c.Assert(err.Error(), gocheck.Equals, "My write error")
var conts []container
coll := collection()
defer coll.Close()
err = coll.Find(nil).All(&conts)
c.Assert(err, gocheck.IsNil)
c.Assert(conts, gocheck.HasLen, 0)
err = dockerCluster().RemoveImage("tsuru/myapp")
c.Assert(err, gocheck.NotNil)
}
func (s *S) TestProvision(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
config.Set("juju:charms-path", "/etc/juju/charms")
defer config.Unset("juju:charms-path")
config.Set("host", "somehost")
defer config.Unset("host")
app := testing.NewFakeApp("trace", "python", 0)
p := JujuProvisioner{}
err := p.Provision(app)
c.Assert(err, gocheck.IsNil)
args := []string{
"deploy", "--repository", "/etc/juju/charms", "local:python", "trace",
}
c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true)
args = []string{
"set", "trace", "app-repo=" + repository.ReadOnlyURL("trace"),
}
c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true)
}
