ey-core 3.4.2 → 3.4.5

data/spec/account_spec.rb

@@ -1,65 +1,65 @@
-require 'spec_helper'
-
-describe 'accounts' do
-  let(:client) {create_client}
-
-  let(:account) {
-    create_account(
-      client: client, creator: client,
-      account: {
-        owner: create_user(client: client, creator: client)
-      }.merge(details)
-    )
-  }
-
-  describe '#type' do
-    let(:details) {{type: 'oracle'}}
-
-    it 'is the account type for the account' do
-      expect(account.type).to eql('oracle')
-    end
-  end
-
-  describe '#signup_via' do
-    let(:details) {{signup_via: 'deis'}}
-
-    it 'is the service through which the owner signed up' do
-      expect(account.signup_via).to eql('deis')
-    end
-  end
-
-  describe '#legacy_id' do
-    let(:details) {{}}
-
-    # Fun fact: we're not allowed to set legacy_id in create_account
-    before(:each) do
-      client.data[:accounts][account.id].merge!(
-        {'legacy_id' => '19283'}
-      )
-
-      account.reload
-    end
-
-    it 'is the legacy_id for the account' do
-      expect(account.legacy_id).to eql('19283')
-    end
-  end
-
-  context 'when searched by legacy_id' do
-    let(:details) {{}}
-    let(:legacy_id) {Cistern::Mock.random_numbers(6)}
-    let(:searched) {client.accounts.all(legacy_id: legacy_id)}
-
-    before(:each) do
-      client.data[:accounts][account.id].merge!(
-        {'legacy_id' => legacy_id}
-      )
-
-      account.reload
-    end
-
-    it 'is a resounding success', mock_only: true do
-      expect(searched).to include(account)
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'accounts' do
+  let(:client) {create_client}
+
+  let(:account) {
+    create_account(
+      client: client, creator: client,
+      account: {
+        owner: create_user(client: client, creator: client)
+      }.merge(details)
+    )
+  }
+
+  describe '#type' do
+    let(:details) {{type: 'oracle'}}
+
+    it 'is the account type for the account' do
+      expect(account.type).to eql('oracle')
+    end
+  end
+
+  describe '#signup_via' do
+    let(:details) {{signup_via: 'deis'}}
+
+    it 'is the service through which the owner signed up' do
+      expect(account.signup_via).to eql('deis')
+    end
+  end
+
+  describe '#legacy_id' do
+    let(:details) {{}}
+
+    # Fun fact: we're not allowed to set legacy_id in create_account
+    before(:each) do
+      client.data[:accounts][account.id].merge!(
+        {'legacy_id' => '19283'}
+      )
+
+      account.reload
+    end
+
+    it 'is the legacy_id for the account' do
+      expect(account.legacy_id).to eql('19283')
+    end
+  end
+
+  context 'when searched by legacy_id' do
+    let(:details) {{}}
+    let(:legacy_id) {Cistern::Mock.random_numbers(6)}
+    let(:searched) {client.accounts.all(legacy_id: legacy_id)}
+
+    before(:each) do
+      client.data[:accounts][account.id].merge!(
+        {'legacy_id' => legacy_id}
+      )
+
+      account.reload
+    end
+
+    it 'is a resounding success', mock_only: true do
+      expect(searched).to include(account)
+    end
+  end
+end

data/spec/account_trial_spec.rb

@@ -1,17 +1,17 @@
-require 'spec_helper'
-
-describe "account_trial" do
-  let!(:client) { create_client }
-
-  context "with an account", :mock_only do
-    let!(:account) { create_account(client: client) }
-
-    it "has trial data" do
-      trial = account.account_trial
-
-      expect(trial.duration).to eq(500)
-      expect(trial.used).to     eq(30)
-      expect(trial.account).to  eq(account)
-    end
-  end
-end
+require 'spec_helper'
+
+describe "account_trial" do
+  let!(:client) { create_client }
+
+  context "with an account", :mock_only do
+    let!(:account) { create_account(client: client) }
+
+    it "has trial data" do
+      trial = account.account_trial
+
+      expect(trial.duration).to eq(500)
+      expect(trial.used).to     eq(30)
+      expect(trial.account).to  eq(account)
+    end
+  end
+end

