func (s *S) TestServicesInstancesHandler(c *C) {
srv := service.Service{Name: "redis", Teams: []string{s.team.Name}}
err := srv.Create()
c.Assert(err, IsNil)
instance := service.ServiceInstance{
Name: "redis-globo",
ServiceName: "redis",
Apps: []string{"globo"},
Teams: []string{s.team.Name},
}
err = instance.Create()
c.Assert(err, IsNil)
request, err := http.NewRequest("GET", "/services/instances", nil)
c.Assert(err, IsNil)
recorder := httptest.NewRecorder()
err = ServicesInstancesHandler(recorder, request, s.user)
c.Assert(err, IsNil)
body, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
var instances []service.ServiceModel
err = json.Unmarshal(body, &instances)
c.Assert(err, IsNil)
expected := []service.ServiceModel{
{Service: "redis", Instances: []string{"redis-globo"}},
}
c.Assert(instances, DeepEquals, expected)
}
func (s *S) TestServicesInstancesHandlerReturnsOnlyServicesThatTheUserHasAccess(c *C) {
u := &auth.User{Email: "*****@*****.**", Password: "******"}
err := u.Create()
c.Assert(err, IsNil)
defer db.Session.Users().Remove(bson.M{"email": u.Email})
srv := service.Service{Name: "redis", IsRestricted: true}
err = db.Session.Services().Insert(srv)
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "redis"})
instance := service.ServiceInstance{
Name: "redis-globo",
ServiceName: "redis",
Apps: []string{"globo"},
}
err = instance.Create()
c.Assert(err, IsNil)
request, err := http.NewRequest("GET", "/services/instances", nil)
c.Assert(err, IsNil)
recorder := httptest.NewRecorder()
err = ServicesInstancesHandler(recorder, request, u)
c.Assert(err, IsNil)
body, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
var instances []service.ServiceModel
err = json.Unmarshal(body, &instances)
c.Assert(err, IsNil)
c.Assert(instances, DeepEquals, []service.ServiceModel{})
}
func (s *S) TestDestroyShouldUnbindAppFromInstance(c *C) {
h := testHandler{}
tsg := s.t.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, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": srvc.Name})
instance := service.ServiceInstance{Name: "MyInstance", Apps: []string{"whichapp"}, ServiceName: srvc.Name}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": instance.Name})
a := App{
Name: "whichapp",
Framework: "",
Teams: []string{},
Units: []Unit{
{Ip: "10.10.10.10", Machine: 1},
},
}
err = CreateApp(&a)
c.Assert(err, IsNil)
err = a.Destroy()
c.Assert(err, IsNil)
n, err := db.Session.ServiceInstances().Find(bson.M{"apps": bson.M{"$in": []string{a.Name}}}).Count()
c.Assert(err, IsNil)
c.Assert(n, Equals, 0)
}
func (s *S) TestUnbindRemovesAppFromServiceInstance(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNoContent)
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
Apps: []string{"painkiller"},
}
instance.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "10.10.10.10"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Unbind(&a)
c.Assert(err, IsNil)
db.Session.ServiceInstances().Find(bson.M{"_id": instance.Name}).One(&instance)
c.Assert(instance.Apps, DeepEquals, []string{})
}
func (s *S) TestUnbindRemovesEnvironmentVariableFromApp(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNoContent)
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
Apps: []string{"painkiller"},
}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a := app.App{
Name: "painkiller",
Teams: []string{s.team.Name},
Env: map[string]bind.EnvVar{
"DATABASE_HOST": {
Name: "DATABASE_HOST",
Value: "arrea",
Public: false,
InstanceName: instance.Name,
},
"MY_VAR": {
Name: "MY_VAR",
Value: "123",
},
},
Units: []app.Unit{
{
Ip: "10.10.10.10",
},
},
}
err = db.Session.Apps().Insert(&a)
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Unbind(&a)
c.Assert(err, IsNil)
newApp := app.App{Name: a.Name}
err = newApp.Get()
c.Assert(err, IsNil)
expected := map[string]bind.EnvVar{
"MY_VAR": {
Name: "MY_VAR",
Value: "123",
},
}
c.Assert(a.Env, DeepEquals, expected)
}
func (s *S) TestRemoveServiceHandlerWIthAssociatedAppsShouldFailAndReturnError(c *C) {
se := service.Service{Name: "foo"}
err := se.Create()
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
c.Assert(err, IsNil)
si := service.ServiceInstance{Name: "foo-instance", ServiceName: "foo", Apps: []string{"foo-bar"}, Teams: []string{s.team.Name}}
err = si.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"name": si.Name})
c.Assert(err, IsNil)
recorder, request := makeRequestToRemoveInstanceHandler("foo-instance", c)
err = RemoveServiceInstanceHandler(recorder, request, s.user)
c.Assert(err, ErrorMatches, "^This service instance has binded apps. Unbind them before removing it$")
}
func (s *S) TestRemoveServiceHandlerWithoutPermissionShouldReturn401(c *C) {
se := service.Service{Name: "foo"}
err := se.Create()
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
c.Assert(err, IsNil)
si := service.ServiceInstance{Name: "foo-instance", ServiceName: "foo"}
err = si.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"name": si.Name})
c.Assert(err, IsNil)
recorder, request := makeRequestToRemoveInstanceHandler("foo-instance", c)
err = RemoveServiceInstanceHandler(recorder, request, s.user)
c.Assert(err, ErrorMatches, "^This user does not have access to this service instance$")
}
func (s *S) TestServicesInstancesHandlerFilterInstancesPerServiceIncludingServicesThatDoesNotHaveInstances(c *C) {
u := &auth.User{Email: "*****@*****.**", Password: "******"}
err := u.Create()
c.Assert(err, IsNil)
defer db.Session.Users().Remove(bson.M{"email": u.Email})
serviceNames := []string{"redis", "mysql", "pgsql", "memcached"}
defer db.Session.Services().RemoveAll(bson.M{"name": bson.M{"$in": serviceNames}})
defer db.Session.ServiceInstances().RemoveAll(bson.M{"service_name": bson.M{"$in": serviceNames}})
for _, name := range serviceNames {
srv := service.Service{Name: name, Teams: []string{s.team.Name}}
err = srv.Create()
c.Assert(err, IsNil)
instance := service.ServiceInstance{
Name: srv.Name + "1",
ServiceName: srv.Name,
Teams: []string{s.team.Name},
}
err = instance.Create()
c.Assert(err, IsNil)
instance = service.ServiceInstance{
Name: srv.Name + "2",
ServiceName: srv.Name,
Teams: []string{s.team.Name},
}
err = instance.Create()
}
srv := service.Service{Name: "oracle", Teams: []string{s.team.Name}}
err = srv.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"name": "oracle"})
request, err := http.NewRequest("GET", "/services/instances", nil)
c.Assert(err, IsNil)
recorder := httptest.NewRecorder()
err = ServicesInstancesHandler(recorder, request, s.user)
c.Assert(err, IsNil)
body, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
var instances []service.ServiceModel
err = json.Unmarshal(body, &instances)
c.Assert(err, IsNil)
expected := []service.ServiceModel{
{Service: "redis", Instances: []string{"redis1", "redis2"}},
{Service: "mysql", Instances: []string{"mysql1", "mysql2"}},
{Service: "pgsql", Instances: []string{"pgsql1", "pgsql2"}},
{Service: "memcached", Instances: []string{"memcached1", "memcached2"}},
{Service: "oracle", Instances: []string(nil)},
}
c.Assert(instances, DeepEquals, expected)
}
func (s *S) TestServicesHandlerShoudGetAllServicesFromUsersTeam(c *C) {
srv := service.Service{Name: "mongodb", OwnerTeams: []string{s.team.Name}}
srv.Create()
defer db.Session.Services().Remove(bson.M{"_id": srv.Name})
si := service.ServiceInstance{Name: "my_nosql", ServiceName: srv.Name, Teams: []string{s.team.Name}}
si.Create()
defer si.Delete()
recorder, request := s.makeRequestToServicesHandler(c)
err := ServicesHandler(recorder, request, s.user)
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
services := make([]service.ServiceModel, 1)
err = json.Unmarshal(b, &services)
expected := []service.ServiceModel{
{Service: "mongodb", Instances: []string{"my_nosql"}},
}
c.Assert(services, DeepEquals, expected)
}
func (s *S) TestRemoveServiceShouldCallTheServiceAPI(c *C) {
var called bool
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = r.Method == "DELETE" && r.URL.Path == "/resources/purity-instance"
}))
defer ts.Close()
se := service.Service{Name: "purity", Endpoint: map[string]string{"production": ts.URL}}
err := se.Create()
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
c.Assert(err, IsNil)
si := service.ServiceInstance{Name: "purity-instance", ServiceName: "purity", Teams: []string{s.team.Name}}
err = si.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"name": si.Name})
recorder, request := makeRequestToRemoveInstanceHandler("purity-instance", c)
err = RemoveServiceInstanceHandler(recorder, request, s.user)
c.Assert(err, IsNil)
c.Assert(called, Equals, true)
}
func (s *S) TestDeleteHandlerReturns403WhenTheServiceHasInstance(c *C) {
se := service.Service{Name: "mysql", OwnerTeams: []string{s.team.Name}}
err := se.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
instance := service.ServiceInstance{Name: "my-mysql", ServiceName: se.Name}
err = instance.Create()
c.Assert(err, IsNil)
defer instance.Delete()
request, err := http.NewRequest("DELETE", fmt.Sprintf("/services/%s?:name=%s", se.Name, se.Name), nil)
c.Assert(err, IsNil)
recorder := httptest.NewRecorder()
err = DeleteHandler(recorder, request, s.user)
c.Assert(err, NotNil)
e, ok := err.(*errors.Http)
c.Assert(ok, Equals, true)
c.Assert(e.Code, Equals, http.StatusForbidden)
c.Assert(e, ErrorMatches, "^This service cannot be removed because it has instances.\nPlease remove these instances before removing the service.$")
}
func (s *S) TestServiceInstanceStatusHandler(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNoContent)
w.Write([]byte(`Service instance "my_nosql" is up`))
}))
defer ts.Close()
srv := service.Service{Name: "mongodb", OwnerTeams: []string{s.team.Name}, Endpoint: map[string]string{"production": ts.URL}}
err := srv.Create()
c.Assert(err, IsNil)
defer srv.Delete()
si := service.ServiceInstance{Name: "my_nosql", ServiceName: srv.Name}
err = si.Create()
c.Assert(err, IsNil)
defer si.Delete()
recorder, request := makeRequestToStatusHandler("my_nosql", c)
err = ServiceInstanceStatusHandler(recorder, request, s.user)
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(string(b), Equals, "Service instance \"my_nosql\" is up")
}
func (s *S) TestBindDoNotAddsAppToServiceInstanceIfCommunicationWithEndpointGoesWrong(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{Name: "my-mysql", ServiceName: "mysql", Teams: []string{s.team.Name}}
instance.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("somecoolapp", "", []string{s.team.Name}, []app.Unit{{Ip: "127.0.0.1"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, Not(IsNil))
n, err := db.Session.ServiceInstances().Find(bson.M{"app": []string{}}).Count()
c.Assert(n, Equals, 0)
}
func (s *S) TestBindAddsAppToTheServiceInstance(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`{"DATABASE_USER":"******","DATABASE_PASSWORD":"******"}`))
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{Name: "my-mysql", ServiceName: "mysql", Teams: []string{s.team.Name}}
instance.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "10.10.10.10"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, IsNil)
db.Session.ServiceInstances().Find(bson.M{"_id": instance.Name}).One(&instance)
c.Assert(instance.Apps, DeepEquals, []string{a.Name})
}
func (s *S) TestBindCallTheServiceAPIAndSetsEnvironmentVariableReturnedFromTheCall(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`{"DATABASE_USER":"******","DATABASE_PASSWORD":"******"}`))
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "127.0.0.1"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, IsNil)
newApp := app.App{Name: a.Name}
err = newApp.Get()
c.Assert(err, IsNil)
expectedEnv := map[string]bind.EnvVar{
"DATABASE_USER": {
Name: "DATABASE_USER",
Value: "root",
Public: false,
InstanceName: instance.Name,
},
"DATABASE_PASSWORD": {
Name: "DATABASE_PASSWORD",
Value: "s3cr3t",
Public: false,
InstanceName: instance.Name,
},
}
c.Assert(a.Env, DeepEquals, expectedEnv)
}
func (s *S) TestUnbindReturnsPreconditionFailedIfTheAppIsNotBindedToTheInstance(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNoContent)
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{Name: "my-mysql", ServiceName: "mysql", Teams: []string{s.team.Name}}
instance.Create()
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "10.10.10.10"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Unbind(&a)
c.Assert(err, NotNil)
e, ok := err.(*errors.Http)
c.Assert(ok, Equals, true)
c.Assert(e, ErrorMatches, "^This app is not binded to this service instance.$")
}
func (s *S) TestBindUnbindsWhenDatabaseUpdateGoesWrong(c *C) {
called := false
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = r.Method == "DELETE" && r.URL.Path == "/resources/their-mysql/hostname/127.0.0.1"
if r.URL.String() == "/resources/their-mysql" {
w.Write([]byte(`{"DATABASE_USER":"******","DATABASE_PASSWORD":"******"}`))
}
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{Name: "their-mysql", ServiceName: "mysql", Teams: []string{s.team.Name}}
a, err := createTestApp("somecoolapp", "", []string{s.team.Name}, []app.Unit{{Ip: "127.0.0.1"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, ErrorMatches, "^not found$")
c.Assert(called, Equals, true)
}
func (s *S) TestUnbindCallsTheUnbindMethodFromAPI(c *C) {
var called int32
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == "DELETE" && r.URL.Path == "/resources/my-mysql/hostname/127.0.0.1" {
atomic.StoreInt32(&called, 1)
}
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
Apps: []string{"painkiller"},
}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "127.0.0.1"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Unbind(&a)
c.Assert(err, IsNil)
ch := make(chan bool)
go func() {
t := time.Tick(1)
for _ = <-t; atomic.LoadInt32(&called) == 0; _ = <-t {
}
ch <- true
}()
select {
case <-ch:
c.SucceedNow()
case <-time.After(1e9):
c.Errorf("Failed to call API after 1 second.")
}
}
func (s *S) TestRemoveServiceInstanceHandler(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
defer ts.Close()
se := service.Service{Name: "foo", Endpoint: map[string]string{"production": ts.URL}}
err := se.Create()
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
c.Assert(err, IsNil)
si := service.ServiceInstance{Name: "foo-instance", ServiceName: "foo", Teams: []string{s.team.Name}}
err = si.Create()
c.Assert(err, IsNil)
recorder, request := makeRequestToRemoveInstanceHandler("foo-instance", c)
err = RemoveServiceInstanceHandler(recorder, request, s.user)
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
c.Assert(string(b), Equals, "service instance successfuly removed")
n, err := db.Session.ServiceInstances().Find(bson.M{"name": "foo-instance"}).Count()
c.Assert(err, IsNil)
c.Assert(n, Equals, 0)
}
func (s *S) TestBindReturnsPreconditionFailedIfTheAppDoesNotHaveAnUnitAndServiceHasEndpoint(c *C) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`{"DATABASE_USER":"******","DATABASE_PASSWORD":"******"}`))
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{Name: "my-mysql", ServiceName: "mysql", Teams: []string{s.team.Name}}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, NotNil)
e, ok := err.(*errors.Http)
c.Assert(ok, Equals, true)
c.Assert(e.Code, Equals, http.StatusPreconditionFailed)
c.Assert(e.Message, Equals, "This app does not have an IP yet.")
}
func (s *S) TestServiceInfoHandlerShouldReturnOnlyInstancesOfTheSameTeamOfTheUser(c *C) {
srv := service.Service{Name: "mongodb", Teams: []string{s.team.Name}}
err := srv.Create()
c.Assert(err, IsNil)
defer srv.Delete()
si1 := service.ServiceInstance{
Name: "my_nosql",
ServiceName: srv.Name,
Apps: []string{},
Teams: []string{s.team.Name},
}
err = si1.Create()
c.Assert(err, IsNil)
defer si1.Delete()
si2 := service.ServiceInstance{
Name: "your_nosql",
ServiceName: srv.Name,
Apps: []string{"wordpress"},
Teams: []string{},
}
err = si2.Create()
c.Assert(err, IsNil)
defer si2.Delete()
request, err := http.NewRequest("GET", fmt.Sprintf("/services/%s?:name=%s", "mongodb", "mongodb"), nil)
c.Assert(err, IsNil)
recorder := httptest.NewRecorder()
err = ServiceInfoHandler(recorder, request, s.user)
c.Assert(err, IsNil)
body, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, IsNil)
var instances []service.ServiceInstance
err = json.Unmarshal(body, &instances)
c.Assert(err, IsNil)
expected := []service.ServiceInstance{si1}
c.Assert(instances, DeepEquals, expected)
}
func (s *S) TestremoveServiceShouldNotRemoveTheServiceIfTheServiceAPICallFail(c *C) {
var called bool
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = r.Method == "DELETE" && r.URL.Path == "/resources/purity-instance"
w.WriteHeader(500)
fmt.Fprint(w, "it's a test!")
}))
defer ts.Close()
se := service.Service{Name: "deepercut", Endpoint: map[string]string{"production": ts.URL}}
err := se.Create()
defer db.Session.Services().Remove(bson.M{"_id": se.Name})
c.Assert(err, IsNil)
si := service.ServiceInstance{Name: "deepercut-instance", ServiceName: "deepercut", Teams: []string{s.team.Name}}
err = si.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"name": si.Name})
recorder, request := makeRequestToRemoveInstanceHandler("deepercut-instance", c)
err = RemoveServiceInstanceHandler(recorder, request, s.user)
c.Assert(err, NotNil)
e, ok := err.(*errors.Http)
c.Assert(ok, Equals, true)
c.Assert(e.Code, Equals, http.StatusInternalServerError)
c.Assert(e.Message, Equals, "Failed to destroy the instance deepercut-instance: it's a test!")
}
func (s *S) TestBindReturnConflictIfTheAppIsAlreadyBinded(c *C) {
srvc := service.Service{Name: "mysql"}
err := srvc.Create()
c.Assert(err, IsNil)
defer db.Session.Services().Remove(bson.M{"_id": "mysql"})
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
Apps: []string{"painkiller"},
}
err = instance.Create()
c.Assert(err, IsNil)
defer db.Session.ServiceInstances().Remove(bson.M{"_id": "my-mysql"})
a, err := createTestApp("painkiller", "", []string{s.team.Name}, []app.Unit{{Ip: "127.0.0.1"}})
c.Assert(err, IsNil)
defer db.Session.Apps().Remove(bson.M{"name": a.Name})
err = instance.Bind(&a)
c.Assert(err, NotNil)
e, ok := err.(*errors.Http)
c.Assert(ok, Equals, true)
c.Assert(e.Code, Equals, http.StatusConflict)
c.Assert(e, ErrorMatches, "^This app is already binded to this service instance.$")
}
