ey-core 3.6.3 → 3.6.5

data/spec/messages_spec.rb

@@ -1,27 +1,27 @@
-require 'spec_helper'
-
-describe 'messages' do
-  let(:client)    { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  context "with a provision address request" do
-    before(:each) do
-      @request = client.addresses.create!(provider: provider, location: "us-west-2")
-    end
-
-    let(:request) { @request }
-
-    it "should create a message for the address" do
-      message = client.messages.create!(message: "hi der", request_id: request.id)
-
-      expect(client.messages.get!(message.identity)).to eq(message)
-    end
-
-    it "should require collection url to create a message" do
-      expect {
-        client.messages.create!(message: "ohai")
-      }.to raise_error(ArgumentError, /missing.*url/)
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'messages' do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  context "with a provision address request" do
+    before(:each) do
+      @request = client.addresses.create!(provider: provider, location: "us-west-2")
+    end
+
+    let(:request) { @request }
+
+    it "should create a message for the address" do
+      message = client.messages.create!(message: "hi der", request_id: request.id)
+
+      expect(client.messages.get!(message.identity)).to eq(message)
+    end
+
+    it "should require collection url to create a message" do
+      expect {
+        client.messages.create!(message: "ohai")
+      }.to raise_error(ArgumentError, /missing.*url/)
+    end
+  end
+end

data/spec/metadata_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
-
-describe 'as a client' do
-  let!(:client) { create_client }
-
-  it "should display metadata information" do
-    environment = Ey::Core::Client.mocking? ? "mock" : "development"
-
-    expect(client.metadata.environment).to eq(environment)
-  end
-end
+require 'spec_helper'
+
+describe 'as a client' do
+  let!(:client) { create_client }
+
+  it "should display metadata information" do
+    environment = Ey::Core::Client.mocking? ? "mock" : "development"
+
+    expect(client.metadata.environment).to eq(environment)
+  end
+end

data/spec/plan_usage_spec.rb

@@ -1,65 +1,65 @@
-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)}) }
-
-  before(:each) do
-    Timecop.freeze(Time.parse("2014-06-04 09:13:39 -0800"))
-
-    now             = Time.now
-    billing_month   = now.strftime("%Y-%m")
-    month_beginning = DateTime.new(now.year, now.month, 1)
-    end_of_month    = DateTime.new(now.year, (now.month + 1) % 12, 1, 23, 59, 59) - 1
-
-    client.data[:plan_usages][account.id].merge!(
-    {
-      "2014-05" => [
-        {
-          "start_at"     => "2014-05-01T00:00:00+00:00",
-          "end_at"       => "2014-05-31T23:59:59+00:00",
-          "type"         => "classic-00",
-          "support"      => "premium",
-          "server_limit" => nil,
-          "flavor_limit" => nil,
-        },
-      ],
-      billing_month => [
-        {
-          "start_at"     => month_beginning.iso8601,
-          "end_at"       => end_of_month.iso8601, # still valid
-          "type"         => "correct-type",
-          "support"      => "premium",
-          "server_limit" => nil,
-          "flavor_limit" => nil,
-        },
-      ],
-    })
-  end
-
-  it "can fetch plan usage for an account and billing_month" do
-    plan_usages = client.plan_usages.all(account_id: account.id, billing_month: "2014-05")
-
-    expect(plan_usages.size).to eq(1)
-
-    plan_usage = plan_usages.first
-
-    expect(plan_usage.start_at).not_to be_nil
-    expect(plan_usage.end_at).not_to be_nil
-
-    expect(plan_usage.type).to eq("classic-00")
-    expect(plan_usage.support).to eq("premium")
-
-    expect(plan_usage.server_limit).to be_nil
-    expect(plan_usage.flavor_limit).to be_nil
-  end
-
-  it "defaults to the current billing_month" do
-    plan_usages = client.plan_usages.all(account_id: account.id)
-
-    expect(plan_usages.size).to eq(1)
-
-    plan_usage = plan_usages.first
-    expect(plan_usage.type).to eq("correct-type")
-  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)}) }
+
+  before(:each) do
+    Timecop.freeze(Time.parse("2014-06-04 09:13:39 -0800"))
+
+    now             = Time.now
+    billing_month   = now.strftime("%Y-%m")
+    month_beginning = DateTime.new(now.year, now.month, 1)
+    end_of_month    = DateTime.new(now.year, (now.month + 1) % 12, 1, 23, 59, 59) - 1
+
+    client.data[:plan_usages][account.id].merge!(
+    {
+      "2014-05" => [
+        {
+          "start_at"     => "2014-05-01T00:00:00+00:00",
+          "end_at"       => "2014-05-31T23:59:59+00:00",
+          "type"         => "classic-00",
+          "support"      => "premium",
+          "server_limit" => nil,
+          "flavor_limit" => nil,
+        },
+      ],
+      billing_month => [
+        {
+          "start_at"     => month_beginning.iso8601,
+          "end_at"       => end_of_month.iso8601, # still valid
+          "type"         => "correct-type",
+          "support"      => "premium",
+          "server_limit" => nil,
+          "flavor_limit" => nil,
+        },
+      ],
+    })
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    plan_usages = client.plan_usages.all(account_id: account.id, billing_month: "2014-05")
+
+    expect(plan_usages.size).to eq(1)
+
+    plan_usage = plan_usages.first
+
+    expect(plan_usage.start_at).not_to be_nil
+    expect(plan_usage.end_at).not_to be_nil
+
+    expect(plan_usage.type).to eq("classic-00")
+    expect(plan_usage.support).to eq("premium")
+
+    expect(plan_usage.server_limit).to be_nil
+    expect(plan_usage.flavor_limit).to be_nil
+  end
+
+  it "defaults to the current billing_month" do
+    plan_usages = client.plan_usages.all(account_id: account.id)
+
+    expect(plan_usages.size).to eq(1)
+
+    plan_usage = plan_usages.first
+    expect(plan_usage.type).to eq("correct-type")
+  end
+end

