simple_deploy 0.5.6 → 0.6.0

data/spec/stack/deployment_spec.rb

@@ -3,19 +3,20 @@ require 'spec_helper'
 describe SimpleDeploy do
 
   before do
-    @attributes = { 'key'         => 'val',
-                    'ssh_gateway' => '1.2.3.4',
-                    'chef_repo' => 'chef_repo',
+    @attributes = { 'key'                     => 'val',
+                    'chef_repo'               => 'chef_repo',
                     'chef_repo_bucket_prefix' => 'chef_repo_bp',
-                    'chef_repo_domain' => 'chef_repo_d',
-                    'app' => 'app',
-                    'app_bucket_prefix' => 'app_bp',
-                    'app_domain' => 'app_d',
-                    'cookbooks' => 'cookbooks',
+                    'chef_repo_domain'        => 'chef_repo_d',
+                    'app'                     => 'app',
+                    'app_bucket_prefix'       => 'app_bp',
+                    'app_domain'              => 'app_d',
+                    'cookbooks'               => 'cookbooks',
                     'cookbooks_bucket_prefix' => 'cookbooks_bp',
-                    'cookbooks_domain' => 'cookbooks_d' }
+                    'cookbooks_domain'        => 'cookbooks_d' }
     @logger_stub = stub 'logger stub'
-    @logger_stub.stub :debug => 'true', :info => 'true'
+    @logger_stub.stub :debug => 'true', 
+                      :info  => 'true',
+                      :error => 'true'
 
     @config_mock = mock 'config mock'
     @config_mock.stub(:logger) { @logger_stub }
@@ -24,6 +25,8 @@ describe SimpleDeploy do
     @stack_mock = mock 'stack mock'
     @stack_mock.stub(:attributes) { @attributes }
 
+    @status_mock = mock 'status mock'
+
     options = { :config      => @config_mock,
                 :instances   => ['1.2.3.4', '4.3.2.1'],
                 :environment => 'test-us-west-1',
@@ -31,112 +34,139 @@ describe SimpleDeploy do
                 :ssh_key     => 'key',
                 :stack       => @stack_mock,
                 :name        => 'stack-name' }
-    @stack = SimpleDeploy::Stack::Deployment.new options
+    @deployment = SimpleDeploy::Stack::Deployment.new options
+    @deployment.stub(:sleep) { false }
   end
 
-  it "should not blow up creating a new deployment" do
-    @stack.class.should == SimpleDeploy::Stack::Deployment
-  end
+  context "manage locks" do
+    before do
+      status_options = { :name        => 'stack-name',
+                         :environment => 'test-us-west-1',
+                         :ssh_user    => 'user',
+                         :config      => @config_mock,
+                         :stack       => @stack_mock }
+      SimpleDeploy::Stack::Deployment::Status.should_receive(:new).
+                                              with(status_options).
+                                              and_return @status_mock
+    end
 
-  describe "creating a deploy" do
-    it "should gracefully tell the user there are no running instances" do
-      options = { :config      => @config_mock,
-                 :instances   => [],
-                 :environment => 'test-us-west-1',
-                 :ssh_user    => 'user',
-                 :ssh_key     => 'key',
-                 :stack       => @stack_mock,
-                 :name        => 'stack-name' }
-      stack = SimpleDeploy::Stack::Deployment.new options
-
-      expect {
-        stack.create_deployment
-      }.to raise_error(RuntimeError, 'There are no running instances to deploy to')
+    describe "clear_for_deployment?" do
+      it "should test the clear_for_deployment method" do
+        @status_mock.stub :clear_for_deployment? => true
+        @deployment.clear_for_deployment?.should be_true
+      end
     end
+
+    describe "clear_deployment_lock" do
+      it "should test the clear_deployment_lock" do
+        @status_mock.should_receive(:clear_deployment_lock).
+                     with(true).
+                     and_return true
+        @deployment.clear_deployment_lock(true).should be_true
+      end
+    end
+
   end
 
   describe "executing a deploy" do
     before do