data/spec/accounts_referrals_spec.rb

@@ -1,20 +1,20 @@
-require 'spec_helper'
-
-describe 'account_referrals' do
-  let(:client) { create_client }
-  let!(:referrer) { create_account(client: client) }
-
-  it 'shows referrals for an account', :mock_only do
-    referral = create_account_referral(client, referrer: referrer)
-
-    expect(referrer.referrals.all).to contain_exactly(referral)
-  end
-
-  it 'shows all account referrals', :mock_only do
-    referral1 = create_account_referral(client)
-    referral2 = create_account_referral(client)
-    account_referrals = client.account_referrals.all
-
-    expect(account_referrals.map(&:identity)).to contain_exactly(referral1.id, referral2.id)
-  end
-end
+require 'spec_helper'
+
+describe 'account_referrals' do
+  let(:client) { create_client }
+  let!(:referrer) { create_account(client: client) }
+
+  it 'shows referrals for an account', :mock_only do
+    referral = create_account_referral(client, referrer: referrer)
+
+    expect(referrer.referrals.all).to contain_exactly(referral)
+  end
+
+  it 'shows all account referrals', :mock_only do
+    referral1 = create_account_referral(client)
+    referral2 = create_account_referral(client)
+    account_referrals = client.account_referrals.all
+
+    expect(account_referrals.map(&:identity)).to contain_exactly(referral1.id, referral2.id)
+  end
+end

data/spec/accounts_spec.rb

