engineyard 1.4.29 → 1.7.0.pre2

data/spec/support/{fake_awsm.rb → git_repos.rb}

@@ -1,10 +1,5 @@
 module EY
   class << self
-    def fake_awsm
-      @fake_awsm ||= load_fake_awsm
-    end
-    alias_method :start_fake_awsm, :fake_awsm
-
     def define_git_repo(name, &setup)
       git_repo_setup[name] ||= setup
     end
@@ -31,15 +26,6 @@ module EY
 
     protected
 
-    def load_fake_awsm
-      config_ru = File.join(EY_ROOT, "spec/support/fake_awsm.ru")
-      unless system("ruby -c '#{config_ru}' > /dev/null")
-        raise SyntaxError, "There is a syntax error in fake_awsm.ru! fix it!"
-      end
-      @server = RealWeb.start_server_in_fork(config_ru)
-      "http://localhost:#{@server.port}"
-    end
-
     def git_repo_setup
       @git_repo_setup ||= {}
     end

data/spec/support/helpers.rb

@@ -24,19 +24,25 @@ module SpecHelpers
 
   module IntegrationHelpers
     def run_ey(command_options, ey_options={})
+
       if respond_to?(:extra_ey_options)   # needed for ssh tests
         ey_options.merge!(extra_ey_options)
+        return ey(command_to_run(command_options), ey_options)
       end
 
-      ey(command_to_run(command_options), ey_options)
+      if ey_options[:expect_failure]
+        fast_failing_ey(command_to_run(command_options))
+      else
+        fast_ey(command_to_run(command_options))
+      end
     end
 
-    def make_scenario(hash)
+    def make_scenario(opts)
       # since nil will silently turn to empty string when interpolated,
       # and there's a lot of string matching involved in integration
       # testing, it would be nice to have early notification of typos.
       scenario = Hash.new { |h,k| raise "Tried to get key #{k.inspect}, but it's missing!" }
-      scenario.merge!(hash)
+      scenario.merge!(opts)
     end
   end
 
@@ -69,21 +75,37 @@ module SpecHelpers
   ZeroExitStatus = Class.new(UnexpectedExit)
 
   def ey_api
-    @api ||= EY::API.new('asdf')
+    @api ||= EY::CloudClient.new('asdf', EY::CLI::UI.new)
+  end
+
+  def ensure_eyrc
+    begin
+      unless (data = read_eyrc) and data['api_token']
+        raise ".eyrc has no token, specs will stall waiting for stdin authentication input"
+      end
+    rescue Errno::ENOENT => e
+      raise ".eyrc must be written before calling run_ey or specs will stall waiting for stdin authentication input"
+    end
   end
 
-  def fast_ey(args)
-    err, out = StringIO.new, StringIO.new
-    capture_stderr_into(err) do
-      capture_stdout_into(out) do
-        with_env('DEBUG' => 'true') do
-          EY::CLI.start(args)
+  def fast_ey(args, options = {})
+
+    ensure_eyrc
+
+    begin
+      err, out = StringIO.new, StringIO.new
+      debug = options[:debug] == false ? nil : 'true'
+      capture_stderr_into(err) do
+        capture_stdout_into(out) do
+          with_env('DEBUG' => debug) do
+            EY::CLI.start(args)
+          end
         end
       end
+    ensure
+      @err, @out = err.string, out.string
+      @raw_ssh_commands, @ssh_commands = extract_ssh_commands(@out)
     end
-  ensure
-    @err, @out = err.string, out.string
-    @raw_ssh_commands, @ssh_commands = extract_ssh_commands(@out)
   end
 
   def fast_failing_ey(*args)
@@ -94,17 +116,8 @@ module SpecHelpers
       # SystemExit typically indicates a bogus command, which we
       # here in expected-to-fail land are entirely happy with.
       nil
-    rescue EY::Error => e
-      more_err, more_out = StringIO.new, StringIO.new
-
-      capture_stderr_into(more_err) do
-        capture_stdout_into(more_out) do
-          EY.ui.print_exception(e)
-        end
-      end
-
-      @err << more_err.string
-      @out << more_out.string
+    rescue EY::Error, EY::CloudClient::Error => e
+      nil
     end
   end
 
