engineyard 3.1.2 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa5f5951ebe7cad41fb763e57467115035698756
-  data.tar.gz: 607f8034d2097f091391b80ab4ac8695bc6fd939
+  metadata.gz: db1c2f9e038b686249fa2d9de438e2a4b15b97e5
+  data.tar.gz: 812ae3efa8e5b4548ef34740ccf76e4f1121a0ce
 SHA512:
-  metadata.gz: f98b5219948d55f06149d1d73aafbea0ebd6fe9d84c7131a6f646b438a533573be8f18e24e58b0ba27071b9c0fb210d425b8cbe5f47f3d8c80dca07adecb12c5
-  data.tar.gz: cf1b674102e9c9dabc0d6c21e92ae45a4c0ff46aca3993e4fb33fe0e5846b2592eba47cb1f11f603f896db3f9bc63a5e91a55e9267b840bfc6395a1f19f2a323
+  metadata.gz: f8e2f9e4d93b5482a9901c5f0074ff19a9ec27d417b2137024894b1ffc21a67dd3a2ffa0bc4d25adec738f9ddb597d4b22217527bc8c056145fe9aae1d5ce577
+  data.tar.gz: bdb090c43460f0e3bbf695f8229485633052456a390e5239377a1a6a162631c5289de1b9506d496026f384c35965261f291d52714c7b38661194e6de5923d0a5

data/lib/engineyard/version.rb

@@ -1,4 +1,4 @@
 module EY
-  VERSION = '3.1.2'
-  ENGINEYARD_SERVERSIDE_VERSION = ENV['ENGINEYARD_SERVERSIDE_VERSION'] || '2.6.2'
+  VERSION = '3.1.3'
+  ENGINEYARD_SERVERSIDE_VERSION = ENV['ENGINEYARD_SERVERSIDE_VERSION'] || '2.6.3'
 end

data/spec/engineyard/cli/api_spec.rb

@@ -4,19 +4,19 @@ require 'engineyard/cli'
 describe EY::CLI::API do
   it "gets the api token from ~/.eyrc if possible" do
     write_eyrc({"api_token" => "asdf"})
-    EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token.should == "asdf"
+    expect(EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token).to eq("asdf")
     clean_eyrc
   end
 
   it "uses the token specified token over the ENV token if passed" do
     ENV['ENGINEYARD_API_TOKEN'] = 'envtoken'
-    EY::CLI::API.new('http://fake.local', EY::CLI::UI.new, 'specifiedtoken').token.should == 'specifiedtoken'
+    expect(EY::CLI::API.new('http://fake.local', EY::CLI::UI.new, 'specifiedtoken').token).to eq('specifiedtoken')
     ENV.delete('ENGINEYARD_API_TOKEN')
   end
 
   it "uses the token from $ENGINEYARD_API_TOKEN if set" do
     ENV['ENGINEYARD_API_TOKEN'] = 'envtoken'
-    EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token.should == 'envtoken'
+    expect(EY::CLI::API.new('http://fake.local', EY::CLI::UI.new).token).to eq('envtoken')
     ENV.delete('ENGINEYARD_API_TOKEN')
   end
 
@@ -35,15 +35,15 @@ describe EY::CLI::API do
     end
 
     it "asks you for your credentials" do
-      EY::CLI::UI::Prompter.questions.should == ["Email: ","Password: "]
+      expect(EY::CLI::UI::Prompter.questions).to eq(["Email: ","Password: "])
     end
 
     it "gets the api token" do
-      @api.token.should == "asdf"
+      expect(@api.token).to eq("asdf")
     end
 
     it "saves the api token to ~/.eyrc" do
-      read_eyrc.should == {"api_token" => "asdf"}
+      expect(read_eyrc).to eq({"api_token" => "asdf"})
     end
   end
 

data/spec/engineyard/cli_spec.rb

@@ -8,9 +8,9 @@ describe EY::CLI do
       EY::CLI.start(["help"])
     end
 
-    out.should include("ey deploy")
-    out.should include("ey ssh")
-    out.should include("ey web enable")
+    expect(out).to include("ey deploy")
+    expect(out).to include("ey ssh")
+    expect(out).to include("ey web enable")
   end
 
   it "delegates help" do
