statistrano 1.2.0

data/spec/lib/statistrano/deployment/strategy/base_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy::Base do
+
+  it "is registered as :base" do
+    expect( Statistrano::Deployment::Strategy.find(:base) ).to eq described_class
+  end
+
+  describe "#initialize" do
+    it "sets name to given name" do
+      subject = described_class.new "hello"
+      expect( subject.name ).to eq "hello"
+    end
+  end
+
+  describe "#deploy" do
+
+    before :each do
+      @remote   = instance_double("Statistrano::Remote").as_null_object
+      @releaser = instance_double("Statistrano::Deployment::Releaser::Revisions").as_null_object
+      allow( Statistrano::Remote ).to receive(:new)
+                                  .and_return(@remote)
+      allow( Statistrano::Deployment::Releaser::Single ).to receive(:new)
+                                                        .and_return(@releaser)
+      @subject = define_deployment "base", :base do
+        remote_dir "/tmp"
+        local_dir  "/tmp"
+        hostname   "localhost"
+        build_task { "empty block" }
+      end
+    end
+
+    context "when check_git is set to true" do
+      it "runs `safe_to_deploy? (and exits if false)" do
+        subject = define_deployment "base", :base do
+          check_git  true
+          git_branch 'master'
+        end
+
+        expect( subject ).to receive(:safe_to_deploy?)
+                         .and_return( false )
+
+        expect{
+          subject.deploy
+        }.to raise_error SystemExit
+      end
+
+      it "will exit if build changes checked in files" do
+        subject = define_deployment "base", :base do
+          check_git true
+          git_branch 'master'
+
+          build_task do
+            # no-op
+          end
+        end
+
+        expect( subject ).to receive(:safe_to_deploy?)
+                         .and_return( true, false ) # simulate git being clear
+                                                    # before the build task, but not
+                                                    # after
+
+        expect{
+          subject.deploy
+        }.to raise_error SystemExit
+      end
+    end
+
+    it "runs `invoke_build_task`" do
+      expect( @subject ).to receive(:invoke_build_task)
+      @subject.deploy
+    end
+
+    it "calls create_release for the releaser" do
+      expect( @releaser ).to receive(:create_release)
+                         .with( @remote, {} )
+
+      @subject.deploy
+    end
+
+    it "calls the post_deploy_task" do
+      expect( @subject ).to receive(:invoke_post_deploy_task)
+      @subject.deploy
+    end
+
+    context "when log_file_path is set" do
+
+      before :each do
+        @subject = define_deployment "base", :base do
+          remote_dir "/tmp"
+          local_dir  "/tmp"
+          hostname   "localhost"
+          build_task do
+            { build_task: 'data' }
+          end
+          post_deploy_task do
+            { post_deploy_task: 'data' }
+          end
+
+          log_file_path '/log/path'
+          log_file_entry do |dep, rel, build_data, post_deploy_data|
+            {
+              log: 'entry',
+            }.merge( build_data ).merge( post_deploy_data )
+          end
+        end
+      end
+
+      it "should create a Remote::File for the log & append log_file_entry to it" do
+        log_file_double = instance_double("Statistrano::Remote::File")
+        expect( Statistrano::Remote::File ).to receive(:new)
+                              .with('/log/path', @remote)
+                              .and_return( log_file_double )
+        expect( log_file_double ).to receive(:append_content!)
+                                 .with('{"log":"entry","build_task":"data","post_deploy_task":"data"}')
+
+        @subject.deploy
+      end
+    end
+
+    context "when log_file_path isn't set" do
+      it "doesn't create a log file" do
+        expect( Statistrano::Remote::File ).not_to receive(:new)
+        @subject.deploy
+      end
+    end
+  end
+
+  describe "#persited_releaser" do
+    it "returns same object each time it's called" do
+      subject = define_deployment "base", :base do
+        remote_dir "/tmp"
+        local_dir  "/tmp"
+        hostname   "localhost"
+        build_task { "empty block" }
+      end
+
+      expect( subject.persisted_releaser ).to eq subject.persisted_releaser
+    end
+  end
+
+  describe "#flush_persisted_releaser!" do
+    it "removes the persisted_releaser" do
+      subject = define_deployment "base", :base do
+        remote_dir "/tmp"
+        local_dir  "/tmp"
+        hostname   "localhost"
+        build_task { "empty block" }
+      end
+
+      first_releaser = subject.persisted_releaser
+      subject.flush_persisted_releaser!
+
+      expect( subject.persisted_releaser ).not_to eq first_releaser
+    end
+  end
+
+end

