ey-core 3.6.4 → 3.6.6

data/features/support/fake_kernel.rb

@@ -1,23 +1,23 @@
-require 'aruba/processes/in_process'
-
-module Aruba
-  module Processes
-    class InProcess < BasicProcess
-      attr_reader :kernel
-
-      class FakeKernel
-        def system(*args)
-          system_commands.push(args.join(' '))
-        end
-
-        def system_commands
-          @system_commands ||= []
-        end
-
-        def abort(msg)
-          exit(false)
-        end
-      end
-    end
-  end
-end
+require 'aruba/processes/in_process'
+
+module Aruba
+  module Processes
+    class InProcess < BasicProcess
+      attr_reader :kernel
+
+      class FakeKernel
+        def system(*args)
+          system_commands.push(args.join(' '))
+        end
+
+        def system_commands
+          @system_commands ||= []
+        end
+
+        def abort(msg)
+          exit(false)
+        end
+      end
+    end
+  end
+end

data/features/support/io.rb

@@ -1,5 +1,5 @@
-After do
-  $stdout = STDOUT
-  $stdin = STDIN
-  $stderr = STDERR
-end
+After do
+  $stdout = STDOUT
+  $stdin = STDIN
+  $stderr = STDERR
+end

data/features/support/mock_api.rb

@@ -1,20 +1,20 @@
-require 'cucumber/rspec/doubles'
-
-# Set up the mocks. Ookla would approve.
-Ey::Core::Client.mock!
-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
-
-Before do
-  # Reset the mocked API before every scenario
-  Ey::Core::Client::Mock.reset!
-
-  # Stub out `#core_client` on all subcommands to ensure that they're using
-  # the mocked client. Otherwise, everything turns to calamity, because the
-  # mocked API is silly.
-  allow_any_instance_of(Ey::Core::Cli::Subcommand).
-    to receive(:core_client).
-    and_return(client)
-end
+require 'cucumber/rspec/doubles'
+
+# Set up the mocks. Ookla would approve.
+Ey::Core::Client.mock!
+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
+
+Before do
+  # Reset the mocked API before every scenario
+  Ey::Core::Client::Mock.reset!
+
+  # Stub out `#core_client` on all subcommands to ensure that they're using
+  # the mocked client. Otherwise, everything turns to calamity, because the
+  # mocked API is silly.
+  allow_any_instance_of(Ey::Core::Cli::Subcommand).
+    to receive(:core_client).
+    and_return(client)
+end

data/features/support/output_helpers.rb

@@ -1,7 +1,7 @@
-module OutputHelpers
-  def output_text
-    last_command_started.output
-  end
-end
-
-World(OutputHelpers)
+module OutputHelpers
+  def output_text
+    last_command_started.output
+  end
+end
+
+World(OutputHelpers)

data/features/support/resource_helpers.rb

@@ -1,201 +1,201 @@
-module ResourceHelpers
-  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"] = "production-cluster" if configuration["type"] == "production"
-    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_environment_variable(options={})
-    application = options[:application] || create_application
-    environment = options[:environment] || create_environment
-
-    environment_variable = options[:environment_variable] || {}
-    environment_variable.merge!(application_id: application.id, environment: environment.id)
-    environment_variable[:name] ||= SecureRandom.hex(8)
-    environment_variable[:value] ||= SecureRandom.hex(32)
-
-    client.environment_variables.create!(environment_variable)
-  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
-
-World(ResourceHelpers)
+module ResourceHelpers
+  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"] = "production-cluster" if configuration["type"] == "production"
+    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_environment_variable(options={})
+    application = options[:application] || create_application
+    environment = options[:environment] || create_environment
+
+    environment_variable = options[:environment_variable] || {}
+    environment_variable.merge!(application_id: application.id, environment: environment.id)
+    environment_variable[:name] ||= SecureRandom.hex(8)
+    environment_variable[:value] ||= SecureRandom.hex(32)
+
+    client.environment_variables.create!(environment_variable)
+  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
+
+World(ResourceHelpers)

data/features/support/server_helpers.rb

@@ -1,27 +1,27 @@
-module ServerHelpers
-  def known_servers
-    begin
-      recall_fact(:known_servers)
-    rescue
-      memorize_fact(:known_servers, [])
-    end
-  end
-
-  def seen_servers
-    begin
-      recall_fact(:seen_servers)
-    rescue
-      memorize_fact(:seen_servers, [])
-    end
-  end
-
-  def first_server
-    known_servers.first
-  end
-
-  def last_server
-    known_servers.last
-  end
-end
-
-World(ServerHelpers)
+module ServerHelpers
+  def known_servers
+    begin
+      recall_fact(:known_servers)
+    rescue
+      memorize_fact(:known_servers, [])
+    end
+  end
+
+  def seen_servers
+    begin
+      recall_fact(:seen_servers)
+    rescue
+      memorize_fact(:seen_servers, [])
+    end
+  end
+
+  def first_server
+    known_servers.first
+  end
+
+  def last_server
+    known_servers.last
+  end
+end
+
+World(ServerHelpers)

data/features/version.feature

@@ -1,8 +1,8 @@
-Feature: Version
-  In order to determine if I'm working with the most recent goodness
-  As a User
-  I want to know what version of ey-core I'm using
-
-  Scenario: Displaying the version
-    When I run `ey-core version`
-    Then I see the current ey-core version
+Feature: Version
+  In order to determine if I'm working with the most recent goodness
+  As a User
+  I want to know what version of ey-core I'm using
+
+  Scenario: Displaying the version
+    When I run `ey-core version`
+    Then I see the current ey-core version

data/features/whoami.feature

@@ -1,14 +1,14 @@
-Feature: Whoami
-  In order to ensure that I'm logged into the right account
-  As a User
-  I want to be able to see my user information
-
-  Background:
-    Given I'm an Engine Yard user
-    And ey-core is configured with my cloud token
-
-  Scenario: Getting the current user information
-    When I run `ey-core whoami`
-    Then I should see my user ID
-    And I should see my email address
-    And I should see my name
+Feature: Whoami
+  In order to ensure that I'm logged into the right account
+  As a User
+  I want to be able to see my user information
+
+  Background:
+    Given I'm an Engine Yard user
+    And ey-core is configured with my cloud token
+
+  Scenario: Getting the current user information
+    When I run `ey-core whoami`
+    Then I should see my user ID
+    And I should see my email address
+    And I should see my name