@@ -18,11 +18,11 @@ describe EY::CLI do
       EY::CLI.start(%w[help web enable])
     end
 
-    out.should match(/remove the maintenance page/i)
+    expect(out).to match(/remove the maintenance page/i)
   end
 
   it "provides error classes" do
-    EY::DeployArgumentError.should be
+    expect(EY::DeployArgumentError).to be
   end
 
 end # EY::CLI

data/spec/engineyard/config_spec.rb

@@ -7,12 +7,12 @@ describe EY::Config do
 
     it "get loaded from the config file" do
       write_yaml({"environments" => {"production" => {"default" => true}}}, 'ey.yml')
-      EY::Config.new.environments["production"]["default"].should be_true
+      expect(EY::Config.new.environments["production"]["default"]).to be_truthy
     end
 
     it "are present when the config file has no environments key" do
       write_yaml({}, 'ey.yml')
-      EY::Config.new.environments.should == {}
+      expect(EY::Config.new.environments).to eq({})
     end
 
     it "rases an error when yaml produces an unexpected result" do
@@ -22,18 +22,18 @@ describe EY::Config do
 
     it "doesnt crash on nil environment" do
       write_yaml({"environments" => {"production" => nil}}, 'ey.yml')
-      EY::Config.new.default_environment.should be_nil
+      expect(EY::Config.new.default_environment).to be_nil
     end
   end
 
   describe "endpoint" do
     it "defaults to production Engine Yard Cloud" do
-      EY::Config.new.endpoint.should == EY::Config.new.default_endpoint
+      expect(EY::Config.new.endpoint).to eq(EY::Config.new.default_endpoint)
     end
 
     it "loads the endpoint from $CLOUD_URL" do
       ENV['CLOUD_URL'] = "http://fake.local/"
-      EY::Config.new.endpoint.should == 'http://fake.local/'
+      expect(EY::Config.new.endpoint).to eq('http://fake.local/')
       ENV.delete('CLOUD_URL')
     end
   end
@@ -44,7 +44,7 @@ describe EY::Config do
 
       write_yaml({"environments" => {"staging"    => {"default" => true}}}, "ey.yml")
       write_yaml({"environments" => {"production" => {"default" => true}}}, "config/ey.yml")
-      EY::Config.new.default_environment.should == "production"
+      expect(EY::Config.new.default_environment).to eq("production")
 
       File.unlink('config/ey.yml') if File.exist?('config/ey.yml')
       File.unlink('ey.yml') if File.exist?('ey.yml')
@@ -53,7 +53,7 @@ describe EY::Config do
     it "looks for ey.yml" do
       write_yaml({"environments" => {"staging" => {"default" => true}}}, "ey.yml")
 
-      EY::Config.new.default_environment.should == "staging"
+      expect(EY::Config.new.default_environment).to eq("staging")
 
       File.unlink('ey.yml') if File.exist?('ey.yml')
     end

data/spec/engineyard/deploy_config_spec.rb

@@ -31,20 +31,20 @@ describe EY::DeployConfig do
     context "with the migrate cli option" do
       it "returns default command when true" do
         dc = deploy_config({'migrate' => true})
-        dc.migrate.should be_true
+        expect(dc.migrate).to be_truthy
         expect { dc.migrate_command }.to raise_error(EY::Error, /'migration_command' not found/)
       end
 
       it "returns false when nil" do
         dc = deploy_config({'migrate' => nil})
-        dc.migrate.should be_false
-        dc.migrate_command.should be_nil
+        expect(dc.migrate).to be_falsey
+        expect(dc.migrate_command).to be_nil
       end
 
       it "return the custom migration command when is a string" do
         dc = deploy_config({'migrate' => 'foo migrate'})
-        dc.migrate.should be_true
-        dc.migrate_command.should == 'foo migrate'
+        expect(dc.migrate).to be_truthy
+        expect(dc.migrate_command).to eq('foo migrate')
       end
     end
 
@@ -52,47 +52,47 @@ describe EY::DeployConfig do
       it "return the migration command when the option is true" do
         env = env_config('migrate' => true, 'migration_command' => 'bar migrate')
         dc = deploy_config({}, env)
