octopolo 0.0.1

data/spec/octopolo/config_spec.rb

@@ -0,0 +1,344 @@
+require "spec_helper"
+require "fileutils"
+
+module Octopolo
+  describe Config do
+    let(:cli) { mock("cli") }
+
+    context "#initialize" do
+      subject { Config }
+
+      it "loads plugins" do
+        subject.any_instance.should_receive(:load_plugins)
+        subject.new(deploy_branch: "foo", branches_to_keep: ["a", "b"])
+      end
+
+      it "sets up methods for all the attributes it receives" do
+        config = subject.new(deploy_branch: "foo", branches_to_keep: ["a", "b"])
+
+        config.deploy_branch.should == "foo"
+        config.branches_to_keep.should == ["a", "b"]
+      end
+    end
+
+    context "default cuzomizable methods" do
+      context "#deploy_branch" do
+        it "is master by default" do
+          Config.new.deploy_branch.should == "master"
+        end
+
+        it "is the specified branch otherwise" do
+          Config.new(deploy_branch: "production").deploy_branch.should == "production"
+        end
+      end
+
+      context "#branches_to_keep" do
+        it "is an empty array by default" do
+          Config.new.branches_to_keep.should == []
+        end
+
+        it "is the specified values otherwise" do
+          Config.new(branches_to_keep: ["a", "b"]).branches_to_keep.should == ["a", "b"]
+        end
+      end
+
+      context "#deploy_methods" do
+        it "is an empty array by default" do
+          Config.new.deploy_methods.should == []
+        end
+
+        it "is the specified values otherwise" do
+          Config.new(deploy_methods: ["a", "b"]).deploy_methods.should == ["a", "b"]
+        end
+      end
+
+      context "#deploy_environments" do
+        it "is an empty array by default" do
+          Config.new.deploy_environments.should == []
+        end
+
+        it "is the specified values otherwise" do
+          Config.new(deploy_environments: ["a", "b"]).deploy_environments.should == ["a", "b"]
+        end
+      end
+
+      context "#github_repo" do
+        it "raises an exception if not given" do
+          expect { Config.new.github_repo }.to raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "returns the specified value otherwise" do
+          Config.new(github_repo: "tstmedia/ngin").github_repo.should == "tstmedia/ngin"
+        end
+      end
+
+      context "#user_notifications" do
+        it "is nil by default" do
+          Config.new.user_notifications.should == nil
+        end
+
+        it "raise an error if it is not an array" do
+          expect { Config.new(user_notifications: {:user => "NickLaMuro"}).user_notifications }.to raise_error(Config::InvalidAttributeSupplied)
+        end
+
+        it "returns the specified value if an array" do
+          Config.new(user_notifications: ["NickLaMuro"]).user_notifications.should == ["NickLaMuro"]
+        end
+
+        it "returns the specified value if as an array if a string" do
+          Config.new(user_notifications: "NickLaMuro").user_notifications.should == ["NickLaMuro"]
+        end
+      end
+
+      context "#plugins" do
+        before { Config.any_instance.stub(:load_plugins) }
+
+        it "defaults to an empty array" do
+          Config.new.plugins.should == []
+        end
+
+        it "raise an error if it is not a string or array" do
+          expect { Config.new(plugins: {:user => "foo-plugin"}).plugins }.to raise_error(Config::InvalidAttributeSupplied)
+        end
+
+        it "returns the specified single plugin as an array" do
+          Config.new(plugins: "octopolo-templates").plugins.should == ["octopolo-templates"]
+        end
+
+        it "returns the specified plugins as an array" do
+          Config.new(plugins: ["op-templates", "op-pivotal"]).plugins.should == ["op-templates", "op-pivotal"]
+        end
+      end
+
+      context "#use_pivotal_tracker" do
+        it "defaults to false" do
+          expect(Config.new.use_pivotal_tracker).to be_false
+        end
+
+        it "forces a truthy value to be true" do
+          expect(Config.new(use_pivotal_tracker: "true").use_pivotal_tracker).to be_true
+        end
+      end
+
+      context "#use_jira" do
+        it "defaults to false" do
+          expect(Config.new.use_jira).to be_false
+        end
+
+        it "forces a truthy value to be true" do
+          expect(Config.new(use_jira: "true").use_jira).to be_true
+        end
+      end
+
+      context "#jira_user" do
+        it "does not raise an exception if jira isn't enabled" do
+          expect { Config.new.jira_user }.to_not raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "raises an exception if not given" do
+          expect { Config.new(use_jira: true).jira_user }.to raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "returns the specified value otherwise" do
+          expect(Config.new(use_jira: true, jira_user: "jira-user").jira_user).to eq("jira-user")
+        end
+      end
+
+      context "#jira_password" do
+        it "does not raise an exception if jira isn't enabled" do
+          expect { Config.new.jira_password }.to_not raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "raises an exception if not given" do
+          expect { Config.new(use_jira: true).jira_password }.to raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "returns the specified value otherwise" do
+          expect(Config.new(use_jira: true, jira_password: "jira-password").jira_password).to eq("jira-password")
+        end
+      end
+      context "#jira_url" do
+        it "does not raise an exception if jira isn't enabled" do
+          expect { Config.new.jira_url }.to_not raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "raises an exception if not given" do
+          expect { Config.new(use_jira: true).jira_url }.to raise_error(Config::MissingRequiredAttribute)
+        end
+
+        it "returns the specified value otherwise" do
+          expect(Config.new(use_jira: true, jira_url: "jira-url").jira_url).to eq("jira-url")
+        end
+      end
+    end
+
+    context "loading in plugins" do
+      context "in a seperate state" do
+        fork {
+          before { Config.new(:plugins => "octopolo_plugin_example") }
+
+          it "include the plugin in the object space" do
+            expect{ ExamplePlugin.new.example_method }.not_to raise_error
+          end
+
+          it "includes any monkey patching" do
+            subject.example_var.should == ExamplePlugin::EXAMPLE_CONSTANT
+          end
+        }
+      end
+
+      context "in a clean state" do
+        it "not include the plugin in the object space" do
+          expect{ ExamplePlugin.new.example_method }.to raise_error NameError
+        end
+
+        it "not include any monkey patching" do
+          expect{ subject.example_var.should }.to raise_error NoMethodError
+        end
+      end
+    end
+
+    context ".parse" do
+      let(:parsed_attributes) { { :foo => "bar" }}
+      subject { Config }
+
+      it "reads from the .octopolo.yml file and creates a new config instance" do
+        subject.should_receive(:attributes_from_file).and_return(parsed_attributes)
+        subject.should_receive(:new).with(parsed_attributes)
+
+        subject.parse
+      end
+    end
+
+    context ".attributes_from_file" do
+      let(:stub_path) { File.join(Dir.pwd, 'spec', 'support', 'sample_octopolo.yml') }
+      subject { Config }
+
+      it "parses the YAML in the octopolo_config_path" do
+        subject.stub(:octopolo_config_path).and_return(stub_path)
+        subject.attributes_from_file.should == YAML.load_file(stub_path)
+      end
+    end
+
+    context ".octopolo_config_path" do
+      let(:project_working_dir) { Dir.pwd }
+      subject { Config }
+      before { project_working_dir }
+
+      it "gives up if it can't find a config file" do
+        File.stub(:exists?) { false }
+        Octopolo::CLI.should_receive(:say).with("Could not find .octopolo.yml or .automation.yml")
+        lambda { subject.octopolo_config_path }.should raise_error(SystemExit)
+        Dir.chdir project_working_dir
+      end
+
+      context "with a .octopolo.yml file" do
+        before do
+          FileUtils.cp "spec/support/sample_octopolo.yml", "spec/support/.octopolo.yml"
+        end
+
+        it "is the .octopolo.yml file in the project directory" do
+          Dir.chdir "spec/support"
+          subject.octopolo_config_path.should == File.join(Dir.pwd, '.octopolo.yml')
+        end
+
+        it "is the .octopolo.yml file in the project directory, two directories up" do
+          FileUtils.mkdir_p "spec/support/tmp/foo"
+          Dir.chdir "spec/support/tmp/foo"
+          subject.octopolo_config_path.should == File.join(Dir.pwd, '.octopolo.yml')
+        end
+
+        after do
+          Dir.chdir project_working_dir
+          FileUtils.rm "spec/support/.octopolo.yml"
+          FileUtils.rm_f "spec/support/tmp"
+        end
+      end
+
+      context "with a .automation.yml file" do
+        before do
+          FileUtils.cp "spec/support/sample_octopolo.yml", "spec/support/.automation.yml"
+        end
+
+        it "is the .octopolo.yml file in the project directory" do
+          Dir.chdir "spec/support"
+          subject.octopolo_config_path.should == File.join(Dir.pwd, '.automation.yml')
+        end
+
+        it "is the .octopolo.yml file in the project directory, two directories up" do
+          FileUtils.mkdir_p "spec/support/tmp/foo"
+          Dir.chdir "spec/support/tmp/foo"
+          subject.octopolo_config_path.should == File.join(Dir.pwd, '.automation.yml')
+        end
+
+        after do
+          Dir.chdir project_working_dir
+          FileUtils.rm "spec/support/.automation.yml"
+          FileUtils.rm_f "spec/support/tmp"
+        end
+      end
+
+    end
+
+    context "#load_plugins" do
+      context "with valid plugins" do
+        subject { Config.new(:plugins => "rspec") }
+
+        it "loads the plugins" do
+          subject.load_plugins
+        end
+      end
+
+      context "with invalid plugins" do
+        subject { Config.new }
+
+        it "skips loading the plugin and displays a message" do
+          subject.instance_variable_set(:@plugins, "not-a-real-plugin")
+          subject.should_receive(:puts)
+                 .with("Plugin 'not-a-real-plugin' failed to load")
+
+          subject.load_plugins
+        end
+      end
+    end
+
+    context "#remote_branch_exists?" do
+      before do
+        Octopolo::CLI.stub(:perform => <<-BR
+                          * origin/production
+                            origin/test
+                            origin/asdf
+                            BR
+                            )
+      end
+
+      it "should find production" do
+        subject.remote_branch_exists?("production").should == true
+      end
+
+      it "shouldn't production" do
+        subject.remote_branch_exists?("not-there").should == false
+      end
+    end
+
+    context "#basedir" do
+      let(:project_working_dir) { Dir.pwd }
+      before do
+        project_working_dir
+        FileUtils.cp "spec/support/sample_octopolo.yml", "spec/support/.octopolo.yml"
+      end
+
+      it "returns the name of the directory containing the .octopolo.yml file" do
+        Dir.chdir "spec/support"
+        config = Config.new
+        expected_value = File.basename(File.dirname(Config.octopolo_config_path))
+        config.basedir.should == expected_value
+      end
+
+      after do
+        Dir.chdir project_working_dir
+        FileUtils.rm "spec/support/.octopolo.yml"
+      end
+    end
+  end
+end

