fourchette 0.1.2 → 0.1.3

data/lib/fourchette/logger.rb

@@ -9,4 +9,4 @@ module Fourchette::Logger
 
     @logger
   end
-end
+end

data/lib/fourchette/pgbackups.rb

@@ -1,4 +1,4 @@
-require "heroku/client/pgbackups"
+require 'heroku/client/pgbackups'
 class Fourchette::Pgbackups
   include Fourchette::Logger
 
@@ -6,34 +6,43 @@ class Fourchette::Pgbackups
     @heroku = Fourchette::Heroku.new
   end
 
-  def copy from, to
+  def copy(from, to)
     ensure_pgbackups_is_present(from)
     ensure_pgbackups_is_present(to)
 
     from_url, from_name = pg_details_for(from)
     to_url, to_name = pg_details_for(to)
 
-    @client =  Heroku::Client::Pgbackups.new pgbackup_url(from)+'/api'
+    @client =  Heroku::Client::Pgbackups.new pgbackup_url(from) + '/api'
     @client.create_transfer(from_url, from_name, to_url, to_name)
   end
 
   private
-  def ensure_pgbackups_is_present heroku_app_name
-    unless @heroku.client.addon.list(heroku_app_name).select { |addon| addon['name'] == 'pgbackups' }.any?
+
+  def ensure_pgbackups_is_present(heroku_app_name)
+    unless existing_backups?
       logger.info "Adding pgbackups to #{heroku_app_name}"
       @heroku.client.addon.create(heroku_app_name, { plan: 'pgbackups' })
     end
   end
 
-  def pg_details_for app_name
+  def existing_backups?
+    @heroku.client.addon.list(heroku_app_name).select do |addon|
+      addon['name'] == 'pgbackups'
+    end.any?
+  end
+
+  def pg_details_for(app_name)
     @heroku.config_vars(app_name).each do |key, value|
-      return [value, key] if key.start_with?('HEROKU_POSTGRESQL_') && key.end_with?('_URL')
+      if key.start_with?('HEROKU_POSTGRESQL_') && key.end_with?('_URL')
+        return [value, key]
+      end
     end
   end
 
-  def pgbackup_url app_name
+  def pgbackup_url(app_name)
     @heroku.config_vars(app_name).each do |k, v|
       return v if k == 'PGBACKUPS_URL'
     end
   end
-end
+end

data/lib/fourchette/pull_request.rb

@@ -1,7 +1,7 @@
 class Fourchette::PullRequest
   include SuckerPunch::Job
 
-  def perform params
+  def perform(params)
     return if qa_skip?(params)
 
     callbacks = Fourchette::Callbacks.new(params)
@@ -25,8 +25,8 @@ class Fourchette::PullRequest
 
   private
 
-  def qa_skip? params
-    params['pull_request']['title'].downcase.include?('[qa skip]')
+  def qa_skip?(params)
+    pr_title = params['pull_request']['title']
+    pr_title.downcase.include?('[qa skip]')
   end
-
 end

data/lib/fourchette/tarball.rb

@@ -12,20 +12,21 @@ class Fourchette::Tarball
   end
 
   private
+
   def prepare_tarball(github_git_url, branch_name)
     clone_path = "tmp/#{SecureRandom.uuid}"
     clone(github_git_url, branch_name, clone_path)
     tar(clone_path)
   end
 
-  def clone(github_git_url,branch_name, clone_path)
-    logger.info "Cloning repository..."
+  def clone(github_git_url, branch_name, clone_path)
+    logger.info 'Cloning repository...'
     repo = Git.clone(github_git_url, clone_path, recursive: true)
     repo.checkout(branch_name)
   end
 
   def tar(path)
-    logger.info "Preparing tarball..."
+    logger.info 'Preparing tarball...'
     filepath = "#{path}/#{expiration_timestamp}.tar.gz"
     system("tar -zcf #{filepath} -C #{path} .")
     filepath
@@ -36,8 +37,8 @@ class Fourchette::Tarball
   end
 
   def tarball_to_url(filepath, github_repo)
-    logger.info "Tarball to URL as a service in progress..."
+    logger.info 'Tarball to URL as a service in progress...'
     cleaned_path = filepath.gsub('tmp/', '').gsub('.tar.gz', '')
     "#{ENV['FOURCHETTE_APP_URL']}/#{github_repo}/#{cleaned_path}"
   end
-end
+end

data/lib/fourchette/version.rb

@@ -1,3 +1,3 @@
 module Fourchette
