ey-core 3.4.5 → 3.6.0.autoscaling1

data/spec/tokens_spec.rb

@@ -1,59 +1,59 @@
-require 'spec_helper'
-
-describe 'tokens' do
-  context "with a hmac client" do
-    let!(:client) { create_client }
-
-    context "with a user" do
-      let!(:email)    { Faker::Internet.email }
-      let!(:password) { SecureRandom.hex(5) }
-      let!(:user)     { client.users.create!(name: Faker::Name.name, email: email, password: password) }
-
-      it "retrieves a token by login information" do
-        if Ey::Core::Client.mocking?
-          token = SecureRandom.hex(10)
-          client.data[:users][user.id]["token"] = token
-        end
-
-        expect(client.get_token_by_login(email: email, password: password).body["api_token"]).to be
-      end
-
-      it "does not retrieve a token with login information with an incorrect password" do
-        if Ey::Core::Client.mocking?
-          token = SecureRandom.hex(10)
-          client.data[:users][user.id]["token"] = token
-        end
-
-        expect {
-          client.get_token_by_login(email: email, password: "whoops")
-        }.to raise_error(Ey::Core::Response::Unauthorized)
-      end
-
-      it "generates a token" do
-        token = client.tokens.create!(on_behalf_of: user)
-        expect(token.auth_id).not_to be_nil
-      end
-
-      it "lists tokens" do
-        tokens = user.tokens.all
-        expect(tokens).not_to be_empty
-      end
-
-      it "gets a token" do
-        token = user.tokens.first
-        expect(token.reload).to be
-      end
-
-      context "with multiple users" do
-        let!(:other_user) { client.users.create(name: Faker::Name.name, email: Faker::Internet.email) }
-
-        it "only shows the correct tokens" do
-          expect(user.tokens.all.count).to eq(1)
-          expect(other_user.tokens.all.count).to eq(1)
-          expect(user.tokens.first.on_behalf_of).to eq(client.url_for("/users/#{user.identity}"))
-          expect(other_user.tokens.first.on_behalf_of).to eq(client.url_for("/users/#{other_user.identity}"))
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'tokens' do
+  context "with a hmac client" do
+    let!(:client) { create_client }
+
+    context "with a user" do
+      let!(:email)    { Faker::Internet.email }
+      let!(:password) { SecureRandom.hex(5) }
+      let!(:user)     { client.users.create!(name: Faker::Name.name, email: email, password: password) }
+
+      it "retrieves a token by login information" do
+        if Ey::Core::Client.mocking?
+          token = SecureRandom.hex(10)
+          client.data[:users][user.id]["token"] = token
+        end
+
+        expect(client.get_token_by_login(email: email, password: password).body["api_token"]).to be
+      end
+
+      it "does not retrieve a token with login information with an incorrect password" do
+        if Ey::Core::Client.mocking?
+          token = SecureRandom.hex(10)
+          client.data[:users][user.id]["token"] = token
+        end
+
+        expect {
+          client.get_token_by_login(email: email, password: "whoops")
+        }.to raise_error(Ey::Core::Response::Unauthorized)
+      end
+
+      it "generates a token" do
+        token = client.tokens.create!(on_behalf_of: user)
+        expect(token.auth_id).not_to be_nil
+      end
+
+      it "lists tokens" do
+        tokens = user.tokens.all
+        expect(tokens).not_to be_empty
+      end
+
+      it "gets a token" do
+        token = user.tokens.first
+        expect(token.reload).to be
+      end
+
+      context "with multiple users" do
+        let!(:other_user) { client.users.create(name: Faker::Name.name, email: Faker::Internet.email) }
+
+        it "only shows the correct tokens" do
+          expect(user.tokens.all.count).to eq(1)
+          expect(other_user.tokens.all.count).to eq(1)
+          expect(user.tokens.first.on_behalf_of).to eq(client.url_for("/users/#{user.identity}"))
+          expect(other_user.tokens.first.on_behalf_of).to eq(client.url_for("/users/#{other_user.identity}"))
+        end
+      end
+    end
+  end
+end

data/spec/untracked_servers_spec.rb