data/spec/provider_locations_spec.rb

@@ -1,85 +1,85 @@
-require 'spec_helper'
-
-describe 'provider locations' do
-  context "with a hmac client" do
-    let!(:client)   { create_client }
-    let!(:account)  { create_account(client: client) }
-    let!(:provider) { create_provider(account: account) }
-
-    let!(:provider_location) do
-      if Ey::Core::Client.mocking?
-        create_provider_location(client,
-                                 :location_name => "Eastern United States",
-                                 :location_id   => "us-east-1",
-                                 :provider      => provider,
-                                 :limits        => {"servers" => 20, "addresses" => 5}
-                                )
-      else
-        provider.provider_locations.first
-      end
-    end
-
-    before do
-    end
-
-    it "finds the provider location" do
-      location = client.provider_locations.get(provider_location.id)
-
-      expect(location.id).to eq(provider_location.id)
-      expect(location.location_name).to eq(provider_location.location_name)
-      expect(location.location_id).to eq(provider_location.location_id)
-      expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
-      expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
-    end
-
-    context "with a provider" do
-      let!(:another_provider) { create_provider(client: client, account: account) }
-      let!(:another_location) do
-        if Ey::Core::Client.mocking?
-          create_provider_location(client,
-                                   :provider      => another_provider,
-                                   :location_name => "Western United States",
-                                   :location_id   => "us-west-1",
-                                   :limits        => {"servers" => 20, "addresses" => 5})
-        else
-          provider.provider_locations.last
-        end
-      end
-
-      it "lists provider locations" do
-        locations = provider.provider_locations.all
-
-        expect(locations.size).to be > 0
-
-        location = locations.first(location_id: provider_location.location_id)
-
-        expect(location.id).to eq(provider_location.id)
-        expect(location.location_name).to eq(provider_location.location_name)
-        expect(location.location_id).to eq(provider_location.location_id)
-        expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
-        expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
-      end
-    end
-
-    describe '#limits=' do
-      let(:new_limits) {{servers: 25, addresses: 10}}
-
-      it 'sets new limits for the provider location' do
-        provider_location.limits = new_limits
-
-        expect(provider_location.limits).to eql(new_limits)
-      end
-
-      it 'is persisted when saved' do
-        limits = {"servers" => 20, "addresses" => 5}
-        provider_location.limits = new_limits
-
-        expect(provider.provider_locations.get(provider_location.id).limits).to eql(limits)
-
-        provider_location.save!
-
-        expect(provider.provider_locations.get(provider_location.id).limits).to eql(new_limits)
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'provider locations' do
+  context "with a hmac client" do
+    let!(:client)   { create_client }
+    let!(:account)  { create_account(client: client) }
+    let!(:provider) { create_provider(account: account) }
+
+    let!(:provider_location) do
+      if Ey::Core::Client.mocking?
+        create_provider_location(client,
+                                 :location_name => "Eastern United States",
+                                 :location_id   => "us-east-1",
+                                 :provider      => provider,
+                                 :limits        => {"servers" => 20, "addresses" => 5}
+                                )
+      else
+        provider.provider_locations.first
+      end
+    end
+
+    before do
+    end
+
+    it "finds the provider location" do
+      location = client.provider_locations.get(provider_location.id)
+
+      expect(location.id).to eq(provider_location.id)
+      expect(location.location_name).to eq(provider_location.location_name)
+      expect(location.location_id).to eq(provider_location.location_id)
+      expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
+      expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
+    end
+
+    context "with a provider" do
+      let!(:another_provider) { create_provider(client: client, account: account) }
+      let!(:another_location) do
+        if Ey::Core::Client.mocking?
+          create_provider_location(client,
+                                   :provider      => another_provider,
+                                   :location_name => "Western United States",
+                                   :location_id   => "us-west-1",
+                                   :limits        => {"servers" => 20, "addresses" => 5})
+        else
+          provider.provider_locations.last
+        end
+      end
+
+      it "lists provider locations" do
+        locations = provider.provider_locations.all
+
+        expect(locations.size).to be > 0
+
+        location = locations.first(location_id: provider_location.location_id)
+
+        expect(location.id).to eq(provider_location.id)
+        expect(location.location_name).to eq(provider_location.location_name)
+        expect(location.location_id).to eq(provider_location.location_id)
+        expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
+        expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
+      end
+    end
+
+    describe '#limits=' do
+      let(:new_limits) {{servers: 25, addresses: 10}}
+
+      it 'sets new limits for the provider location' do
+        provider_location.limits = new_limits
+
+        expect(provider_location.limits).to eql(new_limits)
+      end
+
+      it 'is persisted when saved' do
+        limits = {"servers" => 20, "addresses" => 5}
+        provider_location.limits = new_limits
+
+        expect(provider.provider_locations.get(provider_location.id).limits).to eql(limits)
+
+        provider_location.save!
+
+        expect(provider.provider_locations.get(provider_location.id).limits).to eql(new_limits)
+      end
+    end
+  end
+end