-  VERSION = "0.1.2"
+  VERSION = '0.1.3'
 end

data/lib/fourchette/web.rb

@@ -1,2 +1,2 @@
 require_relative 'web/hooks'
-require_relative 'web/tarball'
+require_relative 'web/tarball'

data/lib/fourchette/web/hooks.rb

@@ -1,5 +1,5 @@
 post '/hooks' do
-  params = JSON.parse(request.env["rack.input"].read)
+  params = JSON.parse(request.env['rack.input'].read)
   Fourchette::PullRequest.new.async.perform(params)
-  "Got it, thanks!"
-end
+  'Got it, thanks!'
+end

data/lib/fourchette/web/tarball.rb

@@ -4,7 +4,10 @@ get '/:github_user/:github_repo/:uuid/:expiration_timestamp' do
     'Oops...'
   else
     logger.info('Serving a tarball!')
-    filepath = Fourchette::Tarball.new.filepath(params['uuid'], params['expiration_timestamp'])
-    send_file filepath, :type => 'application/x-tgz'
+    filepath = Fourchette::Tarball.new.filepath(
+      params['uuid'],
+      params['expiration_timestamp']
+    )
+    send_file filepath, type: 'application/x-tgz'
   end
-end
+end

data/spec/lib/fourchette/fork_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Fourchette::Fork do
   subject { described_class.new(params) }
 
-  let(:params) {
+  let(:params) do
     {
       'pull_request' => {
         'number' => 1,
@@ -12,20 +12,21 @@ describe Fourchette::Fork do
         }
       }
     }
-  }
+  end
   let(:fork_name) { 'my-fork-pr-1' }
 
   before do
-    stub_const('ENV', {
-        'FOURCHETTE_HEROKU_APP_PREFIX' => 'my-fork',
-        'FOURCHETTE_HEROKU_APP_TO_FORK' => 'my-heroku-app-name'
-        })
+    stub_const(
+      'ENV',
+      'FOURCHETTE_HEROKU_APP_PREFIX' => 'my-fork',
+      'FOURCHETTE_HEROKU_APP_TO_FORK' => 'my-heroku-app-name'
+    )
   end
 
   describe '#create' do
     it 'calls #update and #create_unless_exists' do
-      subject.should_receive(:create_unless_exists)
-      subject.should_receive(:update)
+      expect(subject).to receive(:create_unless_exists)
+      expect(subject).to receive(:update)
       subject.create
     end
   end
@@ -37,43 +38,47 @@ describe Fourchette::Fork do
 
     context 'app does NOT exists' do
       before do
-        Fourchette::Heroku.any_instance.stub(:app_exists?).and_return(false)
+        allow_any_instance_of(Fourchette::Heroku).to receive(:app_exists?).and_return(false)
       end
 
       it 'calls the fork creation' do
-        subject.stub(:post_fork_url)
-        Fourchette::Heroku.any_instance.should_receive(:fork).with('my-heroku-app-name', fork_name)
+        allow(subject).to receive(:post_fork_url)
+        expect_any_instance_of(Fourchette::Heroku).to receive(:fork)
+          .with('my-heroku-app-name', fork_name)
       end
 
       it 'post the URL to the fork on the GitHub PR' do
-        Fourchette::Heroku.any_instance.stub(:fork)
-        Fourchette::Heroku.any_instance.stub_chain(:client, :app, :info).and_return({'web_url' => 'rainforestqa.com'})
-        Fourchette::GitHub.any_instance.should_receive(:comment_pr).with(1, 'Test URL: rainforestqa.com')
+        allow_any_instance_of(Fourchette::Heroku).to receive(:fork)
+        allow_any_instance_of(Fourchette::Heroku).to receive_message_chain(:client, :app, :info)
+          .and_return('web_url' => 'rainforestqa.com')
+        expect_any_instance_of(Fourchette::GitHub).to receive(:comment_pr)
+          .with(1, 'Test URL: rainforestqa.com')
       end
     end
 
     context 'app DOES exists' do
       before do
-        Fourchette::Heroku.any_instance.stub(:app_exists?).and_return(true)
+        allow_any_instance_of(Fourchette::Heroku).to receive(:app_exists?).and_return(true)
       end
 
       it 'does nothing' do