@@ -1,59 +1,59 @@
-require 'spec_helper'
-
-RSpec.describe Ey::Core::Client do
-  let!(:client)   { create_client }
-  let!(:account)  { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  # @note private
-  it "creates an untracked server" do
-    provisioner_id = SecureRandom.uuid
-    location       = "us-west-2b"
-    provisioned_id = "i-#{SecureRandom.hex(4)}"
-    state          = "found"
-
-    untracked_server = provider.untracked_servers.create(
-      :provisioner_id => provisioner_id,
-      :location       => location,
-      :provisioned_id => provisioned_id,
-      :state          => state,
-    )
-
-    expect(untracked_server.provisioner_id).to eq(provisioner_id)
-    expect(untracked_server.provisioned_id).to eq(provisioned_id)
-    expect(untracked_server.location).to       eq(location)
-    expect(untracked_server.provider).to       eq(provider)
-    expect(untracked_server.state).to          eq(state)
-
-    untracked_server.reload
-
-    expect(untracked_server.provisioner_id).to eq(provisioner_id)
-    expect(untracked_server.provisioned_id).to eq(provisioned_id)
-    expect(untracked_server.location).to       eq(location)
-    expect(untracked_server.provider).to       eq(provider)
-    expect(untracked_server.state).to          eq(state)
-
-    untracked_server = client.untracked_servers.get!(untracked_server.identity)
-
-    expect(untracked_server.provisioner_id).to eq(provisioner_id)
-    expect(untracked_server.provisioned_id).to eq(provisioned_id)
-    expect(untracked_server.location).to       eq(location)
-    expect(untracked_server.provider).to       eq(provider)
-    expect(untracked_server.state).to          eq(state)
-  end
-
-  context "with an untracked server" do
-    let!(:untracked_server) { create_untracked_server(provider: provider) }
-
-    it "should update server" do
-      expect {
-        untracked_server.update(state: "killed")
-      }.to change { untracked_server.reload.state }.to("killed")
-    end
-
-    it "lists untracked servers" do
-      expect(client.untracked_servers.all).to contain_exactly(untracked_server)
-      expect(provider.untracked_servers.all).to contain_exactly(untracked_server)
-    end
-  end
-end
+require 'spec_helper'
+
+RSpec.describe Ey::Core::Client do
+  let!(:client)   { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  # @note private
+  it "creates an untracked server" do
+    provisioner_id = SecureRandom.uuid
+    location       = "us-west-2b"
+    provisioned_id = "i-#{SecureRandom.hex(4)}"
+    state          = "found"
+
+    untracked_server = provider.untracked_servers.create(
+      :provisioner_id => provisioner_id,
+      :location       => location,
+      :provisioned_id => provisioned_id,
+      :state          => state,
+    )
+
+    expect(untracked_server.provisioner_id).to eq(provisioner_id)
+    expect(untracked_server.provisioned_id).to eq(provisioned_id)
+    expect(untracked_server.location).to       eq(location)
+    expect(untracked_server.provider).to       eq(provider)
+    expect(untracked_server.state).to          eq(state)
+
+    untracked_server.reload
+
+    expect(untracked_server.provisioner_id).to eq(provisioner_id)
+    expect(untracked_server.provisioned_id).to eq(provisioned_id)
+    expect(untracked_server.location).to       eq(location)
+    expect(untracked_server.provider).to       eq(provider)
+    expect(untracked_server.state).to          eq(state)
+
+    untracked_server = client.untracked_servers.get!(untracked_server.identity)
+
+    expect(untracked_server.provisioner_id).to eq(provisioner_id)
+    expect(untracked_server.provisioned_id).to eq(provisioned_id)
+    expect(untracked_server.location).to       eq(location)
+    expect(untracked_server.provider).to       eq(provider)
+    expect(untracked_server.state).to          eq(state)
+  end
+
+  context "with an untracked server" do
+    let!(:untracked_server) { create_untracked_server(provider: provider) }
+
+    it "should update server" do
+      expect {
+        untracked_server.update(state: "killed")
+      }.to change { untracked_server.reload.state }.to("killed")
+    end
+
+    it "lists untracked servers" do
+      expect(client.untracked_servers.all).to contain_exactly(untracked_server)
+      expect(provider.untracked_servers.all).to contain_exactly(untracked_server)
+    end
+  end
+end

data/spec/users_spec.rb

@@ -1,108 +1,108 @@
-require 'spec_helper'
-
-describe 'users' do
-  context "without authentication" do
-    let(:client) { create_unauthenticated_client }
-
-    it "gets an api token", :mock_only do
-      username = ENV["EMAIL"]    || "email"
-      password = ENV["PASSWORD"] || "password"
-      expect(client.get_api_token(username, password).body["api_token"]).not_to be_nil
-    end
-  end
-
-  context "when authenticated" do
-    let!(:client) { create_client }
-
-    it "should create a user" do
-      name  = Faker::Name.name
-      email = Faker::Internet.email
-
-      user = client.users.create!(name: name, email: email)
-      user.name = name
-      user.email = email
-      expect(user.identity).not_to be_nil
-      expect(user.staff).to be_falsy
-      expect(user.password).to be_nil
-
-      expect(user.accounts).to be_empty
-
-      refetched = client.users.get(user.id)
-      expect(refetched.name).to eq name
-      expect(refetched.staff).to be_falsey
-
-      if Ey::Core::Client.mocking?
-        #Can't actually set users as staff in real core API, but apps that use core API may need to test behavior based on a user being staff
-        client.find(:users, user.id).merge!(:staff => true)
-        refetched_again = client.users.get(user.id)
-        expect(refetched_again.staff).to be true
-      end
-    end
-
-    context 'when email address is not available' do
-      it 'should raise an error' do
-        name  = Faker::Name.name
-        email = Faker::Internet.email
-
-        client.users.create!(name: name, email: email)
-
-        expect {
-          client.users.create!(name: name, email: email)
-        }.to raise_exception(Ey::Core::Response::Unprocessable, /Email has already been taken/)
-      end
-    end
-
-    it "should get current user" do
-      expect(client.users.current).to be_a(Ey::Core::Client::User)
-
-      if Ey::Core::Client.mocking?
-        expect(client.users.current.id).to eq(client.current_user["id"])
-      end
-    end
-
-    it "should destroy a user" do
-      name  = Faker::Name.name
-      email = Faker::Internet.email
-
-      user = create_client.users.create!(name: name, email: email)
-      user = client.users.get(user.identity)
-      expect(user.deleted_at).to be_nil
-
-      expect {
-        user.destroy
-      }.to change {client.users.all.size}.by(-1)
-
-      expect(user.reload.deleted_at).not_to be_nil
-
-      expect(client.users.all).not_to include(user)
-      expect(client.users.all(deleted: true)).to include(user)
-      expect(client.users.all(with_deleted: true)).to include(user)
-    end
-
-    context "for the current user" do
-      let!(:user) { client.users.current }
-
-      describe '#token' do
-        subject { user.token }
-
-        context 'for my own user' do
-          it { is_expected.not_to be_nil }
-        end
-
-        context 'for another user' do
-          context 'as a staff user' do
-            before(:each) do
-              client.data[:users][user.id][:staff] = true
-            end
-
-            it { is_expected.not_to be_nil }
-          end
-
-          context 'as a non-staff user' do
-            it { is_expected.not_to be_nil }
-          end
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'users' do
+  context "without authentication" do
+    let(:client) { create_unauthenticated_client }
+
+    it "gets an api token", :mock_only do
+      username = ENV["EMAIL"]    || "email"
+      password = ENV["PASSWORD"] || "password"
+      expect(client.get_api_token(username, password).body["api_token"]).not_to be_nil
+    end
+  end
+
+  context "when authenticated" do
+    let!(:client) { create_client }
+
+    it "should create a user" do
+      name  = Faker::Name.name
+      email = Faker::Internet.email
+
+      user = client.users.create!(name: name, email: email)
+      user.name = name
+      user.email = email
+      expect(user.identity).not_to be_nil
+      expect(user.staff).to be_falsy
+      expect(user.password).to be_nil
+
+      expect(user.accounts).to be_empty
+
+      refetched = client.users.get(user.id)
+      expect(refetched.name).to eq name
+      expect(refetched.staff).to be_falsey
+
+      if Ey::Core::Client.mocking?
+        #Can't actually set users as staff in real core API, but apps that use core API may need to test behavior based on a user being staff
+        client.find(:users, user.id).merge!(:staff => true)
+        refetched_again = client.users.get(user.id)
+        expect(refetched_again.staff).to be true
+      end
+    end
+
+    context 'when email address is not available' do
+      it 'should raise an error' do
+        name  = Faker::Name.name
+        email = Faker::Internet.email
+
+        client.users.create!(name: name, email: email)
+
+        expect {
+          client.users.create!(name: name, email: email)
+        }.to raise_exception(Ey::Core::Response::Unprocessable, /Email has already been taken/)
+      end
+    end
+
+    it "should get current user" do
+      expect(client.users.current).to be_a(Ey::Core::Client::User)
+
+      if Ey::Core::Client.mocking?
+        expect(client.users.current.id).to eq(client.current_user["id"])
+      end
+    end
+
+    it "should destroy a user" do
+      name  = Faker::Name.name
+      email = Faker::Internet.email
+
+      user = create_client.users.create!(name: name, email: email)
+      user = client.users.get(user.identity)
+      expect(user.deleted_at).to be_nil
+
+      expect {
+        user.destroy
+      }.to change {client.users.all.size}.by(-1)
+
+      expect(user.reload.deleted_at).not_to be_nil
+
+      expect(client.users.all).not_to include(user)
+      expect(client.users.all(deleted: true)).to include(user)
+      expect(client.users.all(with_deleted: true)).to include(user)
+    end
+
+    context "for the current user" do
+      let!(:user) { client.users.current }
+
+      describe '#token' do
+        subject { user.token }
+
+        context 'for my own user' do
+          it { is_expected.not_to be_nil }
+        end
+
+        context 'for another user' do
+          context 'as a staff user' do
+            before(:each) do
+              client.data[:users][user.id][:staff] = true
+            end
+
+            it { is_expected.not_to be_nil }
+          end
+
+          context 'as a non-staff user' do
+            it { is_expected.not_to be_nil }
+          end
+        end
+      end
+    end
+  end
+end