data/spec/octopolo/convenience_wrappers_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+require_relative "../../lib/octopolo/convenience_wrappers"
+require_relative "../../lib/octopolo/git"
+
+module Octopolo
+  class Foo
+    include CLIWrapper
+    include ConfigWrapper
+    include UserConfigWrapper
+    include GitWrapper
+  end
+
+  describe CLIWrapper do
+    let(:foo) { Foo.new }
+    let(:cli) { stub(:CLI) }
+
+    context "#cli" do
+      it "wraps around the CLI class" do
+        foo.cli.should == CLI
+      end
+
+      it "uses the given CLI class" do
+        foo.cli = cli
+        foo.cli.should == cli
+      end
+    end
+  end
+
+  describe ConfigWrapper do
+    let(:foo) { Foo.new }
+    let(:config) { stub(:config) }
+
+    context "#config" do
+      it "parses the current config" do
+        Octopolo.should_receive(:config) { config }
+        foo.config.should == config
+      end
+
+      it "uses the given parsed config" do
+        Config.should_not_receive(:parse)
+        foo.config = config
+        foo.config.should == config
+      end
+    end
+  end
+
+  describe UserConfigWrapper do
+    let(:foo) { Foo.new }
+    let(:user_config) { stub(:user_config) }
+
+    context "#user_config" do
+      it "parses the current user config" do
+        UserConfig.should_receive(:parse) { user_config }
+        foo.user_config.should == user_config
+      end
+
+      it "uses the given parsed config" do
+        foo.user_config = user_config
+        UserConfig.should_not_receive(:parse)
+        foo.user_config.should == user_config
+      end
+    end
+  end
+
+  describe GitWrapper do
+    subject { Foo.new }
+    let(:git) { stub(:Git) }
+
+    context "#git" do
+      it "wraps around the Git class" do
+        subject.git.should == Git
+      end
+
+      it "uses the given Git" do
+        subject.git = git
+        subject.git.should == git
+      end
+    end
+  end
+end

