ey-core 3.0.0

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,13 @@
+ENV['MOCK_CORE'] ||= 'true'
+ENV['CORE_URL'] ||= "http://api-development.localdev.engineyard.com:9292"
+
+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"
+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/account_helper.rb

@@ -0,0 +1,71 @@
+module AccountHelper
+  def create_account(options={})
+    creator = options[:creator] || create_client
+    client  = options[:client]
+
+    attributes = options[:account] || {}
+    attributes[:type] ||= "beta" # get around awsm billing requirements for tests
+    attributes[:name] ||= SecureRandom.hex(6)
+
+    if client
+      attributes[:owner] ||= begin
+                               client.users.current
+                             rescue Ey::Core::Response::NotFound
+                             end
+    end
+    attributes[:owner] ||= create_user(client: client)
+
+    created_account = (client || creator).accounts.create!(attributes)
+
+    if client
+      client.accounts.get!(created_account.identity)
+    else
+      created_account
+    end
+  end
+
+  def create_user(options={})
+    creator = options[:creator] || create_client
+    client  = options[:client]
+
+    attributes = options[:user] || {}
+    attributes[:name] ||= Faker::Name.name
+    attributes[:email] ||= Faker::Internet.email
+
+    created_user = creator.users.create!(attributes)
+
+    if client
+      client.users.get!(created_user.identity)
+    else
+      created_user
+    end
+  end
+
+  def create_provider(options={})
+    account = options[:account] || create_account(options)
+
+    attributes = options[:provider] || {}
+    attributes[:type] ||= :aws
+    attributes[:provisioned_id] ||= SecureRandom.hex(8)
+    attributes[:credentials] ||= case attributes[:type]
+                                 when :aws then
+                                   {
+                                     :instance_aws_secret_id  => SecureRandom.hex(6),
+                                     :instance_aws_secret_key => SecureRandom.hex(6),
+                                     :aws_secret_id           => SecureRandom.hex(6),
+                                     :aws_secret_key          => SecureRandom.hex(6),
+                                     :aws_login               => Faker::Internet.email,
+                                     :aws_pass                => SecureRandom.hex(6),
+                                   }
+                                 when :azure then
+                                   {
+                                   }
+                                 end
+
+    account.providers.create!(attributes).resource!
+  end
+end
+
+RSpec.configure do |config|
+  config.include(AccountHelper)
+end

data/spec/support/alert_helper.rb

@@ -0,0 +1,14 @@
+module LegacyAlertHelper
+  def create_legacy_alert(client, attributes={})
+    attributes = Cistern::Hash.stringify_keys(attributes)
+
+    if server = attributes.delete("server")
+      attributes["server"] = client.url_for("/servers/#{server.id}")
+    end
+    client.data[:legacy_alerts][attributes["id"]] = attributes
+  end
+end
+
+RSpec.configure do |config|
+  config.include(LegacyAlertHelper)
+end

data/spec/support/client_helper.rb

@@ -0,0 +1,38 @@
+module ClientHelper
+  def create_client(attributes={})
+    token = if (user = attributes.delete(:user)) && Ey::Core::Client.mocking?
+              core = Ey::Core::Client::Mock.data.values.find { |c| c[:users][user.identity] }
+              core[:users][user.identity]["token"]
+            end
+    token ||= begin
+                token_dotfile = YAML.load_file(File.expand_path("/../../../.token"), __FILE__) rescue {}
+                ENV["CORE_TOKEN"] || token_dotfile[ENV["CORE_URL"]] || "a4bf6558da8c1051536d1596b8931ebd346aff0b"
+              end
+
+    merged_attributes = attributes.merge(token: token, cache: true)
+    merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
+
+    Ey::Core::Client.new(merged_attributes)
+  end
+
+  def create_server_client(server, attributes={})
+    unless core = Ey::Core::Client::Mock.data.values.find { |data| data[:servers][server.identity] }
+      raise "Failed to find server in mock data: #{server}"
+    end
+
+    token = core[:servers][server.identity]["token"]
+
+    merged_attributes = attributes.merge(token: token, cache: true)
+    merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
+
+    Ey::Core::Client.new(merged_attributes)
+  end
+
+  def create_unauthenticated_client
+    Ey::Core::Client.new(token: nil)
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ClientHelper)
+end

data/spec/support/core.rb

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

data/spec/support/coverage.rb

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

data/spec/support/resource_helper.rb

