ey-core 3.4.5 → 3.6.0.autoscaling1

data/spec/ssl_certificates_spec.rb

@@ -1,94 +1,94 @@
-require 'spec_helper'
-
-describe 'as a user' do
-  let!(:client) { create_client }
-  let!(:user)        { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
-  let(:client)       { create_client }
-  let(:account)      { client.accounts.create!(owner: user, name: Faker::Name.first_name) }
-
-  let(:random_cert) do
-    key  = OpenSSL::PKey::RSA.new(1024)
-    name = OpenSSL::X509::Name.parse("/CN=example.org")
-
-    # NB: the order in which these attributes are set seems to be
-    # important in making it self-signed and not just a certificate
-    # with a mystery issuer. It's not clear which attributes have
-    # the ordering requirement.
-    cert = OpenSSL::X509::Certificate.new
-    cert.version    = 2
-    cert.serial     = Time.now.tv_sec            # monotonically increasing
-    cert.not_before = Time.now - (7 * 24 * 60 * 60) # allow for plenty of clock skew
-    cert.not_after  = Time.now + (10 * 356 * 24 * 60 * 60) # allow for plenty of clock skew
-    cert.subject    = name
-    cert.public_key = key.public_key
-    cert.issuer     = name
-
-    cert.sign(key, OpenSSL::Digest::SHA1.new)
-
-    { cert: cert.to_pem, key: key.to_pem }
-  end
-
-  def create_ssl_certificate(params={})
-    params = {
-      account: account,
-      name: "#{Faker::Name.first_name}_cert",
-    }.merge!(params)
-
-    unless params[:self_sign]
-      params[:public_certificate] = random_cert[:cert]
-      params[:private_key] = random_cert[:key]
-    end
-
-    client.ssl_certificates.create!(params).resource!
-  end
-
-  it "can create an ssl certificate" do
-    ssl_certificate = create_ssl_certificate
-    expect(ssl_certificate.id).to be
-    expect(ssl_certificate.public_certificate.strip).to eq(random_cert[:cert].strip)
-    expect(ssl_certificate.private_key.strip).to eq(random_cert[:key].strip)
-  end
-
-  it "create a self signed certificate" do
-    ssl_certificate = create_ssl_certificate(name: "self-signed", self_sign: true)
-
-    expect(ssl_certificate.certificate_chain).to eq(nil)
-    expect(ssl_certificate.id).to be
-    expect(ssl_certificate.name).to eq("self-signed")
-    expect(ssl_certificate.self_signed).to eq(true)
-    expect(ssl_certificate.private_key.strip).not_to eq(random_cert[:key].strip)
-    expect(ssl_certificate.public_certificate.strip).not_to eq(random_cert[:cert].strip)
-  end
-
-  it "can get a created ssl certificate" do
-    ssl_certificate = create_ssl_certificate
-    ssl_certificate = client.ssl_certificates.get(ssl_certificate.id)
-    expect(ssl_certificate).to be
-  end
-
-  it "can update an ssl certificate", focus: true do
-    ssl_certificate = create_ssl_certificate
-    ssl_certificate.name = "changed"
-    ssl_certificate.save!
-
-    ssl_certificate = client.ssl_certificates.get(ssl_certificate.id)
-    expect(ssl_certificate.name).to eq("changed")
-  end
-
-  it "can destroy a ssl certificate" do
-    ssl_certificate = create_ssl_certificate
-    expect { ssl_certificate.destroy }.to change { client.ssl_certificates.all.size }.by(-1)
-    expect(client.ssl_certificates.get(ssl_certificate.id).deleted_at).to_not be(nil)
-  end
-
-  describe "from account" do
-    it "can get a list of ssl certificates for an account" do
-      create_ssl_certificate
-
-      other_account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
-      create_ssl_certificate(account: other_account, name: "other")
-
-      expect(account.ssl_certificates.size).to eq(1)
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+  let!(:user)        { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+  let(:client)       { create_client }
+  let(:account)      { client.accounts.create!(owner: user, name: Faker::Name.first_name) }
+
+  let(:random_cert) do
+    key  = OpenSSL::PKey::RSA.new(1024)
+    name = OpenSSL::X509::Name.parse("/CN=example.org")
+
+    # NB: the order in which these attributes are set seems to be
+    # important in making it self-signed and not just a certificate
+    # with a mystery issuer. It's not clear which attributes have
+    # the ordering requirement.
+    cert = OpenSSL::X509::Certificate.new
+    cert.version    = 2
+    cert.serial     = Time.now.tv_sec            # monotonically increasing
+    cert.not_before = Time.now - (7 * 24 * 60 * 60) # allow for plenty of clock skew
+    cert.not_after  = Time.now + (10 * 356 * 24 * 60 * 60) # allow for plenty of clock skew
+    cert.subject    = name
+    cert.public_key = key.public_key
+    cert.issuer     = name
+
+    cert.sign(key, OpenSSL::Digest::SHA1.new)
+
+    { cert: cert.to_pem, key: key.to_pem }
+  end
+
+  def create_ssl_certificate(params={})
+    params = {
+      account: account,
+      name: "#{Faker::Name.first_name}_cert",
+    }.merge!(params)
+
+    unless params[:self_sign]
+      params[:public_certificate] = random_cert[:cert]
+      params[:private_key] = random_cert[:key]
+    end
+
+    client.ssl_certificates.create!(params).resource!
+  end
+
+  it "can create an ssl certificate" do
+    ssl_certificate = create_ssl_certificate
+    expect(ssl_certificate.id).to be
+    expect(ssl_certificate.public_certificate.strip).to eq(random_cert[:cert].strip)
+    expect(ssl_certificate.private_key.strip).to eq(random_cert[:key].strip)
+  end
+
+  it "create a self signed certificate" do
+    ssl_certificate = create_ssl_certificate(name: "self-signed", self_sign: true)
+
+    expect(ssl_certificate.certificate_chain).to eq(nil)
+    expect(ssl_certificate.id).to be
+    expect(ssl_certificate.name).to eq("self-signed")
+    expect(ssl_certificate.self_signed).to eq(true)
+    expect(ssl_certificate.private_key.strip).not_to eq(random_cert[:key].strip)
+    expect(ssl_certificate.public_certificate.strip).not_to eq(random_cert[:cert].strip)
+  end
+
+  it "can get a created ssl certificate" do
+    ssl_certificate = create_ssl_certificate
+    ssl_certificate = client.ssl_certificates.get(ssl_certificate.id)
+    expect(ssl_certificate).to be
+  end
+
+  it "can update an ssl certificate", focus: true do
+    ssl_certificate = create_ssl_certificate
+    ssl_certificate.name = "changed"
+    ssl_certificate.save!
+
+    ssl_certificate = client.ssl_certificates.get(ssl_certificate.id)
+    expect(ssl_certificate.name).to eq("changed")
+  end
+
+  it "can destroy a ssl certificate" do
+    ssl_certificate = create_ssl_certificate
+    expect { ssl_certificate.destroy }.to change { client.ssl_certificates.all.size }.by(-1)
+    expect(client.ssl_certificates.get(ssl_certificate.id).deleted_at).to_not be(nil)
+  end
+
+  describe "from account" do
+    it "can get a list of ssl certificates for an account" do
+      create_ssl_certificate
+
+      other_account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      create_ssl_certificate(account: other_account, name: "other")
+
+      expect(account.ssl_certificates.size).to eq(1)
+    end
+  end
+end

data/spec/storages_spec.rb

@@ -1,57 +1,57 @@
-require 'spec_helper'
-
-describe 'storages' do
-  let!(:client) { create_client }
-  let!(:account) { create_account(client: client) }
-  let!(:provider) { create_provider(account: account) }
-
-  it "should create a storage" do
-    storage_request = provider.storages.create!(name: SecureRandom.hex(6), location: "us-east-1", provider: provider)
-    storage_request.ready!
-    expect(storage_request.successful).to be_truthy
-  end
-
-  describe "with a storage" do
-    let!(:storage) { provider.storages.create!(name: SecureRandom.hex(6), location: "us-east-1", provider: provider).resource! }
-
-    it "should list storages" do
-      expect(client.storages).to include(storage)
-    end
-
-    it "should get a storage" do
-      expect(client.storages.get(storage.identity)).to eq(storage)
-    end
-
-    it "should destroy a storage" do
-      destroy_request = storage.destroy!
-      destroy_request.ready!
-      expect(destroy_request.successful).to be(true)
-    end
-
-    describe "users" do
-      it "should create a new storage user" do
-        request = storage.storage_users.create!(username: SecureRandom.hex(6), storage: storage, permissions: "admin")
-        request.ready!
-        expect(request.successful).to be(true)
-      end
-
-      describe "with a user" do
-        let!(:user) { storage.storage_users.create!(username: SecureRandom.hex(6), storage: storage, permissions: "admin").resource! }
-
-        it "should list storage users" do
-          expect(storage.storage_users).to include(user)
-        end
-
-        it "should get a storage user" do
-          expect(storage.storage_users.get(user.id)).to eq(user)
-        end
-
-        it "should destroy a storage user" do
-          request = user.destroy!
-          request.ready!
-          expect(request.successful).to be(true)
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe 'storages' do
+  let!(:client) { create_client }
+  let!(:account) { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "should create a storage" do
+    storage_request = provider.storages.create!(name: SecureRandom.hex(6), location: "us-east-1", provider: provider)
+    storage_request.ready!
+    expect(storage_request.successful).to be_truthy
+  end
+
+  describe "with a storage" do
+    let!(:storage) { provider.storages.create!(name: SecureRandom.hex(6), location: "us-east-1", provider: provider).resource! }
+
+    it "should list storages" do
+      expect(client.storages).to include(storage)
+    end
+
+    it "should get a storage" do
+      expect(client.storages.get(storage.identity)).to eq(storage)
+    end
+
+    it "should destroy a storage" do
+      destroy_request = storage.destroy!
+      destroy_request.ready!
+      expect(destroy_request.successful).to be(true)
+    end
+
+    describe "users" do
+      it "should create a new storage user" do
+        request = storage.storage_users.create!(username: SecureRandom.hex(6), storage: storage, permissions: "admin")
+        request.ready!
+        expect(request.successful).to be(true)
+      end
+
+      describe "with a user" do
+        let!(:user) { storage.storage_users.create!(username: SecureRandom.hex(6), storage: storage, permissions: "admin").resource! }
+
+        it "should list storage users" do
+          expect(storage.storage_users).to include(user)
+        end
+
+        it "should get a storage user" do
+          expect(storage.storage_users.get(user.id)).to eq(user)
+        end
+
+        it "should destroy a storage user" do
+          request = user.destroy!
+          request.ready!
+          expect(request.successful).to be(true)
+        end
+      end
+    end
+  end
+end

data/spec/support/cli_helpers.rb

@@ -1,47 +1,47 @@
-require 'belafonte'
-require 'stringio'
-
-def set_up_cli
-  let(:argv) {[]}
-  let(:stdout) {StringIO.new}
-  let(:stderr) {StringIO.new}
-  let(:stdin) {StringIO.new}
-  let(:kernel) {FakeKernel.new}
-  let(:cli) {described_class.new(argv, stdin, stdout, stderr, kernel)}
-  let(:execute) {cli.execute!}
-  let(:client) {create_client}
-  let(:account) {create_account(client: client)}
-  let(:app) {create_application(account: account, client: client)}
-  let(:environment) {create_environment(account: account, app: app)}
-
-  before(:each) do
-    allow_any_instance_of(described_class).
-      to receive(:core_operator_and_environment_for).
-      with(any_args).
-      and_return([client, environment])
-
-    allow_any_instance_of(described_class).
-      to receive(:core_accounts).
-      and_return([account])
-  end
-end
-
-def arguments(command_line)
-  let(:argv) {command_line.split(/\s+/)}
-end
-
-def error_output
-  @error_output ||= []
-  stderr.rewind
-  @error_output += stderr.readlines.map {|line| line.strip}
-  @error_output.uniq!
-  @error_output.join("\n")
-end
-
-def standard_output
-  @standard_output ||= []
-  stdout.rewind
-  @standard_output += stdout.readlines.map {|line| line.strip}
-  @standard_output.uniq!
-  @standard_output.join("\n")
-end
+require 'belafonte'
+require 'stringio'
+
+def set_up_cli
+  let(:argv) {[]}
+  let(:stdout) {StringIO.new}
+  let(:stderr) {StringIO.new}
+  let(:stdin) {StringIO.new}
+  let(:kernel) {FakeKernel.new}
+  let(:cli) {described_class.new(argv, stdin, stdout, stderr, kernel)}
+  let(:execute) {cli.execute!}
+  let(:client) {create_client}
+  let(:account) {create_account(client: client)}
+  let(:app) {create_application(account: account, client: client)}
+  let(:environment) {create_environment(account: account, app: app)}
+
+  before(:each) do
+    allow_any_instance_of(described_class).
+      to receive(:core_operator_and_environment_for).
+      with(any_args).
+      and_return([client, environment])
+
+    allow_any_instance_of(described_class).
+      to receive(:core_accounts).
+      and_return([account])
+  end
+end
+
+def arguments(command_line)
+  let(:argv) {command_line.split(/\s+/)}
+end
+
+def error_output
+  @error_output ||= []
+  stderr.rewind
+  @error_output += stderr.readlines.map {|line| line.strip}
+  @error_output.uniq!
+  @error_output.join("\n")
+end
+
+def standard_output
+  @standard_output ||= []
+  stdout.rewind
+  @standard_output += stdout.readlines.map {|line| line.strip}
+  @standard_output.uniq!
+  @standard_output.join("\n")
+end

data/spec/support/core.rb

@@ -1,23 +1,23 @@
-Cistern.formatter = Cistern::Formatter::AwesomePrint
-
-if ENV['MOCK_CORE'] == 'true'
-  Ey::Core::Client.mock!
-end
-
-Ey::Core::Client::Mock.timeout = 0.1
-Ey::Core::Client::Mock.poll_interval = 0
-
-Ey::Core::Client::Real.timeout = 3
-Ey::Core::Client::Real.poll_interval = 0
-
-RSpec.configure do |config|
-  config.before(:each) do
-    if Ey::Core::Client.mocking?
-      Ey::Core::Client::Mock.reset!
-    elsif defined?(client) && client
-      client.reset! unless ENV["RESET"] == "false"
-    end
-  end
-
-  config.filter_run_excluding(Ey::Core::Client.mocking? ? {real_only: true} : { mock_only: true })
-end
+Cistern.formatter = Cistern::Formatter::AwesomePrint
+
+if ENV['MOCK_CORE'] == 'true'
+  Ey::Core::Client.mock!
+end
+
+Ey::Core::Client::Mock.timeout = 0.1
+Ey::Core::Client::Mock.poll_interval = 0
+
+Ey::Core::Client::Real.timeout = 3
+Ey::Core::Client::Real.poll_interval = 0
+
+RSpec.configure do |config|
+  config.before(:each) do
+    if Ey::Core::Client.mocking?
+      Ey::Core::Client::Mock.reset!
+    elsif defined?(client) && client
+      client.reset! unless ENV["RESET"] == "false"
+    end
+  end
+
+  config.filter_run_excluding(Ey::Core::Client.mocking? ? {real_only: true} : { mock_only: true })
+end

data/spec/support/coverage.rb

@@ -1,43 +1,43 @@
-if ENV['COVERAGE'] and Kernel.respond_to? :caller_locations
-  require 'cistern/coverage'
-
-  SimpleCov.at_exit do
-    puts "Adding cistern coverage data"
-
-    result = SimpleCov.result
-
-    models = Ey::Core::Client.constants.map {|c| Ey::Core::Client.const_get c }.select {|c| c.is_a? Class}.select {|c| c.superclass == Ey::Core::Model }
-
-    models.each do |m|
-      coverage_details = []
-
-      coverage_details += m.attributes.values.select {|opts| opts[:coverage_hits] } rescue []
-      coverage_details += m.associations.values.select {|opts| opts[:coverage_hits] } rescue []
-
-      coverage_details.each do |options|
-        unless result_file = result.files.find {|f| f.filename == options[:coverage_file] }
-          raise "Coverage failed, couldn't find file '#{file}' in the coverage report"
-        end
-
-        # Use the actual calls to the attribute reader as the coverage metric
-        result_file.line(options[:coverage_line]).instance_variable_set(:@coverage, options[:coverage_hits])
-      end
-    end
-
-    result.format!
-  end
-
-  CodeClimate::TestReporter.start
-  SimpleCov.start do
-    add_filter 'spec'
-
-    add_group 'Collections', 'lib/ey-core/collections'
-    add_group 'Models', 'lib/ey-core/models'
-    add_group 'Requests', 'lib/ey-core/requests'
-  end
-elsif ENV['COVERAGE']
-  warn <<-WARN
-Coverage reporting skipped.
-This ruby version lacks necessary method Kernel.caller_locations"
-  WARN
-end
+if ENV['COVERAGE'] and Kernel.respond_to? :caller_locations
+  require 'cistern/coverage'
+
+  SimpleCov.at_exit do
+    puts "Adding cistern coverage data"
+
+    result = SimpleCov.result
+
+    models = Ey::Core::Client.constants.map {|c| Ey::Core::Client.const_get c }.select {|c| c.is_a? Class}.select {|c| c.superclass == Ey::Core::Model }
+
+    models.each do |m|
+      coverage_details = []
+
+      coverage_details += m.attributes.values.select {|opts| opts[:coverage_hits] } rescue []
+      coverage_details += m.associations.values.select {|opts| opts[:coverage_hits] } rescue []
+
+      coverage_details.each do |options|
+        unless result_file = result.files.find {|f| f.filename == options[:coverage_file] }
+          raise "Coverage failed, couldn't find file '#{file}' in the coverage report"
+        end
+
+        # Use the actual calls to the attribute reader as the coverage metric
+        result_file.line(options[:coverage_line]).instance_variable_set(:@coverage, options[:coverage_hits])
+      end
+    end
+
+    result.format!
+  end
+
+  CodeClimate::TestReporter.start
+  SimpleCov.start do
+    add_filter 'spec'
+
+    add_group 'Collections', 'lib/ey-core/collections'
+    add_group 'Models', 'lib/ey-core/models'
+    add_group 'Requests', 'lib/ey-core/requests'
+  end
+elsif ENV['COVERAGE']
+  warn <<-WARN
+Coverage reporting skipped.
+This ruby version lacks necessary method Kernel.caller_locations"
+  WARN
+end

data/spec/support/fake_kernel.rb

@@ -1,21 +1,21 @@
-class FakeKernel
-  attr_reader :exit_status
-
-  def system(*args)
-    system_commands.push(args.join(' '))
-  end
-
-  def system_commands
-    @system_commands ||= []
-  end
-
-  def abort(msg)
-    self.exit(false)
-    #exit(false)
-  end
-
-  def exit(whatevs)
-    whatevs = -1 unless whatevs.is_a?(Integer)
-    @exit_status ||= whatevs
-  end
-end
+class FakeKernel
+  attr_reader :exit_status
+
+  def system(*args)
+    system_commands.push(args.join(' '))
+  end
+
+  def system_commands
+    @system_commands ||= []
+  end
+
+  def abort(msg)
+    self.exit(false)
+    #exit(false)
+  end
+
+  def exit(whatevs)
+    whatevs = -1 unless whatevs.is_a?(Integer)
+    @exit_status ||= whatevs
+  end
+end

data/spec/support/helpers.rb

@@ -1 +1 @@
-require 'ey-core/test_helpers/rspec'
+require 'ey-core/test_helpers/rspec'

data/spec/support/timecop.rb

@@ -1,8 +1,8 @@
-RSpec.configure do |config|
-  config.after(:each) { Timecop.return }
-  config.before(:each) do |example|
-    if time_scale = example.metadata[:scale]
-      Timecop.scale(time_scale)
-    end
-  end
-end
+RSpec.configure do |config|
+  config.after(:each) { Timecop.return }
+  config.before(:each) do |example|
+    if time_scale = example.metadata[:scale]
+      Timecop.scale(time_scale)
+    end
+  end
+end

data/spec/support_trial_spec.rb

@@ -1,33 +1,33 @@
-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 no support trial" do
-      expect(account.support_trial).to be_nil
-    end
-
-    it "returns support_trial if it has one" do
-      Ey::Core::Client::Mock.support_trial_elibigle(client, account.id)
-      account.reload
-      trial = account.support_trial
-      expect(trial).to be
-      expect(trial.started_at).to be_nil
-      expect(trial.expires_at).to be_nil
-      expect(trial.account).to  eq(account)
-    end
-
-    it "returns support_trial if it has one" do
-      Ey::Core::Client::Mock.support_trial_active(client, account.id)
-      account.reload
-      trial = account.support_trial
-      expect(trial).to be
-      expect(trial.started_at).to be
-      expect(trial.expires_at).to be
-      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 no support trial" do
+      expect(account.support_trial).to be_nil
+    end
+
+    it "returns support_trial if it has one" do
+      Ey::Core::Client::Mock.support_trial_elibigle(client, account.id)
+      account.reload
+      trial = account.support_trial
+      expect(trial).to be
+      expect(trial.started_at).to be_nil
+      expect(trial.expires_at).to be_nil
+      expect(trial.account).to  eq(account)
+    end
+
+    it "returns support_trial if it has one" do
+      Ey::Core::Client::Mock.support_trial_active(client, account.id)
+      account.reload
+      trial = account.support_trial
+      expect(trial).to be
+      expect(trial.started_at).to be
+      expect(trial.expires_at).to be
+      expect(trial.account).to  eq(account)
+    end
+  end
+end