zenflow 0.8.0

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+require 'zenflow'
+require 'vcr'
+
+VCR.configure do |c|
+  c.configure_rspec_metadata!
+  c.cassette_library_dir = 'spec/fixtures/cassettes'
+  c.hook_into :webmock
+  c.default_cassette_options = { :record => :new_episodes }
+  c.filter_sensitive_data('<GITHUB-USER>'){ Zenflow::Github.user }
+  c.filter_sensitive_data('<ZENFLOW-TOKEN>'){ Zenflow::Github.zenflow_token }
+end
+
+RSpec.configure do |config|
+  config.order = "random"
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus => true
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+    result
+  end
+end

data/spec/support/shared_examples_for_version_number.rb

@@ -0,0 +1,19 @@
+shared_examples_for "a version" do |version_array|
+  it{expect(subject.instance_variable_get('@version')).to(have_key('major'))}
+  it{expect(subject.instance_variable_get('@version')).to(have_key('minor'))}
+  it{expect(subject.instance_variable_get('@version')).to(have_key('patch'))}
+  it{expect(subject.instance_variable_get('@version')).to(have_key('pre'))}
+
+  it{
+    expect(
+      subject.instance_variable_get('@version')
+    ).to(eq(
+      {
+        'major' => version_array[0],
+        'minor' => version_array[1],
+        'patch' => version_array[2],
+        'pre' => version_array[3]
+      }
+    ) )
+  }
+end

data/spec/zenflow/commands/deploy_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Zenflow::Deploy do
+
+  describe "Zenflow.Deploy" do
+    context 'with migrations' do
+      it 'deploys with migrations' do
+        Zenflow::Branch.should_receive(:push).with('some-server')
+        Zenflow.should_receive(:Log).with("Deploying with migrations to some-server")
+        Zenflow::Shell.should_receive(:run).with("cap some-server deploy:migrations")
+        Zenflow::Deploy('some-server', :migrations => true)
+      end
+    end
+
+    context 'without migrations' do
+      it 'deploys without migrations' do
+        Zenflow::Branch.should_receive(:push).with('some-server')
+        Zenflow.should_receive(:Log).with("Deploying to some-server")
+        Zenflow::Shell.should_receive(:run).with("cap some-server deploy")
+        Zenflow::Deploy('some-server')
+      end
+    end
+  end
+
+  subject {Zenflow::Deploy.new}
+
+  describe '#qa' do
+    it 'Deploys to QA' do
+      Zenflow.should_receive(:Deploy).with('qa', {})
+      subject.qa
+    end
+  end
+
+  describe '#staging' do
+    it 'Deploys to staging' do
+      Zenflow.should_receive(:Deploy).with('staging', {})
+      subject.staging
+    end
+  end
+
+  describe '#staging' do
+    it 'Deploys to production' do
+      Zenflow.should_receive(:Deploy).with('production', {})
+      subject.production
+    end
+  end
+
+end

data/spec/zenflow/commands/feature_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Zenflow::Feature do
+
+  subject { Zenflow::Feature.new }
+
+  it { expect(subject.flow).to eq("feature") }
+  it { expect(subject.branch(:source)).to eq("master") }
+  it { expect(subject.branch(:deploy)).to eq("qa") }
+
+end

data/spec/zenflow/commands/hotfix_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Zenflow::Hotfix do
+
+  subject { Zenflow::Hotfix.new }
+
+  it { expect(subject.flow).to eq("hotfix") }
+  it { expect(subject.branch(:source)).to eq("production") }
+  it { expect(subject.branch(:deploy)).to match_array(["staging", "qa"]) }
+  it { expect(subject.changelog).to eq(:rotate) }
+  it { expect(subject.version).to eq(:patch) }
+  it { expect(subject.tag).to be_true }
+
+end

data/spec/zenflow/commands/release_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zenflow::Release do
+
+  subject { Zenflow::Release.new }
+
+  it { expect(subject.flow).to eq("release") }
+  it { expect(subject.branch(:source)).to eq("master") }
+  it { expect(subject.branch(:destination)).to eq("production") }
+  it { expect(subject.branch(:deploy)).to match_array(["staging", "qa"]) }
+  it { expect(subject.changelog).to eq(:rotate) }
+  it { expect(subject.version).to eq(:minor) }
+  it { expect(subject.tag).to be_true }
+
+end