-        Fourchette::GitHub.any_instance.should_not_receive(:comment_pr)
-        Fourchette::Heroku.any_instance.should_not_receive(:fork)
+        expect_any_instance_of(Fourchette::GitHub).not_to receive(:comment_pr)
+        expect_any_instance_of(Fourchette::Heroku).not_to receive(:fork)
       end
     end
   end
 
   describe '#delete' do
     it 'calls deletes the fork' do
-      Fourchette::GitHub.any_instance.stub(:comment_pr)
-      Fourchette::Heroku.any_instance.should_receive(:delete).with(fork_name)
+      allow_any_instance_of(Fourchette::GitHub).to receive(:comment_pr)
+      expect_any_instance_of(Fourchette::Heroku).to receive(:delete).with(fork_name)
       subject.delete
     end
 
     it 'comments on the GitHub PR' do
-      Fourchette::Heroku.any_instance.stub(:delete)
-      Fourchette::GitHub.any_instance.should_receive(:comment_pr).with(1, 'Test app deleted!')
+      allow_any_instance_of(Fourchette::Heroku).to receive(:delete)
+      expect_any_instance_of(Fourchette::GitHub).to receive(:comment_pr)
+        .with(1, 'Test app deleted!')
       subject.delete
     end
   end
@@ -89,4 +94,4 @@ describe Fourchette::Fork do
   describe '#pr_number' do
     it { expect(subject.pr_number).to eq 1 }
   end
-end
+end

data/spec/lib/fourchette/github_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Fourchette::GitHub do
   subject { described_class.new }
@@ -6,122 +6,122 @@ describe Fourchette::GitHub do
   let(:fake_hooks) { [] }
 
   let(:fake_hook) do
-    hook = double("hook")
-    hook.stub(:config).and_return(nil)
-    hook.stub(:id).and_return(123)
+    hook = double('hook')
+    allow(hook).to receive(:config).and_return(nil)
+    allow(hook).to receive(:id).and_return(123)
     hook
   end
 
   let(:fake_fourchette_hook) do
-    fake_hook.config.stub(:fourchette_env).and_return("something")
+    allow(fake_hook.config).to receive(:fourchette_env).and_return('something')
     fake_hook
   end
 
   let(:fake_enabled_fourchette_hook) do
-    fake_fourchette_hook.stub(:active).and_return(true)
+    allow(fake_fourchette_hook).to receive(:active).and_return(true)
     fake_fourchette_hook
   end
 
   let(:fake_disabled_fourchette_hook) do
-    fake_fourchette_hook.stub(:active).and_return(false)
+    allow(fake_fourchette_hook).to receive(:active).and_return(false)
     fake_fourchette_hook
   end
 
   before do
     allow_message_expectations_on_nil
-    subject.stub(:hooks).and_return(fake_hooks)
-    Octokit::Client.any_instance.stub(:edit_hook)
+    allow(subject).to receive(:hooks).and_return(fake_hooks)
+    allow_any_instance_of(Octokit::Client).to receive(:edit_hook)
   end
 
-  describe "#enable_hook" do
-    context "when there is alerady a Fourchette hook" do
+  describe '#enable_hook' do
+    context 'when there is alerady a Fourchette hook' do
 
-      context "when the hook was enabled" do
+      context 'when the hook was enabled' do
         let(:fake_hooks) { [fake_enabled_fourchette_hook] }
 
-        it "does NOT enable the hook" do
-          Octokit::Client.any_instance.should_not_receive(:edit_hook)
+        it 'does NOT enable the hook' do
+          expect_any_instance_of(Octokit::Client).not_to receive(:edit_hook)
 
           subject.enable_hook
         end
       end
 
-      context "when the hook was disabled" do
+      context 'when the hook was disabled' do
         let(:fake_hooks) { [fake_disabled_fourchette_hook] }
 
-        it "enables the hook" do
-          Octokit::Client.any_instance.should_receive(:edit_hook)
+        it 'enables the hook' do
+          expect_any_instance_of(Octokit::Client).to receive(:edit_hook)
 
           subject.enable_hook
         end
       end
     end
 
-    context "when there is no Fourchette hook yet" do
-      it "adds a hook" do
-        Octokit::Client.any_instance.should_receive(:create_hook)
+    context 'when there is no Fourchette hook yet' do
+      it 'adds a hook' do
+        expect_any_instance_of(Octokit::Client).to receive(:create_hook)
 
         subject.enable_hook
       end
     end
   end
 
-  describe "#disable_hook" do
-    context "where there is an active Fourchette hook" do
+  describe '#disable_hook' do
+    context 'where there is an active Fourchette hook' do
       let(:fake_hooks) { [fake_enabled_fourchette_hook] }
 
