engineyard 1.3.1 → 1.3.2

data/lib/engineyard/thor.rb

@@ -11,28 +11,24 @@ module EY
       @repo ||= EY::Repo.new
     end
 
-    # if an app is supplied, it is used as a constraint for implied environment lookup
-    def fetch_environment(env_name, app = nil)
-      env_name ||= EY.config.default_environment
-      if env_name
-        (app || api).environments.match_one!(env_name)
-      else
-        (app || api.app_for_repo!(repo)).sole_environment!
-      end
-    end
-
-    def fetch_environment_without_app(env_name)
-      fetch_environment(env_name)
-    rescue EY::AmbiguousGitUriError
-      raise EY::AmbiguousEnvironmentGitUriError.new(api.environments)
+    def fetch_environment(environment_name, account_name=nil)
+      environment_name ||= EY.config.default_environment
+      options = {
+        :environment_name => environment_name,
+        :account_name => account_name
+      }
+      options.merge! :repo => repo if repo.exists?
+      api.resolver.environment(options)
     end
 
-    def fetch_app(app_name = nil)
-      if app_name
-        api.apps.match_one!(app_name)
-      else
-        api.app_for_repo!(repo)
-      end
+    def fetch_app_and_environment(app_name = nil, environment_name = nil, account_name=nil)
+      options = {
+        :app_name => app_name,
+        :environment_name => environment_name,
+        :account_name => account_name
+      }
+      options.merge! :repo => repo if repo.exists?
+      api.resolver.app_and_environment(options)
     end
 
     def get_apps(all_apps = false)

data/lib/engineyard/version.rb

@@ -1,3 +1,3 @@
 module EY
-  VERSION = '1.3.1'
+  VERSION = '1.3.2'
 end

data/spec/engineyard/api_spec.rb

@@ -53,34 +53,4 @@ describe EY::API do
     }.should raise_error(EY::Error)
   end
 