data/spec/zenflow/commands/reviews_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zenflow::Reviews do
+
+  describe "#list" do
+    before do
+      pull = double
+      pull.stub(:[]).with("number").and_return(1)
+      pull.stub(:[]).with("head").and_return({ "ref" => "URL" })
+      Zenflow::PullRequest.should_receive(:list).and_return([pull])
+    end
+    it { capture(:stdout) { Zenflow::Reviews.new.invoke(:list) } }
+  end
+
+end

data/spec/zenflow/helpers/ask_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Zenflow do
+
+  describe "prompt" do
+    before do
+      Zenflow.stub(:LogToFile)
+      $stdin.stub(:gets).and_return("good")
+    end
+
+    it "displays a prompt" do
+      Zenflow::Query.should_receive(:print).with(">> How are you? ")
+      Zenflow::Ask("How are you?")
+    end
+
+    it "displays a prompt with options" do
+      Zenflow::Query.should_receive(:print).with(">> How are you? [good/bad] ")
+      Zenflow::Ask("How are you?", options: ["good", "bad"])
+    end
+
+    it "displays a prompt with default" do
+      Zenflow::Query.should_receive(:print).with(">> How are you? [good] ")
+      Zenflow::Ask("How are you?", default: "good")
+    end
+
+    it "displays a prompt with options and default" do
+      Zenflow::Query.should_receive(:print).with(">> How are you? [good/bad] ")
+      Zenflow::Ask("How are you?", options: ["good", "bad"], default: "good")
+    end
+
+    context "on error" do
+      before(:each) do
+        Zenflow::Query.should_receive(:ask_question).at_least(:once).and_return('foo')
+        Zenflow::Query.should_receive(:handle_response).once.and_raise('something failed')
+        $stdout.should_receive(:puts).once
+      end
+
+      it{expect{Zenflow::Ask('howdy', response: 'foo', error_message: 'something failed')}.to raise_error(/something failed/)}
+    end
+
+    context "on interrupt" do
+      before(:each) do
+        Zenflow::Query.should_receive(:ask_question).once.and_return('foo')
+        Zenflow::Query.should_receive(:handle_response).once.and_raise(Interrupt)
+        Zenflow.should_receive(:LogToFile)
+        $stdout.should_receive(:puts).at_least(:once)
+      end
+
+      it{expect{Zenflow::Ask('howdy')}.to raise_error(SystemExit)}
+    end
+  end
+
+  describe Zenflow::Query do
+    describe '.get_response' do
+      context 'with a response' do
+        it{expect(
+          Zenflow::Query.ask_question('foo?', response: 'bar')).to eq('bar')
+        }
+      end
+
+      context 'with a response' do
+        before(:each) do
+          Zenflow::Query.should_receive(:prompt_for_answer).with('foo?',{}).and_return('bar')
+        end
+
+        it{expect(Zenflow::Query.ask_question('foo?')).to eq('bar')}
+      end
+    end
+
+    describe '.prompt_for_answer' do
+      before(:each) do
+        Zenflow::Query.should_receive(:print).with(">> Hi? [yes/bye] ")
+        STDIN.should_receive(:gets).and_return("bye")
+      end
+
+      it{expect(
+        Zenflow::Query.prompt_for_answer('Hi?', options: ['yes','bye'])
+      ).to(
+        eq('bye')
+      ) }
+    end
+
+    describe '.handle_response' do
+      context 'invalid response' do
+        before(:each){Zenflow::Query.should_receive(:valid_response?).and_return(false)}
+        it{expect{Zenflow::Query.handle_response('foo')}.to raise_error}
+      end
+
+      context 'valid response' do
+        before(:each){Zenflow::Query.should_receive(:valid_response?).and_return(true)}
+        it{expect(Zenflow::Query.handle_response('foo')).to eq('foo')}
+        it{expect(Zenflow::Query.handle_response('Y')).to eq('y')}
+        it{expect(Zenflow::Query.handle_response('N')).to eq('n')}
+        it{expect(Zenflow::Query.handle_response('', default: 'foo')).to eq('foo')}
+      end
+    end
+
+    describe '.valid_response?' do
+      it{expect(Zenflow::Query.valid_response?('foo', options: ['foo'])).to eq(true)}
+      it{expect(Zenflow::Query.valid_response?('foo', options: ['bar'])).to eq(false)}
+      it{expect(Zenflow::Query.valid_response?('foo', validate: /foo/)).to eq(true)}
+      it{expect(Zenflow::Query.valid_response?('foo', validate: /bar/)).to eq(false)}
+      it{expect(Zenflow::Query.valid_response?('', required: true)).to eq(false)}
+      it{expect(Zenflow::Query.valid_response?('foo', required: true)).to eq(true)}
+      it{expect(Zenflow::Query.valid_response?('foo', required: false)).to eq(true)}
+      it{expect(Zenflow::Query.valid_response?('', required: false)).to eq(true)}
+    end
+
+    describe '.build_error_message' do
+      it{expect(Zenflow::Query.build_error_message('foo')).to match(/not a valid response/)}
+      it{expect(Zenflow::Query.build_error_message('foo', error_message: 'stupid response.')).to match(/stupid response/)}
+      it{expect(Zenflow::Query.build_error_message('foo', required: true)).to match(/must respond/)}
+    end
+  end
+end