-      it "disables the hook" do
-        Octokit::Client.any_instance.should_receive(:edit_hook)
+      it 'disables the hook' do
+        expect_any_instance_of(Octokit::Client).to receive(:edit_hook)
 
         subject.disable_hook
       end
     end
 
-    context "when there is a disabled Fourchette hook" do
+    context 'when there is a disabled Fourchette hook' do
       let(:fake_hooks) { [fake_disabled_fourchette_hook] }
-      it "does not try to disable a hook" do
-        subject.should_not_receive(:disable)
+      it 'does not try to disable a hook' do
+        expect(subject).not_to receive(:disable)
         subject.disable_hook
       end
     end
 
-    context "when there is no Fourchette hook" do
-      it "does not try to disable a hook" do
-        subject.should_not_receive(:disable)
+    context 'when there is no Fourchette hook' do
+      it 'does not try to disable a hook' do
+        expect(subject).not_to receive(:disable)
         subject.disable_hook
       end
     end
   end
 
-  describe "#update_hook" do
+  describe '#update_hook' do
     let(:fake_hooks) { [fake_enabled_fourchette_hook] }
 
-    it "calls toggle_active_state_to" do
-      subject
-        .should_receive(:toggle_active_state_to)
+    it 'calls toggle_active_state_to' do
+      expect(subject)
+        .to receive(:toggle_active_state_to)
       subject.update_hook
     end
   end
 
-  describe "#delete_hook" do
-    it "deletes the hook on GitHub" do
-      subject.stub(:fourchette_hook).and_return(fake_hook)
-      Octokit::Client.any_instance.should_receive(:remove_hook)
+  describe '#delete_hook' do
+    it 'deletes the hook on GitHub' do
+      allow(subject).to receive(:fourchette_hook).and_return(fake_hook)
+      expect_any_instance_of(Octokit::Client).to receive(:remove_hook)
 
       subject.delete_hook
     end
   end
 
-  describe "#comment_pr" do
+  describe '#comment_pr' do
     before do
-      stub_const("ENV", "FOURCHETTE_GITHUB_PROJECT" => "my-project")
+      stub_const('ENV', 'FOURCHETTE_GITHUB_PROJECT' => 'my-project')
     end
 
-    it "adds a comment" do
-      Octokit::Client.any_instance
-        .should_receive(:add_comment).with("my-project", 1, "yo!")
+    it 'adds a comment' do
+      expect_any_instance_of(Octokit::Client)
+        .to receive(:add_comment).with('my-project', 1, 'yo!')
 
-      subject.comment_pr(1, "yo!")
+      subject.comment_pr(1, 'yo!')
     end
   end
 end

data/spec/lib/fourchette/heroku_spec.rb

@@ -14,14 +14,16 @@ describe Fourchette::Heroku do
   before do
     client = double('client')
     client_app = double('client')
-    client_app.stub(:list).and_return(app_list)
-    client.stub(:app).and_return(client_app)
+    allow(client_app).to receive(:list).and_return(app_list)
+    allow(client).to receive(:app).and_return(client_app)
     config_var = double('config_var')
-    client.stub(:config_var).and_return(config_var)
+    allow(client).to receive(:config_var).and_return(config_var)
 
-    client.app.stub(:info).and_return( { 'git_url' => 'git@heroku.com/something.git' } )
+    allow(client.app).to receive(:info).and_return(
+      'git_url' => 'git@heroku.com/something.git'
+    )
 
-    heroku.stub(:client).and_return(client)
+    allow(heroku).to receive(:client).and_return(client)
   end
 
   describe '#app_exists?' do
@@ -32,42 +34,46 @@ describe Fourchette::Heroku do
 
   describe '#fork' do
     before do
-      heroku.stub(:create_app)
-      heroku.stub(:copy_config)
-      heroku.stub(:copy_add_ons)
-      heroku.stub(:copy_pg)
-      heroku.stub(:copy_RACK_AND_RAILS_ENV_again)
+      allow(heroku).to receive(:create_app)
+      allow(heroku).to receive(:copy_config)
+      allow(heroku).to receive(:copy_add_ons)
+      allow(heroku).to receive(:copy_pg)
+      allow(heroku).to receive(:copy_rack_and_rails_env_again)
     end
 
-    ['create_app', 'copy_config', 'copy_add_ons', 'copy_pg', 'copy_RACK_AND_RAILS_ENV_again'].each do |method_name|
+    %w(
+      create_app copy_config copy_add_ons copy_pg copy_rack_and_rails_env_again
+    ).each do |method_name|
       it "calls `#{method_name}'" do
