ey-core 3.4.5 → 3.6.0.autoscaling1

data/spec/gems_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
-
-describe "gems" do
-  let!(:client) { create_client }
-
-  it "finds a gem" do
-    gem = client.gems.get("ey-core")
-    expect(gem.current_version).to eq(Ey::Core::VERSION)
-    expect(gem.name).to eq("ey-core")
-  end
-end
+require 'spec_helper'
+
+describe "gems" do
+  let!(:client) { create_client }
+
+  it "finds a gem" do
+    gem = client.gems.get("ey-core")
+    expect(gem.current_version).to eq(Ey::Core::VERSION)
+    expect(gem.name).to eq("ey-core")
+  end
+end

data/spec/keypair_deployments_spec.rb

@@ -1,33 +1,33 @@
-require 'spec_helper'
-
-describe "as a user" do
-  let(:client)       { create_client }
-  let!(:account)     { create_account(client: client) }
-  let!(:provider)    { create_provider(account: account) }
-  let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
-  let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
-
-  it "creates a keypair deployment" do
-    keypair_deployment = client.keypair_deployments.create(keypair: keypair, environment: environment)
-
-    expect(keypair_deployment.identity).not_to be_nil
-    expect(keypair_deployment.keypair).to eq(keypair)
-    expect(keypair_deployment.environment).to eq(environment)
-  end
-
-  context "with a keypair deployment" do
-    let!(:keypair_deployment) { client.keypair_deployments.create(keypair: keypair, environment: environment) }
-
-    it "lists the keypair deployment" do
-      expect(client.keypair_deployments.all).to include(keypair_deployment)
-    end
-
-    it "lists an environment's keypairs" do
-      expect(environment.keypairs.all.to_a).to eq([keypair])
-    end
-
-    it "lists a keypair's deployments"
-    it "searches keypairs by name"
-    it "searches keypairs by fingerprint"
-  end
-end
+require 'spec_helper'
+
+describe "as a user" do
+  let(:client)       { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+  let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+  it "creates a keypair deployment" do
+    keypair_deployment = client.keypair_deployments.create(keypair: keypair, environment: environment)
+
+    expect(keypair_deployment.identity).not_to be_nil
+    expect(keypair_deployment.keypair).to eq(keypair)
+    expect(keypair_deployment.environment).to eq(environment)
+  end
+
+  context "with a keypair deployment" do
+    let!(:keypair_deployment) { client.keypair_deployments.create(keypair: keypair, environment: environment) }
+
+    it "lists the keypair deployment" do
+      expect(client.keypair_deployments.all).to include(keypair_deployment)
+    end
+
+    it "lists an environment's keypairs" do
+      expect(environment.keypairs.all.to_a).to eq([keypair])
+    end
+
+    it "lists a keypair's deployments"
+    it "searches keypairs by name"
+    it "searches keypairs by fingerprint"
+  end
+end

data/spec/keypairs_spec.rb

@@ -1,51 +1,51 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let(:client) { create_client }
-
-  it "creates a keypair" do
-    name    = SecureRandom.hex(6)
-    ssh_key = SSHKey.generate
-
-    keypair = client.keypairs.create(name: name, public_key: ssh_key.ssh_public_key)
-
-    expect(keypair.application).to be_nil
-    expect(keypair.identity).not_to be_nil
-    expect(keypair.fingerprint).to be
-
-    expect(keypair.name).to        eq(name)
-    expect(keypair.public_key).to  eq(ssh_key.ssh_public_key)
-    expect(keypair.user).to        eq(client.users.current)
-  end
-
-  context "with a keypair" do
-    let!(:account)     { create_account(client: client) }
-    let!(:environment) { create_environment(account: account, name: SecureRandom.hex(6), boot: false) }
-    let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
-
-    it "deploys to an environment" do
-      keypair_deployment = keypair.deploy(environment)
-
-      expect(keypair_deployment.identity).not_to be_nil
-      expect(keypair_deployment.keypair).to eq(keypair)
-      expect(keypair_deployment.environment).to eq(environment)
-    end
-
-    context "with many keypairs" do
-      let!(:other_a) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
-      let!(:other_b) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
-
-      it "lists a user's keypairs" do
-        expect(client.users.current.keypairs.all).to match_array([keypair, other_a, other_b])
-      end
-
-      it "searches keypairs by name" do
-        expect(client.keypairs.all(name: other_a.name)).to match_array([other_a])
-      end
-
-      it "searches keypairs by fingerprint" do
-        expect(client.keypairs.all(fingerprint: other_b.fingerprint)).to match_array([other_b])
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+
+  it "creates a keypair" do
+    name    = SecureRandom.hex(6)
+    ssh_key = SSHKey.generate
+
+    keypair = client.keypairs.create(name: name, public_key: ssh_key.ssh_public_key)
+
+    expect(keypair.application).to be_nil
+    expect(keypair.identity).not_to be_nil
+    expect(keypair.fingerprint).to be
+
+    expect(keypair.name).to        eq(name)
+    expect(keypair.public_key).to  eq(ssh_key.ssh_public_key)
+    expect(keypair.user).to        eq(client.users.current)
+  end
+
+  context "with a keypair" do
+    let!(:account)     { create_account(client: client) }
+    let!(:environment) { create_environment(account: account, name: SecureRandom.hex(6), boot: false) }
+    let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+    it "deploys to an environment" do
+      keypair_deployment = keypair.deploy(environment)
+
+      expect(keypair_deployment.identity).not_to be_nil
+      expect(keypair_deployment.keypair).to eq(keypair)
+      expect(keypair_deployment.environment).to eq(environment)
+    end
+
+    context "with many keypairs" do
+      let!(:other_a) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+      let!(:other_b) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+      it "lists a user's keypairs" do
+        expect(client.users.current.keypairs.all).to match_array([keypair, other_a, other_b])
+      end
+
+      it "searches keypairs by name" do
+        expect(client.keypairs.all(name: other_a.name)).to match_array([other_a])
+      end
+
+      it "searches keypairs by fingerprint" do
+        expect(client.keypairs.all(fingerprint: other_b.fingerprint)).to match_array([other_b])
+      end
+    end
+  end
+end

data/spec/legacy_alerts_spec.rb

@@ -1,44 +1,44 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let(:client) { create_client }
-
-  context "with an account", :mock_only do
-    let!(:account)     { create_account(client: client) }
-    let!(:provider)    { create_provider(account: account) }
-    let!(:environment) { create_environment(account: account, name: Faker::Name.name) }
-    let(:server)       { environment.servers.first }
-    let(:legacy_alert) { client.legacy_alerts.get(1001) }
-
-    before do
-      create_legacy_alert(client, id: 1001,
-                              type: "cpu",
-                          severity: "warning",
-                            server: server,
-                      acknowledged: false)
-    end
-
-    it "fetches a legacy alert" do
-      a = client.legacy_alerts.get(1001)
-
-      expect(a).not_to be_nil
-      expect(a.id).to          eq(1001)
-      expect(a.type).to        eq("cpu")
-      expect(a.severity).to    eq("warning")
-      expect(a.acknowledged).to be false
-      expect(a.server).to      eq(server)
-    end
-
-    it "lists legacy alerts" do
-      legacy_alerts = client.legacy_alerts.all
-      expect(legacy_alerts.size).to be(1)
-
-      a = legacy_alerts.first
-      expect(a.id).to          eq(1001)
-      expect(a.type).to        eq("cpu")
-      expect(a.severity).to    eq("warning")
-      expect(a.acknowledged).to be false
-      expect(a.server).to      eq(server)
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+
+  context "with an account", :mock_only do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:environment) { create_environment(account: account, name: Faker::Name.name) }
+    let(:server)       { environment.servers.first }
+    let(:legacy_alert) { client.legacy_alerts.get(1001) }
+
+    before do
+      create_legacy_alert(client, id: 1001,
+                              type: "cpu",
+                          severity: "warning",
+                            server: server,
+                      acknowledged: false)
+    end
+
+    it "fetches a legacy alert" do
+      a = client.legacy_alerts.get(1001)
+
+      expect(a).not_to be_nil
+      expect(a.id).to          eq(1001)
+      expect(a.type).to        eq("cpu")
+      expect(a.severity).to    eq("warning")
+      expect(a.acknowledged).to be false
+      expect(a.server).to      eq(server)
+    end
+
+    it "lists legacy alerts" do
+      legacy_alerts = client.legacy_alerts.all
+      expect(legacy_alerts.size).to be(1)
+
+      a = legacy_alerts.first
+      expect(a.id).to          eq(1001)
+      expect(a.type).to        eq("cpu")
+      expect(a.severity).to    eq("warning")
+      expect(a.acknowledged).to be false
+      expect(a.server).to      eq(server)
+    end
+  end
+end