-        dc.migrate.should be_true
-        dc.migrate_command.should == 'bar migrate'
+        expect(dc.migrate).to be_truthy
+        expect(dc.migrate_command).to eq('bar migrate')
       end
 
       it "return the false when migrate is false" do
         env = env_config('migrate' => false, 'migration_command' => 'bar migrate')
         dc = deploy_config({}, env)
-        dc.migrate.should be_false
-        dc.migrate_command.should be_nil
+        expect(dc.migrate).to be_falsey
+        expect(dc.migrate_command).to be_nil
       end
 
       it "tells you to run ey init" do
         env = env_config('migrate' => true)
         dc = deploy_config({}, env)
-        expect(dc.migrate).to be_true
+        expect(dc.migrate).to be_truthy
         expect { dc.migrate_command }.to raise_error(EY::Error, /'migration_command' not found/)
       end
 
       it "return the ey.yml migration_command when command line option --migrate is passed" do
         env = env_config('migrate' => false, 'migration_command' => 'bar migrate')
         dc = deploy_config({'migrate' => true}, env)
-        dc.migrate.should be_true
-        dc.migrate_command.should == 'bar migrate'
+        expect(dc.migrate).to be_truthy
+        expect(dc.migrate_command).to eq('bar migrate')
       end
     end
 
     describe "ref" do
       it "returns the passed ref" do
-        deploy_config({'ref' => 'master'}).ref.should == 'master'
+        expect(deploy_config({'ref' => 'master'}).ref).to eq('master')
       end
 
       it "returns the passed force_ref" do
-        deploy_config({'force_ref' => 'force'}).ref.should == 'force'
+        expect(deploy_config({'force_ref' => 'force'}).ref).to eq('force')
       end
 
       it "returns the ref if force_ref is true" do
-        deploy_config({'ref' => 'master', 'force_ref' => true}).ref.should == 'master'
+        expect(deploy_config({'ref' => 'master', 'force_ref' => true}).ref).to eq('master')
       end
 
       it "overrides the ref if force_ref is set to a string" do
-        deploy_config({'ref' => 'master', 'force_ref' => 'force'}).ref.should == 'force'
+        expect(deploy_config({'ref' => 'master', 'force_ref' => 'force'}).ref).to eq('force')
       end
 
       context "with a default branch" do
@@ -100,41 +100,41 @@ describe EY::DeployConfig do
 
         it "uses the configured default if ref is not passed" do
           out = capture_stdout do
-            deploy_config({}).ref.should == 'default'
+            expect(deploy_config({}).ref).to eq('default')
           end
-          out.should =~ /Using default branch "default" from ey.yml/
+          expect(out).to match(/Using default branch "default" from ey.yml/)
         end
 
         it "raises if a default is set and --ref is passed on the cli (and they don't match)" do
-          lambda { deploy_config({'ref' => 'master'}).ref }.should raise_error(EY::BranchMismatchError)
+          expect { deploy_config({'ref' => 'master'}).ref }.to raise_error(EY::BranchMismatchError)
         end
 
         it "returns the default if a default is set and --ref is the same" do
-          deploy_config({'ref' => 'default'}).ref.should == 'default'
+          expect(deploy_config({'ref' => 'default'}).ref).to eq('default')
         end
 
         it "returns the ref if force_ref is set" do
           out = capture_stdout do
-            deploy_config({'ref' => 'master', 'force_ref' => true}).ref.should == 'master'
+            expect(deploy_config({'ref' => 'master', 'force_ref' => true}).ref).to eq('master')
           end
-          out.should =~ /Default ref overridden with "master"/
+          expect(out).to match(/Default ref overridden with "master"/)
         end
 
         it "returns the ref if force_ref is a branch" do
           out = capture_stdout do
-            deploy_config({'force_ref' => 'master'}).ref.should == 'master'
+            expect(deploy_config({'force_ref' => 'master'}).ref).to eq('master')
           end
-          out.should =~ /Default ref overridden with "master"/
+          expect(out).to match(/Default ref overridden with "master"/)
         end
       end
 
       context "no options, no default" do
         it "uses the repo's current branch" do
-          repo.should_receive(:current_branch).and_return('current')
+          expect(repo).to receive(:current_branch).and_return('current')
           out = capture_stdout do
-            deploy_config({}).ref.should == 'current'
+            expect(deploy_config({}).ref).to eq('current')
           end