-      @deployment_mock = mock 'cap config'
-      @variables_mock = mock 'variables mock'
-      @artifact_mock = mock 'artifact mock'
-      level_stub = stub 'level'
-      level_stub.should_receive(:level=).with(3)
-      Capistrano::Configuration.should_receive(:new).and_return @deployment_mock
-      @deployment_mock.should_receive(:logger).and_return level_stub
-      @deployment_mock.should_receive(:set).with :gateway, '1.2.3.4'
-      @deployment_mock.should_receive(:set).with :user, 'user'
-      @deployment_mock.should_receive(:variables).and_return @variables_mock
-      @variables_mock.should_receive(:[]=).
-                      with :ssh_options, ( { :keys     => 'key',
-                                             :paranoid => false } )
-      @deployment_mock.should_receive(:server).with '1.2.3.4', :instances
-      @deployment_mock.should_receive(:server).with '4.3.2.1', :instances
-      @config_mock.should_receive(:artifacts).
-                   and_return ['cookbooks']
-      @config_mock.should_receive(:artifact_deploy_variable).with('cookbooks').
-                   and_return 'deploy_var'
-      SimpleDeploy::Artifact.should_receive(:new).and_return @artifact_mock
-      @artifact_mock.should_receive(:endpoints).
-                     and_return('s3' => 's3://bucket/dir/key')
-      @stack_mock.should_receive(:instances).exactly(2).times.
-                  and_return [ { 'instancesSet' => 
-                                 [ { 'privateIpAddress' => '10.1.2.3' } ] } ]
-      @config_mock.should_receive(:deploy_script).and_return 'script.sh'
-      @deployment_mock.should_receive(:load).with({:string=>"task :simpledeploy do\n        sudo 'env deploy_var=s3://bucket/dir/key PRIMARY_HOST=10.1.2.3 script.sh'\n        end"}).and_return true
-      @stack.create_deployment
-    end
-
-    it "should deploy if the stack is clear to deploy" do
-      status_mock = mock 'status mock'
+      @config_mock.stub(:artifacts) { ['chef_repo', 'cookbooks', 'app'] }
+      @config_mock.stub(:deploy_script) { '/tmp/script' }
+      @stack_mock.stub(:instances) { [ { 'instancesSet' =>
+                                     [ { 'privateIpAddress' => '10.1.2.3' } ] } ] }
+ 
+      status_options = { :name        => 'stack-name',
+                         :environment => 'test-us-west-1',
+                         :ssh_user    => 'user',
+                         :config      => @config_mock,
+                         :stack       => @stack_mock }
       SimpleDeploy::Stack::Deployment::Status.should_receive(:new).
-                                              and_return status_mock
-      status_mock.stub(:clear_for_deployment?).and_return true
-      status_mock.should_receive(:set_deployment_in_progress)
-      @deployment_mock.should_receive(:simpledeploy)
-      status_mock.should_receive(:unset_deployment_in_progress)
-
-      @stack.execute.should == true
+                                              with(status_options).
+                                              and_return @status_mock
     end
 
-    it "should deploy if the stack is not clear to deploy but forced" do
-      status_mock = mock 'status mock'
-      SimpleDeploy::Stack::Deployment::Status.should_receive(:new).
-                                              and_return status_mock
-      status_mock.should_receive(:clear_for_deployment?).and_return false, true, true
-      status_mock.should_receive(:clear_deployment_lock).with(true)
-      status_mock.should_receive(:set_deployment_in_progress)
-      @deployment_mock.should_receive(:simpledeploy)
-      status_mock.should_receive(:unset_deployment_in_progress)
-
-      @stack.execute(true).should == true
-    end
+    describe "when succesful" do
+      before do
+        @execute_mock = mock "execute"
+        execute_options = { :name        => 'stack-name',
+                            :environment => 'test-us-west-1',
+                            :instances   => ['1.2.3.4', '4.3.2.1'],
+                            :ssh_user    => 'user',
+                            :ssh_key     => 'key',
+                            :config      => @config_mock,
+                            :stack       => @stack_mock }
+        SimpleDeploy::Stack::Execute.should_receive(:new).
+                                     with(execute_options).
+                                     and_return @execute_mock
+        @config_mock.should_receive(:artifact_deploy_variable).
+                     with("cookbooks").
+                     and_return('CHEF_REPO_URL')
+        @config_mock.should_receive(:artifact_deploy_variable).
+                     with("app").
+                     and_return('APP_URL')
+        @config_mock.should_receive(:artifact_deploy_variable).
+                     with("chef_repo").
+                     and_return('CHEF_REPO_URL')
+        @execute_mock.should_receive(:execute).
+                      with( {:sudo=>true, :command=>"env CHEF_REPO_URL=s3://cookbooks_bp-test-us-west-1/cookbooks_d/cookbooks.tar.gz APP_URL=s3://app_bp-test-us-west-1/app_d/app.tar.gz PRIMARY_HOST=10.1.2.3 /tmp/script"} )
+      end
+
+      it "should deploy if the stack is clear to deploy" do
+        @status_mock.stub :clear_for_deployment? => true
+        @status_mock.should_receive(:set_deployment_in_progress)
+        @status_mock.should_receive(:unset_deployment_in_progress)
+        @deployment.execute(false).should be_true
+      end
+
+      it "should deploy if the stack is not clear to deploy but forced and clear in time" do
+        @status_mock.should_receive(:clear_for_deployment?).
+                     and_return(false)
+        @status_mock.should_receive(:clear_deployment_lock).
+                     with(true)
+        @status_mock.should_receive(:clear_for_deployment?).
+                     exactly(2).times.
+                     and_return(true)
+        @status_mock.should_receive(:set_deployment_in_progress)
+        @status_mock.should_receive(:unset_deployment_in_progress)
+        @deployment.execute(true).should be_true
+      end
 
