groove-ey-core 3.6.1

data/lib/ey-core/test_helpers/rspec.rb

@@ -0,0 +1,5 @@
+require 'ey-core/test_helpers'
+
+RSpec.configure do |config|
+  config.include(Ey::Core::TestHelpers)
+end

data/lib/ey-core/token_authentication.rb

@@ -0,0 +1,13 @@
+class Ey::Core::TokenAuthentication < Faraday::Response::Middleware
+  attr_reader :token
+
+  def initialize(app, token)
+    super(app)
+    @token = token
+  end
+
+  def call(env)
+    env[:request_headers]["X-EY-TOKEN"] = token
+    super
+  end
+end

data/lib/ey-core/version.rb

@@ -0,0 +1,5 @@
+module Ey
+  module Core
+    VERSION = "3.6.1"
+  end
+end

data/spec/account_spec.rb

@@ -0,0 +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

data/spec/account_trial_spec.rb

@@ -0,0 +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

data/spec/accounts_referrals_spec.rb

@@ -0,0 +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

data/spec/accounts_spec.rb

@@ -0,0 +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

data/spec/addons_and_vars_spec.rb

@@ -0,0 +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

data/spec/addresses_spec.rb

@@ -0,0 +1,57 @@
+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", scope: "vpc")
+    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)
+    expect(address.scope).to eq("vpc")
+  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

data/spec/alerts_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe 'alerts' do
+  let(:client) { create_client }
+  let(:alert_params) { {
+    :message     => Faker::Lorem.sentence(1),
+    :description => Faker::Hacker.verb,
+    :severity    => "warning",
+    :name        => Faker::Hacker.noun,
+    :external_id => SecureRandom.uuid,
+  } }
+
+  it 'should fail to create an alert with no resource' do
+    expect { client.alerts.create!(alert_params) }.to raise_error Ey::Core::Response::Unprocessable
+  end
+
+  context 'with a database server' do
+    let(:database_server) { create_database_service(client: client).servers.first }
+
+    it 'should create an alert' do
+      alert = nil
+      expect {
+        alert = database_server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size          }.by(1).
+        and change { database_server.alerts.size }.by(1)
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+
+      alert.reload
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+    end
+  end
+
+  context 'with a server' do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+
+    it 'should create an alert' do
+      server = client.servers.all.first
+      alert  = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size }.by(1).
+        and change { server.alerts.size }.by(1)
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+
+      alert.reload
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+    end
+
+    it "create an alert that has been started" do
+      server = client.servers.all.first
+      alert = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params.merge(started_at: Time.now))
+      }.to change { server.alerts.size }.by(1)
+
+      expect(alert.started_at).not_to be_nil
+      expect(alert.reload.started_at).not_to be_nil
+    end
+  end
+
+  context "given some alerts" do
+    let(:database_server)  { create_database_service(client: client).servers.first }
+    let(:database_server2) { create_database_service(client: client).servers.first }
+
+    let!(:alerts) {
+      [
+        client.alerts.create!(
+          :database_server => database_server,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+        client.alerts.create!(
+          :database_server => database_server2,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+      ]
+    }
+
+    it "should list alerts" do
+      expect(
+        client.alerts.all
+      ).to match_array(alerts)
+    end
+
+    it "should filter alerts" do
+      expect(database_server.alerts.all).to match_array(alerts[0])
+      expect(client.alerts.all(database_server: database_server.identity)).to match_array(alerts[0])
+
+      expect(database_server2.alerts.all).to match_array(alerts[1])
+      expect(client.alerts.all(database_server: database_server2.identity)).to match_array(alerts[1])
+    end
+
+    it "should update alert" do
+      alert = alerts.first
+      expect { alert.update(acknowledged: true) }.to change { alert.acknowledged }.from(false).to(true)
+      expect { alert.update(message: "something else") }.to change { alert.reload.message }
+      expect { alert.update(external_id: "new-id") }.to change { alert.reload.external_id }
+      expect { alert.update(started_at: Time.now) }.to change { alert.reload.started_at }.from(nil)
+      expect {
+        alert.update(finished_at: Time.now)
+      }.to  change { alert.reload.finished_at }.from(nil).
+        and change { database_server.alerts.all.size }.by(-1)
+    end
+
+    it 'acknowledges the alert' do
+      alert = alerts.first
+      expect {
+        alert.acknowledge!
+      }.to change { alert.acknowledged }.from(false).to(true)
+    end
+  end
+end