-          out.should =~ /Using current HEAD branch "current"/
+          expect(out).to match(/Using current HEAD branch "current"/)
         end
       end
     end
@@ -144,50 +144,50 @@ describe EY::DeployConfig do
     describe "migrate" do
       it "returns the default migration command when migrate is true" do
         dc = deploy_config({'app' => 'app', 'migrate' => true})
-        dc.migrate.should be_true
-        dc.migrate_command.should == 'rake db:migrate --trace'
+        expect(dc.migrate).to be_truthy
+        expect(dc.migrate_command).to eq('rake db:migrate --trace')
       end
 
       it "returns false when nil" do
         dc = deploy_config({'app' => 'app', 'migrate' => nil})
-        dc.migrate.should be_false
-        dc.migrate_command.should be_nil
+        expect(dc.migrate).to be_falsey
+        expect(dc.migrate_command).to be_nil
       end
 
       it "return the custom migration command when is a string" do
         dc = deploy_config({'app' => 'app', 'migrate' => 'foo migrate'})
-        dc.migrate.should be_true
-        dc.migrate_command.should == 'foo migrate'
+        expect(dc.migrate).to be_truthy
+        expect(dc.migrate_command).to eq('foo migrate')
       end
 
       it "raises if migrate is not passed" do
-        lambda { deploy_config({'app' => 'app'}).migrate }.should raise_error(EY::RefAndMigrateRequiredOutsideRepo)
+        expect { deploy_config({'app' => 'app'}).migrate }.to raise_error(EY::RefAndMigrateRequiredOutsideRepo)
       end
     end
 
     describe "ref" do
       it "returns the passed ref" do
         dc = deploy_config({'app' => 'app', 'ref' => 'master'})
-        dc.ref.should == 'master'
+        expect(dc.ref).to eq('master')
       end
 
       it "returns the passed force_ref" do
         dc = deploy_config({'app' => 'app', 'force_ref' => 'force'})
-        dc.ref.should == 'force'
+        expect(dc.ref).to eq('force')
       end
 
       it "returns the ref if force_ref is true" do
         dc = deploy_config({'app' => 'app', 'ref' => 'master', 'force_ref' => true})
-        dc.ref.should == 'master'
+        expect(dc.ref).to eq('master')
       end
 
       it "overrides the ref if force_ref is set to a string" do
         dc = deploy_config({'app' => 'app', 'ref' => 'master', 'force_ref' => 'force'})
-        dc.ref.should == 'force'
+        expect(dc.ref).to eq('force')
       end
 
       it "raises if ref is not passed" do
-        lambda { deploy_config({'app' => 'app'}).ref }.should raise_error(EY::RefAndMigrateRequiredOutsideRepo)
+        expect { deploy_config({'app' => 'app'}).ref }.to raise_error(EY::RefAndMigrateRequiredOutsideRepo)
       end
     end
   end

data/spec/engineyard/eyrc_spec.rb

@@ -6,27 +6,27 @@ describe EY::EYRC do
 
   describe ".load" do
     it "looks for .eyrc in $EYRC if set" do
-      EY::EYRC.load.path.should == Pathname.new(ENV['EYRC'])
+      expect(EY::EYRC.load.path).to eq(Pathname.new(ENV['EYRC']))
     end
 
     it "looks for .eyrc in $HOME/.eyrc by default" do
       ENV.delete('EYRC')
-      EY::EYRC.load.path.should == Pathname.new("#{ENV['HOME']}/.eyrc")
+      expect(EY::EYRC.load.path).to eq(Pathname.new("#{ENV['HOME']}/.eyrc"))
     end
   end
 
   describe ".new" do
     it "looks for eyrc in any passed file location" do
-      EY::EYRC.new('/tmp/neweyrc').path.should == Pathname.new('/tmp/neweyrc')
+      expect(EY::EYRC.new('/tmp/neweyrc').path).to eq(Pathname.new('/tmp/neweyrc'))
     end
   end
 
   context "with a non-existing .eyrc file" do
     it "has nil api_token" do
-      File.exists?("/tmp/nonexistant").should be_false
+      expect(File.exists?("/tmp/nonexistant")).to be_falsey
       eyrc = EY::EYRC.new('/tmp/nonexistant')