-  it "raises an error when using a git repo that is attached to multiple applications" do
-    repo = mock("repo", :urls => %w[git://github.com/engineyard/dup.git])
-    apps = {"apps" => [
-                      {"id" => 1234, "name" => "app_production", :repository_uri => 'git://github.com/engineyard/prod.git'},
-                      {"id" => 4532, "name" => "app_dup1", :repository_uri => 'git://github.com/engineyard/dup.git'},
-                      {"id" => 4533, "name" => "app_dup2", :repository_uri => 'git://github.com/engineyard/dup.git'},
-                     ]}
-
-    FakeWeb.register_uri(:get, "https://cloud.engineyard.com/api/v2/apps", :status => 200, :content_type => 'application/json',
-                         :body => apps.to_json)
-
-    lambda do
-      EY::API.new("asdf").app_for_repo(repo)
-    end.should raise_error(EY::AmbiguousGitUriError)
-  end
-
-  it "returns the application when given a unique git repo" do
-    repo = mock("repo", :urls => %w[git://github.com/engineyard/prod.git])
-    apps = {"apps" => [
-                      {"id" => 1234, "name" => "app_production", :repository_uri => 'git://github.com/engineyard/prod.git'},
-                      {"id" => 4532, "name" => "app_dup1", :repository_uri => 'git://github.com/engineyard/dup.git'},
-                      {"id" => 4533, "name" => "app_dup2", :repository_uri => 'git://github.com/engineyard/dup.git'},
-                     ]}
-
-    FakeWeb.register_uri(:get, "https://cloud.engineyard.com/api/v2/apps", :status => 200, :content_type => 'application/json',
-                         :body => apps.to_json)
-
-    EY::API.new("asdf").app_for_repo(repo).name.should == "app_production"
-  end
-
 end

data/spec/engineyard/resolver_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe EY::Resolver do
+  def api
+    return @api if @api
+    apps = Object.new
+    def apps.named(name, *args)
+      result = EY::Model::App.from_hash(:name => name)
+      result.stub!(:environments => [])
+      result
+    end
+    environments = Object.new
+    def environments.named(name, *args)
+      result = EY::Model::Environment.from_hash(:name => name)
+      result.stub!(:apps => [])
+      result
+    end
+    @api = mock("api", :apps => apps, :environments => environments)
+  end
+
+  def resolver
+    @resolver ||= EY::Resolver.new(api).tap do |r|
+      r.instance_variable_set("@app_deployments", [])
+    end
+  end
+
+  def new_app_deployment(options)
+    resolver.instance_variable_get("@app_deployments") << options
+    options
+  end
+
+
+  before do
+    @production = new_app_deployment(:environment_name => "app_production", :app_name => "app",           :account_name => "ey", :repository_uri => "git://github.com/repo/app.git")
+    @staging    = new_app_deployment(:environment_name => "app_staging"   , :app_name => "app",           :account_name => "ey", :repository_uri => "git://github.com/repo/app.git")
+    @big        = new_app_deployment(:environment_name => "bigapp_staging", :app_name => "bigapp",        :account_name => "ey", :repository_uri => "git://github.com/repo/bigapp.git")
+    @ey_dup     = new_app_deployment(:environment_name => "app_duplicate" , :app_name => "app_duplicate", :account_name => "ey", :repository_uri => "git://github.com/repo/dup.git")
+    @sumo       = new_app_deployment(:environment_name => "sumo_wrestler" , :app_name => "app_duplicate", :account_name => "ey", :repository_uri => "git://github.com/repo/dup.git")
+    @me_dup     = new_app_deployment(:environment_name => "app_duplicate" , :app_name => "app_duplicate", :account_name => "me", :repository_uri => "git://github.com/repo/dup.git")
+  end
+
+  def repo(url)
+    mock("repo", :urls => [url])
+  end
+
+  def resolve_to(expected)
+    simple_matcher "resolve to" do |(app,environment), _|
+      app.name.should == expected[:app_name]
+      environment.name.should == expected[:environment_name]
+    end
+  end
+
+  describe "#fetch" do
+    it "raises argument error if the conditions are empty" do
+      lambda { resolver.app_and_environment({}) }.should raise_error(ArgumentError)
+    end
+
+    it "raises when there is no app match" do
+      lambda { resolver.app_and_environment(:environment_name => 'app_duplicate', :app_name => 'smallapp') }.should raise_error(EY::InvalidAppError)
+    end
+
+    it "raises when the git repo does not match any apps" do
+      lambda { resolver.app_and_environment(:environment_name => 'app_duplicate', :repo => repo("git://github.com/no-such/app.git")) }.should raise_error(EY::NoAppError)
+    end
+
+    it "raises when there is no environment match" do
+      lambda { resolver.app_and_environment(:environment_name => 'gibberish', :app_name => 'app') }.should raise_error(EY::NoEnvironmentError)
+    end
+
+    it "raises when there are no matches" do
+      lambda { resolver.app_and_environment(:environment_name => 'app_duplicate', :app_name => 'bigapp') }.should raise_error(EY::NoMatchesError)
+      lambda { resolver.app_and_environment(:repo => repo("git://github.com/repo/app.git"), :environment_name => 'app_duplicate') }.should raise_error(EY::NoMatchesError)
+    end
+
+    it "raises when there is more than one match" do
+      lambda { resolver.app_and_environment(:app_name => "app") }.should raise_error(EY::MultipleMatchesError)
+      lambda { resolver.app_and_environment(:account_name => "ey", :app_name => "app") }.should raise_error(EY::MultipleMatchesError)
+      lambda { resolver.app_and_environment(:repo => repo("git://github.com/repo/dup.git")) }.should raise_error(EY::MultipleMatchesError)
+      lambda { resolver.app_and_environment(:repo => repo("git://github.com/repo/app.git")) }.should raise_error(EY::MultipleMatchesError)
+    end
+
+    it "does not include duplicate copies of apps across accounts when raising a more than one match error" do
+      do_include = "--environment='sumo_wrestler' --app='app_duplicate' --account='ey'"
+      do_not_include = "--environment='sumo_wrestler' --app='app_duplicate' --account='me'"
+      lambda do
+        resolver.app_and_environment(:repo => repo("git://github.com/repo/dup.git"))
+      end.should raise_error(EY::MultipleMatchesError) {|e|
+        e.message.should include(do_include)
+        e.message.should_not include(do_not_include)
+      }
+    end
+
+    it "returns one deployment whene there is only one match" do
+      resolver.app_and_environment(:account_name => "ey", :app_name => "big").should resolve_to(@big)
+      resolver.app_and_environment(:environment_name => "production").should resolve_to(@production)
+      resolver.app_and_environment(:repo => repo("git://github.com/repo/bigapp.git")).should resolve_to(@big)
+      resolver.app_and_environment(:repo => repo("git://github.com/repo/app.git"), :environment_name => "staging").should resolve_to(@staging)
+    end
+
+    it "returns the match when an app is specified even when there is a repo" do
+      resolver.app_and_environment(:account_name => "ey", :app_name => "bigapp", :repo => repo("git://github.com/repo/app.git")).should resolve_to(@big)
+    end
+
+    it "returns the specific match even if there is a partial match" do
+      resolver.app_and_environment(:environment_name => 'app_staging', :app_name => 'app').should resolve_to(@staging)
+      resolver.app_and_environment(:environment_name => "app_staging").should resolve_to(@staging)
+      resolver.app_and_environment(:app_name => "app", :environment_name => "staging").should resolve_to(@staging)
+    end
+
+    it "scopes searches under the correct account" do
+      resolver.app_and_environment(:account_name => "ey", :environment_name => "dup", :app_name => "dup").should resolve_to(@ey_dup)
+      resolver.app_and_environment(:account_name => "me", :environment_name => "dup").should resolve_to(@me_dup)
+      resolver.app_and_environment(:account_name => "me", :app_name => "dup").should resolve_to(@me_dup)
+    end
+  end
+end

data/spec/ey/deploy_spec.rb

@@ -26,12 +26,13 @@ end
 describe "ey deploy" do
   given "integration"
 
-  def command_to_run(options)
+  def command_to_run(opts)
     cmd = "deploy"
-    cmd << " --environment #{options[:env]}" if options[:env]
-    cmd << " --app #{options[:app]}" if options[:app]
-    cmd << " --ref #{options[:ref]}" if options[:ref]
-    cmd << " --verbose" if options[:verbose]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --app #{opts[:app]}" if opts[:app]
+    cmd << " --account #{opts[:account]}" if opts[:account]
+    cmd << " --ref #{opts[:ref]}" if opts[:ref]
+    cmd << " --verbose" if opts[:verbose]
     cmd
   end
 
@@ -41,8 +42,7 @@ describe "ey deploy" do
   end
 
   # common behavior
-  it_should_behave_like "it takes an environment name"
-  it_should_behave_like "it takes an app name"
+  it_should_behave_like "it takes an environment name and an app name and an account name"
   it_should_behave_like "it invokes engineyard-serverside"
 end
 
@@ -59,13 +59,13 @@ describe "ey deploy" do
     it "complains when the specified environment does not contain the app" do
       api_scenario "one app, one environment, not linked"
       ey "deploy -e giblets -r master", :expect_failure => true
-      @err.should match(/does not run this application/i)
+      @err.should match(/there is no application configured/i)
     end
 
     it "complains when environment is not specified and app is in >1 environment" do
       api_scenario "one app, many environments"
       ey "deploy", :expect_failure => true
-      @err.should match(/single environment.*2/i)
+      @err.should match(/multiple app deployments possible/i)
     end
 
     it "complains when the app master is in a non-running state" do
@@ -354,4 +354,5 @@ describe "ey deploy" do
       @deploy_command.should =~ /--stack nginx_mongrel/
     end
   end
+
 end

data/spec/ey/list_environments_spec.rb

@@ -10,6 +10,7 @@ describe "ey environments" do
 
   it "lists the environments your app is in" do
     ey "environments"
+    @out.should include('rails232app (main)')
     @out.should =~ /giblets/
     @out.should =~ /bakon/
   end

data/spec/ey/logs_spec.rb

@@ -14,7 +14,7 @@ describe "ey logs" do
   it "complains when it can't infer the environment" do
     api_scenario "one app, many environments"
     ey "logs", :expect_failure => true
-    @err.should =~ /single environment/
+    @err.should =~ /repository url in this directory is ambiguous/i
   end
 end
 
@@ -23,7 +23,8 @@ describe "ey logs" do
 
   def command_to_run(opts)
     cmd = "logs"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -31,5 +32,5 @@ describe "ey logs" do
     @out.should match(/Main logs for #{scenario[:environment]}/)
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end

data/spec/ey/rebuild_spec.rb

@@ -5,7 +5,8 @@ describe "ey rebuild" do
 
   def command_to_run(opts)
     cmd = "rebuild"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -13,5 +14,5 @@ describe "ey rebuild" do
     @out.should =~ /Rebuilding #{scenario[:environment]}/
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end

data/spec/ey/recipes/apply_spec.rb

@@ -5,7 +5,8 @@ describe "ey recipes apply" do
 
   def command_to_run(opts)
     cmd = "recipes apply"
-    cmd << " -e #{opts[:env]}" if opts[:env]
+    cmd << " -e #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -13,7 +14,7 @@ describe "ey recipes apply" do
     @out.should =~ /Uploaded recipes started for #{scenario[:environment]}/
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end
 
 describe "ey recipes apply with an ambiguous git repo" do

data/spec/ey/recipes/download_spec.rb

@@ -2,14 +2,22 @@ require 'spec_helper'
 
 describe "ey recipes download" do
   given "integration"
+  use_git_repo('default')
 
-  after(:each) do
+  before(:each) do
     FileUtils.rm_rf('cookbooks')
   end
 
+  after(:each) do
+    # This test creates + destroys the cookbooks/ directory, thus
+    # rendering the git repo unsuitable for reuse.
+    refresh_git_repo('default')
+  end
+
   def command_to_run(opts)
     cmd = "recipes download"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -18,7 +26,7 @@ describe "ey recipes download" do
     File.read('cookbooks/README').should == "Remove this file to clone an upstream git repository of cookbooks\n"
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 
   it "fails when cookbooks/ already exists" do
     api_scenario "one app, one environment"

data/spec/ey/recipes/upload_spec.rb

@@ -11,7 +11,8 @@ describe "ey recipes upload" do
 
   def command_to_run(opts)
     cmd = "recipes upload"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -19,7 +20,7 @@ describe "ey recipes upload" do
     @out.should =~ /Recipes uploaded successfully for #{scenario[:environment]}/
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end
 
 describe "ey recipes upload with an ambiguous git repo" do

data/spec/ey/rollback_spec.rb

@@ -5,8 +5,9 @@ describe "ey rollback" do
 
   def command_to_run(opts)
     cmd = "rollback"
-    cmd << " -e #{opts[:env]}" if opts[:env]
+    cmd << " -e #{opts[:environment]}" if opts[:environment]
     cmd << " -a #{opts[:app]}" if opts[:app]
+    cmd << " -c #{opts[:account]}" if opts[:account]
     cmd << " --verbose" if opts[:verbose]
     cmd
   end
@@ -17,8 +18,7 @@ describe "ey rollback" do
     @ssh_commands.last.should match(/engineyard-serverside.*deploy rollback.*--app #{scenario[:application]}/)
   end
 
-  it_should_behave_like "it takes an environment name"
-  it_should_behave_like "it takes an app name"
+  it_should_behave_like "it takes an environment name and an app name and an account name"
   it_should_behave_like "it invokes engineyard-serverside"
 
   it "passes along the web server stack to engineyard-serverside" do

data/spec/ey/ssh_spec.rb

@@ -22,13 +22,13 @@ shared_examples_for "running ey ssh for select role" do
   def command_to_run(opts)
     cmd = "ssh #{opts[:ssh_command]}"
     cmd << " #{@ssh_flag}"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
     cmd
   end
 
   it "runs the command on the right servers" do
     api_scenario "one app, one environment"
-    run_ey(:ssh_command => "ls", :env => 'giblets', :verbose => true)
+    run_ey(:ssh_command => "ls", :environment => 'giblets', :verbose => true)
     @hosts.each do |host|
       @raw_ssh_commands.select do |command|
         command =~ /^ssh turkey@#{host}.+ ls$/
@@ -41,13 +41,13 @@ shared_examples_for "running ey ssh for select role" do
 
   it "raises an error when there are no matching hosts" do
     api_scenario "one app, one environment, no instances"
-    run_ey({:ssh_command => "ls", :env => 'giblets', :verbose => true}, :expect_failure => true)
+    run_ey({:ssh_command => "ls", :environment => 'giblets', :verbose => true}, :expect_failure => true)
   end
 
   it "responds correctly when there is no command" do
     if @hosts.count != 1
       api_scenario "one app, one environment"
-      run_ey({:env => 'giblets', :verbose => true}, :expect_failure => true)
+      run_ey({:environment => 'giblets', :verbose => true}, :expect_failure => true)
     end
   end
 end
@@ -77,7 +77,8 @@ describe "ey ssh without a command" do
 
   def command_to_run(opts)
     cmd = "ssh"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -86,7 +87,7 @@ describe "ey ssh without a command" do
     @raw_ssh_commands.should == ["ssh #{ssh_target}"]
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end
 
 describe "ey ssh with a command" do
@@ -94,7 +95,8 @@ describe "ey ssh with a command" do
 
   def command_to_run(opts)
     cmd = "ssh ls"
-    cmd << " --environment #{opts[:env]}" if opts[:env]
+    cmd << " --environment #{opts[:environment]}" if opts[:environment]
+    cmd << " --account #{opts[:account]}" if opts[:account]
     cmd
   end
 
@@ -103,7 +105,7 @@ describe "ey ssh with a command" do
     @raw_ssh_commands.should == ["ssh #{ssh_target} ls"]
   end
 
-  it_should_behave_like "it takes an environment name"
+  it_should_behave_like "it takes an environment name and an account name"
 end
 
 describe "ey ssh --all" do