@@ -123,7 +136,12 @@ module SpecHelpers
   end
 
   def ey(args = [], options = {}, &block)
+    if respond_to?(:extra_ey_options)   # needed for ssh tests
+      options.merge!(extra_ey_options)
+    end
+
     hide_err = options.has_key?(:hide_err) ? options[:hide_err] : options[:expect_failure]
+
     path_prepends = options[:prepend_to_path]
 
     ey_env = {
@@ -154,6 +172,7 @@ module SpecHelpers
     with_env(ey_env) do
       exit_status = Open4::open4("#{eybin} #{Escape.shell_command(args)}") do |pid, stdin, stdout, stderr|
         block.call(stdin) if block
+        stdin.close
         @out = stdout.read
         @err = stderr.read
       end
@@ -172,7 +191,7 @@ module SpecHelpers
   end
 
   def extract_ssh_commands(output)
-    raw_ssh_commands = @out.split(/\n/).find_all do |line|
+    raw_ssh_commands = [@out,@err].join("\n").split(/\n/).find_all do |line|
       line =~ /^bash -lc/ || line =~ /^ssh/
     end
 
@@ -198,9 +217,46 @@ module SpecHelpers
     [raw_ssh_commands, ssh_commands]
   end
 
-  def api_scenario(scenario, remote = "user@git.host:path/to/repo.git")
-    response = ::RestClient.put(EY.fake_awsm + '/scenario', {"scenario" => scenario, "remote" => remote}, {})
-    raise "Setting scenario failed: #{response.inspect}" unless response.code == 200
+  DEPRECATED_SCENARIOS = {
+    "empty"                                               => "User Name",
+    "one app without environment"                         => "App Without Env",
+    "one app, one environment, not linked"                => "Unlinked App",
+    "two apps"                                            => "Two Apps",
+    "one app, one environment"                            => "Linked App",
+    "two accounts, two apps, two environments, ambiguous" => "Multiple Ambiguous Accounts",
+    "one app, one environment, no instances"              => "Linked App Not Running",
+    "one app, one environment, app master red"            => "Linked App Red Master",
+    "one app, many environments"                          => "One App Many Envs",
+    "one app, many similarly-named environments"          => "One App Similarly Named Envs",
+    "two apps, same git uri"                              => "Two Apps Same Git URI",
+  }
+
+  def api_scenario(old_name)
+    clean_eyrc # switching scenarios, always clean up
+    name = DEPRECATED_SCENARIOS[old_name]
+    @scenario = EY::CloudClient::Test::Scenario[name]
+    @scenario_email     = @scenario.email
+    @scenario_password  = @scenario.password
+    @scenario_api_token = @scenario.api_token
+    @scenario
+  end
+
+  def login_scenario(scenario_name)
+    scen = api_scenario(scenario_name)
+    write_eyrc('api_token' => scenario_api_token)
+    scen
+  end
+
+  def scenario_email
+    @scenario_email
+  end
+
+  def scenario_password
+    @scenario_password
+  end
+
+  def scenario_api_token
+    @scenario_api_token
   end
 
   def read_yaml(file)

data/spec/support/matchers.rb

@@ -26,19 +26,3 @@ RSpec::Matchers.define :have_app_code do
     "Expected #has_app_code? to be false on instance: #{instance.inspect}"
   end
 end
-
-RSpec::Matchers.define :resolve_to do |expected|
-  match do |pair|
-    app, env = *pair
-    app.name == expected[:app_name] && env.name == expected[:environment_name]
-  end
-
-  failure_message_for_should do |pair|
-    app, env = *pair
-    "Expected: #{expected[:app_name]}, #{expected[:environment_name]}; Got: #{app.name}, #{env.name}"
-  end
-
-  failure_message_for_should_not do |pair|
-    "Expected to not match: #{expected[:app_name]}, #{expected[:environment_name]}"
-  end
-end

data/spec/support/shared_behavior.rb

@@ -9,7 +9,7 @@ shared_examples_for "it has an ambiguous git repo" do
   use_git_repo('dup test')
 
   before(:all) do
-    api_scenario "two apps, same git uri"
+    login_scenario "two apps, same git uri"
   end
 end
 
@@ -18,10 +18,9 @@ shared_examples_for "it requires an unambiguous git repo" do
 
   it "lists disambiguating environments to choose from" do
     run_ey({}, {:expect_failure => true})
-    @err.should =~ /ambiguous/
-    @err.should =~ /specify one of the following environments/
-    @err.should =~ /giblets \(main\)/
-    @err.should =~ /keycollector_production \(main\)/
+    @err.should include('Multiple environments possible, please be more specific')
+    @err.should =~ /giblets/
+    @err.should =~ /keycollector_production/
   end
 end
 
@@ -29,16 +28,28 @@ shared_examples_for "it takes an environment name and an app name and an account
   include_examples "it takes an app name"
   include_examples "it takes an environment name"
 
+  it "complains when you send --account without a value" do
+    login_scenario "empty"
+    fast_failing_ey command_to_run({}) << '--account'
+    @err.should include("No value provided for option '--account'")
+    fast_failing_ey command_to_run({}) << '-c'
+    @err.should include("No value provided for option '--account'")
+  end
+
   context "when multiple accounts with collaboration" do
     before :all do
-      api_scenario "two accounts, two apps, two environments, ambiguous"
+      login_scenario "two accounts, two apps, two environments, ambiguous"
     end
 
     it "fails when the app and environment are ambiguous across accounts" do
-      run_ey({:environment => "giblets", :app => "rails232app", :ref => 'master'}, {:expect_failure => true})
-      @err.should match(/Multiple app deployments possible/i)
-      @err.should match(/ey \S+ --environment='giblets' --app='rails232app' --account='account_2'/i)
-      @err.should match(/ey \S+ --environment='giblets' --app='rails232app' --account='main'/i)
+      run_ey({:environment => "giblets", :app => "rails232app", :ref => 'master'}, {:expect_failure => !@succeeds_on_multiple_matches})
+      if @succeeds_on_multiple_matches
+        @err.should_not match(/multiple/i)
+      else
+        @err.should match(/Multiple application environments possible/i)
+        @err.should match(/ey \S+ --account='account_2' --app='rails232app' --environment='giblets'/i)
+        @err.should match(/ey \S+ --account='main' --app='rails232app' --environment='giblets'/i)
+      end
     end
 
     it "runs when specifying the account disambiguates the app to deploy" do
@@ -56,9 +67,17 @@ end
 shared_examples_for "it takes an environment name and an account name" do
   include_examples "it takes an environment name"
 
+  it "complains when you send --account without a value" do
+    login_scenario "empty"
+    fast_failing_ey command_to_run({}) << '--account'
+    @err.should include("No value provided for option '--account'")
+    fast_failing_ey command_to_run({}) << '-c'
+    @err.should include("No value provided for option '--account'")
+  end
+
   context "when multiple accounts with collaboration" do
     before :all do
-      api_scenario "two accounts, two apps, two environments, ambiguous"
+      login_scenario "two accounts, two apps, two environments, ambiguous"
     end
 
     it "fails when the app and environment are ambiguous across accounts" do
@@ -86,9 +105,8 @@ shared_examples_for "it takes an environment name and an account name" do
       end
 
       it "returns the error message to the user" do
-        lambda do
-          fast_ey(command_to_run({:environment => "giblets", :account => "main"}))
-        end.should raise_error(EY::Error, /400.*Important infos/)
+        fast_failing_ey(command_to_run({:environment => "giblets", :account => "main"}))
+        @err.should match(/400.*Important infos/)
       end
     end
 
@@ -97,8 +115,8 @@ end
 
 shared_examples_for "it takes an environment name" do
   it "operates on the current environment by default" do
-    api_scenario "one app, one environment"
-    run_ey({:environment => nil}, {:debug => true})
+    login_scenario "one app, one environment"
+    run_ey(:environment => nil)
     verify_ran(make_scenario({
           :environment      => 'giblets',
           :application      => 'rails232app',
@@ -108,9 +126,18 @@ shared_examples_for "it takes an environment name" do
   end
 
   it "complains when you specify a nonexistent environment" do
-    api_scenario "one app, one environment"
-    run_ey({:environment => 'typo-happens-here'}, {:expect_failure => true})
-    @err.should match(/no environment named 'typo-happens-here'/i)
+    login_scenario "one app, one environment"
+    # This test must shell out (not sure why, plz FIXME)
+    ey command_to_run(:environment => 'typo-happens-here'), {:expect_failure => true}
+    @err.should match(/No environment found matching .*typo-happens-here/i)
+  end
+
+  it "complains when you send --environment without a value" do
+    login_scenario "empty"
+    fast_failing_ey command_to_run({}) << '--environment'
+    @err.should include("No value provided for option '--environment'")
+    fast_failing_ey command_to_run({}) << '-e'
+    @err.should include("No value provided for option '--environment'")
   end
 
   context "outside a git repo" do
@@ -126,7 +153,7 @@ shared_examples_for "it takes an environment name" do
     use_git_repo("not actually a git repo")
 
     before :all do
-      api_scenario "one app, one environment"
+      login_scenario "one app, one environment"
     end
 
     it "works (and does not complain about git remotes)" do
@@ -137,44 +164,57 @@ shared_examples_for "it takes an environment name" do
 
   context "given a piece of the environment name" do
     before(:all) do
-      api_scenario "one app, many similarly-named environments"
+      login_scenario "one app, many similarly-named environments"
     end
 
     it "complains when the substring is ambiguous" do
-      run_ey({:environment => 'staging'}, {:expect_failure => true})
-      if @takes_app_name
-        @err.should match(/multiple app deployments possible/i)
+      run_ey({:environment => 'staging'}, {:expect_failure => !@succeeds_on_multiple_matches})
+
+      if @succeeds_on_multiple_matches
+        @err.should_not match(/multiple .* possible/i)
       else
-        @err.should match(/multiple environments possible/i)
+        if @takes_app_name
+          @err.should match(/multiple application environments possible/i)
+        else
+          @err.should match(/multiple environments possible/i)
+        end
       end
     end
 
     it "works when the substring is unambiguous" do
-      api_scenario "one app, many similarly-named environments"
-      run_ey({:environment => 'prod'}, {:debug => true})
+      login_scenario "one app, many similarly-named environments"
+      run_ey({:environment => 'prod', :migrate => true}, {:debug => true})
       verify_ran(make_scenario({
-            :environment      => 'railsapp_production',
-            :application      => 'rails232app',
-            :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
-            :ssh_username     => 'turkey',
-          }))
+        :environment      => 'railsapp_production',
+        :application      => 'rails232app',
+        :master_hostname  => 'app_master_hostname.compute-1.amazonaws.com',
+        :ssh_username     => 'turkey',
+      }))
     end
   end
 
   it "complains when it can't guess the environment and its name isn't specified" do
-    api_scenario "one app, one environment, not linked"
+    login_scenario "one app without environment"
     run_ey({:environment => nil}, {:expect_failure => true})
-    @err.should match(/there is no application configured/i)
+    @err.should match(/No environment found for applications matching remotes:/i)
   end
 end
 
 shared_examples_for "it takes an app name" do
   before { @takes_app_name = true }
 
+  it "complains when you send --app without a value" do
+    login_scenario "empty"
+    fast_failing_ey command_to_run({}) << '--app'
+    @err.should include("No value provided for option '--app'")
+    fast_failing_ey command_to_run({}) << '-a'
+    @err.should include("No value provided for option '--app'")
+  end
+
   it "allows you to specify a valid app" do
-    api_scenario "one app, one environment"
+    login_scenario "one app, one environment"
     Dir.chdir(Dir.tmpdir) do
-      run_ey({:environment => 'giblets', :app => 'rails232app', :ref => 'master'}, {})
+      run_ey({:environment => 'giblets', :app => 'rails232app', :ref => 'master', :migrate => nil}, {})
       verify_ran(make_scenario({
             :environment      => 'giblets',
             :application      => 'rails232app',
@@ -185,9 +225,9 @@ shared_examples_for "it takes an app name" do
   end
 
   it "can guess the environment from the app" do
-    api_scenario "two apps"
+    login_scenario "two apps"
     Dir.chdir(Dir.tmpdir) do
-      run_ey({:app => 'rails232app', :ref => 'master'}, {})
+      run_ey({:app => 'rails232app', :ref => 'master', :migrate => true}, {})
       verify_ran(make_scenario({
             :environment      => 'giblets',
             :application      => 'rails232app',
@@ -198,10 +238,10 @@ shared_examples_for "it takes an app name" do
   end
 
   it "complains when you specify a nonexistant app" do
-    api_scenario "one app, one environment"
+    login_scenario "one app, one environment"
     run_ey({:environment => 'giblets', :app => 'P-time-SAT-solver', :ref => 'master'},
       {:expect_failure => true})
-    @err.should =~ /no app.*P-time-SAT-solver/i
+    @err.should =~ /No app.*P-time-SAT-solver/i
   end
 
 end
@@ -209,7 +249,7 @@ end
 shared_examples_for "it invokes engineyard-serverside" do
   context "with arguments" do
     before(:all) do
-      api_scenario "one app, one environment"
+      login_scenario "one app, one environment"
       run_ey({:environment => 'giblets', :verbose => true})
     end
 
@@ -239,8 +279,8 @@ shared_examples_for "it invokes engineyard-serverside" do
 
   context "when no instances have names" do
     before(:each) do
-      api_scenario "two apps"
-      run_ey({:env => 'giblets', :app => 'rails232app', :ref => 'master', :verbose => true})
+      login_scenario "two apps"
+      run_ey({:env => 'giblets', :app => 'rails232app', :ref => 'master', :migrate => true, :verbose => true})
     end
 
     it "omits the --instance-names parameter" do
@@ -248,63 +288,3 @@ shared_examples_for "it invokes engineyard-serverside" do
     end
   end
 end
-
-shared_examples_for "model collections" do
-  describe "#match_one" do
-    it "works when given an unambiguous substring" do
-      @collection.match_one("prod").name.should == "app_production"
-    end
-
-    it "raises an error when given an ambiguous substring" do
-      lambda {
-        @collection.match_one("staging")
-      }.should raise_error(@collection_class.ambiguous_error)
-    end
-
-    it "returns an exact match if one exists" do
-      @collection.match_one("app_staging").name.should == "app_staging"
-    end
-
-    it "returns nil when it can't find anything" do
-      @collection.match_one("dev-and-production").should be_nil
-    end
-  end
-
-  describe "#match_one!" do
-    it "works when given an unambiguous substring" do
-      @collection.match_one!("prod").name.should == "app_production"
-    end
-
-    it "raises an error when given an ambiguous substring" do
-      lambda {
-        @collection.match_one!("staging")
-      }.should raise_error(@collection_class.ambiguous_error)
-    end
-
-    it "returns an exact match if one exists" do
-      @collection.match_one!("app_staging").name.should == "app_staging"
-    end
-
-    it "raises an error when given an ambiguous exact string" do
-      lambda {
-        @collection.match_one!("app_duplicate")
-      }.should raise_error(@collection_class.ambiguous_error)
-    end
-
-    it "raises an error when it can't find anything" do
-      lambda {
-        @collection.match_one!("dev-and-production")
-      }.should raise_error(@collection_class.invalid_error)
-    end
-  end
-
-  describe "#named" do
-    it "finds matching by name" do
-      @collection.named("app_staging").name.should == "app_staging"
-    end
-
-    it "returns nil when no name matches" do
-      @collection.named("something else").should be_nil
-    end
-  end
-end