data/spec/load_balancers_spec.rb

@@ -1,31 +1,31 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let!(:client)   { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  it "creates a load balancer" do
-    name = Faker::Name.first_name
-    location = "us-east-1"
-
-    req = client.load_balancers.create!(provider: provider,
-                                        name: name,
-                                        location: location)
-
-    load_balancer = req.resource!
-
-    expect(load_balancer.name).to     eq(name)
-    expect(load_balancer.location).to eq(location)
-    expect(load_balancer.provider).to eq(provider)
-  end
-
-  context "with a load balancer" do
-    let!(:load_balancer) { client.load_balancers.create!(provider: provider, name: Faker::Name.first_name, location: "us-east-1").resource! }
-
-    it "destroys a load balancer" do
-      expect { load_balancer.destroy }.to change { client.load_balancers.all.size }.by(-1)
-      expect(load_balancer.reload.deleted_at).not_to be_nil
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client)   { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates a load balancer" do
+    name = Faker::Name.first_name
+    location = "us-east-1"
+
+    req = client.load_balancers.create!(provider: provider,
+                                        name: name,
+                                        location: location)
+
+    load_balancer = req.resource!
+
+    expect(load_balancer.name).to     eq(name)
+    expect(load_balancer.location).to eq(location)
+    expect(load_balancer.provider).to eq(provider)
+  end
+
+  context "with a load balancer" do
+    let!(:load_balancer) { client.load_balancers.create!(provider: provider, name: Faker::Name.first_name, location: "us-east-1").resource! }
+
+    it "destroys a load balancer" do
+      expect { load_balancer.destroy }.to change { client.load_balancers.all.size }.by(-1)
+      expect(load_balancer.reload.deleted_at).not_to be_nil
+    end
+  end
+end

data/spec/logical_databases_spec.rb

@@ -1,38 +1,38 @@
-require 'spec_helper'
-
-describe "as a client" do
-  let(:client)    { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  context "with a database service" do
-    let!(:database_service) { create_database_service(provider: provider, client: client) }
-
-    it "creates a logical database" do
-      logical_database = nil
-      name = SecureRandom.hex(6)
-      extensions = ["postgis"]
-
-      expect {
-        logical_database = database_service.databases.create!(name: name, extensions: extensions).resource!
-      }.to change { client.logical_databases.size }.by(1)
-
-      expect(logical_database.name).to         eq(name)
-      expect(logical_database.username).not_to be_nil
-      expect(logical_database.password).not_to be_nil
-      expect(logical_database.extensions).to   eq(extensions)
-      expect(logical_database.service).to      eq(database_service)
-    end
-
-    context "with a logical database" do
-      let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
-
-      it "destroys the logical database" do
-        expect {
-          logical_database.destroy.ready!
-        }.to change  { logical_database.reload.deleted_at }.from(nil).
-          and change { database_service.databases.reload.all.size }.by(-1)
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe "as a client" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  context "with a database service" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+
+    it "creates a logical database" do
+      logical_database = nil
+      name = SecureRandom.hex(6)
+      extensions = ["postgis"]
+
+      expect {
+        logical_database = database_service.databases.create!(name: name, extensions: extensions).resource!
+      }.to change { client.logical_databases.size }.by(1)
+
+      expect(logical_database.name).to         eq(name)
+      expect(logical_database.username).not_to be_nil
+      expect(logical_database.password).not_to be_nil
+      expect(logical_database.extensions).to   eq(extensions)
+      expect(logical_database.service).to      eq(database_service)
+    end
+
+    context "with a logical database" do
+      let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
+
+      it "destroys the logical database" do
+        expect {
+          logical_database.destroy.ready!
+        }.to change  { logical_database.reload.deleted_at }.from(nil).
+          and change { database_service.databases.reload.all.size }.by(-1)
+      end
+    end
+  end
+end

data/spec/logs_spec.rb

@@ -1,44 +1,44 @@
-require 'spec_helper'
-
-describe 'logs', :mock_only  do
-  let(:client)        { create_client }
-  let!(:account)      { create_account(client: client) }
-  let!(:provider)     { create_provider(account: account) }
-  let!(:environment)  { create_environment(account: account, name: Faker::Name.first_name) }
-  let(:server_client) { create_server_client(client.servers.all.first) }
-
-  describe "create log" do
-    it "can upload a file" do
-      log = server_client.logs.create!(
-        :component_action_id => "123",
-        :file                => "{}",
-        :filename            => "blah.json",
-        :mime_type           => "application/json"
-      )
-      expect(log.id).to be
-      expect(log.download_url).to be
-      expect(log.filename).to eq("blah.json")
-    end
-
-    it "can create a log using body content" do
-      body = "{}"
-      log = server_client.logs.create!(
-        :body                => body,
-        :component_action_id => "123",
-        :mime_type           => "application/json",
-      )
-      expect(log.id).to be
-      expect(log.filename).to be
-      expect(log.download_url).to be
-    end
-  end
-
-  it "can fetch a log" do
-    created_log = server_client.logs.create!(
-      :component_action_id => "123",
-      :file                => "{}",
-      :mime_type           => "application/json"
-    )
-    expect(client.logs.get!(created_log.id)).to eq(created_log)
-  end
-end
+require 'spec_helper'
+
+describe 'logs', :mock_only  do
+  let(:client)        { create_client }
+  let!(:account)      { create_account(client: client) }
+  let!(:provider)     { create_provider(account: account) }
+  let!(:environment)  { create_environment(account: account, name: Faker::Name.first_name) }
+  let(:server_client) { create_server_client(client.servers.all.first) }
+
+  describe "create log" do
+    it "can upload a file" do
+      log = server_client.logs.create!(
+        :component_action_id => "123",
+        :file                => "{}",
+        :filename            => "blah.json",
+        :mime_type           => "application/json"
+      )
+      expect(log.id).to be
+      expect(log.download_url).to be
+      expect(log.filename).to eq("blah.json")
+    end
+
+    it "can create a log using body content" do
+      body = "{}"
+      log = server_client.logs.create!(
+        :body                => body,
+        :component_action_id => "123",
+        :mime_type           => "application/json",
+      )
+      expect(log.id).to be
+      expect(log.filename).to be
+      expect(log.download_url).to be
+    end
+  end
+
+  it "can fetch a log" do
+    created_log = server_client.logs.create!(
+      :component_action_id => "123",
+      :file                => "{}",
+      :mime_type           => "application/json"
+    )
+    expect(client.logs.get!(created_log.id)).to eq(created_log)
+  end
+end

data/spec/memberships_spec.rb

@@ -1,73 +1,73 @@
-require 'spec_helper'
-
-describe "memberships" do
-  let!(:user)         { create_user }
-  let!(:client)       { create_client(user: user) }
-  let!(:account)      { create_account(owner: user) }
-  let!(:collaborator) { create_user }
-
-  it "should create a membership for an email" do
-    email = Faker::Internet.email
-
-    membership = client.memberships.create!(account: account, role: "collaborator", email: email, redirect_url: "http://example.com")
-
-    expect(membership.email).to eq(email)
-    expect(membership.user).to be_nil
-    expect(membership.role).to eq("collaborator")
-    expect(membership.redirect_url).to eq("http://example.com")
-  end
-
-  it "should create a membership for a user" do
-    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
-
-    expect(membership.email).to eq(collaborator.email)
-    expect(membership.user).to eq(collaborator)
-    expect(membership.role).to eq("collaborator")
-  end
-
-  it "should get a membership" do
-    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
-
-    expect(client.memberships.get(membership.id)).to eq(membership)
-
-    expect(account.memberships.size).to eq 1
-    expect(account.memberships.first).to eq membership
-  end
-
-  it "should be able to accept invites", :mock_only do
-    account = client.accounts.create!(owner: user, name: Faker::Name.first_name, type: "normal")
-    collaborator  = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
-
-    collaborator.reload
-    expect(collaborator.accounts.all).to be_empty
-    account.reload
-    expect(account.users.all.size).to eq 1
-    expect(account.users.all.map(&:id)).to eq [user.id]
-    expect(account.owners.all.size).to eq 1
-    expect(account.owners.all.map(&:id)).to eq [user.id]
-
-    invite = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
-
-    collaborator.reload
-    expect(collaborator.accounts.all).to be_empty
-    account.reload
-    expect(account.users.all.size).to eq 1
-    expect(account.users.all.map(&:id)).to eq [user.id]
-    expect(account.owners.all.size).to eq 1
-    expect(account.owners.all.map(&:id)).to eq [user.id]
-
-    collaborator_client = create_client(user: collaborator)
-    membership = collaborator_client.memberships.get(invite.id)
-    membership.accept!
-
-    collaborator.reload
-    expect(collaborator.accounts.all.size).to eq 1
-    expect(collaborator.accounts.first.id).to eq account.id
-    account.reload
-    expect(account.users.all.size).to eq 2
-    expect(account.users.all.map(&:id).sort).to eq [user.id, collaborator.id].sort
-    expect(account.owners.all.size).to eq 1
-    expect(account.owners.all.map(&:id)).to eq [user.id]
-  end
-
-end
+require 'spec_helper'
+
+describe "memberships" do
+  let!(:user)         { create_user }
+  let!(:client)       { create_client(user: user) }
+  let!(:account)      { create_account(owner: user) }
+  let!(:collaborator) { create_user }
+
+  it "should create a membership for an email" do
+    email = Faker::Internet.email
+
+    membership = client.memberships.create!(account: account, role: "collaborator", email: email, redirect_url: "http://example.com")
+
+    expect(membership.email).to eq(email)
+    expect(membership.user).to be_nil
+    expect(membership.role).to eq("collaborator")
+    expect(membership.redirect_url).to eq("http://example.com")
+  end
+
+  it "should create a membership for a user" do
+    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    expect(membership.email).to eq(collaborator.email)
+    expect(membership.user).to eq(collaborator)
+    expect(membership.role).to eq("collaborator")
+  end
+
+  it "should get a membership" do
+    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    expect(client.memberships.get(membership.id)).to eq(membership)
+
+    expect(account.memberships.size).to eq 1
+    expect(account.memberships.first).to eq membership
+  end
+
+  it "should be able to accept invites", :mock_only do
+    account = client.accounts.create!(owner: user, name: Faker::Name.first_name, type: "normal")
+    collaborator  = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+
+    collaborator.reload
+    expect(collaborator.accounts.all).to be_empty
+    account.reload
+    expect(account.users.all.size).to eq 1
+    expect(account.users.all.map(&:id)).to eq [user.id]
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+
+    invite = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    collaborator.reload
+    expect(collaborator.accounts.all).to be_empty
+    account.reload
+    expect(account.users.all.size).to eq 1
+    expect(account.users.all.map(&:id)).to eq [user.id]
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+
+    collaborator_client = create_client(user: collaborator)
+    membership = collaborator_client.memberships.get(invite.id)
+    membership.accept!
+
+    collaborator.reload
+    expect(collaborator.accounts.all.size).to eq 1
+    expect(collaborator.accounts.first.id).to eq account.id
+    account.reload
+    expect(account.users.all.size).to eq 2
+    expect(account.users.all.map(&:id).sort).to eq [user.id, collaborator.id].sort
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+  end
+
+end