groove-ey-core 3.6.1

data/spec/servers_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe 'servers' do
+  let!(:client)      { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:application) { create_application(account: account) }
+
+  context "with a solo environment" do
+
+    let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name) }
+    let!(:server)      { environment.servers.first }
+
+    context "discovering" do
+      it "discovers a server that it knows nothing about" do
+        expect {
+          client.servers.discover(provider: account.providers.first.identity, environment: environment.identity, server: {location: "us-east-1b", provisioned_id: "i-newserver"}).resource!
+        }.to change { client.servers.count }.by(1)
+      end
+    end
+
+    context "with a second account" do
+      let(:account2) { create_account(client: client) }
+      let(:app2)     { create_application(account: account2) }
+
+      context "with a solo env" do
+        let!(:environment2) { create_environment(account: account2, application: application, name: Faker::Name.first_name) }
+        let!(:server2) { environment2.servers.first }
+
+        it "filters servers by account" do
+          expect(client.servers.all(account: account2).map(&:id)).to contain_exactly(server2.id)
+        end
+      end
+    end
+
+    it "has an association with the environment" do
+      expect(server.environment).to eq(environment)
+    end
+
+    it "reboots" do
+      reboot_request = server.reboot
+      reboot_request.ready!
+      expect(reboot_request.successful).to be true
+    end
+
+    it "stops" do
+      request = server.stop
+      request.ready!
+      expect(request.successful).to be true
+    end
+
+    it "starts" do
+      request = server.start
+      request.ready!
+      expect(request.successful).to be true
+    end
+
+    it "reconciles" do
+      request = server.reconcile
+      request.ready!
+      expect(request.successful).to be true
+    end
+
+    it "applies" do
+      expect(server.apply.ready!).to be_successful
+
+      if Ey::Core::Client.mocking?
+        expect(client.data[:instance_updates].count).to eq(1)
+      end
+    end
+
+    it "should reset the server state" do
+      expect {
+        server.reset_state('error')
+      }.to change { server.reload.state }.from('running').to('error')
+    end
+
+    it "does not destroy" do
+      expect {
+        server.destroy
+      }.to raise_error(Ey::Core::Client::NotPermitted)
+    end
+
+    it "lists servers by environment" do
+      expect(environment.servers).to contain_exactly(server)
+    end
+
+    it "searches for servers by role" do
+      expect {
+        environment.servers.all(role: "solo").to contain_exactly(server)
+      }
+    end
+
+    it "adds a dedicated app server" do
+      server = client.servers.create!(
+        :environment => environment,
+        :role        => "app",
+        :flavor_id   => "m3.large",
+        :dedicated   => true,
+      ).resource!
+      expect(server.dedicated).to be_truthy
+    end
+
+    it "adds an app server" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "app",
+          :flavor_id   => "m3.large",
+        ).resource!
+      }.to change { environment.servers.count }.by(1)
+    end
+
+    it "adds a util server" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "util",
+          :flavor_id   => "m3.large",
+          :name        => "resque",
+        ).resource!
+      }.to change { environment.servers.count }.by(1)
+    end
+
+    it "does not add a util server without a name" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "util",
+          :flavor_id   => "m3.large",
+        ).resource!
+      }.to raise_error(Ey::Core::Response::BadRequest, /value is empty: name/)
+    end
+
+    it "does not add a db slave" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "db_slave",
+          :flavor_id   => "m3.large",
+        )
+      }.to raise_error(Ey::Core::Response::Unprocessable, /cannot add a db slave/i)
+    end
+  end
+
+  context "with multiple servers" do
+    let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name, configuration: {"type" => "cluster"}) }
+    let!(:server)      { environment.servers.first }
+
+    it "destroys" do
+      expect {
+        server.destroy.ready!
+      }.to change { server.reload.deleted_at }.from(nil)
+    end
+
+    it "searches for servers by role" do
+      expect(environment.servers.first(role: "app_master")).to be
+      expect(environment.servers.first(role: "app")).to be
+      expect(environment.servers.first(role: "db_master")).to be
+    end
+
+    it "adds an app server" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "app",
+          :flavor_id   => "m3.large",
+        ).resource!
+      }.to change { environment.servers.count }.by(1)
+    end
+
+    it "adds a util server" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "util",
+          :flavor_id   => "m3.large",
+          :name        => "resque",
+        ).resource!
+      }.to change { environment.servers.count }.by(1)
+    end
+
+    it "does not add a util server without a name" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "util",
+          :flavor_id   => "m3.large",
+        ).resource!
+      }.to raise_error(Ey::Core::Response::BadRequest, /value is empty: name/)
+    end
+
+    it "adds a db slave" do
+      expect {
+        client.servers.create!(
+          :environment => environment,
+          :role        => "db_slave",
+          :flavor_id   => "m3.large",
+        ).resource!
+      }.to change { environment.servers.count }.by(1)
+    end
+  end
+end

data/spec/services_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'as a client' do
+  let!(:client) { create_client }
+
+  it "should display services information" do
+    expect(client.services.all).to contain_exactly(client.metadata)
+  end
+end

data/spec/signups_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'signups' do
+  context "with a hmac client" do
+    let!(:client) { create_client }
+
+    let!(:public_feature) do
+      if Ey::Core::Client.mocking?
+        client.create_feature(
+          :id      => "public_feature",
+          :privacy => "public",
+          :name    => "A Public Feature",
+        )
+      else
+        client.features.all.first
+      end
+    end
+
+    it "should create a user and account" do
+      user_params = {
+        :name         => Faker::Name.name,
+        :email        => Faker::Internet.email,
+        :password     => SecureRandom.hex(8),
+      }
+      account_params = {
+        :account_name => SecureRandom.hex(6),
+      }
+      features = [ public_feature.id ]
+
+      signup = client.signup(user: user_params, account: account_params, features: features, redirect_url: "http://redirect.example.com").body["signup"]
+      user = client.users.get(signup["user_id"])
+      account = client.accounts.get(signup["account_id"])
+
+      expect(user.name).to eq(user_params[:name])
+      expect(user.email).to eq(user_params[:email])
+
+      expect(account.name).to eq(account_params[:name])
+
+      expect(user.accounts).to contain_exactly(account)
+      expect(account.features.map(&:id)).to include(*features)
+
+      expect(signup["upgrade_url"]).not_to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+ENV['MOCK_CORE'] ||= 'true'
+ENV['CORE_URL'] ||= "http://api-development.localdev.engineyard.com:9292"
+
+require 'pry'
+require 'pry-nav'
+require 'tempfile'
+
+Bundler.require(:default, :test)
+
+require File.expand_path("../../lib/ey-core", __FILE__)
+Dir[File.expand_path("../{shared,support}/*.rb", __FILE__)].each{|f| require(f)}
+
+RSpec.configure do |config|
+  config.order = "random"
+  config.after(:each) do
+    $stdout = STDOUT
+    $stdin = STDIN
+    $stderr = STDERR
+  end
+
+  #
+  # This allows to have not_change matcher, i.e.
+  #
+  #   expect { something }.to change { other_thing }
+  #     .and not_change { completely_other_things }
+  RSpec::Matchers.define_negated_matcher :not_change, :change
+end

data/spec/ssl_certificates_spec.rb

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

data/spec/storages_spec.rb

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

data/spec/support/cli_helpers.rb

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