func (s *S) TestProvisionerRemoveUnitNotInApp(c *gocheck.C) { out := `{ "NetworkSettings": { "IpAddress": "127.0.0.1", "IpPrefixLen": 8, "Gateway": "10.65.41.1", "PortMapping": { "8888": "90293" } } }` app := testing.NewFakeApp("myapp", "python", 0) fexec := &etesting.FakeExecutor{ Output: map[string][][]byte{ "*": {[]byte("c-10")}, "inspect c-10": {[]byte(out)}, }, } setExecut(fexec) defer setExecut(nil) container, err := newContainer(app) c.Assert(err, gocheck.IsNil) defer container.remove() var p dockerProvisioner err = p.RemoveUnit(testing.NewFakeApp("hisapp", "python", 1), container.Id) c.Assert(err, gocheck.NotNil) c.Assert(err.Error(), gocheck.Equals, "Unit does not belong to this app") _, err = getContainer(container.Id) c.Assert(err, gocheck.IsNil) }
func (s *ELBSuite) TestSwap(c *gocheck.C) { var p JujuProvisioner app1 := testing.NewFakeApp("app1", "python", 1) app2 := testing.NewFakeApp("app2", "python", 1) id1 := s.server.NewInstance() defer s.server.RemoveInstance(id1) id2 := s.server.NewInstance() defer s.server.RemoveInstance(id2) router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(app1.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(app1.GetName()) err = router.AddRoute(app1.GetName(), id1) c.Assert(err, gocheck.IsNil) err = router.AddBackend(app2.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(app2.GetName()) err = router.AddRoute(app2.GetName(), id2) c.Assert(err, gocheck.IsNil) err = p.Swap(app1, app2) c.Assert(err, gocheck.IsNil) app2Routes, err := router.Routes(app2.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(app2Routes, gocheck.DeepEquals, []string{id2}) app1Routes, err := router.Routes(app1.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(app1Routes, gocheck.DeepEquals, []string{id1}) addr, err := router.Addr(app1.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(addr, gocheck.Equals, "app2-some-aws-stuff.us-east-1.elb.amazonaws.com") addr, err = router.Addr(app2.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(addr, gocheck.Equals, "app1-some-aws-stuff.us-east-1.elb.amazonaws.com") }
func (s *S) TestSwap(c *gocheck.C) { var p dockerProvisioner app1 := testing.NewFakeApp("app1", "python", 1) app2 := testing.NewFakeApp("app2", "python", 1) rtesting.FakeRouter.AddBackend(app1.GetName()) rtesting.FakeRouter.AddRoute(app1.GetName(), "127.0.0.1") rtesting.FakeRouter.AddBackend(app2.GetName()) rtesting.FakeRouter.AddRoute(app2.GetName(), "127.0.0.2") err := p.Swap(app1, app2) c.Assert(err, gocheck.IsNil) c.Assert(rtesting.FakeRouter.HasBackend(app1.GetName()), gocheck.Equals, true) c.Assert(rtesting.FakeRouter.HasBackend(app2.GetName()), gocheck.Equals, true) c.Assert(rtesting.FakeRouter.HasRoute(app2.GetName(), "127.0.0.1"), gocheck.Equals, true) c.Assert(rtesting.FakeRouter.HasRoute(app1.GetName(), "127.0.0.2"), gocheck.Equals, true) }
func (s *S) TestDeployFailureSecondStep(c *gocheck.C) { var ( p dockerProvisioner buf bytes.Buffer ) app := testing.NewFakeApp("app", "python", 0) app.AddUnit(&testing.FakeUnit{Name: "app/0"}) p.Provision(app) defer p.Destroy(app) defer s.conn.Collection(s.collName).RemoveAll(bson.M{"appname": app.GetName()}) output := `{ "NetworkSettings": { "IpAddress": "10.10.10.%d", "IpPrefixLen": 8, "Gateway": "10.65.41.1", "PortMapping": {"8888": "37574"} } }` fexec := etesting.FailLaterExecutor{ Succeeds: 3, FakeExecutor: etesting.FakeExecutor{ Output: map[string][][]byte{ "*": {[]byte("c-0955")}, "inspect c-0955": {[]byte(output)}, }, }, } setExecut(&fexec) defer setExecut(nil) err := p.Deploy(app, &buf) c.Assert(err, gocheck.NotNil) c.Assert(buf.String(), gocheck.Equals, "c-0955") c.Assert(fexec.ExecutedCmd("docker", []string{"rm", "c-0955"}), gocheck.Equals, true) c.Assert(app.ProvisionUnits(), gocheck.HasLen, 1) }
func (s *ELBSuite) TestCreateELBUsingVPC(c *gocheck.C) { old, _ := config.Get("juju:elb-avail-zones") config.Unset("juju:elb-avail-zones") config.Set("juju:elb-use-vpc", true) config.Set("juju:elb-vpc-subnets", []string{"subnet-a4a3a2a1", "subnet-002200"}) config.Set("juju:elb-vpc-secgroups", []string{"sg-0900"}) defer func() { config.Set("juju:elb-avail-zones", old) config.Unset("juju:elb-use-vpc") config.Unset("juju:elb-vpc-subnets") config.Unset("juju:elb-vpc-secgroups") }() app := testing.NewFakeApp("relax", "who", 1) manager := ELBManager{} err := manager.Create(app) c.Assert(err, gocheck.IsNil) defer s.client.DeleteLoadBalancer(app.GetName()) conn, coll := manager.collection() defer conn.Close() defer coll.Remove(bson.M{"name": app.GetName()}) resp, err := s.client.DescribeLoadBalancers(app.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) lbd := resp.LoadBalancerDescriptions[0] c.Assert(lbd.Subnets, gocheck.DeepEquals, []string{"subnet-a4a3a2a1", "subnet-002200"}) c.Assert(lbd.SecurityGroups, gocheck.DeepEquals, []string{"sg-0900"}) c.Assert(lbd.Scheme, gocheck.Equals, "internal") c.Assert(lbd.AvailZones, gocheck.HasLen, 0) }
func (s *S) TestGetImageFromAppPlatform(c *gocheck.C) { app := testing.NewFakeApp("myapp", "python", 1) img := getImage(app) repoNamespace, err := config.GetString("docker:repository-namespace") c.Assert(err, gocheck.IsNil) c.Assert(img, gocheck.Equals, fmt.Sprintf("%s/python", repoNamespace)) }
func (s *S) TestExecuteCommandOnceWithoutContainers(c *gocheck.C) { app := testing.NewFakeApp("almah", "static", 2) p := dockerProvisioner{} var stdout, stderr bytes.Buffer err := p.ExecuteCommandOnce(&stdout, &stderr, app, "ls", "-lh") c.Assert(err, gocheck.Not(gocheck.IsNil)) }
func (s *S) TestProvisionerExecuteCommand(c *gocheck.C) { var handler FakeSSHServer handler.output = ". .." server := httptest.NewServer(&handler) defer server.Close() host, port, _ := net.SplitHostPort(server.Listener.Addr().String()) portNumber, _ := strconv.Atoi(port) config.Set("docker:ssh-agent-port", portNumber) defer config.Unset("docker:ssh-agent-port") app := testing.NewFakeApp("starbreaker", "python", 1) container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()}) c.Assert(err, gocheck.IsNil) defer s.removeTestContainer(container) container.HostAddr = host coll := collection() defer coll.Close() coll.Update(bson.M{"id": container.ID}, container) var stdout, stderr bytes.Buffer var p dockerProvisioner err = p.ExecuteCommand(&stdout, &stderr, app, "ls", "-ar") c.Assert(err, gocheck.IsNil) c.Assert(stderr.Bytes(), gocheck.IsNil) c.Assert(stdout.String(), gocheck.Equals, ". ..") body := handler.bodies[0] input := cmdInput{Cmd: "ls", Args: []string{"-ar"}} c.Assert(body, gocheck.DeepEquals, input) ip, _, _ := container.networkInfo() path := fmt.Sprintf("/container/%s/cmd", ip) c.Assert(handler.requests[0].URL.Path, gocheck.DeepEquals, path) }
func (s *S) TestProvisionerDestroy(c *gocheck.C) { err := newImage("tsuru/python", s.server.URL()) c.Assert(err, gocheck.IsNil) cont, err := s.newContainer(nil) c.Assert(err, gocheck.IsNil) app := testing.NewFakeApp(cont.AppName, "python", 1) var p dockerProvisioner p.Provision(app) c.Assert(p.Destroy(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { coll := collection() defer coll.Close() for { ct, err := coll.Find(bson.M{"appname": cont.AppName}).Count() if err != nil { c.Fatal(err) } if ct == 0 { ok <- true return } runtime.Gosched() } }() select { case <-ok: case <-time.After(10e9): c.Fatal("Timed out waiting for the container to be destroyed (10 seconds)") } c.Assert(rtesting.FakeRouter.HasBackend("myapp"), gocheck.Equals, false) }
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 *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 *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) TestDestroyWithELB(c *gocheck.C) { config.Set("juju:charms-path", "/home/charms") defer config.Unset("juju:charms-path") fexec := &etesting.FakeExecutor{} execut = fexec defer func() { execut = 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) 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 *S) TestProvisionerExecuteCommandMultipleContainers(c *gocheck.C) { fexec := &etesting.FakeExecutor{ Output: map[string][][]byte{"*": {[]byte(". ..")}}, } setExecut(fexec) defer setExecut(nil) app := testing.NewFakeApp("starbreaker", "python", 1) err := s.conn.Collection(s.collName).Insert( container{Id: "c-036", AppName: "starbreaker", Type: "python", Ip: "10.10.10.1"}, container{Id: "c-037", AppName: "starbreaker", Type: "python", Ip: "10.10.10.2"}, ) c.Assert(err, gocheck.IsNil) defer s.conn.Collection(s.collName).RemoveAll(bson.M{"_id": bson.M{"$in": []string{"c-036", "c-037"}}}) var stdout, stderr bytes.Buffer var p dockerProvisioner err = p.ExecuteCommand(&stdout, &stderr, app, "ls", "-ar") c.Assert(err, gocheck.IsNil) c.Assert(stderr.Bytes(), gocheck.IsNil) args1 := []string{ "10.10.10.1", "-l", s.sshUser, "-o", "StrictHostKeyChecking no", "--", "ls", "-ar", } args2 := []string{ "10.10.10.1", "-l", s.sshUser, "-o", "StrictHostKeyChecking no", "--", "ls", "-ar", } c.Assert(fexec.ExecutedCmd("ssh", args1), gocheck.Equals, true) c.Assert(fexec.ExecutedCmd("ssh", args2), gocheck.Equals, true) }
func (s *S) TestProvisionerAddr(c *gocheck.C) { out := `{ "NetworkSettings": { "IpAddress": "10.10.10.10", "IpPrefixLen": 8, "Gateway": "10.65.41.1", "PortMapping": {"8888": "37574"} } }` id := "123" runCmd := "run -d -t -p 8888 tsuru/python /bin/bash -c /var/lib/tsuru/add-key key-content && /usr/sbin/sshd -D" fexec := &etesting.FakeExecutor{Output: map[string][][]byte{runCmd: {[]byte(id)}, "inspect " + id: {[]byte(out)}}} setExecut(fexec) defer setExecut(nil) var p dockerProvisioner app := testing.NewFakeApp("myapp", "python", 1) p.Provision(app) defer p.Destroy(app) w := &bytes.Buffer{} err := p.Deploy(app, w) c.Assert(err, gocheck.IsNil) defer p.Destroy(app) defer s.conn.Collection(s.collName).RemoveId(id) addr, err := p.Addr(app) c.Assert(err, gocheck.IsNil) r, err := getRouter() c.Assert(err, gocheck.IsNil) expected, err := r.Addr("myapp") c.Assert(err, gocheck.IsNil) c.Assert(addr, gocheck.Equals, expected) }
func (s *S) TestStartedUnitsShouldReturnTrueForUnreachable(c *gocheck.C) { app := testing.NewFakeApp("almah", "static", 1) app.SetUnitStatus(provision.StatusUnreachable, 0) p := JujuProvisioner{} units := p.startedUnits(app) c.Assert(units, gocheck.HasLen, 1) }
func (s *S) TestProvisionUndefinedCharmsPath(c *gocheck.C) { config.Unset("juju:charms-path") p := JujuProvisioner{} err := p.Provision(testing.NewFakeApp("eternity", "sandman", 0)) c.Assert(err, gocheck.NotNil) c.Assert(err.Error(), gocheck.Equals, `Setting "juju:charms-path" is not defined.`) }
func (s *S) TestDestroy(c *gocheck.C) { fexec := &etesting.FakeExecutor{} setExecut(fexec) defer setExecut(nil) app := testing.NewFakeApp("cribcaged", "python", 3) p := JujuProvisioner{} collection := p.unitsCollection() defer collection.Close() err := collection.Insert( instance{UnitName: "cribcaged/0"}, instance{UnitName: "cribcaged/1"}, instance{UnitName: "cribcaged/2"}, ) c.Assert(err, gocheck.IsNil) err = p.Destroy(app) c.Assert(err, gocheck.IsNil) args := []string{"destroy-service", "cribcaged"} c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true) args = []string{"terminate-machine", "1"} c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true) args = []string{"terminate-machine", "2"} c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true) args = []string{"terminate-machine", "3"} c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true) n, err := collection.Find(bson.M{ "_id": bson.M{ "$in": []string{"cribcaged/0", "cribcaged/1", "cribcaged/2"}, }, }).Count() c.Assert(err, gocheck.IsNil) c.Assert(n, gocheck.Equals, 0) c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true) }
func (s *S) TestRemoveUnitInSameHostAsAnotherUnitShouldEnqueueAnotherBind(c *gocheck.C) { err := newImage("tsuru/python", s.server.URL()) c.Assert(err, gocheck.IsNil) c1, err := s.newContainer(nil) c.Assert(err, gocheck.IsNil) c2, err := s.newContainer(nil) c.Assert(err, gocheck.IsNil) defer rtesting.FakeRouter.RemoveBackend(c1.AppName) client, err := dockerClient.NewClient(s.server.URL()) c.Assert(err, gocheck.IsNil) err = client.StartContainer(c1.ID, nil) c.Assert(err, gocheck.IsNil) a := testing.NewFakeApp(c1.AppName, "python", 0) var p dockerProvisioner err = p.RemoveUnit(a, c1.ID) c.Assert(err, gocheck.IsNil) _, err = getContainer(c1.ID) c.Assert(err, gocheck.NotNil) _, err = getContainer(c2.ID) c.Assert(err, gocheck.IsNil) q, err := getQueue() c.Assert(err, gocheck.IsNil) message, err := q.Get(1e6) c.Assert(err, gocheck.IsNil) expected := &queue.Message{Action: app.BindService, Args: []string{a.GetName(), c2.ID}} c.Assert(message, gocheck.DeepEquals, expected) }
func (s *S) TestRemoveUnit(c *gocheck.C) { fexec := &etesting.FakeExecutor{} setExecut(fexec) defer setExecut(nil) app := testing.NewFakeApp("two", "rush", 3) p := JujuProvisioner{} collection := p.unitsCollection() defer collection.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) ran := make(chan bool, 1) go func() { for { args1 := []string{"remove-unit", "two/2"} args2 := []string{"terminate-machine", "3"} if fexec.ExecutedCmd("juju", args1) && fexec.ExecutedCmd("juju", args2) { ran <- true } runtime.Gosched() } }() select { case <-ran: case <-time.After(2e9): c.Errorf("Did not run terminate-machine command after 2 seconds.") } n, err := collection.Find(bson.M{"_id": "two/2"}).Count() c.Assert(err, gocheck.IsNil) c.Assert(n, gocheck.Equals, 0) }
func (s *S) TestProvisionerRestartCallsTheRestartHook(c *gocheck.C) { var handler FakeSSHServer handler.output = "caad7bbd5411" server := httptest.NewServer(&handler) defer server.Close() host, port, _ := net.SplitHostPort(server.Listener.Addr().String()) portNumber, _ := strconv.Atoi(port) config.Set("docker:ssh-agent-port", portNumber) defer config.Unset("docker:ssh-agent-port") var p dockerProvisioner app := testing.NewFakeApp("almah", "static", 1) newImage("tsuru/python", s.server.URL()) cont, err := s.newContainer(&newContainerOpts{AppName: app.GetName()}) c.Assert(err, gocheck.IsNil) defer s.removeTestContainer(cont) cont.HostAddr = host coll := collection() defer coll.Close() err = coll.Update(bson.M{"id": cont.ID}, cont) c.Assert(err, gocheck.IsNil) err = p.Restart(app) c.Assert(err, gocheck.IsNil) input := cmdInput{Cmd: "/var/lib/tsuru/restart"} body := handler.bodies[0] c.Assert(body, gocheck.DeepEquals, input) ip, _, _ := cont.networkInfo() path := fmt.Sprintf("/container/%s/cmd", ip) c.Assert(handler.requests[0].URL.Path, gocheck.DeepEquals, path) }
func (s *S) TestRemoveUnknownUnit(c *gocheck.C) { app := testing.NewFakeApp("tears", "rush", 2) p := JujuProvisioner{} err := p.RemoveUnit(app, "tears/2") c.Assert(err, gocheck.NotNil) c.Assert(err.Error(), gocheck.Equals, `App "tears" does not have a unit named "tears/2".`) }
func (s *S) TestExecuteCommandOnce(c *gocheck.C) { var handler FakeSSHServer handler.output = ". .." server := httptest.NewServer(&handler) defer server.Close() host, port, _ := net.SplitHostPort(server.Listener.Addr().String()) portNumber, _ := strconv.Atoi(port) config.Set("docker:ssh-agent-port", portNumber) defer config.Unset("docker:ssh-agent-port") app := testing.NewFakeApp("almah", "static", 1) p := dockerProvisioner{} container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()}) c.Assert(err, gocheck.IsNil) defer s.removeTestContainer(container) container.HostAddr = host coll := collection() defer coll.Close() coll.Update(bson.M{"id": container.ID}, container) var stdout, stderr bytes.Buffer err = p.ExecuteCommandOnce(&stdout, &stderr, app, "ls", "-lh") c.Assert(err, gocheck.IsNil) c.Assert(stderr.Bytes(), gocheck.IsNil) c.Assert(stdout.String(), gocheck.Equals, ". ..") body := handler.bodies[0] input := cmdInput{Cmd: "ls", Args: []string{"-lh"}} c.Assert(body, gocheck.DeepEquals, input) }
func (s *S) TestAddr(c *gocheck.C) { app := testing.NewFakeApp("blue", "who", 1) p := JujuProvisioner{} addr, err := p.Addr(app) c.Assert(err, gocheck.IsNil) c.Assert(addr, gocheck.Equals, app.ProvisionedUnits()[0].GetIp()) }
func (s *S) TestNewContainer(c *gocheck.C) { oldClusterNodes := clusterNodes clusterNodes = map[string]string{"server": s.server.URL()} defer func() { clusterNodes = oldClusterNodes }() app := testing.NewFakeApp("app-name", "brainfuck", 1) rtesting.FakeRouter.AddBackend(app.GetName()) defer rtesting.FakeRouter.RemoveBackend(app.GetName()) dockerCluster().PullImage( docker.PullImageOptions{Repository: "tsuru/brainfuck"}, docker.AuthConfiguration{}, ) cont, err := newContainer(app, getImage(app), []string{"docker", "run"}) c.Assert(err, gocheck.IsNil) defer s.removeTestContainer(&cont) c.Assert(cont.ID, gocheck.Not(gocheck.Equals), "") c.Assert(cont, gocheck.FitsTypeOf, container{}) c.Assert(cont.AppName, gocheck.Equals, app.GetName()) c.Assert(cont.Type, gocheck.Equals, app.GetPlatform()) c.Assert(cont.Name, gocheck.Not(gocheck.Equals), "") c.Assert(cont.Name, gocheck.HasLen, 20) u, _ := url.Parse(s.server.URL()) host, _, _ := net.SplitHostPort(u.Host) c.Assert(cont.HostAddr, gocheck.Equals, host) user, err := config.GetString("docker:ssh:user") c.Assert(err, gocheck.IsNil) dcli, _ := docker.NewClient(s.server.URL()) container, err := dcli.InspectContainer(cont.ID) c.Assert(err, gocheck.IsNil) c.Assert(container.Config.User, gocheck.Equals, user) }
func (s *ELBSuite) TestDestroyWithELB(c *gocheck.C) { 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 && msg.Args[0] == "jimmy" { msg.Delete() } else { q.Release(msg, 0) } }
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 *S) TestStartedUnits(c *gocheck.C) { app := testing.NewFakeApp("almah", "static", 2) app.SetUnitStatus(provision.StatusDown, 1) p := JujuProvisioner{} units := p.startedUnits(app) c.Assert(units, gocheck.HasLen, 1) }
func (s *ELBSuite) TestCreateELB(c *gocheck.C) { app := testing.NewFakeApp("together", "gotthard", 1) manager := ELBManager{} manager.e = s.client err := manager.Create(app) c.Assert(err, gocheck.IsNil) defer s.client.DeleteLoadBalancer(app.GetName()) conn, coll := manager.collection() defer conn.Close() defer coll.Remove(bson.M{"name": app.GetName()}) resp, err := s.client.DescribeLoadBalancers("together") c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) c.Assert(resp.LoadBalancerDescriptions[0].ListenerDescriptions, gocheck.HasLen, 1) listener := resp.LoadBalancerDescriptions[0].ListenerDescriptions[0].Listener c.Assert(listener.InstancePort, gocheck.Equals, 80) c.Assert(listener.LoadBalancerPort, gocheck.Equals, 80) c.Assert(listener.InstanceProtocol, gocheck.Equals, "HTTP") c.Assert(listener.Protocol, gocheck.Equals, "HTTP") c.Assert(listener.SSLCertificateId, gocheck.Equals, "") dnsName := resp.LoadBalancerDescriptions[0].DNSName var lb loadBalancer err = s.conn.Collection(s.cName).Find(bson.M{"name": app.GetName()}).One(&lb) c.Assert(err, gocheck.IsNil) c.Assert(lb.DNSName, gocheck.Equals, dnsName) }
func (s *S) TestDeployShouldRestart(c *gocheck.C) { out := `{ "NetworkSettings": { "IpAddress": "10.10.10.10", "IpPrefixLen": 8, "Gateway": "10.65.41.1", "PortMapping": {"8888": "37574"} } }` fexec := &etesting.FakeExecutor{ Output: map[string][][]byte{ "*": {[]byte("8yasfiajfias")}, "inspect 8yasfiajfias": {[]byte(out)}, }, } setExecut(fexec) defer setExecut(nil) p := dockerProvisioner{} app := testing.NewFakeApp("cribcaged", "python", 1) p.Provision(app) defer p.Destroy(app) w := &bytes.Buffer{} err := p.Deploy(app, w) defer p.Destroy(app) defer s.conn.Collection(s.collName).RemoveId(out) c.Assert(err, gocheck.IsNil) c.Assert(app.Commands, gocheck.DeepEquals, []string{"restart"}) }