func (s *S) TestDeployAppSaveDeployErrorData(c *gocheck.C) {
provisioner := testing.PipelineErrorFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
a := App{
Name: "testErrorApp",
Platform: "zend",
Teams: []string{s.team.Name},
}
err := s.conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": a.Name})
provisioner.Provision(&a)
defer provisioner.Destroy(&a)
writer := &bytes.Buffer{}
err = Deploy(DeployOptions{
App: &a,
Version: "version",
Commit: "1ee1f1084927b3a5db59c9033bc5c4abefb7b93c",
OutputStream: writer,
})
c.Assert(err, gocheck.NotNil)
var result map[string]interface{}
s.conn.Deploys().Find(bson.M{"app": a.Name}).One(&result)
c.Assert(result["app"], gocheck.Equals, a.Name)
c.Assert(result["error"], gocheck.NotNil)
}
func (s *PlatformSuite) TestPlatformWithAppsCantBeRemoved(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, nil, nil)
c.Assert(err, gocheck.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
appName := "test_another_app"
app := App{
Name: appName,
Platform: name,
}
err = conn.Apps().Insert(app)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformRemove(name)
c.Assert(err, gocheck.NotNil)
}
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 *PlatformSuite) TestPlatformUpdateShouldSetUpdatePlatformFlagOnApps(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, nil, nil)
c.Assert(err, gocheck.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
appName := "test_app"
app := App{
Name: appName,
Platform: name,
}
err = conn.Apps().Insert(app)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformUpdate(name, args, nil)
c.Assert(err, gocheck.IsNil)
a, err := GetByName(appName)
c.Assert(err, gocheck.IsNil)
c.Assert(a.UpdatePlatform, gocheck.Equals, true)
}
func (s *S) TestDeployCustomPipeline(c *gocheck.C) {
provisioner := testing.PipelineFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
a := App{
Name: "otherapp",
Platform: "zend",
Teams: []string{s.team.Name},
}
err := s.conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": a.Name})
provisioner.Provision(&a)
defer provisioner.Destroy(&a)
writer := &bytes.Buffer{}
err = Deploy(DeployOptions{
App: &a,
Version: "version",
Commit: "1ee1f1084927b3a5db59c9033bc5c4abefb7b93c",
OutputStream: writer,
})
c.Assert(err, gocheck.IsNil)
c.Assert(provisioner.ExecutedPipeline(), gocheck.Equals, true)
}
func (s *PlatformSuite) TestPlatformRemove(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
err = PlatformRemove("platform_dont_exists")
c.Assert(err, gocheck.NotNil)
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, nil, nil)
c.Assert(err, gocheck.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
err = PlatformRemove(name)
c.Assert(err, gocheck.IsNil)
err = PlatformRemove("")
c.Assert(err, gocheck.NotNil)
c.Assert(err.Error(), gocheck.Equals, "Platform name is required!")
}
func (s *S) TestShouldRegisterAllCommandsFromProvisioners(c *gocheck.C) {
fp := testing.NewFakeProvisioner()
p := AdminCommandableProvisioner{FakeProvisioner: *fp}
provision.Register("fakeAdminProvisioner", &p)
manager := buildManager("tsuru-admin")
fake, ok := manager.Commands["fake-admin"]
c.Assert(ok, gocheck.Equals, true)
c.Assert(fake, gocheck.FitsTypeOf, &FakeAdminCommand{})
}
func (s *S) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_collector_test")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
s.provisioner = ttesting.NewFakeProvisioner()
app.Provisioner = s.provisioner
config.Set("queue-server", "127.0.0.1:0")
}
func (s *S) TestCheckoutFailure(c *gocheck.C) {
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("failed to update"))
p.PrepareFailure("ExecuteCommand", errors.New("exit status 128"))
app := testing.NewFakeApp("moon", "python", 1)
out, err := checkout(p, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7")
c.Assert(err, gocheck.NotNil)
c.Assert(err.Error(), gocheck.Equals, "exit status 128")
c.Assert(string(out), gocheck.Equals, "failed to update")
}
func (s *S) TestShouldRegisterAllCommandsFromProvisioners(c *gocheck.C) {
fp := testing.NewFakeProvisioner()
p := CommandableProvisioner{FakeProvisioner: *fp}
provision.Register("comm", &p)
manager := buildManager()
fake, ok := manager.Commands["fake"]
c.Assert(ok, gocheck.Equals, true)
tsrFake, ok := fake.(*tsrCommand)
c.Assert(ok, gocheck.Equals, true)
c.Assert(tsrFake.Command, gocheck.FitsTypeOf, &FakeCommand{})
}
func (s *S) TestPullRepository(c *gocheck.C) {
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("pulled"))
app := testing.NewFakeApp("your", "python", 1)
out, err := fetch(p, app)
c.Assert(err, gocheck.IsNil)
c.Assert(string(out), gocheck.Equals, "pulled")
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("cd %s && git fetch origin", path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
func (s *DeploySuite) SetUpSuite(c *gocheck.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_deploy_api_tests")
config.Set("aut:hash-cost", 4)
var err error
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
s.createUserAndTeam(c)
s.provisioner = testing.NewFakeProvisioner()
app.Provisioner = s.provisioner
}
func (s *S) TestCheckout(c *gocheck.C) {
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("updated"))
app := testing.NewFakeApp("moon", "python", 1)
out, err := checkout(p, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7")
c.Assert(err, gocheck.IsNil)
c.Assert(out, gocheck.IsNil)
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("cd %s && git checkout 5734f0042844fdeb5bbc1b72b18f2dc1779cade7", path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
func (s *S) SetUpSuite(c *gocheck.C) {
err := config.ReadConfigFile("testdata/config.yaml")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
s.createUserAndTeam(c)
s.t = &tsuruTesting.T{}
s.provisioner = tsuruTesting.NewFakeProvisioner()
app.Provisioner = s.provisioner
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
}
func (s *BindSuite) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_service_bind_test")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
s.user = auth.User{Email: "*****@*****.**"}
s.user.Create()
s.team = auth.Team{Name: "metallica", Users: []string{s.user.Email}}
s.conn.Teams().Insert(s.team)
app.Provisioner = ttesting.NewFakeProvisioner()
}
func (s *PlatformSuite) TestPlatformUpdateWithoutName(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
err := PlatformUpdate("", nil, nil)
c.Assert(err, gocheck.NotNil)
c.Assert(err.Error(), gocheck.Equals, "Platform name is required.")
}
func (s *S) SetUpSuite(c *gocheck.C) {
err := config.ReadConfigFile("testdata/config.yaml")
c.Assert(err, gocheck.IsNil)
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
s.t = &ttesting.T{}
s.createUserAndTeam(c)
s.t.SetGitConfs(c)
s.provisioner = ttesting.NewFakeProvisioner()
Provisioner = s.provisioner
platform := Platform{Name: "python"}
s.conn.Platforms().Insert(platform)
}
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 (p *PlatformSuite) TestPlatformRemove(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd("test", nil, nil)
c.Assert(err, gocheck.IsNil)
request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil)
recorder := httptest.NewRecorder()
err = platformRemove(recorder, request, nil)
c.Assert(err, gocheck.IsNil)
}
func BenchmarkUpdate(b *testing.B) {
b.StopTimer()
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "collector-benchmark")
conn, err := db.Conn()
if err != nil {
panic(err)
}
defer conn.Apps().Database.DropDatabase()
_, names := getFakeApps(conn)
app.Provisioner = ttesting.NewFakeProvisioner()
fakeUnits := getFakeUnits(names)
b.StartTimer()
for i := 0; i < b.N; i++ {
update(fakeUnits)
}
}
func (p *PlatformSuite) TestPlatformAdd(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
dockerfile_url := "http://localhost/Dockerfile"
body := fmt.Sprintf("name=%s&dockerfile=%s", "teste", dockerfile_url)
request, _ := http.NewRequest("POST", "/platforms/add", strings.NewReader(body))
request.Header.Add("Content-Type", "application/x-www-form-urlencoded")
recorder := httptest.NewRecorder()
result := platformAdd(recorder, request, nil)
c.Assert(result, gocheck.IsNil)
}
func (s *S) SetUpSuite(c *gocheck.C) {
var err error
s.server, err = elbtest.NewServer()
c.Assert(err, gocheck.IsNil)
config.Set("juju:elb-endpoint", s.server.URL())
config.Set("juju:use-elb", true)
region := aws.SAEast
region.ELBEndpoint = s.server.URL()
s.client = elb.New(aws.Auth{AccessKey: "some", SecretKey: "thing"}, region)
c.Assert(err, gocheck.IsNil)
config.Set("juju:elb-avail-zones", []interface{}{"my-zone-1a", "my-zone-1b"})
config.Set("aws:access-key-id", "access")
config.Set("aws:secret-access-key", "s3cr3t")
s.provisioner = testing.NewFakeProvisioner()
app.Provisioner = s.provisioner
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "router_elb_tests")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
}
func (p *PlatformSuite) TestPlatformUpdate(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd("wat", nil, nil)
c.Assert(err, gocheck.IsNil)
dockerfile_url := "http://localhost/Dockerfile"
body := fmt.Sprintf("dockerfile=%s", dockerfile_url)
request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", strings.NewReader(body))
request.Header.Add("Content-Type", "application/x-www-form-urlencoded")
recorder := httptest.NewRecorder()
result := platformUpdate(recorder, request, nil)
c.Assert(result, gocheck.IsNil)
c.Assert(recorder.Body.String(), gocheck.Equals, "\nOK!\n")
}
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 *PlatformSuite) TestPlatformAdd(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
name := "test_platform_add"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, args, nil)
defer conn.Platforms().Remove(bson.M{"_id": name})
c.Assert(err, gocheck.IsNil)
platform := provisioner.GetPlatform(name)
c.Assert(platform.Name, gocheck.Equals, name)
c.Assert(platform.Args, gocheck.DeepEquals, args)
c.Assert(platform.Version, gocheck.Equals, 1)
}
func (s *PlatformSuite) TestPlatformAddWithProvisionerError(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
provisioner.PrepareFailure("PlatformAdd", errors.New("build error"))
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
name := "test_platform_add"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, args, nil)
defer conn.Platforms().Remove(bson.M{"_id": name})
c.Assert(err, gocheck.NotNil)
count, err := conn.Platforms().FindId(name).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(count, gocheck.Equals, 0)
}
func (s *PlatformSuite) TestPlatformAddDuplicate(c *gocheck.C) {
provisioner := testing.ExtensibleFakeProvisioner{
FakeProvisioner: testing.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
name := "test_platform_add"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(name, args, nil)
defer conn.Platforms().Remove(bson.M{"_id": name})
c.Assert(err, gocheck.IsNil)
provisioner.PlatformRemove(name)
err = PlatformAdd(name, args, nil)
_, ok := err.(DuplicatePlatformError)
c.Assert(ok, gocheck.Equals, true)
}
func (s *ELBSuite) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "juju_elb_tests")
s.conn, err = db.Conn()
s.server, err = elbtest.NewServer()
c.Assert(err, gocheck.IsNil)
config.Set("juju:elb-endpoint", s.server.URL())
config.Set("juju:use-elb", true)
region := aws.SAEast
region.ELBEndpoint = s.server.URL()
s.client = elb.New(aws.Auth{AccessKey: "some", SecretKey: "thing"}, region)
c.Assert(err, gocheck.IsNil)
s.cName = "juju_test_elbs"
config.Set("juju:elb-collection", s.cName)
config.Set("juju:elb-avail-zones", []interface{}{"my-zone-1a", "my-zone-1b"})
config.Set("aws:access-key-id", "access")
config.Set("aws:secret-access-key", "s3cr3t")
config.Set("git:ro-host", "git.tsuru.io")
config.Set("queue", "fake")
config.Set("juju:units-collection", "juju_units_test_elb")
s.provisioner = testing.NewFakeProvisioner()
app.Provisioner = s.provisioner
}
func (s *PlatformSuite) SetUpSuite(c *gocheck.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "platform_tests")
s.provisioner = testing.NewFakeProvisioner()
Provisioner = s.provisioner
}
