auto_tagger 0.1.5 → 0.2.0

data/spec/auto_tagger/base_spec.rb

@@ -1,85 +1,269 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
-describe AutoTagger::Runner do
-  before(:each) do
-    stub(Dir).pwd { File.join(File.dirname(__FILE__), '..', '..') }
+describe AutoTagger::Base do
+
+  describe "#repo" do
+    it "returns a repo with the correct options" do
+      base = AutoTagger::Base.new :path => "/foo",
+                                  :dry_run => true,
+                                  :verbose => true,
+                                  :executable => "/usr/bin/git"
+      AutoTagger::Git::Repo.should_receive(:new).with "/foo",
+                                                      :execute_commands => false,
+                                                      :verbose => true,
+                                                      :executable => "/usr/bin/git"
+      base.repo
+    end
+  end
+
+  describe "#last_ref_from_previous_stage" do
+    it "returns nil if there is no previous stage" do
+      refs = "0f7324495f06e2b refs/tags/ci/2001"
+      base = AutoTagger::Base.new :stages => ["ci", "demo", "production"], :stage => "ci"
+      base.repo.stub(:read).and_return(refs)
+      base.last_ref_from_previous_stage.should be_nil
+    end
+
+    it "returns nil if there are no matching refs" do
+      refs = "0f7324495f06e2b refs/tags-ci/2001"
+      base = AutoTagger::Base.new :stages => ["ci", "demo", "production"], :stage => "ci"
+      base.repo.stub(:read).and_return(refs)
+      base.last_ref_from_previous_stage.should be_nil
+    end
+
+    it "should return the last ref from the previous stage" do
+      refs = %Q{
+        41dee06050450ac refs/tags/ci/2003
+        41dee06050450a5 refs/tags/ci/2003
+        61c6627d766c1be refs/tags/demo/2001
+      }
+      base = AutoTagger::Base.new :stages => ["ci", "demo", "production"], :stage => "demo"
+      base.repo.stub(:read).and_return(refs)
+      ref = AutoTagger::Git::Ref.new(base.repo, "41dee06050450ac", "refs/tags/ci/2003")
+      base.last_ref_from_previous_stage.name.should == "refs/tags/ci/2003"
+    end
   end
 
-  describe ".new" do
-    it "blows up if you don't pass an stage" do
+  describe "#create_ref" do
+    it "creates a ref with the given sha and returns the ref" do
+      base = AutoTagger::Base.new :stage => "demo"
+      base.stub(:timestamp).and_return("20081010")
+
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("update-ref refs/tags/demo/20081010 abc123")
+
+      ref = base.create_ref "abc123"
+      ref.name.should == "refs/tags/demo/20081010"
+      ref.sha.should == "abc123"
+    end
+
+    it "defaults to the latest commit sha" do
+      base = AutoTagger::Base.new :stage => "demo"
+      base.stub(:timestamp).and_return("20081010")
+
+      base.repo.should_receive(:latest_commit_sha).and_return("abc123")
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("update-ref refs/tags/demo/20081010 abc123")
+
+      ref = base.create_ref
+      ref.name.should == "refs/tags/demo/20081010"
+      ref.sha.should == "abc123"
+    end
+
+    it "respects the passed in date separator" do
+      time = Time.now.utc
+      timestamp = time.strftime("%Y-%m-%d-%H-%M-%S")
+      base = AutoTagger::Base.new :stage => "ci", :date_separator => "-"
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("update-ref refs/tags/ci/#{timestamp} abc123")
+      base.create_ref "abc123"
+    end
+
+    it "raises an error if the stage is not set" do
       proc do
-        AutoTagger::Runner.new(nil)
-      end.should raise_error(AutoTagger::EnvironmentCannotBeBlankError)
+        AutoTagger::Base.new({}).create_ref
+      end.should raise_error(AutoTagger::Base::StageCannotBeBlankError)
     end
 
-    it "sets the stage when it's passed" do
-      AutoTagger::Runner.new("ci").stage.should == "ci"
+    it "fetches tags before creating tags" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("fetch origin refs/tags/*:refs/tags/*")
+      base.create_ref "abc123"
     end
 
-    it "sets the path to Dir.pwd when nil" do
-      mock(Dir).pwd { "/foo" }
-      mock(AutoTagger::Repository).new("/foo")
-      AutoTagger::Runner.new("ci")
+    it "does not fetch tags before creating tags if fetch tags is false" do
+      base = AutoTagger::Base.new :stage => "ci", :fetch_tags => false
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("push origin refs/tags/*:refs/tags/*")
+      base.create_ref "abc123"
     end
 