data/spec/lib/statistrano/deployment/strategy/branches_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy::Branches do
+
+  describe "#new" do
+    it "creates a deployment with a name" do
+      deployment = described_class.new("name")
+      expect( deployment.name ).to eq "name"
+    end
+
+    it "respects the default configs" do
+      allow( Asgit ).to receive(:current_branch).and_return('first_branch')
+      deployment = described_class.new("name")
+
+      expect( deployment.config.public_dir ).to eq "first_branch"
+    end
+  end
+
+end

data/spec/lib/statistrano/deployment/strategy/check_git_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy::CheckGit do
+
+  before :each do
+    class Subject
+      include Statistrano::Deployment::Strategy::CheckGit
+
+      def config
+        Struct.new(:check_git,:git_branch).new(true,'master')
+      end
+    end
+
+    allow( Asgit ).to receive(:working_tree_clean?).and_return(true)
+    allow( Asgit ).to receive(:current_branch).and_return('master')
+    allow( Asgit ).to receive(:remote_up_to_date?).and_return(true)
+  end
+
+  let(:subject) { Subject.new }
+
+  describe "#safe_to_deploy?" do
+    it "is false if the working_tree is dirty" do
+      allow( Asgit ).to receive(:working_tree_clean?).and_return(false)
+      expect( subject.safe_to_deploy? ).to be_falsy
+    end
+    it "is false if the current_branch does not match set branch" do
+      allow( Asgit ).to receive(:current_branch).and_return('not_master')
+      expect( subject.safe_to_deploy? ).to be_falsy
+    end
+    it "is false if out of sync with remote" do
+      allow( Asgit ).to receive(:remote_up_to_date?).and_return(false)
+      expect( subject.safe_to_deploy? ).to be_falsy
+    end
+    it "is true if working_tree is clean, on correct branch, and in sync with remote" do
+      expect( subject.safe_to_deploy? ).to be_truthy
+    end
+  end
+
+end

data/spec/lib/statistrano/deployment/strategy/invoke_tasks_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy::InvokeTasks do
+
+  before :each do
+    class InvokeTasksSubject
+      include Statistrano::Deployment::Strategy::InvokeTasks
+
+      def config; end
+    end
+  end
+
+  let(:subject) { InvokeTasksSubject.new }
+
+  describe "#invoke_post_deploy_task" do
+    it "calls_or_invokes the post_deploy_task" do
+      allow( subject ).to receive_message_chain(:config, :post_deploy_task)
+                      .and_return "foo"
+      expect( subject ).to receive(:call_or_invoke_task).with "foo"
+      subject.invoke_post_deploy_task
+    end
+  end
+
+  describe "#invoke_build_task" do
+    it "calls_or_invokes the build_task" do
+      allow( subject ).to receive_message_chain(:config, :build_task)
+                      .and_return "foo"
+      expect( subject ).to receive(:call_or_invoke_task).with "foo"
+      subject.invoke_build_task
+    end
+  end
+
+  describe "#call_or_invoke_task" do
+    it "calls the task if it is a proc" do
+      expect( subject.call_or_invoke_task( -> { "hello" } ) ).to eq "hello"
+    end
+
+    it "passes self as the arg if proc has arity of 1" do
+      task = Proc.new { |s| expect(s).to(eq(subject)) }
+      subject.call_or_invoke_task(task)
+    end
+
+    it "invokes a rake task if it is a string" do
+      rake_double = double("Rake::Task")
+      expect( Rake::Task ).to receive(:[])
+                          .with("hello")
+                          .and_return( rake_double )
+      expect( rake_double ).to receive(:invoke)
+
+      subject.call_or_invoke_task("hello")
+    end
+
+    it "catches exceptions and then aborts" do
+      proc_raises_exception = -> { raise Exception, "ermagerd" }
+
+      expect( Statistrano::Log ).to receive(:error)
+                                .with "exiting due to error in task",
+                                      "Exception: ermagerd"
+
+      expect {
+        subject.call_or_invoke_task(proc_raises_exception)
+      }.to raise_error SystemExit
+    end
+  end
+
+end