-    it "should not deploy if the stack is not clear to deploy and not forced" do
-      status_mock = mock 'status mock'
-      SimpleDeploy::Stack::Deployment::Status.should_receive(:new).
-                                              and_return status_mock
-      status_mock.stub(:clear_for_deployment?).and_return false
-      @logger_stub.should_receive(:error)
+    end
 
-      @stack.execute.should == false
+    describe "when unsuccesful" do
+      it "should not deploy if the stack is not clear to deploy but forced however does not clear in time" do
+        @status_mock.stub(:clear_for_deployment?) { false }
+        @status_mock.should_receive(:clear_deployment_lock).
+                     with(true)
+        @deployment.execute(true).should be_false
+      end
+
+      it "should not deploy if the stack is not clear to deploy and not forced" do
+        @status_mock.should_receive(:clear_deployment_lock).never
+        @status_mock.stub :clear_for_deployment? => false
+        @deployment.execute(false).should be_false
+      end
     end
   end
 
   describe "get_artifact_endpoints" do
     before do
       @config_mock.stub(:artifacts) { ['chef_repo', 'cookbooks', 'app'] }
-      @config_mock.should_receive(:artifact_deploy_variable).with('chef_repo').and_return('CHEF_REPO_URL')
-      @config_mock.should_receive(:artifact_deploy_variable).with('app').and_return('APP_URL')
-      @config_mock.should_receive(:artifact_deploy_variable).with('cookbooks').and_return('COOKBOOKS_URL')
+      @config_mock.should_receive(:artifact_deploy_variable).
+                   with('chef_repo').and_return('CHEF_REPO_URL')
+      @config_mock.should_receive(:artifact_deploy_variable).
+                   with('app').and_return('APP_URL')
+      @config_mock.should_receive(:artifact_deploy_variable).
+                   with('cookbooks').and_return('COOKBOOKS_URL')
     end
 
     it "should create S3 endpoints" do
-      endpoints = @stack.send :get_artifact_endpoints
+      endpoints = @deployment.send :get_artifact_endpoints
 
       endpoints['CHEF_REPO_URL'].should == 's3://chef_repo_bp-test-us-west-1/chef_repo_d/chef_repo.tar.gz'
       endpoints['APP_URL'].should == 's3://app_bp-test-us-west-1/app_d/app.tar.gz'
       endpoints['COOKBOOKS_URL'].should == 's3://cookbooks_bp-test-us-west-1/cookbooks_d/cookbooks.tar.gz'
     end
+
   end
 end