data/spec/zenflow/helpers/branch_command_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+module BranchCommandSpec
+
+  class TestCommand < Zenflow::BranchCommand
+    flow "test"
+    branch source: "master"
+    branch destination: "production"
+    branch deploy: "deploy1"
+    branch deploy: "deploy2"
+    version :patch
+    changelog :rotate
+    tag true
+  end
+
+  describe "Zenflow::BranchCommand" do
+    describe "#branches" do
+      before do
+        Zenflow.should_receive(:Log).with("Available test branches:")
+        Zenflow::Branch.should_receive(:list).with("test").and_return(["YES"])
+        Zenflow.should_receive(:Log).with("* YES", indent: true, color: false)
+      end
+      it { TestCommand.new.invoke(:branches) }
+    end
+
+    describe "#start" do
+      context "when online" do
+        before do
+          Zenflow.should_receive(:Ask).and_return("new-test-branch")
+          Zenflow::Branch.should_receive(:update).with("master")
+          Zenflow::Branch.should_receive(:create).with("test/new-test-branch", "master")
+          Zenflow::Branch.should_receive(:push).with("test/new-test-branch")
+          Zenflow::Branch.should_receive(:track).with("test/new-test-branch")
+        end
+        it { TestCommand.new.invoke(:start) }
+      end
+
+      context "when offline" do
+        before do
+          Zenflow.should_receive(:Ask).and_return("new-test-branch")
+          Zenflow::Branch.should_receive(:checkout).with("master")
+          Zenflow::Branch.should_receive(:create).with("test/new-test-branch", "master")
+        end
+        it { TestCommand.new.invoke(:start, nil, offline: true) }
+      end
+
+      context "when supplying a name" do
+        before do
+          Zenflow::Branch.should_receive(:update).with("master")
+          Zenflow::Branch.should_receive(:create).with("test/new-test-branch", "master")
+          Zenflow::Branch.should_receive(:push).with("test/new-test-branch")
+          Zenflow::Branch.should_receive(:track).with("test/new-test-branch")
+        end
+        it { TestCommand.new.invoke(:start, ["new-test-branch"]) }
+      end
+
+      context "when asking for a name" do
+        before do
+          $stdin.should_receive(:gets).and_return("new-test-branch\n")
+          Zenflow::Branch.should_receive(:update).with("master")
+          Zenflow::Branch.should_receive(:create).with("test/new-test-branch", "master")
+          Zenflow::Branch.should_receive(:push).with("test/new-test-branch")
+          Zenflow::Branch.should_receive(:track).with("test/new-test-branch")
+        end
+        it { expect(capture(:stdout){ TestCommand.new.invoke(:start) }).to eq(">> Name of the test: ") }
+      end
+    end
+
+    describe "#deploy" do
+      context "when a project is not deployable" do
+        before do
+          Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+          Zenflow::Config.should_receive(:[]).with(:deployable).and_return(false)
+          Zenflow.should_receive(:Log).with("This project is not deployable right now", color: :red)
+        end
+        it { expect{TestCommand.new.invoke(:deploy)}.to raise_error(SystemExit) }
+      end
+
+      context "without running migrations" do
+        before do
+          Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+          Zenflow::Config.should_receive(:[]).with(:deployable).and_return(true)
+          Zenflow::Branch.should_receive(:update).with("deploy1")
+          Zenflow::Branch.should_receive(:update).with("deploy2")
+          Zenflow::Branch.should_receive(:merge).with("test/new-test-branch").twice
+          Zenflow.should_receive(:Deploy).with("deploy1", {})
+          Zenflow.should_receive(:Deploy).with("deploy2", {})
+          Zenflow::Branch.should_receive(:checkout).with("test/new-test-branch")
+        end
+        it { TestCommand.new.invoke(:deploy) }
+      end
+
+      context "when running migrations" do
+        before do
+          Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+          Zenflow::Config.should_receive(:[]).with(:deployable).and_return(true)
+          Zenflow::Branch.should_receive(:update).with("deploy1")
+          Zenflow::Branch.should_receive(:update).with("deploy2")
+          Zenflow::Branch.should_receive(:merge).with("test/new-test-branch").twice
+          Zenflow.should_receive(:Deploy).with("deploy1", { "migrations" => true })
+          Zenflow.should_receive(:Deploy).with("deploy2", { "migrations" => true })
+          Zenflow::Branch.should_receive(:checkout).with("test/new-test-branch")
+        end
+        it { TestCommand.new.invoke(:deploy, [], "migrations" => true) }
+      end
+    end
+
+    describe "#update" do
+      before do
+        Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+        Zenflow::Branch.should_receive(:update).with("master")
+        Zenflow::Branch.should_receive(:checkout).with("test/new-test-branch")
+        Zenflow::Branch.should_receive(:merge).with("master")
+      end
+      it { TestCommand.new.invoke(:update) }
+    end
+
+    describe "#diff" do
+      before do
+        Zenflow.should_receive(:Log).with("Displaying diff with master")
+        Zenflow::Shell.should_receive(:[]).with("git difftool master")
+      end
+      it { TestCommand.new.invoke(:diff) }
+    end
+
+    describe "#compare" do
+      before do
+        Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+        Zenflow.should_receive(:Log).with("Opening GitHub compare view for master...test/new-test-branch")
+        Zenflow::Repo.should_receive(:slug).and_return("test-repo")
+        Zenflow::Shell.should_receive(:[]).with("open https://github.com/test-repo/compare/master...test/new-test-branch")
+      end
+      it { TestCommand.new.invoke(:compare) }
+    end
+
+    describe "#review" do
+      context "when pull request is found" do
+        before do
+          Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+          Zenflow::PullRequest.should_receive(:find_by_ref).with("test/new-test-branch").and_return({ html_url: "URL"})
+          Zenflow.should_receive(:Log).with("A pull request for test/new-test-branch already exists", color: :red)
+          Zenflow.should_receive(:Log).with("URL", indent: true, color: false)
+        end
+        it { expect{TestCommand.new.invoke(:review)}.to raise_error(SystemExit) }
+      end
+
+      context "with new pull request" do
+        before do
+          Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+          Zenflow::PullRequest.should_receive(:find_by_ref).with("test/new-test-branch").and_return(false)
+        end
+
+        context "with valid request" do
+          before do
+            Zenflow.should_receive(:Ask).with("Describe this test:", required: true).and_return("A great test")
+            pull = double(valid?: true)
+            pull.stub(:[]).with("html_url").and_return("URL")
+            Zenflow::PullRequest.should_receive(:create).with(
+              base:  "master",
+              head:  "test/new-test-branch",
+              title: "test: new-test-branch",
+              body:  "A great test"
+            ).and_return(pull)
+            Zenflow.should_receive(:Log).with("Pull request was created!")
+            Zenflow.should_receive(:Log).with("URL", indent: true, color: false)
+            Zenflow::Shell.should_receive(:[]).with("open URL")
+          end
+          it { TestCommand.new.invoke(:review) }
+        end
+
+        context "with invalid request" do
+          let(:pull){ double(valid?: false) }
+
+          before do
+            Zenflow.should_receive(:Ask).with("Describe this test:", required: true).and_return("A great test")
+            Zenflow::PullRequest.should_receive(:create).with(
+              base:  "master",
+              head:  "test/new-test-branch",
+              title: "test: new-test-branch",
+              body:  "A great test"
+            ).and_return(pull)
+            Zenflow.should_receive(:Log).with("There was a problem creating the pull request:", color: :red)
+          end
+
+          it "displays errors" do
+            pull.stub(:[]).with("errors").and_return([{"message" => "ERROR"},{"message" => "ERROR"}])
+            Zenflow.should_receive(:Log).with("* ERROR", indent: true, color: :red).twice
+            TestCommand.new.invoke(:review)
+          end
+
+          it "displays an error message" do
+            pull.stub(:[]).with("errors")
+            pull.stub(:[]).with("message").and_return("ERROR")
+            Zenflow.should_receive(:Log).with("* ERROR", indent: true, color: :red)
+            TestCommand.new.invoke(:review)
+          end
+
+          it "handles unexpected failure" do
+            pull.stub(:[]).with("errors")
+            pull.stub(:[]).with("message")
+            Zenflow.should_receive(:Log).with(" * unexpected failure, both 'errors' and 'message' were empty in the response")
+            TestCommand.new.invoke(:review)
+          end
+        end
+      end
+    end
+
+    describe "#abort" do
+      let(:branch_name){"test/new-test-branch"}
+      before {
+        Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+        Zenflow::Branch.should_receive(:checkout).with("master")
+      }
+
+      context "when online" do
+        before do
+          Zenflow::Branch.should_receive(:delete_remote).with(branch_name)
+          Zenflow::Branch.should_receive(:delete_local).with(branch_name, force: true)
+        end
+        it { TestCommand.new.invoke(:abort) }
+      end
+
+      context "when offline" do
+        before do
+          Zenflow::Branch.should_receive(:delete_local).with(branch_name, force: true)
+        end
+        it { TestCommand.new.invoke(:abort, [], offline: true) }
+      end
+    end
+
+    describe "#finish" do
+      before do
+        Zenflow::Branch.should_receive(:current).with("test").and_return("new-test-branch")
+      end
+
+      context "with confirmations" do
+        it "without deployment to staging" do
+          Zenflow::Config.should_receive(:[]).with(:confirm_staging).and_return(true)
+          Zenflow.should_receive(:Ask).with("Has this been tested in a staging environment first?", options: ["Y", "n"], default: "Y").and_return("n")
+          Zenflow.should_receive(:Log).with("Sorry, deploy to a staging environment first", color: :red)
+          expect{TestCommand.new.invoke(:finish)}.to raise_error(SystemExit)
+        end
+
+        it "without review" do
+          Zenflow::Config.should_receive(:[]).with(:confirm_staging).and_return(true)
+          Zenflow::Config.should_receive(:[]).with(:confirm_review).and_return(true)
+          Zenflow.should_receive(:Ask).with("Has this been tested in a staging environment first?", options: ["Y", "n"], default: "Y").and_return("y")
+          Zenflow.should_receive(:Ask).with("Has this been code reviewed yet?", options: ["Y", "n"], default: "Y").and_return("n")
+          Zenflow.should_receive(:Log).with("Please have someone look at this first", color: :red)
+          expect{TestCommand.new.invoke(:finish)}.to raise_error(SystemExit)
+        end
+      end
+
+      context "without confirmations" do
+        before do
+          Zenflow::Config.should_receive(:[]).with(:confirm_staging).and_return(false)
+          Zenflow::Config.should_receive(:[]).with(:confirm_review).and_return(false)
+        end
+
+        context "when online" do
+          before do
+            Zenflow::Branch.should_receive(:update).with("production")
+            Zenflow::Branch.should_receive(:checkout).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:merge).with("production")
+
+            Zenflow::Version.should_receive(:update).with(:patch)
+
+            Zenflow::Changelog.should_receive(:update).with(rotate: true, name: "new-test-branch").and_return("YES")
+
+            Zenflow::Branch.should_receive(:checkout).with("master")
+            Zenflow::Branch.should_receive(:merge).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:push).with("master")
+            Zenflow::Branch.should_receive(:checkout).with("production")
+            Zenflow::Branch.should_receive(:merge).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:push).with("production")
+
+            Zenflow::Branch.should_receive(:tag).with(Zenflow::Version.current.to_s, "YES")
+            Zenflow::Branch.should_receive(:push).with(:tags)
+
+            Zenflow::Branch.should_receive(:delete_remote).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:delete_local).with("test/new-test-branch", force: true)
+          end
+          it { TestCommand.new.invoke(:finish) }
+        end
+
+        context "when offline" do
+          before do
+            Zenflow::Branch.should_receive(:checkout).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:merge).with("production")
+
+            Zenflow::Version.should_receive(:update).with(:patch)
+
+            Zenflow::Changelog.should_receive(:update).with(rotate: true, name: "new-test-branch").and_return("YES")
+
+            Zenflow::Branch.should_receive(:checkout).with("master")
+            Zenflow::Branch.should_receive(:merge).with("test/new-test-branch")
+            Zenflow::Branch.should_receive(:checkout).with("production")
+            Zenflow::Branch.should_receive(:merge).with("test/new-test-branch")
+
+            Zenflow::Branch.should_receive(:tag).with(Zenflow::Version.current.to_s, "YES")
+
+            Zenflow::Branch.should_receive(:delete_local).with("test/new-test-branch", force: true)
+          end
+          it { TestCommand.new.invoke(:finish, [], offline: true) }
+        end
+      end
+    end
+  end
+
+end