-    it "expands the path when the path is passed" do
-      mock(AutoTagger::Repository).new(File.expand_path("."))
-      AutoTagger::Runner.new("ci", ".")
+    it "pushes tags before creating tags" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("push origin refs/tags/*:refs/tags/*")
+      base.create_ref "abc123"
     end
 
-    it "exposes the working directory" do
-      mock(AutoTagger::Repository).new(File.expand_path("."))
-      AutoTagger::Runner.new("ci", ".").working_directory.should == File.expand_path(".")
+    it "does not push tags before creating tags if push tags is false" do
+      base = AutoTagger::Base.new :stage => "ci", :push_tags => false
+      base.repo.stub(:exec) { true }
+      base.repo.should_receive(:exec).with("push origin refs/tags/*:refs/tags/*")
+      base.create_ref "abc123"
     end
   end
 
-  describe "#create_tag" do
-    it "generates the correct commands" do
-      time = Time.local(2001,1,1)
-      mock(Time).now.once {time}
-      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
-      mock(File).exists?(anything).twice { true }
+  describe "#delete_locally" do
+    it "blows up if you don't enter a stage" do
+      base = AutoTagger::Base.new({})
+      proc do
+        base.delete_locally
+      end.should raise_error(AutoTagger::Base::StageCannotBeBlankError)
+    end
 
-      mock(AutoTagger::Commander).execute?("/foo", "git fetch origin --tags") {true}
-      mock(AutoTagger::Commander).execute?("/foo", "git tag ci/#{timestamp}") {true}
-      mock(AutoTagger::Commander).execute?("/foo", "git push origin --tags")  {true}
+    it "executes the local delete commands for all the refs that match" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.stub(:refs_for_stage) do
+        [
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008"),
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009"),
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2010")
+        ]
+      end
+      base.repo.should_receive(:exec).with("update-ref -d refs/tags/ci/2008")
+      base.repo.should_receive(:exec).with("update-ref -d refs/tags/ci/2009")
+      base.repo.should_not_receive(:exec).with("update-ref -d refs/tags/ci/2010")
+      base.delete_locally
+    end
+  end
 
-      AutoTagger::Runner.new("ci", "/foo").create_tag
+  describe "#delete_on_remote" do
+    it "blows up if you don't enter a stage" do
+      base = AutoTagger::Base.new({})
+      proc do
+        base.delete_on_remote
+      end.should raise_error(AutoTagger::Base::StageCannotBeBlankError)
     end
 
-    it "allows you to base it off an existing tag or commit" do
-      time = Time.local(2001,1,1)
-      mock(Time).now.once {time}
-      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
-      mock(File).exists?(anything).twice { true }
+    it "does not push if there are no tags" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.stub(:refs_for_stage).with("ci") {[]}
+      base.repo.should_not_receive(:exec)
+      base.delete_on_remote
+    end
 
-      mock(AutoTagger::Commander).execute?("/foo", "git fetch origin --tags") {true}
-      mock(AutoTagger::Commander).execute?("/foo", "git tag ci/#{timestamp} guid") {true}
-      mock(AutoTagger::Commander).execute?("/foo", "git push origin --tags")  {true}
+    it "executes the remote delete commands in a batch" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.stub(:refs_for_stage).with("ci") do
+        [
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008"),
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009"),
+          AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2010")
+        ]
+      end
+      base.repo.should_receive(:exec).with("push origin :refs/tags/ci/2008 :refs/tags/ci/2009")
+      base.delete_on_remote
+    end
+  end
 
-      AutoTagger::Runner.new("ci", "/foo").create_tag("guid")
+  describe "#cleanup" do
+    it "blows up if you don't enter a stage" do
+      base = AutoTagger::Base.new({})
+      proc do
+        base.cleanup
+      end.should raise_error(AutoTagger::Base::StageCannotBeBlankError)
     end
 
