func TestInstanceTerminate(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("SystemGet").Return(nil, nil)
os.Setenv("RACK", "convox-test")
aws := test.StubAws(
test.DeleteInstanceCycle("i-4a5513f4"),
)
defer aws.Close()
body := test.HTTPBody("DELETE", "http://convox/instances/i-4a5513f4", nil)
var resp map[string]bool
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, true, resp["success"])
}
}
func TestInstanceList(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("InstanceList").Return(testProvider.Instances, nil)
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
body := test.HTTPBody("GET", "http://convox/instances", nil)
var resp []client.Instance
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 3, len(resp))
}
}
// Test the primary path: creating an app on a `convox` rack
// Return to testing against a `convox-test` rack afterwards
func TestAppCreate(t *testing.T) {
r := os.Getenv("RACK")
os.Setenv("RACK", "convox")
defer os.Setenv("RACK", r)
aws := test.StubAws(
test.DescribeStackNotFound("application"),
test.CreateAppStackCycle("convox-application"),
test.DescribeAppStackCycle("convox-application"),
)
defer aws.Close()
val := url.Values{"name": []string{"application"}}
body := test.HTTPBody("POST", "http://convox/apps", val)
if assert.NotEqual(t, "", body) {
var resp map[string]string
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, "application", resp["name"])
assert.Equal(t, "running", resp["status"])
}
}
}
// post memory=2048 should error
func TestFormationScaleMemory2048(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Capacity: structs.Capacity{
InstanceMemory: 1024,
},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
testProvider.On("CapacityGet").Return(testProvider.Capacity, nil)
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-application"),
test.DescribeAppStackCycle("convox-test-application"),
test.GetItemAppReleaseCycle("convox-test-application"),
test.UpdateAppStackCycle("convox-test-application", "1", "512"),
)
defer aws.Close()
provider.TestProvider.Capacity = structs.Capacity{
InstanceMemory: 1024,
}
val := url.Values{"count": []string{""}, "memory": []string{"2048"}}
body := test.HTTPBody("POST", "http://convox/apps/application/formation/main", val)
assert.Equal(t, `{"error":"requested memory 2048 greater than instance size 1024"}`, body)
}
// post count=0 should set MainDesiredCount=0 in the stack update
func TestFormationScaleCount0(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Capacity: structs.Capacity{},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("CapacityGet").Return(testProvider.Capacity, nil)
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-application"),
test.DescribeAppStackCycle("convox-test-application"),
test.GetItemAppReleaseCycle("convox-test-application"),
test.UpdateAppStackCycle("convox-test-application", "0", "256"),
)
defer aws.Close()
val := url.Values{"count": []string{"0"}, "memory": []string{""}}
body := test.HTTPBody("POST", "http://convox/apps/application/formation/main", val)
assert.Equal(t, `{"success":true}`, body)
}
func TestBuildDelete(t *testing.T) {
models.TestProvider = &provider.TestProvider{
App: structs.App{
Name: "app-name",
Release: "release-id",
},
Build: structs.Build{
Id: "build-id",
},
Release: structs.Release{
Id: "release-id",
Build: "not-build-id",
},
}
// setup expectations on current provider
models.TestProvider.On("AppGet", "app-name").Return(&models.TestProvider.App, nil)
models.TestProvider.On("BuildGet", "app-name", "build-id").Return(&models.TestProvider.Build, nil)
models.TestProvider.On("ReleaseGet", "app-name", "release-id").Return(&models.TestProvider.Release, nil)
models.TestProvider.On("BuildDelete", "app-name", "build-id").Return(&models.TestProvider.Build, nil)
models.TestProvider.On("ReleaseDelete", "app-name", "build-id").Return(nil)
// make request
body := test.HTTPBody("DELETE", "http://convox/apps/app-name/builds/build-id", nil)
// assert on expectations
models.TestProvider.AssertExpectations(t)
// assert on response
resp := new(structs.Build)
err := json.Unmarshal([]byte(body), resp)
if assert.Nil(t, err) {
assert.Equal(t, "build-id", resp.Id)
}
}
func TestBuildDelete(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Build: structs.Build{
Id: "build-id",
},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("BuildDelete", "app-name", "build-id").Return(&testProvider.Build, nil)
// make request
body := test.HTTPBody("DELETE", "http://convox/apps/app-name/builds/build-id", nil)
// assert on expectations
testProvider.AssertExpectations(t)
// assert on response
resp := new(structs.Build)
err := json.Unmarshal([]byte(body), resp)
if assert.Nil(t, err) {
assert.Equal(t, "build-id", resp.Id)
}
}
func TestInstanceList(t *testing.T) {
models.TestProvider = &provider.TestProvider{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
// setup expectations on current provider
models.TestProvider.On("InstanceList").Return(models.TestProvider.Instances, nil)
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
body := test.HTTPBody("GET", "http://convox/instances", nil)
var resp []client.Instance
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 3, len(resp))
}
}
func TestBuildDeleteActive(t *testing.T) {
models.TestProvider = &provider.TestProvider{
App: structs.App{
Name: "httpd",
Release: "release-id",
},
Build: structs.Build{
Id: "BHINCLZYYVN",
},
Release: structs.Release{
Id: "release-id",
Build: "BHINCLZYYVN",
},
}
models.TestProvider.On("AppGet", "httpd").Return(&models.TestProvider.App, nil)
models.TestProvider.On("BuildGet", "httpd", "BHINCLZYYVN").Return(&models.TestProvider.Build, nil)
models.TestProvider.On("ReleaseGet", "httpd", "release-id").Return(&models.TestProvider.Release, nil)
body := test.HTTPBody("DELETE", "http://convox/apps/httpd/builds/BHINCLZYYVN", nil)
// assert on expectations
models.TestProvider.AssertExpectations(t)
// assert on response
resp := make(map[string]string)
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
fmt.Fprintf(os.Stderr, "%s\n", resp)
assert.Equal(t, "cannot delete build contained in active release", resp["error"])
}
}
func TestProcessesListWithDetached(t *testing.T) {
models.TestProvider = &provider.TestProvider{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
// setup expectations on current provider
models.TestProvider.On("InstanceList").Return(models.TestProvider.Instances, nil)
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffCycle("convox-test-cluster"),
test.DescribeTasksOneoffCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesCycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
test.ListECSOneoffContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
)
defer docker.Close()
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", url.Values{})
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "echo 1", resp[0].Command)
assert.Equal(t, "/bin/sh -c yes", resp[1].Command)
}
}
func TestProcessesList(t *testing.T) {
// set current provider
models.TestProvider = &provider.TestProvider{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
// setup expectations on current provider
models.TestProvider.On("InstanceList").Return(models.TestProvider.Instances, nil)
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffEmptyCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesCycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
// query for every container to get CPU and Memory stats
test.StatsCycle(),
)
defer docker.Close()
v := url.Values{}
v.Add("stats", "true")
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v)
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 1, len(resp))
assert.Equal(t, 0.0974, resp[0].Memory)
}
}
func TestGetProcessesWithDeployments(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffEmptyCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesWithDeploymentsCycle("convox-test-cluster"),
test.DescribeTaskDefinition3Cycle("convox-test-cluster"),
test.DescribeTaskDefinition1Cycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
// query for every container to get CPU and Memory stats
test.StatsCycle(),
)
defer docker.Close()
v := url.Values{}
v.Add("stats", "true")
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v)
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "8dfafdbc3a40", resp[0].Id)
assert.Equal(t, 0.0974, resp[0].Memory)
assert.Equal(t, "pending", resp[1].Id)
assert.EqualValues(t, 0, resp[1].Memory)
}
}
func TestAppList(t *testing.T) {
aws := test.StubAws(test.DescribeStackCycleWithoutQuery("convox-test-bar"))
defer aws.Close()
body := test.HTTPBody("GET", "http://convox/apps", nil)
var resp []map[string]string
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, "bar", resp[0]["name"])
assert.Equal(t, "running", resp[0]["status"])
}
}
// post count=0 should set MainDesiredCount=0 in the stack update
func TestFormationScaleCount0(t *testing.T) {
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-application"),
test.DescribeAppStackCycle("convox-test-application"),
test.GetItemAppReleaseCycle("convox-test-application"),
test.UpdateAppStackCycle("convox-test-application", "0", "256"),
)
defer aws.Close()
val := url.Values{"count": []string{"0"}, "memory": []string{""}}
body := test.HTTPBody("POST", "http://convox/apps/application/formation/main", val)
assert.Equal(t, `{"success":true}`, body)
}
// post memory=foo should 403
func TestFormationScaleMemoryInvalid(t *testing.T) {
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-application"),
test.DescribeAppStackCycle("convox-test-application"),
test.GetItemAppReleaseCycle("convox-test-application"),
test.UpdateAppStackCycle("convox-test-application", "1", "256"),
)
defer aws.Close()
val := url.Values{"count": []string{""}, "memory": []string{"foo"}}
body := test.HTTPBody("POST", "http://convox/apps/application/formation/main", val)
assert.Equal(t, `{"error":"memory must be numeric"}`, body)
}
func TestGetProcessesWithDeployments(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
os.Setenv("TEST", "true")
aws := test.StubAws(
test.DescribeAppStackCycle("myapp-staging"),
test.DescribeAppStackCycle("myapp-staging"),
test.ListTasksCycle("convox-test-cluster"),
test.DescribeTasksCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeContainerInstancesFilteredCycle("convox-test-cluster"),
test.DescribeInstancesFilteredCycle(),
test.DescribeAppStackResourcesCycle("myapp-staging"),
test.DescribeServicesWithDeploymentsCycle("convox-test-cluster"),
test.DescribeTaskDefinition3Cycle("convox-test-cluster"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.DescribeTaskDefinition1Cycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
test.ListContainersCycle(),
test.ListConvoxContainersCycle(),
test.ListConvoxContainersCycle(),
test.ListConvoxContainersCycle(),
test.StatsCycle(),
)
defer docker.Close()
v := url.Values{}
v.Add("stats", "false")
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v)
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "pending", resp[1].Id)
//assert.Equal(t, "8dfafdbc3a40", resp[1].Id)
//assert.Equal(t, "8dfafdbc3a40", resp[2].Id)
//assert.Equal(t, "4932cce0897b", resp[3].Id)
//assert.Equal(t, "pending", resp[4].Id)
}
}
/* NOTE: the S3 stuff f***s up b.c the client ries to prepend the
bucket name to the ephermeral host, so you get `app-XXX.127.0.0.1`
*/
func TestAppDelete(t *testing.T) {
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-bar"),
test.DeleteStackCycle("convox-test-bar"),
)
defer aws.Close()
body := test.HTTPBody("DELETE", "http://convox/apps/bar", nil)
var resp map[string]bool
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, true, resp["success"])
}
}
func TestAppShowUnbound(t *testing.T) {
aws := test.StubAws(
test.DescribeStackNotFound("convox-test-bar"),
test.DescribeAppStackCycle("bar"),
)
defer aws.Close()
body := test.HTTPBody("GET", "http://convox/apps/bar", nil)
var resp map[string]string
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, "bar", resp["name"])
assert.Equal(t, "running", resp["status"])
}
}
func TestProcessesListWithAttached(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffEmptyCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesCycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersCycle("79bd711b1756"),
test.InspectCycle("79bd711b1756"),
test.ListOneoffContainersEmptyCycle(),
)
defer docker.Close()
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", url.Values{})
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "/bin/sh -c bash", resp[0].Command)
assert.Equal(t, "echo 1", resp[1].Command)
}
}
func TestInstanceTerminate(t *testing.T) {
os.Setenv("RACK", "convox-test")
aws := test.StubAws(
test.DeleteInstanceCycle("i-4a5513f4"),
)
defer aws.Close()
body := test.HTTPBody("DELETE", "http://convox/instances/i-4a5513f4", nil)
var resp map[string]bool
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, true, resp["success"])
}
}
// post memory=2048 should error
func TestFormationScaleMemory2048(t *testing.T) {
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-application"),
test.DescribeAppStackCycle("convox-test-application"),
test.GetItemAppReleaseCycle("convox-test-application"),
test.UpdateAppStackCycle("convox-test-application", "1", "512"),
)
defer aws.Close()
provider.TestProvider.Capacity = structs.Capacity{
InstanceMemory: 1024,
}
val := url.Values{"count": []string{""}, "memory": []string{"2048"}}
body := test.HTTPBody("POST", "http://convox/apps/application/formation/main", val)
assert.Equal(t, `{"error":"requested memory 2048 greater than instance size 1024"}`, body)
}
func TestProcessesList(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
os.Setenv("TEST", "true")
aws := test.StubAws(
test.DescribeAppStackCycle("myapp-staging"),
test.DescribeAppStackCycle("myapp-staging"),
test.ListTasksCycle("convox-test-cluster"),
test.DescribeTasksCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeContainerInstancesFilteredCycle("convox-test-cluster"),
test.DescribeInstancesFilteredCycle(),
test.DescribeAppStackResourcesCycle("myapp-staging"),
test.DescribeServicesCycle("convox-test-cluster"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
)
defer aws.Close()
docker := test.StubDocker(
test.ListContainersCycle(),
test.ListConvoxContainersCycle(),
test.ListConvoxContainersCycle(),
test.ListConvoxContainersCycle(),
test.StatsCycle(),
)
defer docker.Close()
// Note: there is a synchronization issue inside the Docker Stats fanout
// So while the StatsCycle does work sometimes, the test bypasses stats for now
v := url.Values{}
v.Add("stats", "false")
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v)
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 1, len(resp))
assert.Equal(t, 0.0, resp[0].Memory)
}
}
/* NOTE: the S3 stuff f***s up b.c the client ries to prepend the
bucket name to the ephermeral host, so you get `app-XXX.127.0.0.1`
*/
func TestAppDelete(t *testing.T) {
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-bar"),
test.DeleteStackCycle("convox-test-bar"),
)
defer aws.Close()
// setup expectations on current provider
models.TestProvider.On("AppDelete", "bar").Return(nil)
body := test.HTTPBody("DELETE", "http://convox/apps/bar", nil)
var resp map[string]bool
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, true, resp["success"])
}
}
func TestInstanceList(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
provider.TestProvider.Instances = structs.Instances{
structs.Instance{},
structs.Instance{},
structs.Instance{},
}
body := test.HTTPBody("GET", "http://convox/instances", nil)
var resp []client.Instance
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 3, len(resp))
}
}
func TestInstanceList(t *testing.T) {
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
)
defer aws.Close()
body := test.HTTPBody("GET", "http://convox/instances", nil)
var resp []client.Instance
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 3, len(resp))
}
}
func TestGetProcessesWithDeployments(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("InstanceList").Return(testProvider.Instances, nil)
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffEmptyCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesWithDeploymentsCycle("convox-test-cluster"),
test.DescribeTaskDefinition3Cycle("convox-test-cluster"),
test.DescribeTaskDefinition1Cycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersEmptyCycle(),
// query for every container to get CPU and Memory stats
test.StatsCycle(),
)
defer docker.Close()
v := url.Values{}
v.Add("stats", "true")
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v)
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "8dfafdbc3a40", resp[0].Id)
assert.Equal(t, 0.0974, resp[0].Memory)
assert.Equal(t, "pending", resp[1].Id)
assert.EqualValues(t, 0, resp[1].Memory)
}
}
func TestProcessesListWithAttached(t *testing.T) {
// set current provider
testProvider := &provider.TestProviderRunner{
Instances: []structs.Instance{
structs.Instance{},
structs.Instance{},
structs.Instance{},
},
}
provider.CurrentProvider = testProvider
defer func() {
//TODO: remove: as we arent updating all tests we need tos et current provider back to a
//clean default one (I miss rspec before)
provider.CurrentProvider = new(provider.TestProviderRunner)
}()
// setup expectations on current provider
testProvider.On("InstanceList").Return(testProvider.Instances, nil)
os.Setenv("RACK", "convox-test")
os.Setenv("CLUSTER", "convox-test-cluster")
aws := test.StubAws(
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackCycle("convox-test-myapp-staging"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.ListContainerInstancesCycle("convox-test-cluster"),
test.DescribeContainerInstancesCycle("convox-test-cluster"),
test.DescribeInstancesCycle(),
test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"),
test.DescribeTasksCycle("convox-test-cluster"),
test.ListTasksOneoffEmptyCycle("convox-test-cluster"),
test.DescribeTaskDefinitionCycle("convox-test-cluster"),
test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"),
test.DescribeServicesCycle("convox-test-cluster"),
)
defer aws.Close()
docker := test.StubDocker(
// query for every ECS task to get docker id, command, created
test.ListECSContainersCycle(),
// query every instance for one-off containers
test.ListOneoffContainersEmptyCycle(),
test.ListOneoffContainersCycle("79bd711b1756"),
test.InspectCycle("79bd711b1756"),
test.ListOneoffContainersEmptyCycle(),
)
defer docker.Close()
body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", url.Values{})
var resp client.Processes
err := json.Unmarshal([]byte(body), &resp)
if assert.Nil(t, err) {
assert.Equal(t, 2, len(resp))
assert.Equal(t, "/bin/sh -c bash", resp[0].Command)
assert.Equal(t, "echo 1", resp[1].Command)
}
}
