func (s *PlatformSuite) TestPlatformUpdateDisabletrueFileIn(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["disabled"] = "true"
err = PlatformAdd(provision.PlatformOptions{Name: name})
c.Assert(err, check.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
appName := "test_app_2"
app := App{
Name: appName,
Platform: name,
}
err = conn.Apps().Insert(app)
c.Assert(err, check.IsNil)
defer conn.Apps().Remove(bson.M{"name": appName})
err = PlatformUpdate(provision.PlatformOptions{Name: name, Args: args, Input: bytes.NewReader(nil)})
c.Assert(err, check.IsNil)
platf, err := GetPlatform(name)
c.Assert(err, check.IsNil)
c.Assert(platf.Disabled, check.Equals, true)
a, err := GetByName(appName)
c.Assert(err, check.IsNil)
c.Assert(a.UpdatePlatform, check.Equals, true)
}
func (s *S) TestDeployAppSaveDeployErrorData(c *check.C) {
provisioner := provisiontest.NewFakeProvisioner()
provisioner.PrepareFailure("GitDeploy", errors.New("deploy error"))
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, check.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, check.NotNil)
var result map[string]interface{}
s.conn.Deploys().Find(bson.M{"app": a.Name}).One(&result)
c.Assert(result["app"], check.Equals, a.Name)
c.Assert(result["error"], check.NotNil)
}
func (p *PlatformSuite) TestPlatformUpdate(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil})
c.Assert(err, check.IsNil)
var buf bytes.Buffer
dockerfileURL := "http://localhost/Dockerfile"
writer := multipart.NewWriter(&buf)
writer.WriteField("dockerfile", dockerfileURL)
writer.Close()
request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", &buf)
request.Header.Add("Content-Type", writer.FormDataContentType())
recorder := httptest.NewRecorder()
token := createToken(c)
result := platformUpdate(recorder, request, token)
c.Assert(result, check.IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, check.IsNil)
var msg io.SimpleJsonMessage
json.Unmarshal(b, &msg)
c.Assert(errors.New(msg.Error), check.ErrorMatches, "")
}
func (s *PlatformSuite) TestPlatformUpdateDisableFalseWithoutDockerfile(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = ""
args["disabled"] = "false"
err = PlatformAdd(provision.PlatformOptions{Name: name})
c.Assert(err, check.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
appName := "test_app_4"
app := App{
Name: appName,
Platform: name,
}
err = conn.Apps().Insert(app)
c.Assert(err, check.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformUpdate(provision.PlatformOptions{Name: name, Args: args})
c.Assert(err, check.IsNil)
platf, err := GetPlatform(name)
c.Assert(err, check.IsNil)
c.Assert(platf.Disabled, check.Equals, false)
}
func (s *PlatformSuite) TestPlatformUpdateShouldSetUpdatePlatformFlagOnApps(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(provision.PlatformOptions{Name: name})
c.Assert(err, check.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, check.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformUpdate(provision.PlatformOptions{Name: name, Args: args})
c.Assert(err, check.IsNil)
a, err := GetByName(appName)
c.Assert(err, check.IsNil)
c.Assert(a.UpdatePlatform, check.Equals, true)
}
func (p *PlatformSuite) TestPlatformAdd(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
var buf bytes.Buffer
dockerfileURL := "http://localhost/Dockerfile"
writer := multipart.NewWriter(&buf)
writer.WriteField("name", "test")
writer.WriteField("dockerfile", dockerfileURL)
fileWriter, err := writer.CreateFormFile("dockerfile_content", "Dockerfile")
c.Assert(err, check.IsNil)
fileWriter.Write([]byte("FROM tsuru/java"))
writer.Close()
request, _ := http.NewRequest("POST", "/platforms/add", &buf)
request.Header.Add("Content-Type", writer.FormDataContentType())
recorder := httptest.NewRecorder()
token := createToken(c)
result := platformAdd(recorder, request, token)
c.Assert(result, check.IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, check.IsNil)
var msg io.SimpleJsonMessage
json.Unmarshal(b, &msg)
c.Assert(errors.New(msg.Error), check.ErrorMatches, "")
}
func (s *PlatformSuite) TestPlatformUpdateDisableFalseWithDockerfile(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
args["disabled"] = "false"
err = PlatformAdd(name, nil, nil)
c.Assert(err, check.IsNil)
defer conn.Platforms().Remove(bson.M{"_id": name})
appName := "test_app_3"
app := App{
Name: appName,
Platform: name,
}
err = conn.Apps().Insert(app)
c.Assert(err, check.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformUpdate(name, args, nil)
c.Assert(err, check.IsNil)
a, err := GetByName(appName)
c.Assert(err, check.IsNil)
c.Assert(a.UpdatePlatform, check.Equals, true)
platf, err := getPlatform(name)
c.Assert(err, check.IsNil)
c.Assert(platf.Disabled, check.Equals, false)
}
func (p *PlatformSuite) TestPlatformUpdateDisableFalseAndDockerfile(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil})
c.Assert(err, check.IsNil)
dockerfile_url := "http://localhost/Dockerfile"
body := fmt.Sprintf("dockerfile=%s", dockerfile_url)
request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat&disabled=false", strings.NewReader(body))
request.Header.Add("Content-Type", "multipart/form-data")
recorder := httptest.NewRecorder()
token := createToken(c)
result := platformUpdate(recorder, request, token)
c.Assert(result, check.IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, check.IsNil)
var msg io.SimpleJsonMessage
json.Unmarshal(b, &msg)
c.Assert(errors.New(msg.Error), check.ErrorMatches, "")
}
func (s *PlatformSuite) TestPlatformWithAppsCantBeRemoved(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(provision.PlatformOptions{Name: name})
c.Assert(err, check.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, check.IsNil)
defer conn.Apps().Remove(bson.M{"_id": appName})
err = PlatformRemove(name)
c.Assert(err, check.NotNil)
}
func (s *PlatformSuite) TestPlatformRemoveAlwaysRemoveFromDB(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = PlatformRemove("platform_dont_exists")
c.Assert(err, check.NotNil)
name := "test_platform_update"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(provision.PlatformOptions{Name: name})
c.Assert(err, check.IsNil)
provisioner.PlatformRemove(name)
defer conn.Platforms().Remove(bson.M{"_id": name})
err = PlatformRemove(name)
c.Assert(err, check.IsNil)
count, err := conn.Platforms().Find(bson.M{"_id": name}).Count()
c.Assert(err, check.IsNil)
c.Assert(count, check.Equals, 0)
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
repositorytest.Reset()
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
app.AuthScheme = nativeScheme
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
s.Pool = "test1"
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
repository.Manager().CreateUser(s.adminuser.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func (s *ConsumptionSuite) SetUpTest(c *check.C) {
repositorytest.Reset()
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_consumption_test")
config.Set("auth:hash-cost", 4)
config.Set("repo-manager", "fake")
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.team = &auth.Team{Name: "tsuruteam"}
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
s.token = customUserWithPermission(c, "consumption-master-user", permission.Permission{
Scheme: permission.PermServiceInstance,
Context: permission.Context(permission.CtxTeam, s.team.Name),
}, permission.Permission{
Scheme: permission.PermServiceRead,
Context: permission.Context(permission.CtxTeam, s.team.Name),
})
s.user, err = s.token.User()
c.Assert(err, check.IsNil)
app.AuthScheme = nativeScheme
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
}
func (s *PlatformSuite) TestPlatformUpdateOnlyDisableTrue(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil})
c.Assert(err, check.IsNil)
dockerfileURL := ""
body := fmt.Sprintf("dockerfile=%s", dockerfileURL)
request, err := http.NewRequest("PUT", "/platforms/wat?disabled=true", strings.NewReader(body))
c.Assert(err, check.IsNil)
token := createToken(c)
request.Header.Add("Authorization", "b "+token.GetValue())
request.Header.Add("Content-Type", "multipart/form-data")
recorder := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream")
var msg io.SimpleJsonMessage
json.Unmarshal(recorder.Body.Bytes(), &msg)
c.Assert(errors.New(msg.Error), check.ErrorMatches, "")
}
func (s *PlatformSuite) TestPlatformUpdate(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil})
c.Assert(err, check.IsNil)
var buf bytes.Buffer
dockerfileURL := "http://localhost/Dockerfile"
writer := multipart.NewWriter(&buf)
writer.WriteField("dockerfile", dockerfileURL)
writer.Close()
request, _ := http.NewRequest("PUT", "/platforms/wat", &buf)
request.Header.Add("Content-Type", writer.FormDataContentType())
token := createToken(c)
request.Header.Set("Authorization", "b "+token.GetValue())
recorder := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(recorder, request)
var msg io.SimpleJsonMessage
json.Unmarshal(recorder.Body.Bytes(), &msg)
c.Assert(errors.New(msg.Error), check.ErrorMatches, "")
c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream")
}
func (s *BindSuite) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
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 = provisiontest.NewFakeProvisioner()
}
func (s *S) TestShouldRegisterAllCommandsFromProvisioners(c *check.C) {
fp := provisiontest.NewFakeProvisioner()
p := AdminCommandableProvisioner{FakeProvisioner: *fp}
provision.Register("fakeAdminProvisioner", &p)
manager := buildManager("tsuru-admin")
fake, ok := manager.Commands["fake-admin"]
c.Assert(ok, check.Equals, true)
c.Assert(fake, check.FitsTypeOf, &FakeAdminCommand{})
}
func (s *PlatformSuite) TestPlatformUpdateWithoutName(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
err := PlatformUpdate(provision.PlatformOptions{Name: ""})
c.Assert(err, check.Equals, ErrPlatformNameMissing)
}
func (s *S) TestShouldRegisterAllCommandsFromProvisioners(c *check.C) {
fp := provisiontest.NewFakeProvisioner()
p := CommandableProvisioner{FakeProvisioner: *fp}
provision.Register("comm", &p)
manager := buildManager()
fake, ok := manager.Commands["fake"]
c.Assert(ok, check.Equals, true)
tsurudFake, ok := fake.(*tsurudCommand)
c.Assert(ok, check.Equals, true)
c.Assert(tsurudFake.Command, check.FitsTypeOf, &FakeCommand{})
}
func (s *BindSuite) SetUpSuite(c *check.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, check.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 = provisiontest.NewFakeProvisioner()
}
func (s *PlatformSuite) TestPlatformUpdateWithoutName(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
err := PlatformUpdate(provision.PlatformOptions{Name: ""})
c.Assert(err, check.NotNil)
c.Assert(err.Error(), check.Equals, "Platform name is required.")
}
func (s *S) TestFindNodeByAddrs(c *check.C) {
p := provisiontest.NewFakeProvisioner()
err := p.AddNode(provision.AddNodeOptions{
Address: "http://addr1",
})
c.Assert(err, check.IsNil)
node, err := provision.FindNodeByAddrs(p, []string{"addr1", "notfound"})
c.Assert(err, check.IsNil)
c.Assert(node.Address(), check.Equals, "http://addr1")
_, err = provision.FindNodeByAddrs(p, []string{"addr2"})
c.Assert(err, check.Equals, provision.ErrNodeNotFound)
}
func (s *S) TestFindNodeByAddrsAmbiguous(c *check.C) {
p := provisiontest.NewFakeProvisioner()
err := p.AddNode(provision.AddNodeOptions{
Address: "http://addr1",
})
c.Assert(err, check.IsNil)
err = p.AddNode(provision.AddNodeOptions{
Address: "http://addr2",
})
c.Assert(err, check.IsNil)
_, err = provision.FindNodeByAddrs(p, []string{"addr1", "addr2"})
c.Assert(err, check.ErrorMatches, `addrs match multiple nodes: \[addr1 addr2\]`)
}
func (s *DeploySuite) SetUpSuite(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_deploy_api_tests")
config.Set("aut:hash-cost", 4)
config.Set("admin-team", "tsuruteam")
config.Set("repo-manager", "fake")
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
}
func (s *S) SetUpSuite(c *check.C) {
err := config.ReadConfigFile("testdata/config.yaml")
c.Assert(err, check.IsNil)
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.provisioner = provisiontest.NewFakeProvisioner()
Provisioner = s.provisioner
AuthScheme = nativeScheme
data, err := json.Marshal(AppLock{})
c.Assert(err, check.IsNil)
err = json.Unmarshal(data, &s.zeroLock)
c.Assert(err, check.IsNil)
}
func (p *PlatformSuite) TestPlatformRemove(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd("test", nil, nil)
c.Assert(err, check.IsNil)
request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil)
recorder := httptest.NewRecorder()
err = platformRemove(recorder, request, nil)
c.Assert(err, check.IsNil)
}
func (s *DeploySuite) SetUpTest(c *check.C) {
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
routertest.FakeRouter.Reset()
repositorytest.Reset()
err := dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.conn.Platforms().Insert(app.Platform{Name: "python"})
opts := provision.AddPoolOptions{Name: "pool1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
user, err := s.token.User()
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(user.Email)
}
func (p *PlatformSuite) TestPlatformRemove(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
err := app.PlatformAdd(provision.PlatformOptions{Name: "test", Args: nil, Output: nil})
c.Assert(err, check.IsNil)
request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil)
recorder := httptest.NewRecorder()
token := createToken(c)
err = platformRemove(recorder, request, token)
c.Assert(err, check.IsNil)
}
func (p *PlatformSuite) TestPlatformAdd(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.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, check.IsNil)
c.Assert(recorder.Body.String(), check.Equals, "\nOK!\n")
}
func (*PlatformSuite) TestPlatformRemoveNotFound(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
oldProvisioner := app.Provisioner
app.Provisioner = &provisioner
defer func() {
app.Provisioner = oldProvisioner
}()
request, err := http.NewRequest("DELETE", "/platforms/not-found", nil)
c.Assert(err, check.IsNil)
token := createToken(c)
request.Header.Set("Authorization", "b "+token.GetValue())
recorder := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusNotFound)
}
func (s *PlatformSuite) TestPlatformAddDuplicate(c *check.C) {
provisioner := provisiontest.ExtensibleFakeProvisioner{
FakeProvisioner: provisiontest.NewFakeProvisioner(),
}
Provisioner = &provisioner
defer func() {
Provisioner = s.provisioner
}()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
name := "test_platform_add"
args := make(map[string]string)
args["dockerfile"] = "http://localhost/Dockerfile"
err = PlatformAdd(provision.PlatformOptions{Name: name, Args: args})
defer conn.Platforms().Remove(bson.M{"_id": name})
c.Assert(err, check.IsNil)
provisioner.PlatformRemove(name)
err = PlatformAdd(provision.PlatformOptions{Name: name, Args: args})
c.Assert(err, check.Equals, DuplicatePlatformError)
}