@@ -1,113 +1,113 @@
-require 'spec_helper'
-
-describe 'accounts' do
-
-  let!(:client) { create_client }
-
-  context "with a user" do
-    let!(:user) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
-    let(:user_client) { create_client }
-
-    it "should create an account" do
-      name = Faker::Name.first_name
-
-      account = client.accounts.create!(owner: user, name: name)
-
-      # signup_via is foyer only
-      # account = client.accounts.create!(owner: user, name: name, signup_via: "deis")
-      # expect(account.signup_via).to eq("deis")
-
-      expect(account.name).to eq(name)
-      expect(account.support_plan).to eq("standard")
-
-      users = account.users.all
-      expect(users.size).to eq(1)
-      expect(users.first).to eq(user)
-    end
-
-    it "should create an account by name_prefix" do
-      account1 = client.accounts.create!(owner: user, name_prefix: "azure")
-      account2 = client.accounts.create!(owner: user, name_prefix: "azure")
-
-      expect(account1.name).to match(/azure/)
-      expect(account2.name).to match(/azure/)
-    end
-
-    it "should cancel an account" do
-      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-      c = account.cancel!(:requested_by => user)
-      expect(c.kind).to eq "self"
-      account_refetched = client.accounts.get(account.id)
-      expect(account_refetched.cancelled_at).not_to be_nil
-      expect(account_refetched.cancellation).to eq c
-    end
-
-    it "should get an account" do
-      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-
-      expect(client.accounts.get(account.id)).to eq(account)
-    end
-
-    it "should have a nil cancellation" do
-      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-      expect(account.cancellation).to be_nil
-    end
-
-    it "should get all accounts for a user" do
-      account         = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-      another_user    = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
-      client.accounts.create!(owner: another_user, name: Faker::Name.first_name)
-
-      expect(user.accounts.all).to match_array([account])
-    end
-
-    context "a second user" do
-      let!(:user2) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
-
-      it "should not be associated with unrelated users" do
-        name = Faker::Name.first_name
-
-        account = client.accounts.create!(owner: user2, name: name)
-
-        users = account.users.all
-
-        expect(users.size).to eq(1)
-        expect(users.first).to eq(user2)
-      end
-    end
-
-    it "should search by legacy_id", mock_only: true do
-      legacy_id = Cistern::Mock.random_numbers(6)
-
-      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-      client.data[:accounts][account.id]["legacy_id"] = legacy_id
-
-      expect(client.accounts.first(legacy_id: legacy_id)).to eq(account)
-    end
-
-    context "owners" do
-      it "should contain the owner user" do
-        account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-
-        owner = account.owners.all.first
-        expect(owner.id).to eq(user.id)
-      end
-    end
-  end
-
-  context "with two clients pointed to different clouds", :mock_only do
-    let!(:client_1) { create_client(url: 'http://client-1.example.com') }
-    let!(:client_2) { create_client(url: 'http://client-2.example.com') }
-
-    it "should not about each other's accounts" do
-      owner_1   = client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
-      account_1 = client_1.accounts.create!(owner: owner_1, name: Faker::Name.first_name)
-
-      owner_2   = client_2.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
-      account_2 = client_2.accounts.create!(owner: owner_2, name: Faker::Name.first_name)
-
-      expect(client_1.accounts.get(account_2.id)).to be_nil
-      expect(client_2.accounts.get(account_1.id)).to be_nil
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'accounts' do
+
+  let!(:client) { create_client }
+
+  context "with a user" do
+    let!(:user) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+    let(:user_client) { create_client }
+
+    it "should create an account" do
+      name = Faker::Name.first_name
+
+      account = client.accounts.create!(owner: user, name: name)
+
+      # signup_via is foyer only
+      # account = client.accounts.create!(owner: user, name: name, signup_via: "deis")
+      # expect(account.signup_via).to eq("deis")
+
+      expect(account.name).to eq(name)
+      expect(account.support_plan).to eq("standard")
+
+      users = account.users.all
+      expect(users.size).to eq(1)
+      expect(users.first).to eq(user)
+    end
+
+    it "should create an account by name_prefix" do
+      account1 = client.accounts.create!(owner: user, name_prefix: "azure")
+      account2 = client.accounts.create!(owner: user, name_prefix: "azure")
+
+      expect(account1.name).to match(/azure/)
+      expect(account2.name).to match(/azure/)
+    end
+
+    it "should cancel an account" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      c = account.cancel!(:requested_by => user)
+      expect(c.kind).to eq "self"
+      account_refetched = client.accounts.get(account.id)
+      expect(account_refetched.cancelled_at).not_to be_nil
+      expect(account_refetched.cancellation).to eq c
+    end
+
+    it "should get an account" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+
+      expect(client.accounts.get(account.id)).to eq(account)
+    end
+
+    it "should have a nil cancellation" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      expect(account.cancellation).to be_nil
+    end
+
+    it "should get all accounts for a user" do
+      account         = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      another_user    = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      client.accounts.create!(owner: another_user, name: Faker::Name.first_name)
+
+      expect(user.accounts.all).to match_array([account])
+    end
+
+    context "a second user" do
+      let!(:user2) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+
+      it "should not be associated with unrelated users" do
+        name = Faker::Name.first_name
+
+        account = client.accounts.create!(owner: user2, name: name)
+
+        users = account.users.all
+
+        expect(users.size).to eq(1)
+        expect(users.first).to eq(user2)
+      end
+    end
+
+    it "should search by legacy_id", mock_only: true do
+      legacy_id = Cistern::Mock.random_numbers(6)
+
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      client.data[:accounts][account.id]["legacy_id"] = legacy_id
+
+      expect(client.accounts.first(legacy_id: legacy_id)).to eq(account)
+    end
+
+    context "owners" do
+      it "should contain the owner user" do
+        account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+
+        owner = account.owners.all.first
+        expect(owner.id).to eq(user.id)
+      end
+    end
+  end
+
+  context "with two clients pointed to different clouds", :mock_only do
+    let!(:client_1) { create_client(url: 'http://client-1.example.com') }
+    let!(:client_2) { create_client(url: 'http://client-2.example.com') }
+
+    it "should not about each other's accounts" do
+      owner_1   = client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      account_1 = client_1.accounts.create!(owner: owner_1, name: Faker::Name.first_name)
+
+      owner_2   = client_2.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      account_2 = client_2.accounts.create!(owner: owner_2, name: Faker::Name.first_name)
+
+      expect(client_1.accounts.get(account_2.id)).to be_nil
+      expect(client_2.accounts.get(account_1.id)).to be_nil
+    end
+  end
+end