-      eyrc.exist?.should be_false
-      eyrc.api_token.should be_nil
+      expect(eyrc.exist?).to be_falsey
+      expect(eyrc.api_token).to be_nil
     end
   end
 
@@ -36,20 +36,20 @@ describe EY::EYRC do
     end
 
     it "exists" do
-      EY::EYRC.load.exist?.should be_true
+      expect(EY::EYRC.load.exist?).to be_truthy
     end
 
     it "recalls the api_token" do
-      EY::EYRC.load.api_token.should == 'abcd'
+      expect(EY::EYRC.load.api_token).to eq('abcd')
     end
 
     it "deletes the api_token" do
       EY::EYRC.load.delete_api_token
-      EY::EYRC.load.api_token.should be_nil
+      expect(EY::EYRC.load.api_token).to be_nil
     end
 
     it "writes the api_token to api_token: .eyrc" do
-      read_yaml(ENV['EYRC']).should == {"api_token" => "abcd"}
+      expect(read_yaml(ENV['EYRC'])).to eq({"api_token" => "abcd"})
     end
   end
 
@@ -61,16 +61,16 @@ describe EY::EYRC do
     end
 
     it "recalls the api_token" do
-      EY::EYRC.load.api_token.should == 'abcd'
+      expect(EY::EYRC.load.api_token).to eq('abcd')
     end
 
     it "deletes the api token safely on logout" do
       EY::EYRC.load.delete_api_token
-      read_yaml(ENV['EYRC']).should == {"http://localhost/" => {"api_token" => "5678"}}
+      expect(read_yaml(ENV['EYRC'])).to eq({"http://localhost/" => {"api_token" => "5678"}})
     end
 
     it "maintains other random info in the file" do
-      read_yaml(ENV['EYRC']).should == {"api_token" => "abcd", "http://localhost/" => {"api_token" => "5678"}}
+      expect(read_yaml(ENV['EYRC'])).to eq({"api_token" => "abcd", "http://localhost/" => {"api_token" => "5678"}})
     end
   end
 end

data/spec/engineyard/repo_spec.rb

@@ -23,34 +23,34 @@ describe EY::Repo do
 
   describe ".new" do
     it "creates a working repo object in a repo" do
-      EY::Repo.new.remotes.should be_empty
+      expect(EY::Repo.new.remotes).to be_empty
     end
 
     it "doesn't raise if created outside a repository until trying to do something" do
       ENV['GIT_DIR'] = nil
       Dir.chdir('/tmp') do
         repo = EY::Repo.new
-        lambda { repo.remotes }.should raise_error(EY::Repo::NotAGitRepository)
+        expect { repo.remotes }.to raise_error(EY::Repo::NotAGitRepository)
       end
     end
   end
 
   describe ".exist?" do
     it "is true when env vars are set to a repo" do
-      EY::Repo.should be_exist
+      expect(EY::Repo).to be_exist
     end
 
     it "is true when pwd is a repo" do
       Dir.chdir(File.dirname(ENV['GIT_DIR'])) do
         ENV['GIT_DIR'] = nil
-        EY::Repo.should be_exist
+        expect(EY::Repo).to be_exist
       end
     end
 
     it "is false when outside of any repo" do
       ENV['GIT_DIR'] = nil
       Dir.chdir('/tmp') do
-        EY::Repo.should_not be_exist
+        expect(EY::Repo).not_to be_exist
       end
     end
   end
@@ -64,18 +64,18 @@ describe EY::Repo do
     describe "current_branch method" do
       it "returns the name of the current branch" do
         set_head "ref: refs/heads/master"
-        @repo.current_branch.should == "master"
+        expect(@repo.current_branch).to eq("master")
       end
 
       it "returns nil if there is no current branch" do
         set_head "20bf478ab6a91ec5771130aa4c8cfd3d150c4146"
-        @repo.current_branch.should be_nil
+        expect(@repo.current_branch).to be_nil
       end
     end # current_branch
 
     describe "#fail_on_no_remotes!" do
       it "raises when there are no remotes" do
-        lambda { @repo.fail_on_no_remotes! }.should raise_error(EY::Repo::NoRemotesError)
+        expect { @repo.fail_on_no_remotes! }.to raise_error(EY::Repo::NoRemotesError)
       end
     end