data/spec/stack/execute_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe SimpleDeploy::Stack::Execute do
+  before do
+    @ssh_mock = mock 'ssh'
+    options = { :config      => @config,
+                :instances   => @instances,
+                :environment => @environment,
+                :ssh_user    => @ssh_user,
+                :ssh_key     => @ssh_key,
+                :stack       => @stack,
+                :name        => @name }
+
+    SimpleDeploy::Stack::SSH.should_receive(:new).
+                             with(options).
+                             and_return @ssh_mock
+    @execute = SimpleDeploy::Stack::Execute.new options
+  end
+
+  it "should call execute with the given options" do
+    options = { :sudo => true, :command => 'uname' }
+    @ssh_mock.should_receive(:execute).
+              with(options).
+              and_return true
+    @execute.execute(options).should be_true
+  end
+end

data/spec/stack/ssh_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe SimpleDeploy::Stack::SSH do
+  before do
+    @stack_mock = mock 'stack'
+    @task_mock = mock 'task'
+    @config_mock = mock 'config'
+    @logger_stub = stub 'logger', :debug => true,
+                                  :info  => true,
+                                  :error => true
+    @config_mock.stub :logger => @logger_stub
+    @config_mock.should_receive(:region).
+                 with('test-env').
+                 and_return 'test-us-west-1'
+    @stack_mock.stub :attributes => { :ssh_gateway => false }
+  end
+
+  context "when unsuccessful" do
+    it "should notify the user there are no running instances" do
+      options = { :config      => @config_mock,
+                  :instances   => [],
+                  :environment => 'test-env',
+                  :ssh_user    => 'user',
+                  :ssh_key     => 'key',
+                  :stack       => @stack_mock,
+                  :name        => 'test-stack' }
+      @ssh = SimpleDeploy::Stack::SSH.new options
+      error = 'There are no running instances to execute this command.'
+      expect { @ssh.execute(:sudo    => true,
+                   :command => 'uname') }.to raise_error(RuntimeError, error)
+ 
+    end
+  end
+
+  context "when successful" do
+    before do
+      options = { :config      => @config_mock,
+                  :instances   => ['1.2.3.4', '4.3.2.1'],
+                  :environment => 'test-env',
+                  :ssh_user    => 'user',
+                  :ssh_key     => 'key',
+                  :stack       => @stack_mock,
+                  :name        => 'test-stack' }
+      @ssh = SimpleDeploy::Stack::SSH.new options
+    end
+  
+    describe "when execute called" do
+      before do
+        task_logger_mock = mock 'task_logger'
+        @ssh_options = Hash.new
+        Capistrano::Configuration.should_receive(:new).
+                                  with(:output => @logger_stub).
+                                  and_return @task_mock
+        @task_mock.stub :logger    => task_logger_mock,
+                        :variables => @ssh_options
+        task_logger_mock.should_receive(:level=).with(3)
+        @task_mock.should_receive(:set).with :user, 'user'
+        @task_mock.should_receive(:server).with('1.2.3.4', :instances)
+        @task_mock.should_receive(:server).with('4.3.2.1', :instances)
+      end
+
+      describe "when succesful" do
+        it "should execute a task with sudo" do
+          @task_mock.should_receive(:load).with({:string=>"task :execute do\n          sudo 'uname'\n          end"})
+          @task_mock.should_receive(:execute).and_return true
+          @ssh.execute(:sudo    => true,
+                       :command => 'uname').should be_true
+        end
+
+        it "should execute a task as the calling user " do
+          @task_mock.should_receive(:load).with({:string=>"task :execute do\n          run 'uname'\n          end"})
+          @task_mock.should_receive(:execute).and_return true
+          @ssh.execute(:sudo    => false,
+                       :command => 'uname').should be_true
+        end
+      end
+      
+      after do
+          @ssh_options.should == { :ssh_options => { 
+                                     :keys => 'key', :paranoid => false 
+                                   }
+                                 }
+      end
+    end
+  end
+end

data/spec/stack_spec.rb

@@ -98,6 +98,7 @@ describe SimpleDeploy do
       deployment_mock.should_receive(:clear_for_deployment?).and_return(false, true, true)
       deployment_mock.should_receive(:clear_deployment_lock).with(true)
       @stack.stub(:deployment).and_return(deployment_mock)