@@ -0,0 +1,190 @@
+module ResourceHelper
+  def load_blueprint(options={})
+    application      = create_application(account: account)
+    database_service = create_database_service(provider: account.providers.first)
+    environment      = create_environment(account: account, application: application, database_service: database_service, environment: {name: "environment#{SecureRandom.hex(4)}"})
+
+    [database_service, environment]
+  end
+
+  def create_application(options={})
+    account = options.delete(:account) || create_account(options)
+    options = Cistern::Hash.stringify_keys(options)
+
+    options["name"]       ||= "application#{SecureRandom.hex(4)}"
+    options["repository"] ||= "git://github.com/engineyard/todo.git"
+    options["type"]       ||= "rails4"
+
+    account.applications.create!(options)
+  end
+
+  def create_server(client, options={})
+    options = Cistern::Hash.stringify_keys(options)
+
+    request = environment.servers.create(
+      "flavor" => "m3.medium",
+      "role"   => "util",
+    )
+
+    request.resource!
+  end
+
+  def create_cost(client, options={})
+    account = options[:account] || create_account(client: client)
+    level = options[:level] || "summarized"
+    finality = options[:finality] || "estimated"
+    related_resource_type = options[:related_resource_type] || "account"
+    category = options[:category] || "non-server"
+    description = options[:description] || "AWS Other Services"
+    value = options[:value] || "1763"
+    environment = options[:environment] || nil
+
+    client.data[:costs] << {
+      billing_month:         "2015-07",
+      data_type:             "cost",
+      level:                 level,
+      finality:              finality,
+      related_resource_type: related_resource_type,
+      category:              category,
+      units:                 "USD cents",
+      description:           description,
+      value:                 value,
+      account:               client.url_for("accounts/#{account.identity}"),
+      environment:           environment
+    }
+  end
+
+  def create_account_referral(client, options={})
+    referred = options.delete(:referred) || create_account(client: client)
+    referrer = options.delete(:referrer) || create_account(client: client)
+
+    account_referral_id = SecureRandom.uuid
+    referral = client.data[:account_referrals][account_referral_id] = {
+      "id" => account_referral_id,
+      "referrer" => client.url_for("accounts/#{referrer.identity}"),
+      "referred" => client.url_for("accounts/#{referred.identity}"),
+    }
+
+    client.account_referrals.new(referral)
+  end
+
+  def create_firewall(client, options={})
+    provider = options.fetch(:provider) { create_provider(client: client) }
+
+    firewall_params = options[:firewall] || {}
+    name     = firewall_params.delete(:name) || SecureRandom.hex(6)
+    location = firewall_params.delete(:location) || "us-west-2"
+
+    client.firewalls.create!(
+      :name     => name,
+      :location => location,
+      :provider => provider,
+    ).resource!
+  end
+
+  def create_database_service(options={})
+    provider = options[:provider] || create_provider(options.merge(client: client))
+
+    database_service_params = Hashie::Mash.new(
+      :name     => Faker::Name.first_name,
+      :provider => provider,
+    ).merge(options.fetch(:database_service, {}))
+
+    database_server_params = Hashie::Mash.new(
+        :location => "us-west-2c",
+        :flavor   => "db.m3.large",
+        :engine   => "postgres",
+        :version  => "9.3.5",
+    ).merge(options.fetch(:database_server, {}))
+
+    client.database_services.create!(database_service_params.merge(database_server: database_server_params)).resource!
+  end
+
+  def create_environment(options={})
+    account = options[:account] || create_account(options)
+
+    unless account.providers.first || options[:provider]
+      create_provider(account: account)
+    end
+
+    environment             = options[:environment] || {}
+    application             = options[:application] || create_application(account: account)
+    database_service        = options[:database_service]
+    configuration           = Cistern::Hash.stringify_keys(options[:configuration] || {})
+    configuration["type"] ||= "solo"
+    environment[:name]    ||= options.fetch(:name, SecureRandom.hex(3))
+    environment[:region]  ||= "us-west-2"
+
+    environment.merge!(application_id: application.id, account: account)
+    environment.merge!(database_service: database_service) if database_service
+    environment = client.environments.create!(environment)
+
+    unless options[:boot] == false
+      request = environment.boot(configuration: configuration, application_id: application.id)
+      request.ready!
+    end
+    environment
+  end
+
+  def create_provider_location(client, attributes={})
+    attributes = Cistern::Hash.stringify_keys(attributes)
+
+    if provider = attributes.delete("provider")
+      attributes["provider"] = client.url_for("/providers/#{provider.id}")
+    end
+
+    attributes["id"] ||= client.uuid
+    client.data[:provider_locations][attributes["id"]] = attributes
+
+    client.provider_locations.new(attributes)
+  end
+
+  def create_server_event(client, attributes={})
+    attributes = Cistern::Hash.stringify_keys(attributes)
+
+    attributes.fetch("type")
+
+    if server = attributes.delete("server")
+      attributes["server"] = client.url_for("/servers/#{server.id}")
+    end
+
+    event_id = attributes["id"] ||= SecureRandom.uuid
+
+    client.server_events.new(
+      client.data[:server_events][event_id] = attributes
+    )
+  end
+
+  def create_logical_database(options={})
+    database_service = options.fetch(:database_service) { create_database_service(options) }
+
+    database_service.databases.create!(
+      :name     => SecureRandom.hex(6),
+      :username => "ey#{SecureRandom.hex(6)}",
+      :password => SecureRandom.hex(8),
+    ).resource!
+  end
+
+  def create_untracked_server(options={})
+    provider = options.fetch(:provider) { create_provider(options) }
+
+    untracked_server = options[:untracked_server] || {}
+
+    provisioner_id = untracked_server[:provisioner_id] || SecureRandom.uuid
+    location       = untracked_server[:location]       || "us-west-2b"
+    provisioned_id = untracked_server[:provisioned_id] || "i-#{SecureRandom.hex(4)}"
+    state          = untracked_server[:state]          || "found"
+
+    client.untracked_servers.create(
+      :location       => location,
+      :provider       => provider,
+      :provisioned_id => provisioned_id,
+      :provisioner_id => provisioner_id,
+      :state          => state,
+    )
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ResourceHelper)
+end