ey-core 3.4.2 → 3.4.5

data/spec/alerts_spec.rb

@@ -1,155 +1,155 @@
-require 'spec_helper'
-
-describe 'alerts' do
-  let(:client) { create_client }
-  let(:alert_params) { {
-    :message     => Faker::Lorem.sentence(1),
-    :description => Faker::Hacker.verb,
-    :severity    => "warning",
-    :name        => Faker::Hacker.noun,
-    :external_id => SecureRandom.uuid,
-  } }
-
-  it 'should fail to create an alert with no resource' do
-    expect { client.alerts.create!(alert_params) }.to raise_error Ey::Core::Response::Unprocessable
-  end
-
-  context 'with a database server' do
-    let(:database_server) { create_database_service(client: client).servers.first }
-
-    it 'should create an alert' do
-      alert = nil
-      expect {
-        alert = database_server.alerts.create!(alert_params)
-      }.to change  { client.alerts.size          }.by(1).
-        and change { database_server.alerts.size }.by(1)
-
-      expect(alert.database_server).to eq(database_server)
-      expect(alert.resource).to        eq(database_server)
-
-      expect(alert.description).to     eq(alert_params[:description])
-      expect(alert.external_id).to     eq(alert_params[:external_id])
-      expect(alert.finished_at).to     eq(nil)
-      expect(alert.message).to         eq(alert_params[:message])
-      expect(alert.name).to            eq(alert_params[:name])
-      expect(alert.severity).to        eq(alert_params[:severity])
-
-      alert.reload
-
-      expect(alert.database_server).to eq(database_server)
-      expect(alert.resource).to        eq(database_server)
-
-      expect(alert.description).to     eq(alert_params[:description])
-      expect(alert.external_id).to     eq(alert_params[:external_id])
-      expect(alert.finished_at).to     eq(nil)
-      expect(alert.message).to         eq(alert_params[:message])
-      expect(alert.name).to            eq(alert_params[:name])
-      expect(alert.severity).to        eq(alert_params[:severity])
-    end
-  end
-
-  context 'with a server' do
-    let!(:account)     { create_account(client: client) }
-    let!(:provider)    { create_provider(account: account) }
-    let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
-
-    it 'should create an alert' do
-      server = client.servers.all.first
-      alert  = nil
-
-      expect {
-        alert = server.alerts.create!(alert_params)
-      }.to change  { client.alerts.size }.by(1).
-        and change { server.alerts.size }.by(1)
-
-      expect(alert.message).to     eq(alert_params[:message])
-      expect(alert.description).to eq(alert_params[:description])
-      expect(alert.severity).to    eq(alert_params[:severity])
-      expect(alert.name).to        eq(alert_params[:name])
-      expect(alert.external_id).to eq(alert_params[:external_id])
-      expect(alert.started_at).to  be_nil
-      expect(alert.server).to      eq(server)
-
-      alert.reload
-
-      expect(alert.message).to     eq(alert_params[:message])
-      expect(alert.description).to eq(alert_params[:description])
-      expect(alert.severity).to    eq(alert_params[:severity])
-      expect(alert.name).to        eq(alert_params[:name])
-      expect(alert.external_id).to eq(alert_params[:external_id])
-      expect(alert.started_at).to  be_nil
-      expect(alert.server).to      eq(server)
-    end
-
-    it "create an alert that has been started" do
-      server = client.servers.all.first
-      alert = nil
-
-      expect {
-        alert = server.alerts.create!(alert_params.merge(started_at: Time.now))
-      }.to change { server.alerts.size }.by(1)
-
-      expect(alert.started_at).not_to be_nil
-      expect(alert.reload.started_at).not_to be_nil
-    end
-  end
-
-  context "given some alerts" do
-    let(:database_server)  { create_database_service(client: client).servers.first }
-    let(:database_server2) { create_database_service(client: client).servers.first }
-
-    let!(:alerts) {
-      [
-        client.alerts.create!(
-          :database_server => database_server,
-          :message         => Faker::Lorem.sentence(1),
-          :description     => Faker::Hacker.verb,
-          :severity        => "warning",
-          :name            => Faker::Hacker.noun,
-          :external_id     => SecureRandom.uuid,
-        ),
-        client.alerts.create!(
-          :database_server => database_server2,
-          :message         => Faker::Lorem.sentence(1),
-          :description     => Faker::Hacker.verb,
-          :severity        => "warning",
-          :name            => Faker::Hacker.noun,
-          :external_id     => SecureRandom.uuid,
-        ),
-      ]
-    }
-
-    it "should list alerts" do
-      expect(
-        client.alerts.all
-      ).to match_array(alerts)
-    end
-
-    it "should filter alerts" do
-      expect(database_server.alerts.all).to match_array(alerts[0])
-      expect(client.alerts.all(database_server: database_server.identity)).to match_array(alerts[0])
-
-      expect(database_server2.alerts.all).to match_array(alerts[1])
-      expect(client.alerts.all(database_server: database_server2.identity)).to match_array(alerts[1])
-    end
-
-    it "should update alert" do
-      alert = alerts.first
-      expect { alert.update(acknowledged: true) }.to change { alert.acknowledged }.from(false).to(true)
-      expect { alert.update(message: "something else") }.to change { alert.reload.message }
-      expect { alert.update(external_id: "new-id") }.to change { alert.reload.external_id }
-      expect { alert.update(started_at: Time.now) }.to change { alert.reload.started_at }.from(nil)
-      expect {
-        alert.update(finished_at: Time.now)
-      }.to  change { alert.reload.finished_at }.from(nil).
-        and change { database_server.alerts.all.size }.by(-1)
-    end
-
-    it 'acknowledges the alert' do
-      alert = alerts.first
-      expect {
-        alert.acknowledge!
-      }.to change { alert.acknowledged }.from(false).to(true)
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'alerts' do
+  let(:client) { create_client }
+  let(:alert_params) { {
+    :message     => Faker::Lorem.sentence(1),
+    :description => Faker::Hacker.verb,
+    :severity    => "warning",
+    :name        => Faker::Hacker.noun,
+    :external_id => SecureRandom.uuid,
+  } }
+
+  it 'should fail to create an alert with no resource' do
+    expect { client.alerts.create!(alert_params) }.to raise_error Ey::Core::Response::Unprocessable
+  end
+
+  context 'with a database server' do
+    let(:database_server) { create_database_service(client: client).servers.first }
+
+    it 'should create an alert' do
+      alert = nil
+      expect {
+        alert = database_server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size          }.by(1).
+        and change { database_server.alerts.size }.by(1)
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+
+      alert.reload
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+    end
+  end
+
+  context 'with a server' do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+
+    it 'should create an alert' do
+      server = client.servers.all.first
+      alert  = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size }.by(1).
+        and change { server.alerts.size }.by(1)
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+
+      alert.reload
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+    end
+
+    it "create an alert that has been started" do
+      server = client.servers.all.first
+      alert = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params.merge(started_at: Time.now))
+      }.to change { server.alerts.size }.by(1)
+
+      expect(alert.started_at).not_to be_nil
+      expect(alert.reload.started_at).not_to be_nil
+    end
+  end
+
+  context "given some alerts" do
+    let(:database_server)  { create_database_service(client: client).servers.first }
+    let(:database_server2) { create_database_service(client: client).servers.first }
+
+    let!(:alerts) {
+      [
+        client.alerts.create!(
+          :database_server => database_server,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+        client.alerts.create!(
+          :database_server => database_server2,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+      ]
+    }
+
+    it "should list alerts" do
+      expect(
+        client.alerts.all
+      ).to match_array(alerts)
+    end
+
+    it "should filter alerts" do
+      expect(database_server.alerts.all).to match_array(alerts[0])
+      expect(client.alerts.all(database_server: database_server.identity)).to match_array(alerts[0])
+
+      expect(database_server2.alerts.all).to match_array(alerts[1])
+      expect(client.alerts.all(database_server: database_server2.identity)).to match_array(alerts[1])
+    end
+
+    it "should update alert" do
+      alert = alerts.first
+      expect { alert.update(acknowledged: true) }.to change { alert.acknowledged }.from(false).to(true)
+      expect { alert.update(message: "something else") }.to change { alert.reload.message }
+      expect { alert.update(external_id: "new-id") }.to change { alert.reload.external_id }
+      expect { alert.update(started_at: Time.now) }.to change { alert.reload.started_at }.from(nil)
+      expect {
+        alert.update(finished_at: Time.now)
+      }.to  change { alert.reload.finished_at }.from(nil).
+        and change { database_server.alerts.all.size }.by(-1)
+    end
+
+    it 'acknowledges the alert' do
+      alert = alerts.first
+      expect {
+        alert.acknowledge!
+      }.to change { alert.acknowledged }.from(false).to(true)
+    end
+  end
+end

data/spec/application_archives_spec.rb

@@ -1,39 +1,39 @@
-require 'spec_helper'
-
-describe 'application_archives' do
-  let(:client)       { create_client }
-  let!(:account)     { create_account(client: client) }
-  let!(:provider)    { create_provider(account: account) }
-  let!(:application) { account.applications.create!(name: "hello_servlet", type: "java") }
-
-  it "should create an application archive" do
-    archive = application.archives.create!(filename: "helloservlet.war")
-
-    # FIXME: archive.application.should == application
-    expect(archive.filename).to eq("helloservlet.war")
-    expect(archive.upload_successful).to eq(false)
-    expect(archive.upload_url).to be
-  end
-
-  context "with an archive", :mock_only do # needs uploaded archives to pass
-    let!(:archive) { application.archives.create!(filename: "helloservlet.war") }
-
-    it "should upload, mark that it was successful, and download" do
-      archive.upload(body: "enterprise")
-
-      expect(archive.upload_successful).to eq(true)
-
-      expect(archive.download.body).to eq("enterprise")
-    end
-
-    context "with multiple archives" do
-      let!(:another_application) { account.applications.create!(name: "hello_bean", type: "java") }
-      let!(:another_archive)     { another_application.archives.create!(filename: "helloservlet.war") }
-
-      it "should list based on application" do
-        expect(application.archives.all).to match_array([archive])
-        expect(another_application.archives.all).to match_array([another_archive])
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'application_archives' do
+  let(:client)       { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:application) { account.applications.create!(name: "hello_servlet", type: "java") }
+
+  it "should create an application archive" do
+    archive = application.archives.create!(filename: "helloservlet.war")
+
+    # FIXME: archive.application.should == application
+    expect(archive.filename).to eq("helloservlet.war")
+    expect(archive.upload_successful).to eq(false)
+    expect(archive.upload_url).to be
+  end
+
+  context "with an archive", :mock_only do # needs uploaded archives to pass
+    let!(:archive) { application.archives.create!(filename: "helloservlet.war") }
+
+    it "should upload, mark that it was successful, and download" do
+      archive.upload(body: "enterprise")
+
+      expect(archive.upload_successful).to eq(true)
+
+      expect(archive.download.body).to eq("enterprise")
+    end
+
+    context "with multiple archives" do
+      let!(:another_application) { account.applications.create!(name: "hello_bean", type: "java") }
+      let!(:another_archive)     { another_application.archives.create!(filename: "helloservlet.war") }
+
+      it "should list based on application" do
+        expect(application.archives.all).to match_array([archive])
+        expect(another_application.archives.all).to match_array([another_archive])
+      end
+    end
+  end
+end

data/spec/applications_spec.rb

@@ -1,65 +1,65 @@
-require 'spec_helper'
-
-describe 'applications' do
-  let(:client)        { create_client }
-
-  let!(:account)     { create_account(client: client) }
-  let!(:provider)    { create_provider(account: account) }
-
-  let(:app_name)     { SecureRandom.hex(12) }
-  let(:repository)   { "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{app_name}/#{app_name}.git" }
-
-  it "should create an application" do
-    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
-
-    expect(application.id).not_to be_nil
-    expect(application.name).to eq(app_name)
-    expect(application.type).to eq("rails3")
-    expect(application.language).to eq("ruby")
-    expect(application.repository).to eq(repository)
-  end
-
-  it "should create a deploy keypair when creating an application" do
-    expect {
-      account.applications.create!(name: app_name, type: "rails3", repository: repository)
-    }.to change { client.keypairs.count }.by(1)
-  end
-
-  it "should list an application's keypairs" do
-    client.keypairs.create(name: "rando", public_key: SSHKey.generate.ssh_public_key) # an existing keypair
-
-    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
-
-    keypair = application.keypairs.one
-    expect(keypair.public_key).to be
-  end
-
-  it "should search for application by type" do
-    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
-    client.applications.create!(name: SecureRandom.hex(3), type: "rails2", repository: repository, account: account)
-
-    expect(client.applications.all(type: "rails3").size).to eq(1)
-    expect(client.applications.first(type: "rails3")).to eq(application)
-  end
-
-  it "should search for application by repository" do
-    other_repository = "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{Faker::Name.first_name}/#{Faker::Name.last_name}.git"
-
-    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
-    client.applications.create!(name: app_name, type: "rails3", repository: other_repository, account: account)
-
-    expect(client.applications.all(repository: repository).size).to eq(1)
-    expect(client.applications.first(repository: repository)).to eq(application)
-  end
-
-  it "has the correct language for all app types" do
-    expect(account.applications.create!(name: "merb_app", type: "merb", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "rack_app", type: "rack", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "rails2_app", type: "rails2", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "rails3_app", type: "rails3", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "rails4_app", type: "rails4", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "sinatra_app", type: "sinatra", repository: repository).language).to eq("ruby")
-    expect(account.applications.create!(name: "php_app", type: "php", repository: repository).language).to eq("php")
-    expect(account.applications.create!(name: "nodejs_app", type: "nodejs", repository: repository).language).to eq("nodejs")
-  end
-end
+require 'spec_helper'
+
+describe 'applications' do
+  let(:client)        { create_client }
+
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+
+  let(:app_name)     { SecureRandom.hex(12) }
+  let(:repository)   { "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{app_name}/#{app_name}.git" }
+
+  it "should create an application" do
+    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
+
+    expect(application.id).not_to be_nil
+    expect(application.name).to eq(app_name)
+    expect(application.type).to eq("rails3")
+    expect(application.language).to eq("ruby")
+    expect(application.repository).to eq(repository)
+  end
+
+  it "should create a deploy keypair when creating an application" do
+    expect {
+      account.applications.create!(name: app_name, type: "rails3", repository: repository)
+    }.to change { client.keypairs.count }.by(1)
+  end
+
+  it "should list an application's keypairs" do
+    client.keypairs.create(name: "rando", public_key: SSHKey.generate.ssh_public_key) # an existing keypair
+
+    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
+
+    keypair = application.keypairs.one
+    expect(keypair.public_key).to be
+  end
+
+  it "should search for application by type" do
+    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
+    client.applications.create!(name: SecureRandom.hex(3), type: "rails2", repository: repository, account: account)
+
+    expect(client.applications.all(type: "rails3").size).to eq(1)
+    expect(client.applications.first(type: "rails3")).to eq(application)
+  end
+
+  it "should search for application by repository" do
+    other_repository = "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{Faker::Name.first_name}/#{Faker::Name.last_name}.git"
+
+    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
+    client.applications.create!(name: app_name, type: "rails3", repository: other_repository, account: account)
+
+    expect(client.applications.all(repository: repository).size).to eq(1)
+    expect(client.applications.first(repository: repository)).to eq(application)
+  end
+
+  it "has the correct language for all app types" do
+    expect(account.applications.create!(name: "merb_app", type: "merb", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rack_app", type: "rack", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails2_app", type: "rails2", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails3_app", type: "rails3", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails4_app", type: "rails4", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "sinatra_app", type: "sinatra", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "php_app", type: "php", repository: repository).language).to eq("php")
+    expect(account.applications.create!(name: "nodejs_app", type: "nodejs", repository: repository).language).to eq("nodejs")
+  end
+end

data/spec/auto_scaling_groups_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  context "with an environment" do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:app)         { create_application(account: account, client: client) }
+    let!(:environment) { create_environment(client: client, account: account, application: app, configuration: { type: "production"}) }
+
+    it "adds an auto scaling group" do
+      expect {
+        client.auto_scaling_groups.create!(minimum_size: 2, maximum_size: 6, environment: environment).resource!
+      }.to change { environment.reload.auto_scaling_group }.from(nil).and change { client.auto_scaling_groups.count }.by(1)
+    end
+
+    context "with an auto scaling group" do
+      let!(:group) { client.auto_scaling_groups.create!(minimum_size: 2, maximum_size: 6, environment: environment).resource! }
+
+      it "destroys the auto scaling group" do
+        expect {
+          group.destroy.ready!
+        }.to change { group.reload.deleted_at }.from(nil).and change { client.environments.get(environment.id).auto_scaling_group }.to(nil)
+      end
+    end
+  end
+end

data/spec/billing_spec.rb

@@ -1,31 +1,31 @@
-require 'spec_helper'
-
-describe 'billing', :mock_only do
-  let!(:consumer_client) { create_client }
-
-  context "with account" do
-    let!(:user)       { consumer_client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
-    let!(:account)    { consumer_client.accounts.create!(owner: user, name_prefix: Faker::Name.first_name) }
-
-    it "has billing state" do
-      billing = consumer_client.billing.get(account.id)
-      expect(billing.state).to eq "requested"
-    end
-
-    it "can update billing state" do
-      billing = consumer_client.billing.get(account.id)
-      billing.state = "verified"
-      billing.save
-
-      billing = consumer_client.billing.get(account.id)
-      expect(billing.state).to eq "verified"
-
-      billing = consumer_client.billing.put_state(account.id, "finalized")
-      expect(billing.state).to eq "finalized"
-
-      billing = consumer_client.billing.get(account.id)
-      expect(billing.state).to eq "finalized"
-    end
-
-  end
-end
+require 'spec_helper'
+
+describe 'billing', :mock_only do
+  let!(:consumer_client) { create_client }
+
+  context "with account" do
+    let!(:user)       { consumer_client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+    let!(:account)    { consumer_client.accounts.create!(owner: user, name_prefix: Faker::Name.first_name) }
+
+    it "has billing state" do
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "requested"
+    end
+
+    it "can update billing state" do
+      billing = consumer_client.billing.get(account.id)
+      billing.state = "verified"
+      billing.save
+
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "verified"
+
+      billing = consumer_client.billing.put_state(account.id, "finalized")
+      expect(billing.state).to eq "finalized"
+
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "finalized"
+    end
+
+  end
+end