ey-core 3.4.2 → 3.4.5

data/spec/blueprints_spec.rb

@@ -1,47 +1,47 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let!(:client) { create_client }
-
-  context "with a blueprint" 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(account: account, app: app, environment: { name: SecureRandom.hex(3)}, configuration: { type: "production"}) }
-    let!(:blueprint)   { environment.save_blueprint("name" => SecureRandom.hex(3)) }
-
-    it "changes the name" do
-      name = SecureRandom.hex(4)
-      expect {
-        blueprint.update(name: name)
-      }.to change { blueprint.reload.name }.to(name)
-    end
-
-    it "deletes the blueprint" do
-      expect {
-        blueprint.destroy
-      }.to change { blueprint.reload }.to(nil)
-    end
-
-    it "boots an environment from a blueprint" do
-      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
-
-      expect {
-        new_environment.boot("blueprint_id" => blueprint.id)
-      }.to change { new_environment.servers.count }.to(5)
-    end
-
-    it "boots an environment from a blueprint with an IP Address" do
-      address = client.addresses.create!(provider: provider, location: "us-west-2").resource!
-      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
-
-      expect {
-        new_environment.boot("blueprint_id" => blueprint.id, "ip_id" => address.id)
-      }.to change { new_environment.servers.count }.to(5)
-
-      app_master = new_environment.servers.detect{|s| s.role == "app_master"}
-      expect(app_master.address).to eq address
-    end
-
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  context "with a blueprint" 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(account: account, app: app, environment: { name: SecureRandom.hex(3)}, configuration: { type: "production"}) }
+    let!(:blueprint)   { environment.save_blueprint("name" => SecureRandom.hex(3)) }
+
+    it "changes the name" do
+      name = SecureRandom.hex(4)
+      expect {
+        blueprint.update(name: name)
+      }.to change { blueprint.reload.name }.to(name)
+    end
+
+    it "deletes the blueprint" do
+      expect {
+        blueprint.destroy
+      }.to change { blueprint.reload }.to(nil)
+    end
+
+    it "boots an environment from a blueprint" do
+      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
+
+      expect {
+        new_environment.boot("blueprint_id" => blueprint.id)
+      }.to change { new_environment.servers.count }.to(5)
+    end
+
+    it "boots an environment from a blueprint with an IP Address" do
+      address = client.addresses.create!(provider: provider, location: "us-west-2").resource!
+      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
+
+      expect {
+        new_environment.boot("blueprint_id" => blueprint.id, "ip_id" => address.id)
+      }.to change { new_environment.servers.count }.to(5)
+
+      app_master = new_environment.servers.detect{|s| s.role == "app_master"}
+      expect(app_master.address).to eq address
+    end
+
+  end
+end

data/spec/client_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
-
-describe "client" do
-  it "recognizes the config_file parameter" do
-    tempfile = Tempfile.new('ey-core')
-    token    = SecureRandom.hex(20)
-    tempfile.write <<-EOF
----
-'http://api-development.localdev.engineyard.com:9292/': #{token}
-    EOF
-    tempfile.rewind
-
-    client = Ey::Core::Client.new(config_file: tempfile)
-    expect(client.instance_variable_get(:@token)).to eq(token)
-  end
-end
+require 'spec_helper'
+
+describe "client" do
+  it "recognizes the config_file parameter" do
+    tempfile = Tempfile.new('ey-core')
+    token    = SecureRandom.hex(20)
+    tempfile.write <<-EOF
+---
+'http://api-development.localdev.engineyard.com:9292/': #{token}
+    EOF
+    tempfile.rewind
+
+    client = Ey::Core::Client.new(config_file: tempfile)
+    expect(client.instance_variable_get(:@token)).to eq(token)
+  end
+end

data/spec/collection_spec.rb

@@ -1,43 +1,43 @@
-require 'spec_helper'
-
-describe "Ey::Core::Collection" do
-  let!(:client) { create_client(user: create_user) }
-
-  context "with some accounts" do
-    before(:each) { 50.times { create_account(client: client) } }
-
-    describe "#total_count" do
-      it "can get the total item count" do
-        expect(client.accounts.all.total_count).to eq(50)
-      end
-    end
-
-    describe "#first" do
-      it "can get the first item" do
-        account = client.accounts.all[1]
-
-        expect(client.accounts.first(name: account.name)).to eq(account)
-      end
-    end
-
-    describe "#each_page" do
-      it "should yield multiple pages" do
-        count = 0
-
-        client.accounts.all.each_page { |_| count += 1 }
-
-        expect(count).to eq(3)
-      end
-    end
-
-    describe "#each_entry" do
-      it "should yield multiple entries" do
-        count = 0
-
-        client.accounts.all.each_entry { |*| count += 1 }
-
-        expect(count).to eq(50)
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe "Ey::Core::Collection" do
+  let!(:client) { create_client(user: create_user) }
+
+  context "with some accounts" do
+    before(:each) { 50.times { create_account(client: client) } }
+
+    describe "#total_count" do
+      it "can get the total item count" do
+        expect(client.accounts.all.total_count).to eq(50)
+      end
+    end
+
+    describe "#first" do
+      it "can get the first item" do
+        account = client.accounts.all[1]
+
+        expect(client.accounts.first(name: account.name)).to eq(account)
+      end
+    end
+
+    describe "#each_page" do
+      it "should yield multiple pages" do
+        count = 0
+
+        client.accounts.all.each_page { |_| count += 1 }
+
+        expect(count).to eq(3)
+      end
+    end
+
+    describe "#each_entry" do
+      it "should yield multiple entries" do
+        count = 0
+
+        client.accounts.all.each_entry { |*| count += 1 }
+
+        expect(count).to eq(50)
+      end
+    end
+  end
+end

data/spec/costs_spec.rb

@@ -1,22 +1,22 @@
-require 'spec_helper'
-
-describe 'Costs' do
-  let(:client)   { create_client }
-  let!(:account) { create_account(client: client) }
-
-  it 'should return an empty array with no costs' do
-    expect(account.costs.all).to be_empty
-  end
-
-  it 'should get costs for an account', :mock_only do
-    create_cost(client, account: account)
-    expect(account.costs.all).not_to be_empty
-  end
-
-  it 'should search costs', :mock_only do
-    create_cost(client, account: account, level: 'total')
-    create_cost(client, account: account, level: 'summarized')
-    costs = account.costs.select { |c| c.level == 'total' }
-    expect(costs.first.level).to eq 'total'
-  end
-end
+require 'spec_helper'
+
+describe 'Costs' do
+  let(:client)   { create_client }
+  let!(:account) { create_account(client: client) }
+
+  it 'should return an empty array with no costs' do
+    expect(account.costs.all).to be_empty
+  end
+
+  it 'should get costs for an account', :mock_only do
+    create_cost(client, account: account)
+    expect(account.costs.all).not_to be_empty
+  end
+
+  it 'should search costs', :mock_only do
+    create_cost(client, account: account, level: 'total')
+    create_cost(client, account: account, level: 'summarized')
+    costs = account.costs.select { |c| c.level == 'total' }
+    expect(costs.first.level).to eq 'total'
+  end
+end

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