data/spec/lib/statistrano/deployment/strategy/releases_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy::Releases do
+
+  it "is registered as :releases" do
+    expect( Statistrano::Deployment::Strategy.find(:releases) ).to eq described_class
+  end
+
+  describe "#remotes" do
+
+    let(:default_options) do
+      {
+        remote_dir:       nil,
+        local_dir:        nil,
+        hostname:         nil,
+        user:             nil,
+        password:         nil,
+        keys:             nil,
+        forward_agent:    nil,
+        verbose:        false,
+        build_task:       nil,
+        check_git:        nil,
+        git_branch:       nil,
+        repo_url:         nil,
+        post_deploy_task: nil,
+        dir_permissions:  755,
+        file_permissions: 644,
+        rsync_flags:      '-aqz --delete-after',
+        pre_symlink_task: nil,
+        release_count:    5,
+        release_dir:      "releases",
+        public_dir:       "current",
+        log_file_path:    nil,
+        log_file_entry:   nil
+      }
+    end
+
+    it "returns remotes cache if set" do
+      subject = described_class.new 'multi'
+      subject.instance_variable_set(:@_remotes, 'remotes')
+
+      expect( subject.remotes ).to eq 'remotes'
+    end
+
+    it "sets remote cache with results" do
+      allow( Statistrano::Remote ).to receive(:new)
+      subject = described_class.new 'multi'
+      remotes = subject.remotes
+
+      expect( remotes ).not_to be_nil
+      expect( subject.instance_variable_get(:@_remotes) ).to eq remotes
+    end
+
+    it "initializes a Remote with each remote" do
+      deployment = define_deployment "multi", :releases do
+        remotes [
+          { hostname: 'web01' },
+          { hostname: 'web02' }
+        ]
+      end
+
+      expect( Statistrano::Remote ).to receive(:new).exactly(2).times
+      deployment.remotes
+    end
+
+    it "merges remote data with global data" do
+      deployment = define_deployment "multi", :releases do
+        remote_dir "remote_dir"
+        remotes [
+          { hostname: 'web01', remote_dir: 'web01_remote_dir' }
+        ]
+      end
+
+      config_double = instance_double("Statistrano::Config")
+      expect( Statistrano::Config ).to receive(:new)
+                                   .with(default_options.merge({remotes: [{hostname: 'web01', remote_dir: 'web01_remote_dir'}]})
+                                                        .merge(hostname: 'web01', remote_dir: 'web01_remote_dir'))
+                                   .and_return(config_double)
+      expect( Statistrano::Remote ).to receive(:new)
+                                   .with(config_double)
+      deployment.remotes
+    end
+  end
+
+  describe "#deploy" do
+    context "when check_git is set to true" do
+      it "runs `safe_to_deploy? (and exits if false)" do
+        subject = define_deployment "multi", :releases do
+          check_git  true
+          git_branch 'master'
+        end
+
+        expect( subject ).to receive(:safe_to_deploy?)
+                         .and_return( false )
+
+        expect{
+          subject.deploy
+        }.to raise_error SystemExit
+      end
+    end
+
+    context "when build task is defined as a Proc" do
+      context "when build task returns hash" do
+        it "passes hash to build" do
+          subject = define_deployment "multi", :releases do
+            build_task do
+              {foo: 'bar'}
+            end
+            remotes [{one: 'two'}]
+          end
+          remote   = instance_double("Statistrano::Remote")
+          releaser = instance_double("Statistrano::Deployment::Releaser::Revisions")
+          allow( Statistrano::Remote ).to receive(:new)
+                                      .and_return(remote)
+          allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+                                                               .and_return(releaser)
+
+          expect( releaser ).to receive(:create_release)
+                            .with( remote, {foo: 'bar'} )
+
+          subject.deploy
+        end
+      end
+
+      context "when build task returns foo" do
+        it "passes a blank hash to create_release" do
+          subject = define_deployment "multi", :releases do
+            build_task do
+              'foo'
+            end
+            remotes [{one: 'two'}]
+          end
+          remote   = instance_double("Statistrano::Remote")
+          releaser = instance_double("Statistrano::Deployment::Releaser::Revisions")
+          allow( Statistrano::Remote ).to receive(:new)
+                                      .and_return(remote)
+          allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+                                                               .and_return(releaser)
+
+          expect( releaser ).to receive(:create_release)
+                            .with( remote, {} )
+
+          subject.deploy
+        end
+      end
+    end
+
+    it "runs create_release for each remote" do
+      @subject = define_deployment "multi", :releases do
+        build_task 'nil:bar'
+        post_deploy_task 'foo:bar'
+        remotes [{remote: 'one'},{remote: 'two'}]
+      end
+      task_double = double(invoke: nil)
+      allow( Rake::Task ).to receive(:[])
+                         .and_return(task_double)
+
+      remote   = instance_double("Statistrano::Remote")
+      releaser = instance_double("Statistrano::Deployment::Releaser::Revisions")
+      allow( Statistrano::Remote ).to receive(:new)
+                                  .and_return(remote)
+      allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+                                                           .and_return(releaser)
+
+      expect( releaser ).to receive(:create_release)
+                        .with(remote, {}).twice
+      @subject.deploy
+    end
+
+    context "when post_deploy_task is a proc" do
+      it "calls the post_deploy_task task" do
+        allow( Statistrano::Remote ).to receive(:new)
+        allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+          .and_return( double("Statistrano::Deployment::Releaser::Revisions").as_null_object )
+        subject     = define_deployment "multi", :releases
+        task_double = -> {}
+        config      = double("Statistrano::Config", build_task: -> {},
+                                                    check_git: false,
+                                                    options: { remotes: [] },
+                                                    post_deploy_task: task_double,
+                                                    log_file_path: nil)
+        allow( subject ).to receive(:config).and_return(config)
+
+        expect( task_double ).to receive(:call)
+        subject.deploy
+      end
+    end
+
+    context "when post_deploy_task is a string" do
+      it "invokes the post_deploy_task once" do
+        allow( Statistrano::Remote ).to receive(:new)
+        allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+          .and_return( double("Statistrano::Deployment::Releaser::Revisions").as_null_object )
+        @subject = define_deployment "multi", :releases do
+          build_task 'nil:bar'
+          post_deploy_task 'foo:bar'
+        end
+
+        task_double      = double(invoke: nil)
+        post_task_double = double
+        allow( Rake::Task ).to receive(:[]).with('nil:bar')
+                           .and_return(task_double)
+        expect( Rake::Task ).to receive(:[]).with('foo:bar')
+                            .and_return(post_task_double)
+        expect( post_task_double ).to receive(:invoke).once
+
+        @subject.deploy
+      end
+    end
+  end
+
+  describe "#rollback_release" do
+    it "calls rollback_release on each remote" do
+      subject = define_deployment "multi", :releases do
+        build_task 'nil:bar'
+        post_deploy_task 'foo:bar'
+        remotes [{remote: 'one'},{remote: 'two'}]
+      end
+
+      remote   = instance_double("Statistrano::Remote")
+      releaser = instance_double("Statistrano::Deployment::Releaser::Revisions")
+      allow( Statistrano::Remote ).to receive(:new)
+                                  .and_return(remote)
+      allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+                                                           .and_return(releaser)
+
+      expect( releaser ).to receive(:rollback_release)
+                        .with(remote).twice
+      subject.rollback_release
+    end
+  end
+
+  describe "#prune_releases" do
+    it "calls prune_releases on each remote" do
+      subject = define_deployment "multi", :releases do
+        build_task 'nil:bar'
+        post_deploy_task 'foo:bar'
+        remotes [{remote: 'one'},{remote: 'two'}]
+      end
+
+      remote   = instance_double("Statistrano::Remote")
+      releaser = instance_double("Statistrano::Deployment::Releaser::Revisions")
+      allow( Statistrano::Remote ).to receive(:new)
+                                  .and_return(remote)
+      allow( Statistrano::Deployment::Releaser::Revisions ).to receive(:new)
+                                                           .and_return(releaser)
+
+      expect( releaser ).to receive(:prune_releases)
+                        .with(remote).twice
+      subject.prune_releases
+    end
+  end
+
+  describe "#list_releases" do
+  end
+
+end

