ey-core 3.4.5 → 3.5.0

data/features/step_definitions/accounts_steps.rb

@@ -1,23 +1,37 @@
-Given %(I'm an Engine Yard user) do
-  memorize_fact(:me, create_user(client: client))
-  true
-end
-
-Given %(ey-core is configured with my cloud token) do
-  add_config_option(
-    'https://api.engineyard.com/' => current_user_hash['token']
-  )
-end
-
-Given %(I'm associated with several accounts) do
-  account1 = create_account(client: client, owner: current_user)
-  account2 = create_account(client: client, owner: current_user)
-  memorize_fact(:accounts, [account1, account2])
-end
-
-Then %(I see the name and ID of each of my accounts) do
-  recall_fact(:accounts).each do |account|
-    expect(output_text).to include(account.id)
-    expect(output_text).to include(account.name)
-  end
-end
+Given %(I'm an Engine Yard user) do
+  memorize_fact(:me, create_user(client: client))
+  true
+end
+
+Given %(ey-core is configured with my cloud token) do
+  add_config_option(
+    'https://api.engineyard.com/' => current_user_hash['token']
+  )
+end
+
+Given %(I'm associated with several accounts) do
+  account1 = create_account(client: client, owner: current_user)
+  account2 = create_account(client: client, owner: current_user)
+  memorize_fact(:accounts, [account1, account2])
+end
+
+Given %r(^I have the following accounts:$) do |account_names|
+  account_names.hashes.each do |account_hash|
+    known_accounts.push(
+      create_account(
+        client: client,
+        owner: current_user,
+        account: {
+          name: account_hash['Account Name']
+        }
+      )
+    )
+  end
+end
+
+Then %(I see the name and ID of each of my accounts) do
+  recall_fact(:accounts).each do |account|
+    expect(output_text).to include(account.id)
+    expect(output_text).to include(account.name)
+  end
+end

data/features/step_definitions/applications_steps.rb

@@ -1,46 +1,39 @@
-Given %r(^I have the following accounts:$) do |account_names|
-  account_names.hashes.each do |account_hash|
-    known_accounts.push(
-      create_account(
-        client: client,
-        owner: current_user,
-        account: {
-          name: account_hash['Account Name']
-        }
-      )
-    )
-  end
-end
-
-Given %(each of my accounts has several applications) do
-  known_accounts.each do |account|
-    known_apps.push(
-      create_application(account: account, name: "#{account.name}_1")
-    )
-
-    known_apps.push(
-      create_application(account: account, name: "#{account.name}_2")
-    )
-  end
-end
-
-Then %(I see the name and ID for all of my applications) do
-  known_apps.each do |app|
-    expect(output_text).to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
-  end
-end
-
-Then %(I see the applications in the one account) do
-  account_named('one').applications.all.each do |app|
-    expect(output_text).to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
-  end
-end
-
-Then %(I do not see applications from other accounts) do
-  two = account_named('two').applications.all.to_a
-  three = account_named('three').applications.all.to_a
-
-  (two + three).each do |app|
-    expect(output_text).not_to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
-  end
-end
+Given %(each of my accounts has several applications) do
+  known_accounts.each do |account|
+    known_apps.push(
+      create_application(account: account, name: "#{account.name}_1")
+    )
+
+    known_apps.push(
+      create_application(account: account, name: "#{account.name}_2")
+    )
+  end
+end
+
+Given(/^I have the following applications:$/) do |applications|
+  applications.hashes.each do |application_hash|
+    account = known_accounts.find { |acc| acc.name == application_hash['Account Name'] }
+    known_apps.push(create_application(account: account, name: application_hash['Application Name']))
+  end
+end
+
+Then %(I see the name and ID for all of my applications) do
+  known_apps.each do |app|
+    expect(output_text).to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
+  end
+end
+
+Then %(I see the applications in the one account) do
+  account_named('one').applications.all.each do |app|
+    expect(output_text).to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
+  end
+end
+
+Then %(I do not see applications from other accounts) do
+  two = account_named('two').applications.all.to_a
+  three = account_named('three').applications.all.to_a
+
+  (two + three).each do |app|
+    expect(output_text).not_to match(/#{Regexp.escape(app.id.to_s)}\s+\|\s+#{Regexp.escape(app.name)}/)
+  end
+end

data/features/step_definitions/current_user_steps.rb

@@ -1,11 +1,11 @@
-Then %(I should see my user ID) do
-  expect(output_text).to match(/#{Regexp.escape(current_user.id)}/)
-end
-
-Then %(I should see my email address) do
-  expect(output_text).to match(/#{Regexp.escape(current_user.email)}/)
-end
-
-Then %(I should see my name) do
-  expect(output_text).to match(/#{Regexp.escape(current_user.name)}/)
-end
+Then %(I should see my user ID) do
+  expect(output_text).to match(/#{Regexp.escape(current_user.id)}/)
+end
+
+Then %(I should see my email address) do
+  expect(output_text).to match(/#{Regexp.escape(current_user.email)}/)
+end
+
+Then %(I should see my name) do
+  expect(output_text).to match(/#{Regexp.escape(current_user.name)}/)
+end

data/features/step_definitions/deprecated_command_steps.rb

@@ -1,3 +1,3 @@
-Then %(I am advised that this command has been deprecated) do
-  expect(output_text).to match(/.*This command is deprecated.*/)
-end
+Then %(I am advised that this command has been deprecated) do
+  expect(output_text).to match(/.*This command is deprecated.*/)
+end

data/features/step_definitions/environment_variables_steps.rb

@@ -0,0 +1,51 @@
+Given(/^I have the following environment variables:$/) do |variables|
+  variables.hashes.each do |variable_hash|
+    application = known_apps.find { |app| app.name == variable_hash['Application Name'] }
+    environment = known_environments.find { |env| env.name == variable_hash['Environment Name'] }
+    known_environment_variables.push(
+      create_environment_variable(
+        application: application,
+        environment: environment,
+        environment_variable: {
+          name: variable_hash['Name'],
+          value: variable_hash['Value'],
+          sensitive: variable_hash['Sensitive']
+        }
+      )
+    )
+  end
+end
+
+Then(/^I see the name and value for all of my environments as well as name of associated environment and application$/) do
+  known_environment_variables.each do |environment_variable|
+    expect(output_text).to match(match_environment_variable_regexp(environment_variable))
+  end
+end
+
+Then(/^I see the environment variables associated with `(\w+)` environment$/) do |environment_name|
+  known_environment_variables.each do |environment_variable|
+    next unless environment_variable.environment_name == environment_name
+    expect(output_text).to match(match_environment_variable_regexp(environment_variable))
+  end
+end
+
+Then(/^I do not see environment variables associated with any other environments different from `(\w+)`$/) do |environment_name|
+  known_environment_variables.each do |environment_variable|
+    next if environment_variable.environment_name == environment_name
+    expect(output_text).not_to match(match_environment_variable_regexp(environment_variable))
+  end
+end
+
+Then(/^I see the environment variables associated with `(\w+)` application$/) do |application_name|
+  known_environment_variables.each do |environment_variable|
+    next unless environment_variable.application_name == application_name
+    expect(output_text).to match(match_environment_variable_regexp(environment_variable))
+  end
+end
+
+Then(/^I do not see environment variables associated with any other applications different from `(\w+)`$/) do |application_name|
+  known_environment_variables.each do |environment_variable|
+    next if environment_variable.application_name == application_name
+    expect(output_text).not_to match(match_environment_variable_regexp(environment_variable))
+  end
+end

data/features/step_definitions/environments_steps.rb

@@ -1,37 +1,52 @@
-Given %(each of my applications has an environment) do
-  known_accounts.each do |account|
-    account.applications.each do |app|
-      known_environments.push(
-        create_environment(
-          account: account,
-          application: app,
-          environment: {
-            name: "#{app.name}_env"
-          }
-        )
-      )
-    end
-  end
-end
-
-Then %(I see the name and ID for all of my environments) do
-  known_environments.each do |environment|
-    expect(output_text).to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
-  end
-end
-
-Then %(I see the environments in the one account) do
-  account_named('one').environments.all.each do |environment|
-    expect(output_text).to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
-  end
-end
-
-Then %(I do not see environments from other accounts) do
-  two = account_named('two').environments.all.to_a
-  three = account_named('three').environments.all.to_a
-
-  (two + three).each do |environment|
-    expect(output_text).not_to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
-  end
-
-end
+Given %(each of my applications has an environment) do
+  known_accounts.each do |account|
+    account.applications.each do |app|
+      known_environments.push(
+        create_environment(
+          account: account,
+          application: app,
+          environment: {
+            name: "#{app.name}_env"
+          }
+        )
+      )
+    end
+  end
+end
+
+Given(/^I have the following environments:$/) do |environments|
+  environments.hashes.each do |environment_hash|
+    application = known_apps.find { |app| app.name == environment_hash['Application Name'] }
+    known_environments.push(
+      create_environment(
+        account: application.account,
+        application: application,
+        environment: {
+          name: environment_hash['Environment Name']
+        }
+      )
+    )
+  end
+end
+
+Then %(I see the name and ID for all of my environments) do
+  known_environments.each do |environment|
+    expect(output_text).to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
+  end
+end
+
+Then %(I see the environments in the one account) do
+  account_named('one').environments.all.each do |environment|
+    expect(output_text).to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
+  end
+end
+
+Then %(I do not see environments from other accounts) do
+  two = account_named('two').environments.all.to_a
+  three = account_named('three').environments.all.to_a
+
+  (two + three).each do |environment|
+    expect(output_text).not_to match(/#{Regexp.escape(environment.id.to_s)}\s+\|\s+#{Regexp.escape(environment.name)}/)
+  end
+
+end

data/features/step_definitions/version_steps.rb

@@ -1,3 +1,3 @@
-Then %(I see the current ey-core version) do
-  expect(output_text).to include(Ey::Core::VERSION)
-end
+Then %(I see the current ey-core version) do
+  expect(output_text).to include(Ey::Core::VERSION)
+end

data/features/support/account_helpers.rb

@@ -1,89 +1,89 @@
-module AccountHelpers
-  def account_named(name)
-    client.accounts.first(name: name)
-  end
-
-  def known_accounts
-    begin
-      recall_fact(:known_accounts)
-    rescue
-      memorize_fact(:known_accounts, [])
-    end
-  end
-
-  def first_account
-    known_accounts.first.reload
-  end
-
-  def last_account
-    known_accounts.last.reload
-  end
-
-  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
-
-World(AccountHelpers)
+module AccountHelpers
+  def account_named(name)
+    client.accounts.first(name: name)
+  end
+
+  def known_accounts
+    begin
+      recall_fact(:known_accounts)
+    rescue
+      memorize_fact(:known_accounts, [])
+    end
+  end
+
+  def first_account
+    known_accounts.first.reload
+  end
+
+  def last_account
+    known_accounts.last.reload
+  end
+
+  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
+
+World(AccountHelpers)

data/features/support/app_helpers.rb

@@ -1,19 +1,19 @@
-module AppHelpers
-  def known_apps
-    begin
-      recall_fact(:known_apps)
-    rescue
-      memorize_fact(:known_apps, [])
-    end
-  end
-
-  def first_app
-    known_apps.first.reload
-  end
-
-  def last_app
-    known_apps.last.reload
-  end
-end
-
-World(AppHelpers)
+module AppHelpers
+  def known_apps
+    begin
+      recall_fact(:known_apps)
+    rescue
+      memorize_fact(:known_apps, [])
+    end
+  end
+
+  def first_app
+    known_apps.first.reload
+  end
+
+  def last_app
+    known_apps.last.reload
+  end
+end
+
+World(AppHelpers)

data/features/support/aruba.rb

@@ -1 +1 @@
-require 'aruba/cucumber'
+require 'aruba/cucumber'

data/features/support/boilerplate.rb

@@ -1 +1 @@
-require 'faker'
+require 'faker'

data/features/support/client_helpers.rb

@@ -1,36 +1,36 @@
-module ClientHelpers
-  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
-
-World(ClientHelpers)
+module ClientHelpers
+  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
+
+World(ClientHelpers)