-    it "returns the tag that was created" do
-      time = Time.local(2001,1,1)
-      mock(Time).now.once {time}
-      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
-      mock(File).exists?(anything).twice { true }
-      mock(AutoTagger::Commander).execute?(anything, anything).times(any_times) {true}
+    it "executes delete locally" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.stub(:refs_for_stage).with("ci") { [AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008")] }
+      base.should_receive(:delete_local_refs)
+      base.cleanup
+    end
 
-      AutoTagger::Runner.new("ci", "/foo").create_tag.should == "ci/#{timestamp}"
+    it "executes delete on remote if push refs is true" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      base.stub(:refs_for_stage).with("ci") { [AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008")] }
+      base.should_receive(:delete_remote_refs)
+      base.cleanup
+    end
+
+    it "does not execute delete on remote if push refs is false" do
+      base = AutoTagger::Base.new :stage => "ci", :offline => true
+      base.repo.stub(:exec) { true }
+      base.stub(:refs_for_stage).with("ci") { [AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008")] }
+      base.should_not_receive(:delete_remote_refs)
+      base.cleanup
     end
   end
 
-  describe "#latest_tag" do
-    it "generates the correct commands" do
-      mock(File).exists?(anything).twice { true }
+  describe ".items_to_remove" do
+    it "returns the items that can be removed from an array, based on the keep value passed in" do
+      AutoTagger::Base.items_to_remove(["2008"], 0).should == ["2008"]
+      AutoTagger::Base.items_to_remove(["2008"], 1).should == []
+      AutoTagger::Base.items_to_remove(["2008", "2009"], 0).should == ["2008", "2009"]
+      AutoTagger::Base.items_to_remove(["2008", "2009"], 1).should == ["2008"]
+      AutoTagger::Base.items_to_remove(["2008", "2009"], 2).should == []
+      AutoTagger::Base.items_to_remove(["2008", "2009"], 3).should == []
+      AutoTagger::Base.items_to_remove(["2008", "2009", "2010"], 0).should == ["2008", "2009", "2010"]
+      AutoTagger::Base.items_to_remove(["2008", "2009", "2010"], 1).should == ["2008", "2009"]
+      AutoTagger::Base.items_to_remove(["2008", "2009", "2010"], 2).should == ["2008"]
+      AutoTagger::Base.items_to_remove(["2008", "2009", "2010"], 3).should == []
+    end
+  end
 
-      mock(AutoTagger::Commander).execute?("/foo", "git fetch origin --tags") {true}
-      mock(AutoTagger::Commander).execute("/foo", "git tag") { "ci_01" }
+  describe "#refs_for_stage" do
+    it "returns refs that match the given stage" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.repo.stub(:exec) { true }
+      refs = [
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/auto_tags/ci/2008"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags-ci/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/heads/master")
+      ]
+      base.repo.stub(:refs) { mock("RefSet", :all => refs) }
+      base.refs_for_stage("ci").should == [
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009")
+      ]
+    end
+  end
 
-      AutoTagger::Runner.new("ci", "/foo").latest_tag
+  describe "#list" do
+    it "return a list of refs for the given stage" do
+      base = AutoTagger::Base.new :stage => "ci"
+      base.should_receive(:fetch)
+      base.should_receive(:refs_for_stage).with("ci")
+      base.list
     end
   end
 
+  describe "#release_tag_entries" do
+    it "lists the last ref from each stage" do
+      base = AutoTagger::Base.new :stage => "ci", :stages => ["ci", "demo", "production"]
+      base.repo.stub(:exec) { true }
+      refs = [
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2008"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/demo/2008"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/demo/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/production/2008"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/production/2009")
+      ]
+      base.repo.stub(:refs) { mock("RefSet", :all => refs) }
+      base.release_tag_entries.should == [
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/ci/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/demo/2009"),
+        AutoTagger::Git::Ref.new(base.repo, "abc123", "refs/tags/production/2009")
+      ]
+    end
+  end
+
+
 end

data/spec/auto_tagger/capistrano_helper_spec.rb

@@ -1,145 +1,115 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe AutoTagger::CapistranoHelper do
 
-  describe ".new" do
-    it "blows up if there are no stages" do
-      proc do
-        AutoTagger::CapistranoHelper.new({})
-      end.should raise_error(AutoTagger::StageManager::NoStagesSpecifiedError)
+  describe "#ref" do
+    it "returns the specified branch when passed the :head variable" do
+      helper = AutoTagger::CapistranoHelper.new :branch => "release", :head => nil
+      helper.ref.should == "release"
     end
-  end
 
-  describe "#variables" do
-    it "returns all variables" do
-      AutoTagger::CapistranoHelper.new({:autotagger_stages => [:bar]}).variables.should == {:autotagger_stages => [:bar]}
+    it "returns the specified tag" do
+      helper = AutoTagger::CapistranoHelper.new :tag => "v0.1.7"
+      helper.ref.should == "v0.1.7"
+    end
+
+    it "returns the specified ref" do
+      helper = AutoTagger::CapistranoHelper.new :ref => "refs/auto_tags/ci"
+      helper.ref.should == "refs/auto_tags/ci"
     end
-  end
 
-  describe "#working_directory" do
-    it "returns the hashes' working directory value" do
-      AutoTagger::CapistranoHelper.new({:autotagger_stages => [:bar], :working_directory => "/foo"}).working_directory.should == "/foo"
+    it "returns the sha of the last ref from that stage" do
+      helper = AutoTagger::CapistranoHelper.new({})
+      ref = mock(AutoTagger::Git::Ref, :sha => "abc123")
+      auto_tagger = mock AutoTagger::Base, :last_ref_from_previous_stage => ref
+      helper.stub(:auto_tagger) { auto_tagger }
+      helper.ref.should == "abc123"
     end
 
-    it "defaults to Dir.pwd if it's not set, or it's nil" do
-      mock(Dir).pwd { "/bar" }
-      AutoTagger::CapistranoHelper.new({:autotagger_stages => [:bar]}).working_directory.should == "/bar"
+    it "returns the branch when specified" do
+      helper = AutoTagger::CapistranoHelper.new :branch => "release"
+      helper.ref.should == "release"
     end
   end
 
-  describe "#stage" do
-    it "returns the hashes' current stage value" do
-      AutoTagger::CapistranoHelper.new({:autotagger_stages => [:bar], :stage => :bar}).stage.should == :bar
-      AutoTagger::CapistranoHelper.new({:autotagger_stages => [:bar]}).stage.should be_nil
+  describe "#auto_tagger" do
+    it "returns an AutoTagger::Base object with the correct options" do
+      helper = AutoTagger::CapistranoHelper.new({})
+      helper.stub(:auto_tagger_options).and_return({:foo => "bar"})
+      AutoTagger::Base.should_receive(:new).with({:foo => "bar"})
+      helper.auto_tagger
     end
   end
 
-  describe "#release_tag_entries" do
-    it "returns a column-justifed version of all the commits" do
-      mock(AutoTagger::Commander).execute("/foo", "git tag").times(any_times) { "ci/01\nstaging/01\nproduction/01" }
-      mock(AutoTagger::Commander).execute("/foo", "git --no-pager log ci/01 --pretty=oneline -1") { "guid1" }
-      mock(AutoTagger::Commander).execute("/foo", "git --no-pager log staging/01 --pretty=oneline -1") { "guid2" }
-      mock(AutoTagger::Commander).execute("/foo", "git --no-pager log production/01 --pretty=oneline -1") { "guid3" }
-      mock(AutoTagger::Commander).execute?("/foo", "git fetch origin --tags").times(any_times) { true }
-      mock(File).exists?(anything).times(any_times) {true}
-
-      variables = {
-        :working_directory => "/foo",
-        :autotagger_stages => [:ci, :staging, :production]
-      }
-      histories = AutoTagger::CapistranoHelper.new(variables).release_tag_entries
-      histories.length.should == 3
-      histories[0].should include("ci/01", "guid1")
-      histories[1].should include("staging/01", "guid2")
-      histories[2].should include("production/01", "guid3")
+  describe "#auto_tagger_options" do
+    it "includes :stage from :auto_tagger_stage, :stage" do
+      helper = AutoTagger::CapistranoHelper.new :stage => "demo"
+      helper.auto_tagger_options[:stage].should == "demo"
+
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_stage => "demo"
+      helper.auto_tagger_options[:stage].should == "demo"
+
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_stage => "demo", :stage => "ci"
+      helper.auto_tagger_options[:stage].should == "demo"
     end
 
-    it "ignores tags delimited with '_'" do
-      mock(AutoTagger::Commander).execute("/foo", "git tag").times(any_times) { "ci/01\nci_02" }
-      mock(AutoTagger::Commander).execute("/foo", "git --no-pager log ci/01 --pretty=oneline -1") { "guid1" }
-      mock(AutoTagger::Commander).execute?("/foo", "git fetch origin --tags").times(any_times) { true }
-      mock(File).exists?(anything).times(any_times) {true}
-
-      variables = {
-        :working_directory => "/foo",
-        :autotagger_stages => [:ci]
-      }
-      histories = AutoTagger::CapistranoHelper.new(variables).release_tag_entries
-      histories.length.should == 1
-      histories[0].should include("ci/01", "guid1")
+    it "includes stages" do
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_stages => ["demo"]
+      helper.auto_tagger_options[:stages].should == ["demo"]
     end
-  end
 
-  describe "#branch" do
-    describe "with :head and :branch specified" do
-      it "returns master" do
-        variables = {
-          :autotagger_stages => [:bar],
-          :head => nil,
-          :branch => "foo"
-        }
-        AutoTagger::CapistranoHelper.new(variables).branch.should == "foo"
-      end
+    it "includes :auto_tagger_working_directory" do
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_working_directory => "/foo"
+      helper.auto_tagger_options[:path].should == "/foo"
     end
 
-    describe "with :head specified, but no branch specified" do
-      it "returns master" do
-        variables = {
-          :autotagger_stages => [:bar],
-          :head => nil
-        }
-        AutoTagger::CapistranoHelper.new(variables).branch.should == nil
-      end
+    it "includes and deprecates :working_directory" do
+      AutoTagger::Deprecator.should_receive(:warn)
+      helper = AutoTagger::CapistranoHelper.new :working_directory => "/foo"
+      helper.auto_tagger_options[:path].should == "/foo"
     end
 
-    describe "with :branch specified" do
-      it "returns the value of branch" do
-        variables = {
-          :autotagger_stages => [:bar],
-          :branch => "foo"
-        }
-        AutoTagger::CapistranoHelper.new(variables).branch.should == "foo"
+    [
+      :date_separator,
+      :push_refs,
+      :fetch_refs,
+      :remote,
+      :ref_path,
+      :offline,
+      :dry_run,
+      :verbose,
+      :refs_to_keep,
+      :executable,
+      :opts_file
+    ].each do |key|
+      it "incudes :#{key}" do
+        helper = AutoTagger::CapistranoHelper.new :"auto_tagger_#{key}" => "value"
+        helper.auto_tagger_options[key].should == "value"
       end
     end
 
-    describe "with a previous stage with a tag" do
-      it "returns the latest tag for the previous stage" do
-        variables = {
-          :autotagger_stages => [:foo, :bar],
-          :stage => :bar,
-          :branch => "master",
-          :working_directory => "/foo"
-        }
-        tagger = Object.new
-        mock(tagger).latest_tag { "foo_01" }
-        mock(AutoTagger::Runner).new("foo", "/foo") { tagger }
-        AutoTagger::CapistranoHelper.new(variables).branch.should == "foo_01"
-      end
+  end
+
+  describe "#stages" do
+    it "understands :stages" do
+      helper = AutoTagger::CapistranoHelper.new :stages => ["demo"]
+      helper.stages.should == ["demo"]
     end
 
-    describe "with no branch and a previous stage with no tag" do
-      it "returns nil" do
-        variables = {
-          :autotagger_stages => [:foo, :bar],
-          :stage => :bar,
-          :working_directory => "/foo"
-        }
-        tagger = Object.new
-        mock(tagger).latest_tag { nil }
-        mock(AutoTagger::Runner).new("foo", "/foo") { tagger }
-        AutoTagger::CapistranoHelper.new(variables).branch.should == nil
-      end
+    it "understands :auto_tagger_stages" do
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_stages => ["demo"]
+      helper.auto_tagger_options[:stages].should == ["demo"]
     end
 
-    describe "with no branch and previous stage" do
-      it "returns nil" do
-        variables = {
-          :autotagger_stages => [:bar],
-          :stage => :bar
-        }
-        AutoTagger::CapistranoHelper.new(variables).previous_stage.should be_nil
-        AutoTagger::CapistranoHelper.new(variables).branch.should == nil
-      end
+    it "understands and deprecates :autotagger_stages" do
+      AutoTagger::Deprecator.should_receive(:warn)
+      helper = AutoTagger::CapistranoHelper.new :autotagger_stages => ["demo"]
+      helper.stages.should == ["demo"]
+    end
+
+    it "makes all stages strings" do
+      helper = AutoTagger::CapistranoHelper.new :auto_tagger_stages => [:demo]
+      helper.stages.should == ["demo"]
     end
   end