paratrooper 2.4.1 → 3.0.0.beta1

data/spec/paratrooper/deploy_spec.rb

@@ -19,7 +19,6 @@ describe Paratrooper::Deploy do
   let(:options) { Hash.new }
   let(:heroku) do
     double(:heroku,
-      app_url: 'application_url',
       app_restart: true,
       app_maintenance_on: true,
       app_maintenance_off: true,
@@ -36,93 +35,26 @@ describe Paratrooper::Deploy do
   end
   let(:http_client) { double(:http_client).as_null_object }
 
-  describe "tag=" do
-    specify "tag is set and @tag_name holds value" do
-      deployer.tag = "tag_name"
-      expect(deployer.tag_name).to eq("tag_name")
-    end
-  end
-
-  describe "match_tag_to=" do
-    specify "match_tag is set and @match_tag_name holds value" do
-      deployer.match_tag = "staging"
-      expect(deployer.match_tag_name).to eq("staging")
-    end
-  end
-
-  describe "branch=" do
-    specify "branch is set and @branch_name holds value" do
-      deployer.branch = "branch_name"
-      expect(deployer.branch_name).to eq("branch_name")
-    end
+  before do
+    allow(screen_notifier).to receive(:notify)
   end
 
   describe "passing a block to initialize" do
     it "sets attributes on self" do
       deployer = described_class.new(app_name, default_options) do |p|
-        p.match_tag = "staging"
-        p.tag = "production"
-        p.debug = true
         p.deployment_host = "HOST"
-        p.protocol = "MOM"
-      end
-      expect(deployer.match_tag_name).to eq("staging")
-      expect(deployer.tag_name).to eq("production")
-      expect(deployer.debug).to be_true
-      expect(deployer.deployment_host).to eq("HOST")
-      expect(deployer.protocol).to eq("MOM")
-    end
-  end
-
-  describe "options" do
-    context "accepts :tag" do
-      let(:options) { { tag: 'tag_name' } }
-
-      it "and responds to #tag_name" do
-        expect(deployer.tag_name).to eq('tag_name')
-      end
-    end
-
-    context "accepts :heroku_auth" do
-      let(:options) { { heroku_auth: heroku } }
-      let(:heroku) { double(:heroku) }
-
-      it "and responds to #heroku" do
-        expect(deployer.heroku).to eq(heroku)
+        p.protocol        = "MOM"
       end
+      expect(deployer.config.deployment_host).to eq("HOST")
+      expect(deployer.config.protocol).to eq("MOM")
     end
 
-    context "accepts :notifiers" do
-      let(:options) { { notifiers: [notifiers] } }
-      let(:notifiers) { double(:notifier) }
-
-      it "and responds to #notifiers" do
-        expect(deployer.notifiers).to eq([notifiers])
-      end
-    end
-
-    describe "protocol" do
-      context "accepts :protocol" do
-        let(:options) { { protocol: 'https' } }
-
-        it "and responds to #protocol" do
-          expect(deployer.protocol).to eq('https')
-        end
-      end
-
-      context "no value passed" do
-        it "and responds to #protocol with default value" do
-          expect(deployer.protocol).to eq('http')
-        end
-      end
-    end
-
-    context "accepts :deployment_host" do
-      let(:options) { { deployment_host: 'host_name' } }
-
-      it "and responds to #notifiers" do
-        expect(deployer.deployment_host).to eq('host_name')
+    it "lazy loads dependent options" do
+      deployer = described_class.new(app_name, api_key: 'API_KEY') do |p|
+        p.force_push = false
       end
+      expect(deployer.config.api_key).to eq('API_KEY')
+      expect(deployer.config.force_push).to eq(false)
     end
   end
 
@@ -132,32 +64,32 @@ describe Paratrooper::Deploy do
 
       context "with pending migrations" do
         before do
-          migration_check.stub(:migrations_waiting?).and_return(true)
+          allow(migration_check).to receive(:migrations_waiting?).and_return(true)
         end
 
         it 'sends notification' do
-          deployer.should_receive(:notify).with(:activate_maintenance_mode).once
+          expect(deployer).to receive(:notify).with(:activate_maintenance_mode).once
           deployer.activate_maintenance_mode
         end
 
         it "makes call to heroku to turn on maintenance mode" do
-          heroku.should_receive(:app_maintenance_on)
+          expect(heroku).to receive(:app_maintenance_on)
           deployer.activate_maintenance_mode
         end
       end
 
       context "without pending migrations" do
         before do
-          migration_check.stub(:migrations_waiting?).and_return(false)
+          allow(migration_check).to receive(:migrations_waiting?).and_return(false)
         end
 
         it 'does not send notification' do
-          deployer.should_not_receive(:notify).with(:activate_maintenance_mode)
+          expect(deployer).to_not receive(:notify).with(:activate_maintenance_mode)
           deployer.activate_maintenance_mode
         end
 
         it "does not make a call to heroku to turn on maintenance mode" do
-          heroku.should_not_receive(:app_maintenance_on)
+          expect(heroku).to_not receive(:app_maintenance_on)
           deployer.activate_maintenance_mode
         end
       end
@@ -167,16 +99,16 @@ describe Paratrooper::Deploy do
       let(:options) { { maintenance: false } }
 
       before do
-        migration_check.stub(:migrations_waiting?).and_return(true)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(true)
       end
 
       it 'does not send notification' do
-        deployer.should_not_receive(:notify).with(:activate_maintenance_mode)
+        expect(deployer).to_not receive(:notify).with(:activate_maintenance_mode)
         deployer.activate_maintenance_mode
       end
 
       it "does not make a call to heroku to turn on maintenance mode" do
-        heroku.should_not_receive(:app_maintenance_on)
+        expect(heroku).to_not receive(:app_maintenance_on)
         deployer.activate_maintenance_mode
       end
     end
@@ -185,16 +117,16 @@ describe Paratrooper::Deploy do
       let(:options) { { } }
 
       before do
-        migration_check.stub(:migrations_waiting?).and_return(true)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(true)
       end
 
       it 'does not send notification' do
-        deployer.should_not_receive(:notify).with(:activate_maintenance_mode)
+        expect(deployer).to_not receive(:notify).with(:activate_maintenance_mode)
         deployer.activate_maintenance_mode
       end
 
       it "does not make a call to heroku to turn on maintenance mode" do
-        heroku.should_not_receive(:app_maintenance_on)
+        expect(heroku).to_not receive(:app_maintenance_on)
         deployer.activate_maintenance_mode
       end
     end
@@ -202,163 +134,103 @@ describe Paratrooper::Deploy do
 
   describe "#deactivate_maintenance_mode" do
     context "when maintenance_mode option is 'true'" do
-      let(:options) { { maintenance_mode: true } }
+      let(:options) { { maintenance: true } }
 
       context "with pending migrations" do
         before do
-          migration_check.stub(:migrations_waiting?).and_return(true)
+          allow(migration_check).to receive(:migrations_waiting?).and_return(true)
         end
 
         it 'sends notification' do
-          deployer.should_receive(:notify).with(:deactivate_maintenance_mode).once
+          expect(deployer).to receive(:notify).with(:deactivate_maintenance_mode).once
           deployer.deactivate_maintenance_mode
         end
 
         it "makes call to heroku to turn on maintenance mode" do
-          heroku.should_receive(:app_maintenance_off)
+          expect(heroku).to receive(:app_maintenance_off)
           deployer.deactivate_maintenance_mode
         end
       end
 
       context "without pending migrations" do
         before do
-          migration_check.stub(:migrations_waiting?).and_return(false)
+          allow(migration_check).to receive(:migrations_waiting?).and_return(false)
         end
 
         it 'does not send notification' do
-          deployer.should_not_receive(:notify).with(:deactivate_maintenance_mode)
+          expect(deployer).to_not receive(:notify).with(:deactivate_maintenance_mode)
           deployer.deactivate_maintenance_mode
         end
 
         it "does not make a call to heroku to turn on maintenance mode" do
-          heroku.should_not_receive(:app_maintenance_off)
+          expect(heroku).to_not receive(:app_maintenance_off)
           deployer.deactivate_maintenance_mode
         end
       end
     end
   end
 
-  describe "#update_repo_tag" do
-    context "when a tag_name is available" do
-      let(:options) { { tag: 'awesome' } }
-
-      before do
-        system_caller.stub(:execute)
-      end
-
-      it 'sends notification' do
-        deployer.should_receive(:notify).with(:update_repo_tag).once
-        deployer.update_repo_tag
-      end
-
-      context "when deploy_tag is available" do
-        before do
-          options.merge!(match_tag: 'deploy_this')
-        end
-
-        it 'creates a git tag at deploy_tag reference point' do
-          system_caller.should_receive(:execute).with('git tag awesome deploy_this -f')
-          deployer.update_repo_tag
-        end
-      end
-
-      context "when no deploy_tag is available" do
-        it 'creates a git tag at HEAD' do
-          system_caller.should_receive(:execute).with('git tag awesome master -f')
-          deployer.update_repo_tag
-        end
-      end
-
-      it 'pushes git tag' do
-        expected = 'git push -f origin awesome'
-        system_caller.should_receive(:execute).with(expected)
-        deployer.update_repo_tag
-      end
-    end
-
-    context "when a tag_name is unavailable" do
-      let(:options) { Hash.new }
-
-      it 'no repo tags are created' do
-        system_caller.should_not_receive(:execute)
-        deployer.update_repo_tag
+  describe "#push_repo" do
+    let(:notifier) { double(:notifier) }
+    let(:source_control) { double(:source_control) }
+    let(:deployer) do
+      described_class.new('APP') do |d|
+        d.notifiers = notifier
+        d.source_control = source_control
       end
     end
-  end
 
-  describe "#push_repo" do
     before do
-      system_caller.stub(:execute)
-    end
-
-    it 'sends notification' do
-      deployer.should_receive(:notify)
-        .with(:push_repo, reference_point: 'master').once
-      deployer.push_repo
+      allow(source_control).to receive(:reference_point)
+      allow(source_control).to receive(:remote)
+      allow(source_control).to receive(:push_to_deploy)
+      allow(notifier).to receive(:notify)
     end
 
-    context "when branch_name is available" do
-      before do
-        deployer.branch_name = "BRANCH_NAME"
+    it "sends notification" do
+      allow(notifier).to receive(:notify) do |step, options|
+        expect(step).to eq(:push_repo)
       end
+      deployer.push_repo
 
-      it 'pushes branch_name to heroku' do
-        expected_call = 'git push -f git@heroku.com:app.git refs/heads/BRANCH_NAME:refs/heads/master'
-        system_caller.should_receive(:execute).with(expected_call)
-        deployer.push_repo
-      end
+      expect(notifier).to have_received(:notify).once
     end
 
-    context "when tag_name with no branch_name is available" do
-      before do
-        deployer.tag_name = "TAG_NAME"
-      end
+    it "pushes repo to remote" do
+      deployer.push_repo
 
-      it 'pushes branch_name to heroku' do
-        expected_call = 'git push -f git@heroku.com:app.git refs/tags/TAG_NAME:refs/heads/master'
-        system_caller.should_receive(:execute).with(expected_call)
-        deployer.push_repo
-      end
+      expect(source_control).to have_received(:push_to_deploy)
     end
-
-    context "when no branch_name or tag_name" do
-      it 'pushes master repo to heroku' do
-        expected_call = 'git push -f git@heroku.com:app.git master:refs/heads/master'
-        system_caller.should_receive(:execute).with(expected_call)
-        deployer.push_repo
-      end
-    end
-
   end
 
   describe "#run_migrations" do
     before do
-      system_caller.stub(:execute)
+      allow(system_caller).to receive(:execute)
     end
 
     context "when new migrations are waiting to be run" do
       before do
-        migration_check.stub(:migrations_waiting?).and_return(true)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(true)
       end
 
       it 'sends notification' do
-        deployer.should_receive(:notify).with(:run_migrations).once
+        expect(deployer).to receive(:notify).with(:run_migrations).once
         deployer.run_migrations
       end
 
       it 'pushes repo to heroku' do
-        heroku.should_receive(:run_migrations)
+        expect(heroku).to receive(:run_migrations)
         deployer.run_migrations
       end
     end
 
     context "when no migrations are available to be run" do
       before do
-        migration_check.stub(:migrations_waiting?).and_return(false)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(false)
       end
 
       specify "heroku is not notified to run migrations" do
-        heroku.should_not_receive(:run_migrations)
+        expect(heroku).to_not receive(:run_migrations)
         deployer.run_migrations
       end
     end
@@ -367,7 +239,7 @@ describe Paratrooper::Deploy do
   describe "#app_restart" do
     context 'when a restart is required due to pending migrations' do
       before do
-        migration_check.stub(:migrations_waiting?).and_return(true)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(true)
       end
 
       it 'sends notification' do
@@ -383,7 +255,7 @@ describe Paratrooper::Deploy do
 
     context 'when a restart is not required' do
       before do
-        migration_check.stub(:migrations_waiting?).and_return(false)
+        allow(migration_check).to receive(:migrations_waiting?).and_return(false)
       end
 
       it 'does not send notification' do
@@ -398,68 +270,41 @@ describe Paratrooper::Deploy do
     end
   end
 
-  describe "#warm_instance" do
-    before do
-      system_caller.stub(:execute)
-    end
-
-    it 'sends notification' do
-      deployer.should_receive(:notify).with(:warm_instance).once
-      deployer.warm_instance(0)
-    end
-
-    it 'pings application url' do
-      expected_url = 'http://application_url'
-      expect(http_client).to receive(:get).with(expected_url)
-      deployer.warm_instance(0)
-    end
-
-    context 'with optional protocol' do
-      let(:options) { { protocol: 'https' } }
+  describe "#add_callback" do
+    it "adds callback" do
+      callback = proc do |output|
+        system("touch spec/fixtures/test.txt")
+      end
 
-      it 'pings application url using the protocol' do
-        expected_url = 'https://application_url'
-        expect(http_client).to receive(:get).with(expected_url)
-        deployer.warm_instance(0)
+      deployer = described_class.new(app_name, default_options) do |p|
+        p.add_callback(:before_setup, &callback)
       end
+
+      expect(deployer.config.callbacks[:before_setup]).to eq([callback])
     end
 
-    describe "#add_callback" do
-      it "adds callback" do
+    context "when messaging is added to callback" do
+      it "is called" do
         callback = proc do |output|
-          system("touch spec/fixtures/test.txt")
+          output.display("Whoo Hoo!")
         end
 
+        allow(screen_notifier).to receive(:display).with("Whoo Hoo!")
+
         deployer = described_class.new(app_name, default_options) do |p|
           p.add_callback(:before_setup, &callback)
         end
+        deployer.setup
 
-        expect(deployer.callbacks[:before_setup]).to eq([callback])
-      end
-
-      context "when messaging is added to callback" do
-        it "is called" do
-          callback = proc do |output|
-            output.display("Whoo Hoo!")
-          end
-
-          screen_notifier.stub(:display).with("Whoo Hoo!")
-
-          deployer = described_class.new(app_name, default_options) do |p|
-            p.add_callback(:before_setup, &callback)
-          end
-          deployer.setup
-
-          expect(screen_notifier).to have_received(:display).with("Whoo Hoo!")
-        end
+        expect(screen_notifier).to have_received(:display).with("Whoo Hoo!")
       end
     end
+  end
 
-    describe "#add_remote_task" do
-      it "makes call to heroku to run task" do
-        expect(heroku).to receive(:run_task).with("rake some:task:to:run")
-        deployer.add_remote_task("rake some:task:to:run")
-      end
+  describe "#add_remote_task" do
+    it "makes call to heroku to run task" do
+      expect(heroku).to receive(:run_task).with("rake some:task:to:run")
+      deployer.add_remote_task("rake some:task:to:run")
     end
   end
 end