ey-core 3.6.4 → 3.6.5

data/spec/database_plan_usage_spec.rb

@@ -1,39 +1,39 @@
-require "spec_helper"
-
-describe "plan_usage", :mock_only do
-  let!(:client)  { create_client }
-  let!(:account) { create_account(client: client, account: { owner: create_user(client: client)}) }
-  let!(:provider)    { create_provider(account: account) }
-  let!(:database_service)    { create_database_service(provider: provider) }
-
-  before(:each) do
-    client.find(:database_plan_usages, account.id).merge!(
-      "2014-07" => [
-        {
-          "start_at"      => "2014-05-01T00:00:00+00:00",
-          "end_at"        => "2014-05-31T23:59:59+00:00",
-          "report_time"   => Time.now.iso8601,
-          "type"          => "self-service-00",
-          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
-        },
-      ]
-    )
-  end
-
-  it "can fetch plan usage for an account and billing_month" do
-    database_plan_usages = client.database_plan_usages.all(account_id: account.id, billing_month: "2014-07")
-
-    expect(database_plan_usages.size).to eq(1)
-
-    database_plan_usage = database_plan_usages.first
-
-    expect(database_plan_usage.start_at).not_to be_nil
-    expect(database_plan_usage.end_at).not_to be_nil
-    expect(database_plan_usage.report_time).not_to be_nil
-
-    expect(database_plan_usage.type).to eq("self-service-00")
-
-    expect(database_plan_usage.database_service).to eq(database_service)
-  end
-
-end
+require "spec_helper"
+
+describe "plan_usage", :mock_only do
+  let!(:client)  { create_client }
+  let!(:account) { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:database_service)    { create_database_service(provider: provider) }
+
+  before(:each) do
+    client.find(:database_plan_usages, account.id).merge!(
+      "2014-07" => [
+        {
+          "start_at"      => "2014-05-01T00:00:00+00:00",
+          "end_at"        => "2014-05-31T23:59:59+00:00",
+          "report_time"   => Time.now.iso8601,
+          "type"          => "self-service-00",
+          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    database_plan_usages = client.database_plan_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(database_plan_usages.size).to eq(1)
+
+    database_plan_usage = database_plan_usages.first
+
+    expect(database_plan_usage.start_at).not_to be_nil
+    expect(database_plan_usage.end_at).not_to be_nil
+    expect(database_plan_usage.report_time).not_to be_nil
+
+    expect(database_plan_usage.type).to eq("self-service-00")
+
+    expect(database_plan_usage.database_service).to eq(database_service)
+  end
+
+end

data/spec/database_server_snapshots_spec.rb

@@ -1,41 +1,41 @@
-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 server" do
-    let!(:database_service) { create_database_service(provider: provider, client: client) }
-    let!(:database_server)  { database_service.servers.first }
-
-    it "should discover database server snapshots", :mock_only do
-      expect {
-        snapshots = client.database_server_snapshots.discover(provider).resource!
-        expect(snapshots).to be_a(Ey::Core::Client::DatabaseServerSnapshots)
-        expect(snapshots.count).not_to eq(0)
-      }.to change { database_server.snapshots.count }
-    end
-
-    it "creates a snapshot" do
-      snapshot = database_server.snapshots.create.resource!
-
-      expect(snapshot.database_server).to eq(database_server)
-      expect(snapshot.database_service).to eq(database_service)
-      expect(snapshot.provisioned_id).to be
-
-      expect(database_service.snapshots).to contain_exactly(snapshot)
-      expect(database_server.snapshots).to  contain_exactly(snapshot)
-    end
-
-    context "with a snapshot" do
-      let!(:snapshot) { database_server.snapshots.create.resource! }
-
-      it "destroys" do
-        expect {
-          snapshot.destroy!.resource!
-        }.to change { snapshot.reload.deleted_at }.from(nil)
-      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 server" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:database_server)  { database_service.servers.first }
+
+    it "should discover database server snapshots", :mock_only do
+      expect {
+        snapshots = client.database_server_snapshots.discover(provider).resource!
+        expect(snapshots).to be_a(Ey::Core::Client::DatabaseServerSnapshots)
+        expect(snapshots.count).not_to eq(0)
+      }.to change { database_server.snapshots.count }
+    end
+
+    it "creates a snapshot" do
+      snapshot = database_server.snapshots.create.resource!
+
+      expect(snapshot.database_server).to eq(database_server)
+      expect(snapshot.database_service).to eq(database_service)
+      expect(snapshot.provisioned_id).to be
+
+      expect(database_service.snapshots).to contain_exactly(snapshot)
+      expect(database_server.snapshots).to  contain_exactly(snapshot)
+    end
+
+    context "with a snapshot" do
+      let!(:snapshot) { database_server.snapshots.create.resource! }
+
+      it "destroys" do
+        expect {
+          snapshot.destroy!.resource!
+        }.to change { snapshot.reload.deleted_at }.from(nil)
+      end
+    end
+  end
+end

data/spec/database_server_usage_spec.rb

@@ -1,49 +1,49 @@
-require "spec_helper"
-
-describe "server_usage", :mock_only do
-  let!(:client)      { create_client }
-  let!(:account)     { create_account(client: client, account: { owner: create_user(client: client)}) }
-  let!(:provider)    { create_provider(account: account) }
-  let!(:database_service)    { create_database_service(provider: provider) }
-
-  before(:each) do
-    client.find(:database_server_usages, account.id).merge!(
-      "2014-07" => [
-        {
-          "start_at"         => "2014-05-01T00:00:00+00:00",
-          "end_at"           => "2014-05-31T23:59:59+00:00",
-          "report_time"      => Time.now.iso8601,
-          "provisioned_id"   => "e982somedb",
-          "flavor"           => "db.r3.8xlarge",
-          "multi_az"         => false,
-          "master"           => false,
-          "location"         => "us-east-1d",
-          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
-          "provider"         => "https://api.engineyard.com/providers/#{provider.id}",
-        },
-      ]
-    )
-  end
-
-  it "can fetch usage for an account and billing_month" do
-    database_server_usages = client.database_server_usages.all(account_id: account.id, billing_month: "2014-07")
-
-    expect(database_server_usages.size).to eq(1)
-
-    database_server_usage = database_server_usages.first
-
-    expect(database_server_usage.start_at).not_to be_nil
-    expect(database_server_usage.end_at).not_to be_nil
-    expect(database_server_usage.report_time).not_to be_nil
-
-    expect(database_server_usage.provisioned_id).to   eq("e982somedb")
-    expect(database_server_usage.flavor).to   eq("db.r3.8xlarge")
-    expect(database_server_usage.multi_az).to eq(false)
-    expect(database_server_usage.master).to   eq(false)
-    expect(database_server_usage.location).to eq("us-east-1d")
-
-    expect(database_server_usage.database_service).to eq(database_service)
-    expect(database_server_usage.provider).to    eq(provider)
-  end
-
-end
+require "spec_helper"
+
+describe "server_usage", :mock_only do
+  let!(:client)      { create_client }
+  let!(:account)     { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:database_service)    { create_database_service(provider: provider) }
+
+  before(:each) do
+    client.find(:database_server_usages, account.id).merge!(
+      "2014-07" => [
+        {
+          "start_at"         => "2014-05-01T00:00:00+00:00",
+          "end_at"           => "2014-05-31T23:59:59+00:00",
+          "report_time"      => Time.now.iso8601,
+          "provisioned_id"   => "e982somedb",
+          "flavor"           => "db.r3.8xlarge",
+          "multi_az"         => false,
+          "master"           => false,
+          "location"         => "us-east-1d",
+          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
+          "provider"         => "https://api.engineyard.com/providers/#{provider.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch usage for an account and billing_month" do
+    database_server_usages = client.database_server_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(database_server_usages.size).to eq(1)
+
+    database_server_usage = database_server_usages.first
+
+    expect(database_server_usage.start_at).not_to be_nil
+    expect(database_server_usage.end_at).not_to be_nil
+    expect(database_server_usage.report_time).not_to be_nil
+
+    expect(database_server_usage.provisioned_id).to   eq("e982somedb")
+    expect(database_server_usage.flavor).to   eq("db.r3.8xlarge")
+    expect(database_server_usage.multi_az).to eq(false)
+    expect(database_server_usage.master).to   eq(false)
+    expect(database_server_usage.location).to eq("us-east-1d")
+
+    expect(database_server_usage.database_service).to eq(database_service)
+    expect(database_server_usage.provider).to    eq(provider)
+  end
+
+end

data/spec/database_servers_spec.rb

@@ -1,61 +1,61 @@
-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 server" do
-    let!(:database_service) { create_database_service(provider: provider, client: client) }
-    let!(:database_server)  { database_service.servers.first }
-
-    it "should list the database server" do
-      expect(client.database_servers.all).to include(database_server)
-    end
-
-    context "and a bunch of others" do
-      let!(:_) { create_database_service }
-
-      it "should find a database server by provider" do
-        expect(client.database_servers.all(provider: provider.id)).to contain_exactly(database_server)
-      end
-    end
-
-    it "should add a message" do
-      message = nil
-
-      expect {
-        message = database_server.messages.create(message: Faker::Lorem.sentence(1))
-      }.to change { database_server.messages.size }.by(1)
-
-      expect(database_server.messages.first).to eq(message)
-    end
-
-    it "should create a replica" do
-      replica = client.database_servers.create!(provider: provider, replication_source: database_server).resource!
-
-      expect(client.database_servers.all).to include(replica)
-      expect(replica.replication_source).to  eq(database_server)
-      expect(replica.database_service).to    eq(database_server.database_service)
-      expect(replica.engine).to              eq(database_server.engine)
-      expect(replica.version).to             eq(database_server.version)
-      expect(replica.flavor).to              eq(database_server.flavor)
-      expect(replica.location).to            eq(database_server.location)
-      expect(replica.storage).to             eq(database_server.storage)
-      expect(replica.modifiers).to           eq(database_server.modifiers)
-      expect(replica.firewalls).not_to       be_nil
-
-      expect(database_service.reload.servers).to contain_exactly(database_server, replica)
-    end
-
-    it "should rediscover a database server and list its revisions", :mock_only do
-      expect {
-        database_server.discover.ready!
-      }.to change { database_server.reload.flavor }.and change { database_server.revisions.count }
-
-      revision = database_server.revisions.first
-      expect(revision.database_server).to eq(database_server)
-      expect(revision.data).to have_key("flavor")
-    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 server" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:database_server)  { database_service.servers.first }
+
+    it "should list the database server" do
+      expect(client.database_servers.all).to include(database_server)
+    end
+
+    context "and a bunch of others" do
+      let!(:_) { create_database_service }
+
+      it "should find a database server by provider" do
+        expect(client.database_servers.all(provider: provider.id)).to contain_exactly(database_server)
+      end
+    end
+
+    it "should add a message" do
+      message = nil
+
+      expect {
+        message = database_server.messages.create(message: Faker::Lorem.sentence(1))
+      }.to change { database_server.messages.size }.by(1)
+
+      expect(database_server.messages.first).to eq(message)
+    end
+
+    it "should create a replica" do
+      replica = client.database_servers.create!(provider: provider, replication_source: database_server).resource!
+
+      expect(client.database_servers.all).to include(replica)
+      expect(replica.replication_source).to  eq(database_server)
+      expect(replica.database_service).to    eq(database_server.database_service)
+      expect(replica.engine).to              eq(database_server.engine)
+      expect(replica.version).to             eq(database_server.version)
+      expect(replica.flavor).to              eq(database_server.flavor)
+      expect(replica.location).to            eq(database_server.location)
+      expect(replica.storage).to             eq(database_server.storage)
+      expect(replica.modifiers).to           eq(database_server.modifiers)
+      expect(replica.firewalls).not_to       be_nil
+
+      expect(database_service.reload.servers).to contain_exactly(database_server, replica)
+    end
+
+    it "should rediscover a database server and list its revisions", :mock_only do
+      expect {
+        database_server.discover.ready!
+      }.to change { database_server.reload.flavor }.and change { database_server.revisions.count }
+
+      revision = database_server.revisions.first
+      expect(revision.database_server).to eq(database_server)
+      expect(revision.data).to have_key("flavor")
+    end
+  end
+end

data/spec/database_services_spec.rb

@@ -1,76 +1,76 @@
-require 'spec_helper'
-
-describe "database services" do
-  let(:client)    { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  it "creates a database service" do
-    name     = Faker::Name.first_name
-    location = "us-west-2c"
-
-    database_service_params = Hashie::Mash.new(
-      :provider        => provider,
-      :name            => name,
-      :service_level   => 'self-service',
-      :database_server => {
-        :location  => location,
-        :flavor    => "db.m3.large",
-        :engine    => "postgres",
-        :version   => "9.3.5",
-        :modifiers => { :multi_az => true },
-      })
-
-    database_service = client.database_services.create!(database_service_params).resource!
-
-    expect(database_service.id).not_to be_nil
-    expect(database_service.name).to eq(database_service_params.name)
-    expect(database_service.provider).to eq(database_service_params.provider)
-    expect(database_service.servers.size).to eq(1)
-
-    server = database_service.servers.first
-    expect(server.provider).to       eq(provider)
-    expect(server.provisioned_id).to eq("#{name.downcase}master")
-    expect(server.location).to       eq(location)
-    expect(server.engine).to         eq(database_service_params.database_server.engine)
-    expect(server.version).to        eq(database_service_params.database_server.version)
-    expect(server.modifiers).to      eq(database_service_params.database_server.modifiers)
-    expect(server.endpoint).not_to   be_nil
-    expect(server.master?).to        be_truthy
-
-    firewall = client.firewalls.last
-    expect(server.firewalls).to  contain_exactly(firewall)
-    expect(firewall.location).to eq("us-west-2")
-    expect(firewall.provider).to eq(provider)
-  end
-
-  context "with a database service" do
-    let!(:database_service) { create_database_service(provider: provider, client: client) }
-    let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
-
-    it "destroys a database service" do
-
-      firewall = database_service.servers.first.firewalls.first
-
-      expect {
-        database_service.destroy.ready!
-      }.to change  { database_service.reload.deleted_at }.from(nil).
-        and change { client.database_servers.size }.by(-database_service.servers.size).
-        and change { client.logical_databases.size }.by(-database_service.databases.size).
-        and change { firewall.reload.deleted_at }.from(nil)
-    end
-
-    it "shows the environment's database service in an environment" do
-      environment_database_service, environment = load_blueprint
-
-      expect(environment.database_service).to eq(environment_database_service)
-    end
-
-
-    it 'lists database services in an account' do
-      environment_database_service, environment = load_blueprint
-
-      expect(client.database_services.all(account: environment.account.id).map(&:id)).to include(environment_database_service.id)
-    end
-  end
-end
+require 'spec_helper'
+
+describe "database services" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates a database service" do
+    name     = Faker::Name.first_name
+    location = "us-west-2c"
+
+    database_service_params = Hashie::Mash.new(
+      :provider        => provider,
+      :name            => name,
+      :service_level   => 'self-service',
+      :database_server => {
+        :location  => location,
+        :flavor    => "db.m3.large",
+        :engine    => "postgres",
+        :version   => "9.3.5",
+        :modifiers => { :multi_az => true },
+      })
+
+    database_service = client.database_services.create!(database_service_params).resource!
+
+    expect(database_service.id).not_to be_nil
+    expect(database_service.name).to eq(database_service_params.name)
+    expect(database_service.provider).to eq(database_service_params.provider)
+    expect(database_service.servers.size).to eq(1)
+
+    server = database_service.servers.first
+    expect(server.provider).to       eq(provider)
+    expect(server.provisioned_id).to eq("#{name.downcase}master")
+    expect(server.location).to       eq(location)
+    expect(server.engine).to         eq(database_service_params.database_server.engine)
+    expect(server.version).to        eq(database_service_params.database_server.version)
+    expect(server.modifiers).to      eq(database_service_params.database_server.modifiers)
+    expect(server.endpoint).not_to   be_nil
+    expect(server.master?).to        be_truthy
+
+    firewall = client.firewalls.last
+    expect(server.firewalls).to  contain_exactly(firewall)
+    expect(firewall.location).to eq("us-west-2")
+    expect(firewall.provider).to eq(provider)
+  end
+
+  context "with a database service" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
+
+    it "destroys a database service" do
+
+      firewall = database_service.servers.first.firewalls.first
+
+      expect {
+        database_service.destroy.ready!
+      }.to change  { database_service.reload.deleted_at }.from(nil).
+        and change { client.database_servers.size }.by(-database_service.servers.size).
+        and change { client.logical_databases.size }.by(-database_service.databases.size).
+        and change { firewall.reload.deleted_at }.from(nil)
+    end
+
+    it "shows the environment's database service in an environment" do
+      environment_database_service, environment = load_blueprint
+
+      expect(environment.database_service).to eq(environment_database_service)
+    end
+
+
+    it 'lists database services in an account' do
+      environment_database_service, environment = load_blueprint
+
+      expect(client.database_services.all(account: environment.account.id).map(&:id)).to include(environment_database_service.id)
+    end
+  end
+end

data/spec/deployments_spec.rb

@@ -1,24 +1,24 @@
-require 'spec_helper'
-
-describe "deployments" do
-  let!(:client) { create_client }
-  let!(:account) { create_account(client: client) }
-  let!(:application) { create_application(account: account) }
-  let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name) }
-
-  before(:each) { environment.deploy(application, ref: "HEAD").resource! }
-
-  it "lists deployments" do
-    expect(environment.deployments).not_to be_empty
-    deployment = environment.deployments.first
-    expect(deployment.reload).to be
-  end
-
-  it "times out a deployment" do
-    deployment = environment.deployments.first
-
-    expect {
-      deployment.timeout
-    }.to change { deployment.reload.successful }.to(false)
-  end
-end
+require 'spec_helper'
+
+describe "deployments" do
+  let!(:client) { create_client }
+  let!(:account) { create_account(client: client) }
+  let!(:application) { create_application(account: account) }
+  let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name) }
+
+  before(:each) { environment.deploy(application, ref: "HEAD").resource! }
+
+  it "lists deployments" do
+    expect(environment.deployments).not_to be_empty
+    deployment = environment.deployments.first
+    expect(deployment.reload).to be
+  end
+
+  it "times out a deployment" do
+    deployment = environment.deployments.first
+
+    expect {
+      deployment.timeout
+    }.to change { deployment.reload.successful }.to(false)
+  end
+end

data/spec/docker_registry_credentials_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let(:client) { create_client }
-  let(:location) { 'us-east-1' }
-  let!(:account) { create_account(client: client) }
-
-  it 'returns a valid docker registry credentials' do
-    credentials = account.retrieve_docker_registry_credentials(location)
-
-    expect(credentials.username).to be
-    expect(credentials.password).to be
-    expect(credentials.registry_endpoint).to match(/#{location}/)
-    expect(credentials.expires_at).to be > (Time.now + 6 * 3600).to_i
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+  let(:location) { 'us-east-1' }
+  let!(:account) { create_account(client: client) }
+
+  it 'returns a valid docker registry credentials' do
+    credentials = account.retrieve_docker_registry_credentials(location)
+
+    expect(credentials.username).to be
+    expect(credentials.password).to be
+    expect(credentials.registry_endpoint).to match(/#{location}/)
+    expect(credentials.expires_at).to be > (Time.now + 6 * 3600).to_i
+  end
+end