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) }