data/spec/addons_and_vars_spec.rb

@@ -1,62 +1,62 @@
-require 'spec_helper'
-
-describe 'addons' do
-  let!(:client) { create_client }
-
-  context "with user and account" do
-    let!(:account) { create_account(client: client) }
-
-    it "list addons" do
-      expect(account.addons.all).to be_empty
-    end
-
-    describe "create addon" do
-      before do
-        @addon = account.addons.create!(
-          :name => "fooooo",
-          :sso_url => "http://example.com",
-          :vars => {foo: "bar", baz: "bob"})
-      end
-
-      it "creates the addon" do
-        expect(@addon.name).to eq "fooooo"
-        expect(@addon.sso_url).to eq "http://example.com"
-        expect(@addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
-      end
-
-      it "shows in the list" do
-        expect(account.addons.all.size).to eq 1
-        addon = account.addons.first
-        expect(addon.name).to eq "fooooo"
-        expect(addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
-      end
-
-      it "can be fetched" do
-        addon_refetched = account.addons.get(@addon.id)
-        expect(addon_refetched.id).to eq @addon.id
-        expect(addon_refetched.name).to eq "fooooo"
-        expect(addon_refetched.vars).to eq({"foo" => "bar", "baz" => "bob"})
-      end
-
-      #Effectively also tests that the resource_url is set in all the ways an addon can be fetched
-      it "can be updated (3 ways)" do
-        tryit = Proc.new do |add, name, vars|
-          add.name = name
-          add.vars = vars
-          add.save!
-          add.reload
-          expect(add.name).to eq name
-          expect(add.vars).to eq vars
-        end
-        tryit.call(account.addons.get(@addon.id), "fetchedwithget", "fetchsingle" => "GET")
-        tryit.call(account.addons.first, "fetchedfromlist", "fetchmulti" => "GET")
-        tryit.call(@addon, "createresult", "created" => "POST")
-      end
-
-      it "can be destroyed" do
-        @addon.destroy
-        expect(account.addons.all.size).to eq 0
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'addons' do
+  let!(:client) { create_client }
+
+  context "with user and account" do
+    let!(:account) { create_account(client: client) }
+
+    it "list addons" do
+      expect(account.addons.all).to be_empty
+    end
+
+    describe "create addon" do
+      before do
+        @addon = account.addons.create!(
+          :name => "fooooo",
+          :sso_url => "http://example.com",
+          :vars => {foo: "bar", baz: "bob"})
+      end
+
+      it "creates the addon" do
+        expect(@addon.name).to eq "fooooo"
+        expect(@addon.sso_url).to eq "http://example.com"
+        expect(@addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      it "shows in the list" do
+        expect(account.addons.all.size).to eq 1
+        addon = account.addons.first
+        expect(addon.name).to eq "fooooo"
+        expect(addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      it "can be fetched" do
+        addon_refetched = account.addons.get(@addon.id)
+        expect(addon_refetched.id).to eq @addon.id
+        expect(addon_refetched.name).to eq "fooooo"
+        expect(addon_refetched.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      #Effectively also tests that the resource_url is set in all the ways an addon can be fetched
+      it "can be updated (3 ways)" do
+        tryit = Proc.new do |add, name, vars|
+          add.name = name
+          add.vars = vars
+          add.save!
+          add.reload
+          expect(add.name).to eq name
+          expect(add.vars).to eq vars
+        end
+        tryit.call(account.addons.get(@addon.id), "fetchedwithget", "fetchsingle" => "GET")
+        tryit.call(account.addons.first, "fetchedfromlist", "fetchmulti" => "GET")
+        tryit.call(@addon, "createresult", "created" => "POST")
+      end
+
+      it "can be destroyed" do
+        @addon.destroy
+        expect(account.addons.all.size).to eq 0
+      end
+    end
+  end
+end

data/spec/addresses_spec.rb

@@ -1,56 +1,56 @@
-require 'spec_helper'
-
-describe 'addresses' do
-  let(:client)    { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  it "creates an address" do
-    request = client.addresses.create!(provider: provider, location: "us-west-2")
-    address = request.resource!
-    expect(address.id).not_to be_nil
-    expect(address.ip_address).not_to be_nil
-    expect(address.provisioned_id).not_to be_nil
-    expect(address.provider).to eq(provider)
-  end
-
-  context "with an address" do
-    let(:location) { "us-west-2" }
-    let!(:address) { client.addresses.all.find{|a| a.location.match(location) && a.server_id.nil?} || client.addresses.create!(provider: provider, location: location).resource! }
-
-    it "searches by provisioned_id" do
-      addresses = client.addresses.all(provisioned_id: address.provisioned_id)
-      expect(addresses.size).to eq(1)
-      expect(addresses.first).to eq(address)
-    end
-
-    it "searches by ip_address" do
-      addresses = client.addresses.all(ip_address: address.ip_address)
-      expect(addresses.size).to eq(1)
-      expect(addresses.first).to eq(address)
-    end
-
-    it "lists addresses" do
-      addresses = client.addresses.all
-      expect(addresses.to_a).to include(address)
-    end
-
-    context "with a server" do
-      let!(:environment) { create_environment(account: account, name: Faker::Name.first_name, configuration: {"type" => "cluster"}) }
-
-      it "attaches and detach an address from a server" do
-        server = environment.servers.first(role: "app_master")
-
-        expect(server).to be
-
-        address.attach(server).ready!
-
-        address = server.reload.address
-        address.detach.ready!
-
-        expect(server.reload.address).to be_nil
-        expect(address.reload.server).to be_nil
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'addresses' do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates an address" do
+    request = client.addresses.create!(provider: provider, location: "us-west-2")
+    address = request.resource!
+    expect(address.id).not_to be_nil
+    expect(address.ip_address).not_to be_nil
+    expect(address.provisioned_id).not_to be_nil
+    expect(address.provider).to eq(provider)
+  end
+
+  context "with an address" do
+    let(:location) { "us-west-2" }
+    let!(:address) { client.addresses.all.find{|a| a.location.match(location) && a.server_id.nil?} || client.addresses.create!(provider: provider, location: location).resource! }
+
+    it "searches by provisioned_id" do
+      addresses = client.addresses.all(provisioned_id: address.provisioned_id)
+      expect(addresses.size).to eq(1)
+      expect(addresses.first).to eq(address)
+    end
+
+    it "searches by ip_address" do
+      addresses = client.addresses.all(ip_address: address.ip_address)
+      expect(addresses.size).to eq(1)
+      expect(addresses.first).to eq(address)
+    end
+
+    it "lists addresses" do
+      addresses = client.addresses.all
+      expect(addresses.to_a).to include(address)
+    end
+
+    context "with a server" do
+      let!(:environment) { create_environment(account: account, name: Faker::Name.first_name, configuration: {"type" => "cluster"}) }
+
+      it "attaches and detach an address from a server" do
+        server = environment.servers.first(role: "app_master")
+
+        expect(server).to be
+
+        address.attach(server).ready!
+
+        address = server.reload.address
+        address.detach.ready!
+
+        expect(server.reload.address).to be_nil
+        expect(address.reload.server).to be_nil
+      end
+    end
+  end
+end