-        heroku.should_receive(method_name)
+        expect(heroku).to receive(method_name)
         heroku.fork(from_app_name, to_app_name)
       end
     end
   end
 
   describe '#git_url' do
-    it { expect(heroku.git_url(to_app_name)).to eq 'git@heroku.com/something.git' }
+    it 'returns the correct git URL' do
+      expect(heroku.git_url(to_app_name)).to eq 'git@heroku.com/something.git'
+    end
   end
 
   describe '#delete' do
     it 'calls delete on the Heroku client' do
-      heroku.client.app.should_receive(:delete).with(to_app_name)
+      expect(heroku.client.app).to receive(:delete).with(to_app_name)
       heroku.delete(to_app_name)
     end
   end
 
   describe '#config_vars' do
     it 'calls config_var.info on the Heroku client' do
-      heroku.client.config_var.should_receive(:info).with(from_app_name)
+      expect(heroku.client.config_var).to receive(:info).with(from_app_name)
       heroku.config_vars(from_app_name)
     end
   end
 
   describe '#create_app' do
     it 'calls app.create on the Heroku client' do
-      heroku.client.app.should_receive(:create).with({ name: to_app_name })
+      expect(heroku.client.app).to receive(:create).with(name: to_app_name)
       heroku.create_app(to_app_name)
     end
   end
@@ -80,37 +86,41 @@ describe Fourchette::Heroku do
         'DATABASE_URL' => 'FAIL@POSTGRES/DB'
       }
     end
-    let(:cleaned_vars) { { 'WHATEVER' => 'ok'} }
+    let(:cleaned_vars) { { 'WHATEVER' => 'ok' } }
 
     it 'calls #config_vars' do
-      heroku.client.config_var.stub(:update)
-      heroku.should_receive(:config_vars).with(from_app_name).and_return(vars)
+      allow(heroku.client.config_var).to receive(:update)
+      expect(heroku).to receive(:config_vars).with(from_app_name).and_return(vars)
       heroku.copy_config(from_app_name, to_app_name)
     end
 
     it 'updates config vars without postgres URLs' do
-      heroku.client.config_var.should_receive(:update).with(to_app_name, cleaned_vars )
-      heroku.stub(:config_vars).and_return(vars)
+      expect(heroku.client.config_var).to receive(:update)
+        .with(to_app_name, cleaned_vars)
+      allow(heroku).to receive(:config_vars).and_return(vars)
       heroku.copy_config('from', to_app_name)
     end
   end
 
   describe '#copy_add_ons' do
-    let(:addon_list) { [ { 'plan' => { 'name' => 'redistogo' } } ] }
+    let(:addon_list) { [{ 'plan' => { 'name' => 'redistogo' } }] }
 
     before do
-      heroku.client.stub(:addon).and_return(double('addon'))
-      heroku.client.addon.stub(:create)
-      heroku.client.addon.stub(:list).and_return(addon_list)
+      allow(heroku.client).to receive(:addon).and_return(double('addon'))
+      allow(heroku.client.addon).to receive(:create)
+      allow(heroku.client.addon).to receive(:list).and_return(addon_list)
     end
 
     it 'gets the addon list' do
-      heroku.client.addon.should_receive(:list).with(from_app_name).and_return(addon_list)
+      expect(heroku.client.addon).to receive(:list).with(from_app_name)
+        .and_return(addon_list)
       heroku.copy_add_ons(from_app_name, to_app_name)
     end
 
     it 'creates addons' do
-      heroku.client.addon.should_receive(:create).with(to_app_name, { plan: 'redistogo' })
+      expect(heroku.client.addon).to receive(:create).with(
+        to_app_name,  plan: 'redistogo'
+      )
       heroku.copy_add_ons(from_app_name, to_app_name)
     end
   end
@@ -118,16 +128,32 @@ describe Fourchette::Heroku do
   describe '#copy_pg' do
 
     before do
-      heroku.client.stub(:addon).and_return(double('addon'))
-      heroku.client.addon.stub(:list).and_return(addon_list)
+      allow(heroku.client).to receive(:addon).and_return(double('addon'))
+      allow(heroku.client.addon).to receive(:list).and_return(addon_list)
     end
 
     context 'when a heroku-postgresql addon is enabled' do