data/spec/lib/statistrano/deployment/strategy_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment::Strategy do
+
+  def store_registered_cache
+    @registered_cache = described_class.instance_variable_get(:@_registered)
+  end
+
+  def restore_registered_cache
+    described_class.instance_variable_set(:@_registered, @registered_cache)
+  end
+
+  def remove_registered_cache
+    if described_class.instance_variable_defined?(:@_registered)
+      described_class.send(:remove_instance_variable, :@_registered)
+    end
+  end
+
+  before :all do
+    store_registered_cache
+  end
+
+  after :all do
+    restore_registered_cache
+  end
+
+  before :each do
+    class Foo; end
+    class Woo; end
+    remove_registered_cache
+  end
+
+  describe "::registered" do
+
+    it "returns the @_registered variable" do
+      described_class.instance_variable_set(:@_registered, 'foo')
+      expect( described_class.registered ).to eq 'foo'
+    end
+
+    it "defaults to a Hash if no registered are set" do
+      hash = {}
+      expect( described_class.registered ).to eq hash
+    end
+
+  end
+
+  describe "::register" do
+
+    it "adds the class to the strategy cache" do
+      described_class.register(Foo,:foo)
+      expect( described_class.registered[:foo] ).to eq Foo
+    end
+
+    it "symbolizes provided names" do
+      described_class.register(Woo,'woo')
+      expect( described_class.registered ).to have_key :woo
+    end
+
+  end
+
+  describe "::find" do
+
+    it "returns registered strategy" do
+      described_class.register(Foo,:foo)
+      expect( described_class.find(:foo) ).to eq Foo
+    end
+
+    it "raises an UndefinedStrategy error if no strategy defined" do
+      expect {
+        described_class.find(:missing)
+      }.to raise_error Statistrano::Deployment::Strategy::UndefinedStrategy
+    end
+
+  end
+
+end

data/spec/lib/statistrano/deployment_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Statistrano::Deployment do
+end