data/spec/providers_spec.rb

@@ -1,105 +1,105 @@
-require 'spec_helper'
-
-describe 'providers' do
-  context "with a hmac client" do
-    let!(:client)  { create_client }
-    let!(:account) { create_account(client: client) }
-
-    ["azure", "aws"].each do |provider|
-      it "has possible #{provider} locations without a provider type" do
-        locations = client.provider.possible_locations(provider)
-        expect(locations).to be_a(Array)
-        expect(locations).not_to be_empty
-      end
-    end
-
-    context "with an account" do
-      ["aws"].each do |type|
-        it "creates a #{type} provider" do
-          provisioned_id = SecureRandom.hex(8)
-          provider = account.providers.create!(type: type, provisioned_id: provisioned_id, credentials: {}).resource!
-
-          expect(provider.account).to        eq(account)
-          expect(provider.type).to           eq(type)
-          expect(provider.provisioned_id).to eq(provisioned_id)
-        end
-
-        context "with a #{type} provider" do
-          let!(:provider) { account.providers.create!(type: type, provisioned_id: SecureRandom.hex(8), credentials: {}).resource! }
-
-          it "gets an provider" do
-            expect(account.providers.get(provider.id)).to eq(provider)
-          end
-
-          it "has possible provider locations" do
-            expect(provider.possible_locations).to be_a(Array)
-            expect(provider.possible_locations).not_to be_empty
-          end
-
-          it "gets providers" do
-            another_account = create_account(client: client)
-            create_provider(account: another_account)
-
-            account_providers = account.providers.all
-
-            expect(account_providers.size).to eq(1)
-            expect(account_providers.first).to eq(provider)
-          end
-
-          it "destroys the provider" do
-            expect(provider.destroy.ready!).to be_successful
-            expect(provider.reload.cancelled_at).not_to be_nil
-          end
-
-          it "discovers locations for the #{type} provider", :mock_only do
-            provider.possible_locations.each do |location_id|
-              provider_location = nil
-              expect {
-                provider_location = provider.provider_locations.discover(location_id).resource!
-                expect(provider_location).to be_a(Ey::Core::Client::ProviderLocation)
-                expect(provider_location.location_id).to eq(location_id)
-              }.to change { provider.provider_locations.all.reload.count }
-            end
-          end
-        end
-      end
-    end
-
-    context "with two clients pointed to the same cloud", :mock_only do
-      let!(:client_1) { create_client(url: "http://client.example.com") }
-      let!(:owner)    { client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
-      let!(:client_1_account_1) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
-      let!(:client_1_account_2) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
-
-      it "does not clobber other accounts' providers" do
-        # this just tests that the mock behaves reasonably
-        client_1_account_1.providers.create!(type: "aws").ready!
-
-        expect(client_1_account_1.providers.all.count).to eq(1)
-        expect(client_1_account_2.providers.all.count).to eq(0)
-
-        client_1_account_2.providers.create!(type: "aws").ready!
-
-        expect(client_1_account_1.providers.all.count).to eq(1)
-        expect(client_1_account_2.providers.all.count).to eq(1)
-
-        client_2 = create_client(url: "http://client.example.com")
-
-        client_2_account_1 = client_2.accounts.get(client_1_account_1.id)
-        expect(client_2_account_1).not_to be_nil
-        client_2_account_2 = client_2.accounts.get(client_1_account_2.id)
-        expect(client_2_account_2).not_to be_nil
-
-        client_2_account_2.providers.create!(type: "aws").ready!
-
-        expect(client_1_account_1.providers.all.count).to eq(1)
-        expect(client_2_account_1.providers.all.count).to eq(1)
-        expect(client_1_account_2.providers.all.count).to eq(2)
-        expect(client_2_account_2.providers.all.count).to eq(2)
-
-        expect(client_1.providers.count).to eq(3)
-        expect(client_2.providers.count).to eq(3)
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'providers' do
+  context "with a hmac client" do
+    let!(:client)  { create_client }
+    let!(:account) { create_account(client: client) }
+
+    ["azure", "aws"].each do |provider|
+      it "has possible #{provider} locations without a provider type" do
+        locations = client.provider.possible_locations(provider)
+        expect(locations).to be_a(Array)
+        expect(locations).not_to be_empty
+      end
+    end
+
+    context "with an account" do
+      ["aws"].each do |type|
+        it "creates a #{type} provider" do
+          provisioned_id = SecureRandom.hex(8)
+          provider = account.providers.create!(type: type, provisioned_id: provisioned_id, credentials: {}).resource!
+
+          expect(provider.account).to        eq(account)
+          expect(provider.type).to           eq(type)
+          expect(provider.provisioned_id).to eq(provisioned_id)
+        end
+
+        context "with a #{type} provider" do
+          let!(:provider) { account.providers.create!(type: type, provisioned_id: SecureRandom.hex(8), credentials: {}).resource! }
+
+          it "gets an provider" do
+            expect(account.providers.get(provider.id)).to eq(provider)
+          end
+
+          it "has possible provider locations" do
+            expect(provider.possible_locations).to be_a(Array)
+            expect(provider.possible_locations).not_to be_empty
+          end
+
+          it "gets providers" do
+            another_account = create_account(client: client)
+            create_provider(account: another_account)
+
+            account_providers = account.providers.all
+
+            expect(account_providers.size).to eq(1)
+            expect(account_providers.first).to eq(provider)
+          end
+
+          it "destroys the provider" do
+            expect(provider.destroy.ready!).to be_successful
+            expect(provider.reload.cancelled_at).not_to be_nil
+          end
+
+          it "discovers locations for the #{type} provider", :mock_only do
+            provider.possible_locations.each do |location_id|
+              provider_location = nil
+              expect {
+                provider_location = provider.provider_locations.discover(location_id).resource!
+                expect(provider_location).to be_a(Ey::Core::Client::ProviderLocation)
+                expect(provider_location.location_id).to eq(location_id)
+              }.to change { provider.provider_locations.all.reload.count }
+            end
+          end
+        end
+      end
+    end
+
+    context "with two clients pointed to the same cloud", :mock_only do
+      let!(:client_1) { create_client(url: "http://client.example.com") }
+      let!(:owner)    { client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+      let!(:client_1_account_1) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
+      let!(:client_1_account_2) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
+
+      it "does not clobber other accounts' providers" do
+        # this just tests that the mock behaves reasonably
+        client_1_account_1.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(0)
+
+        client_1_account_2.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(1)
+
+        client_2 = create_client(url: "http://client.example.com")
+
+        client_2_account_1 = client_2.accounts.get(client_1_account_1.id)
+        expect(client_2_account_1).not_to be_nil
+        client_2_account_2 = client_2.accounts.get(client_1_account_2.id)
+        expect(client_2_account_2).not_to be_nil
+
+        client_2_account_2.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_2_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(2)
+        expect(client_2_account_2.providers.all.count).to eq(2)
+
+        expect(client_1.providers.count).to eq(3)
+        expect(client_2.providers.count).to eq(3)
+      end
+    end
+  end
+end

data/spec/requests/upload_file_spec.rb

@@ -1,25 +1,25 @@
-require 'spec_helper'
-
-describe "#upload_file" do
-  it "should upload a multipart_file", :real_only do
-    requests = []
-    canary = lambda { |env| requests << Rack::Request.new(env); [200, {}, []] }
-    client = Ey::Core::Client.new(adapter: [:rack, canary], token: "blah")
-
-    begin
-      file = Tempfile.new('foo')
-      file.write("bar")
-      file.close
-
-      client.upload_file(:file => file.path)
-    ensure
-      file.close
-      file.unlink   # deletes the temp file
-    end
-
-    request = requests.first
-
-    expect(request.content_type).to eq("multipart/form-data")
-    expect(request.body.read).to eq("bar")
-  end
-end
+require 'spec_helper'
+
+describe "#upload_file" do
+  it "should upload a multipart_file", :real_only do
+    requests = []
+    canary = lambda { |env| requests << Rack::Request.new(env); [200, {}, []] }
+    client = Ey::Core::Client.new(adapter: [:rack, canary], token: "blah")
+
+    begin
+      file = Tempfile.new('foo')
+      file.write("bar")
+      file.close
+
+      client.upload_file(:file => file.path)
+    ensure
+      file.close
+      file.unlink   # deletes the temp file
+    end
+
+    request = requests.first
+
+    expect(request.content_type).to eq("multipart/form-data")
+    expect(request.body.read).to eq("bar")
+  end
+end