+      @stack.stub(:sleep).and_return(false)
 
       Stackster::Stack.should_receive(:new).with(:environment => 'test-env',
                                                  :name        => 'test-stack',
@@ -167,10 +168,10 @@ describe SimpleDeploy do
 
     it 'should use the private IP when vpc' do
       stack = SimpleDeploy::Stack.new :environment => 'test-env',
-                                       :name        => 'test-stack',
-                                       :logger      => 'my-logger',
-                                       :config      => @config_stub,
-                                       :internal    => false
+                                      :name        => 'test-stack',
+                                      :logger      => 'my-logger',
+                                      :config      => @config_stub,
+                                      :internal    => false
       stack.stub(:stack) { @stack_mock }
 
       @instances.first['instancesSet'].first['vpcId'] = 'my-vpc'
@@ -181,10 +182,10 @@ describe SimpleDeploy do
 
     it 'should use the private IP when internal' do
       stack = SimpleDeploy::Stack.new :environment => 'test-env',
-                                       :name        => 'test-stack',
-                                       :logger      => 'my-logger',
-                                       :config      => @config_stub,
-                                       :internal    => true
+                                      :name        => 'test-stack',
+                                      :logger      => 'my-logger',
+                                      :config      => @config_stub,
+                                      :internal    => true
       stack.stub(:stack) { @stack_mock }
       @stack_mock.stub(:instances).and_return(@instances)
 
@@ -193,10 +194,10 @@ describe SimpleDeploy do
 
     it 'should use the public IP when not vpc and not internal' do
       stack = SimpleDeploy::Stack.new :environment => 'test-env',
-                                       :name        => 'test-stack',
-                                       :logger      => 'my-logger',
-                                       :config      => @config_stub,
-                                       :internal    => false
+                                      :name        => 'test-stack',
+                                      :logger      => 'my-logger',
+                                      :config      => @config_stub,
+                                      :internal    => false
       stack.stub(:stack) { @stack_mock }
       @stack_mock.stub(:instances).and_return(@instances)
 
@@ -209,14 +210,65 @@ describe SimpleDeploy do
         { 'ipAddress' => '50.40.30.21', 'privateIpAddress' => '10.1.2.4' }] }]
 
       stack = SimpleDeploy::Stack.new :environment => 'test-env',
+                                      :name        => 'test-stack',
+                                      :logger      => 'my-logger',
+                                      :config      => @config_stub,
+                                      :internal    => false
+      stack.stub(:stack) { @stack_mock }
+      @stack_mock.stub(:instances).and_return(@instances)
+
+      stack.instances.should == ['50.40.30.20', '50.40.30.21']
+    end
+  end
+
+  describe 'deploy' do
+    before do
+      @stack = SimpleDeploy::Stack.new :environment => 'test-env',
                                        :name        => 'test-stack',
                                        :logger      => 'my-logger',
                                        :config      => @config_stub,
                                        :internal    => false
-      stack.stub(:stack) { @stack_mock }
-      @stack_mock.stub(:instances).and_return(@instances)
+      @deployment_mock = mock "deployment"
+      @stack.stub(:deployment).and_return(@deployment_mock)
+    end
 
-      stack.instances.should == ['50.40.30.20', '50.40.30.21']
+    it "should call exec on deployment" do
+      @deployment_mock.should_receive(:execute).with(true).and_return true
+      @stack.deploy(true).should be_true
+    end
+
+    it "should not force the deployment by default" do
+      @deployment_mock.should_receive(:execute).with(false).and_return true
+      @stack.deploy.should be_true
+    end
+
+    it "should return false if the deployment fails" do
+      @deployment_mock.should_receive(:execute).with(false).and_return false
+      @stack.deploy.should be_false
+    end
+  end
+
+  describe 'execute' do
+    before do
+      @stack = SimpleDeploy::Stack.new :environment => 'test-env',
+                                       :name        => 'test-stack',
+                                       :logger      => 'my-logger',
+                                       :config      => @config_stub,
+                                       :internal    => false
+      @execute_mock = mock "execute"
+      @stack.stub(:executer).and_return(@execute_mock)
+    end
+
+    it "should call exec with the given args" do
+      @execute_mock.should_receive(:execute).
+                    with(:arg => 'val').and_return true
+      @stack.execute(:arg => 'val').should be_true
+    end
+
+    it "should return false if the exec fails" do
+      @execute_mock.should_receive(:execute).
+                    with(:arg => 'val').and_return false
+      @stack.execute(:arg => 'val').should be_false
     end
   end
 end