-      let(:addon_list) { [{ 'addon_service' => { 'name' => 'Heroku Postgres' } }] }
+      let(:addon_list) { [{ 'addon_service' => { 'name' => addon_name } }] }
+
+      shared_examples 'app with pg' do
+        it 'calls Fourchette::Pgbackups#copy' do
+          expect_any_instance_of(Fourchette::Pgbackups).to receive(:copy).with(
+            from_app_name, to_app_name
+          )
+          heroku.copy_pg(from_app_name, to_app_name)
+        end
+      end
 
-      it 'calls Fourchette::Pgbackups#copy' do
-        Fourchette::Pgbackups.any_instance.should_receive(:copy).with(from_app_name, to_app_name)
-        heroku.copy_pg(from_app_name, to_app_name)
+      context "when the addon name is 'Heroku Postgres'" do
+        let(:addon_name) { 'Heroku Postgres' }
+
+        it_behaves_like 'app with pg'
+      end
+
+      context "when the addon name is 'heroku-postgresql'" do
+        let(:addon_name) { 'heroku-postgresql' }
+
+        it_behaves_like 'app with pg'
       end
     end
 
@@ -135,51 +161,58 @@ describe Fourchette::Heroku do
       let(:addon_list) { [{ 'addon_service' => { 'name' => 'redistogo' } }] }
 
       it 'does not call Fourchette::Pgbackups#copy' do
-        # Had to work around lack of support for any_instance and should_not_receive
-        # see https://github.com/rspec/rspec-mocks/issues/164 for more details
+        # Had to work around lack of support for any_instance and
+        # should_not_receive
+        # See https://github.com/rspec/rspec-mocks/issues/164 for more details
         count = 0
-        Fourchette::Pgbackups.any_instance.stub(:copy) do |from_app_name, to_app_name|
-          count += 1
-        end
+        allow_any_instance_of(Fourchette::Pgbackups).to receive(:copy) do |_from_app_name, _to_app_name|
+            count += 1
+          end
         heroku.copy_pg(from_app_name, to_app_name)
-        count.should eq(0)
+        expect(count).to eq(0)
       end
     end
   end
 
-  describe '#copy_RACK_AND_RAILS_ENV_again' do
+  describe '#copy_rack_and_rails_env_again' do
     context 'with RACK_ENV or RAILS_ENV setup' do
       before do
-        heroku.stub(:get_original_env).and_return({ 'RACK_ENV' => 'qa' })
+        allow(heroku).to receive(:get_original_env).and_return('RACK_ENV' => 'qa')
       end
 
       it 'updates the config vars' do
-        heroku.client.config_var.should_receive(:update).with(to_app_name,  { 'RACK_ENV' => 'qa' })
-        heroku.copy_RACK_AND_RAILS_ENV_again(from_app_name, to_app_name)
+        expect(heroku.client.config_var).to receive(:update).with(
+          to_app_name, 'RACK_ENV' => 'qa'
+        )
+        heroku.copy_rack_and_rails_env_again(from_app_name, to_app_name)
       end
     end
 
     context 'with NO env setup' do
       before do
-        heroku.stub(:get_original_env).and_return({})
+        allow(heroku).to receive(:get_original_env).and_return({})
       end
 
       it 'does not update config vars' do
-        heroku.client.config_var.should_not_receive(:update)
-        heroku.copy_RACK_AND_RAILS_ENV_again(from_app_name, to_app_name)
+        expect(heroku.client.config_var).not_to receive(:update)
+        heroku.copy_rack_and_rails_env_again(from_app_name, to_app_name)
       end
     end
   end
 
   describe '#get_original_env' do
     before do
-      stub_cong_var = { 'RACK_ENV' => 'qa', 'RAILS_ENV' => 'staging', 'DATABASE_URL' => 'postgres://....' }
-      heroku.stub_chain(:client, :config_var, :info).and_return(stub_cong_var)
+      stub_cong_var = {
+        'RACK_ENV' => 'qa',
+        'RAILS_ENV' => 'staging',
+        'DATABASE_URL' => 'postgres://....'
+      }
+      allow(heroku).to receive_message_chain(:client, :config_var, :info).and_return(stub_cong_var)
     end
 
     it 'returns the set env vars' do
       return_value = heroku.get_original_env(from_app_name)
-      expect(return_value).to eq({'RACK_ENV' => 'qa', 'RAILS_ENV' => 'staging'})
+      expect(return_value).to eq('RACK_ENV' => 'qa', 'RAILS_ENV' => 'staging')
     end
   end
 end