data/spec/octopolo/dated_branch_creator_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+require_relative "../../lib/octopolo/dated_branch_creator"
+
+module Octopolo
+  describe DatedBranchCreator do
+    let(:type) { stub(:string) }
+    let(:branch_name) { stub(:string) }
+    let(:cli) { stub(:CLI) }
+    let(:config) { stub(:Config, app_name: "fooapp", deploy_branch: "somebranch") }
+    let(:git) { stub(:Git) }
+
+    subject { DatedBranchCreator.new type }
+
+    before do
+      subject.cli = cli
+      subject.config = config
+      subject.git = git
+    end
+
+    context ".perform(branch_type)" do
+      let(:creator) { stub(:DatedBranchCreator) }
+
+      it "instantiates a new creator and performs it" do
+        DatedBranchCreator.should_receive(:new).with(type) { creator }
+        creator.should_receive(:perform)
+        DatedBranchCreator.perform(type).should == creator
+      end
+    end
+
+    context ".new(branch_type)" do
+      it "remembers the branch_type" do
+        test = DatedBranchCreator.new(type)
+        test.branch_type.should == type
+      end
+    end
+
+    context "#perform" do
+      it "creates the branch and handles cleaning up and posting about it" do
+        subject.should_receive(:create_branch)
+        subject.should_receive(:delete_old_branches)
+
+        subject.perform
+      end
+    end
+
+    context "#create_branch" do
+      let(:runner) { stub("script::new_branch") }
+
+      before do
+        subject.stub(branch_name: branch_name)
+      end
+
+      it "creates a branch from its #branch_name" do
+        git.should_receive(:new_branch).with(branch_name, config.deploy_branch)
+        subject.create_branch
+      end
+    end
+
+    context "#date_suffix" do
+      it "uses today's date" do
+        subject.date_suffix.should == Date.today.strftime("%Y.%m.%d")
+      end
+    end
+
+    context "#branch_name" do
+      it "properly generates a name for staging branches" do
+        subject.branch_type = Git::STAGING_PREFIX
+        subject.branch_name.should == "#{Git::STAGING_PREFIX}.#{subject.date_suffix}"
+      end
+
+      it "properly generates a name for deployable branches" do
+        subject.branch_type = Git::DEPLOYABLE_PREFIX
+        subject.branch_name.should == "#{Git::DEPLOYABLE_PREFIX}.#{subject.date_suffix}"
+      end
+
+      it "properly generates a name for qaready branches" do
+        subject.branch_type = Git::QAREADY_PREFIX
+        subject.branch_name.should == "#{Git::QAREADY_PREFIX}.#{subject.date_suffix}"
+      end
+
+      it "raises an exception for other branch types" do
+        subject.branch_type = "asdfasdfasdf"
+        expect { subject.branch_name }.to raise_error(DatedBranchCreator::InvalidBranchType, "'#{subject.branch_type}' is not a valid branch type")
+      end
+    end
+
+    context "#delete_old_branches" do
+      it "does nothing if no extra branches" do
+        subject.stub(extra_branches: [])
+        cli.should_not_receive(:ask_boolean)
+        subject.delete_old_branches
+      end
+
+      context "having extra branches" do
+        let(:extras) { %w(foo bar) }
+        let(:message) { "Do you want to delete the old #{subject.branch_type} branch(es)? (#{extras.join(", ")})"}
+
+        before do
+          subject.stub(extra_branches: extras)
+        end
+
+        it "deletes these branches if user opts to" do
+          cli.should_receive(:ask_boolean).with(message) { true }
+          extras.each do |extra|
+            Git.should_receive(:delete_branch).with(extra)
+          end
+          subject.delete_old_branches
+        end
+
+        it "does nothing if user opts not to delete" do
+          cli.should_receive(:ask_boolean).with(message) { false }
+          cli.should_not_receive(:perform)
+          subject.delete_old_branches
+        end
+      end
+    end
+
+    context "#extra_branches" do
+      let(:extra_deployables) { %w(foo bar) }
+      let(:extra_stagings) { %w(bing bang) }
+
+      it "gets the correct list for staging branches" do
+        subject.branch_type = Git::STAGING_PREFIX
+        Git.stub(:branches_for).with(Git::STAGING_PREFIX) { extra_stagings + [subject.branch_name] }
+        subject.extra_branches.should_not include subject.branch_name
+        subject.extra_branches.should == extra_stagings
+      end
+
+      it "gets the correct list for deployable branches" do
+        subject.branch_type = Git::DEPLOYABLE_PREFIX
+        Git.stub(:branches_for).with(Git::DEPLOYABLE_PREFIX) { extra_deployables + [subject.branch_name] }
+        subject.extra_branches.should_not include subject.branch_name
+        subject.extra_branches.should == extra_deployables
+      end
+
+      it "raises an exception for any other branch type" do
+        subject.branch_type = "asdfasdfasdf"
+        expect { subject.extra_branches }.to raise_error(DatedBranchCreator::InvalidBranchType, "'#{subject.branch_type}' is not a valid branch type")
+      end
+  ; end
+
+  end
+end