zenflow 0.8.0

data/spec/zenflow/helpers/cli_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe Zenflow::CLI do
+
+  subject {Zenflow::CLI.new}
+
+  describe "#version" do
+    it 'outputs the version number' do
+      subject.should_receive(:puts).with("Zenflow #{Zenflow::VERSION}")
+      subject.version
+    end
+  end
+
+  describe "#help" do
+    it 'displays helpful information' do
+      subject.should_receive(:version)
+      $stdout.should_receive(:puts).at_least(:once)
+      subject.help
+    end
+  end
+
+  describe "#authorize_github" do
+    context "when a zenflow_token is already saved" do
+      before do
+        Zenflow::Github.should_receive(:zenflow_token).and_return('super secret token')
+      end
+
+      context "and the user decides to set a new one" do
+        before do
+          Zenflow.should_receive(:Ask).and_return('y')
+        end
+
+        it "authorizes with Github" do
+          Zenflow::Github.should_receive(:authorize)
+          subject.authorize_github
+        end
+      end
+
+      context "and the user decides not to set a new one" do
+        before do
+          Zenflow.should_receive(:Ask).and_return('n')
+        end
+
+        it "does not authorize with Github" do
+          Zenflow::Github.should_not_receive(:authorize)
+          subject.authorize_github
+        end
+      end
+    end
+
+    context "when a zenflow_token is not already saved" do
+      before do
+        Zenflow::Github.should_receive(:zenflow_token).and_return(nil)
+      end
+
+      it "authorizes with Github" do
+        Zenflow::Github.should_receive(:authorize)
+        subject.authorize_github
+      end
+    end
+  end
+
+  describe "#already_configured" do
+    let(:question) {['There is an existing config file. Overwrite it?', {:options => ["y", "N"], :default => "N"}]}
+    before do
+      Zenflow.should_receive(:Log).with('Warning', :color => :red)
+    end
+
+    context "when the user wants to overwrite the configuration" do
+      before do
+        Zenflow.should_receive(:Ask).with(*question).and_return('y')
+      end
+
+      it "forces initialization" do
+        subject.should_receive(:init).with(true)
+        subject.already_configured
+      end
+    end
+
+    context "when the user does not want to overwrite the configuration" do
+      before do
+        Zenflow.should_receive(:Ask).with(*question).and_return('n')
+      end
+
+      it "aborts" do
+        Zenflow.should_receive(:Log).with('Aborting...', :color => :red)
+        lambda{ subject.already_configured}.should raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe "#configure_branch" do
+    context "when the user wants to configure a staging branch" do
+      before do
+        Zenflow.should_receive(:Ask).with("Use a branch for staging releases and hotfixes?", :options => ["Y", "n"], :default => "Y").and_return('y')
+      end
+
+      it 'names the staging branch whatever the user wants' do
+        Zenflow.should_receive(:Ask).with("What is the name of that branch?", :default => "staging").and_return('staging')
+        Zenflow::Config.should_receive(:[]=).with(:staging_branch, 'staging')
+        subject.configure_branch(:staging_branch, "Use a branch for staging releases and hotfixes?", 'staging')
+      end
+    end
+
+    context "when the user does not want to configure a staging branch" do
+      before do
+        Zenflow.should_receive(:Ask).with("Use a branch for staging releases and hotfixes?", :options => ["Y", "n"], :default => "Y").and_return('n')
+      end
+
+      it 'names the staging branch whatever the user wants' do
+        Zenflow::Config.should_receive(:[]=).with(:staging_branch, false)
+        subject.configure_branch(:staging_branch, "Use a branch for staging releases and hotfixes?", 'staging')
+      end
+    end
+  end
+
+  describe "#configure_project" do
+    it 'asks the user to name their project' do
+      Zenflow.should_receive(:Ask).with("What is the name of this project?", :required => true).and_return('zenflow')
+      Zenflow.should_receive(:Log).with("Project")
+      Zenflow::Config.should_receive(:[]=).with(:project, 'zenflow')
+      subject.configure_project
+    end
+  end
+
+  describe "#configure_branches" do
+    it 'configures branches for the project' do
+      Zenflow.should_receive(:Ask).with("What is the name of the main development branch?", :default => "master").and_return('master')
+      Zenflow.should_receive(:Log).with("Branches")
+      Zenflow::Config.should_receive(:[]=).with(:development_branch, 'master')
+      subject.should_receive(:configure_branch).exactly(3).times
+      subject.configure_branches
+    end
+  end
+
+  describe "#configure_remotes" do
+    context "when the user wants to configure a backup remote" do
+      before do
+        Zenflow.should_receive(:Ask).with("Use a backup remote?", :options => ["Y", "n"], :default => "n").and_return('y')
+      end
+
+      it 'configures the primary remote and a backup remote' do
+        Zenflow.should_receive(:Ask).with("What is the name of your primary remote?", :default => "origin").and_return('origin')
+        Zenflow::Config.should_receive(:[]=).with(:remote, 'origin')
+        Zenflow.should_receive(:Ask).with("What is the name of your backup remote?", :default => "backup").and_return('backup')
+        Zenflow::Config.should_receive(:[]=).with(:backup_remote, 'backup')
+        subject.configure_remotes
+      end
+    end
+
+    context "when the user does not want to configure a backup remote" do
+      before do
+        Zenflow.should_receive(:Ask).with("Use a backup remote?", :options => ["Y", "n"], :default => "n").and_return('n')
+      end
+
+      it 'configures the primary remote and a backup remote' do
+        Zenflow.should_receive(:Ask).with("What is the name of your primary remote?", :default => "origin").and_return('origin')
+        Zenflow::Config.should_receive(:[]=).with(:remote, 'origin')
+        Zenflow.should_not_receive(:Ask).with("What is the name of your backup remote?", :default => "backup")
+        Zenflow::Config.should_receive(:[]=).with(:backup_remote, false)
+        subject.configure_remotes
+      end
+    end
+  end
+
+  describe "#set_up_changelog" do
+    context "when the changelog doesn't already exist" do
+      before do
+        File.should_receive(:exist?).with("CHANGELOG.md").and_return(false)
+        Zenflow.should_receive(:Log).with("Changelog Management")
+      end
+
+      context "when the user wants to set up a changelog" do
+        it 'sets up the changelog' do
+          Zenflow.should_receive(:Ask).with("Set up a changelog?", :options => ["Y", "n"], :default => "Y").and_return('y')
+          Zenflow::Changelog.should_receive(:create)
+          subject.set_up_changelog
+        end
+      end
+
+      context "when the user does not want to set up a changelog" do
+        it 'does not set up the changelog' do
+          Zenflow.should_receive(:Ask).with("Set up a changelog?", :options => ["Y", "n"], :default => "Y").and_return('n')
+          Zenflow::Changelog.should_not_receive(:create)
+          subject.set_up_changelog
+        end
+      end
+    end
+
+    context "when the changelog already exists" do
+      before do
+        File.should_receive(:exist?).with("CHANGELOG.md").and_return(true)
+      end
+
+      it 'does not set up the changelog' do
+        Zenflow.should_not_receive(:Log).with("Changelog Management")
+        Zenflow.should_not_receive(:Ask).with("Set up a changelog?", :options => ["Y", "n"], :default => "Y")
+        Zenflow::Changelog.should_not_receive(:create)
+        subject.set_up_changelog
+      end
+    end
+  end
+
+  describe "#confirm_some_stuff" do
+    it "confirms staging deployment and code review requirements" do
+      Zenflow.should_receive(:Log).with("Confirmations")
+      Zenflow.should_receive(:Ask).with("Require deployment to a staging environment?", :options => ["Y", "n"], :default => "Y").and_return('y')
+      Zenflow::Config.should_receive(:[]=).with(:confirm_staging, true)
+      Zenflow.should_receive(:Ask).with("Require code reviews?", :options => ["Y", "n"], :default => "Y").and_return('n')
+      Zenflow::Config.should_receive(:[]=).with(:confirm_review, false)
+      subject.confirm_some_stuff
+    end
+  end
+
+  describe "#init" do
+    context "when zenflow has not been configured" do
+      before do
+        Zenflow::Config.should_receive(:configured?).and_return(false)
+      end
+
+      it 'configures zenflow' do
+        subject.should_not_receive(:already_configured)
+        subject.should_receive(:set_up_github)
+        subject.should_receive(:authorize_github)
+        subject.should_receive(:configure_project)
+        subject.should_receive(:configure_branches)
+        subject.should_receive(:configure_remotes)
+        subject.should_receive(:confirm_some_stuff)
+        subject.should_receive(:set_up_changelog)
+        Zenflow::Config.should_receive(:save!)
+        subject.init
+      end
+    end
+
+    context "when zenflow has already been configured" do
+      before do
+        Zenflow::Config.should_receive(:configured?).and_return(true)
+      end
+
+      context 'and it is forced to initialize' do
+        it 'configures zenflow' do
+          subject.should_not_receive(:already_configured)
+          subject.should_receive(:set_up_github)
+          subject.should_receive(:authorize_github)
+          subject.should_receive(:configure_project)
+          subject.should_receive(:configure_branches)
+          subject.should_receive(:configure_remotes)
+          subject.should_receive(:confirm_some_stuff)
+          subject.should_receive(:set_up_changelog)
+          Zenflow::Config.should_receive(:save!)
+          subject.init(true)
+        end
+      end
+
+      context 'and it is forced to initialize' do
+        before do
+          Zenflow.should_receive(:Log).with('Warning', :color => :red)
+          Zenflow.should_receive(:Ask).and_return('n')
+          Zenflow.should_receive(:Log).with('Aborting...', :color => :red)
+        end
+
+        it 'calls already_configured' do
+          subject.should_receive(:already_configured).and_call_original
+          subject.should_not_receive(:authorize_github)
+          subject.should_not_receive(:configure_project)
+          subject.should_not_receive(:configure_branches)
+          subject.should_not_receive(:configure_remotes)
+          subject.should_not_receive(:confirm_some_stuff)
+          subject.should_not_receive(:set_up_changelog)
+          Zenflow::Config.should_not_receive(:save!)
+          lambda{ subject.init}.should raise_error(SystemExit)
+        end
+      end
+    end
+  end
+
+end

data/spec/zenflow/helpers/github_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Zenflow::Github do
+  describe '.user' do
+    let(:user){'github-user'}
+
+    before(:each){
+      Zenflow::Shell.should_receive(:run).and_return(user)
+    }
+
+    it "returns the user" do
+      expect(Zenflow::Github.user).to eq(user)
+    end
+  end
+
+  describe '.authorize' do
+    context "when authorization fails" do
+      before do
+        Zenflow.should_receive("Log").with("Authorizing with GitHub... Enter your GitHub password.")
+        Zenflow::Github.should_receive(:user).and_return('adamkittelson')
+        Zenflow::Shell.should_receive(:run).and_return('{"message": "failed to authorize, bummer"}')
+      end
+
+      it "logs that something went wrong" do
+        Zenflow.should_receive("Log").with("Something went wrong. Error from GitHub was: failed to authorize, bummer")
+        Zenflow::Github.authorize
+      end
+    end
+
+    context "when authorization succeeds" do
+      before do
+        Zenflow.should_receive("Log").with("Authorizing with GitHub... Enter your GitHub password.")
+        Zenflow::Github.should_receive(:user).and_return('adamkittelson')
+        Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.github.com/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"token": "super secure token"}')
+      end
+
+      it "adds the token to git config and logs a happy message of success" do
+        Zenflow::Shell.should_receive(:run).with("git config --global zenflow.token super secure token", :silent => true)
+        Zenflow.should_receive("Log").with("Authorized!")
+        Zenflow::Github.authorize
+      end
+    end
+
+  end
+end

data/spec/zenflow/helpers/help_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Zenflow::Help do
+
+  describe "Zenflow.Help" do
+    it "initializes and returns a new Zenflow::Help object" do
+      expect(Zenflow.Help.class).to eq(Zenflow::Help.new.class)
+    end
+  end
+
+  subject { Zenflow::Help.new(:command  => 'test-help',
+                              :summary  => "tests Zenflow::Help",
+                              :usage    => "test-help (optional please)",
+                              :commands => ['test-help', 'spec-help'])}
+
+  it "has an amazing banner" do
+    expect(subject.banner).to eq("\e[36m- Summary ------------------------------\e[0m\ntests Zenflow::Help\n\n\e[36m- Usage --------------------------------\e[0m\ntest-help (optional please)\n\n\e[36m- Available Commands -------------------\e[0m\n[\"test-help\", \"spec-help\"]\n\n\e[36m- Options ------------------------------\e[0m")
+  end
+
+  context "#unknown_command" do
+    describe "when the command is missing" do
+      it "logs the error and exits" do
+        Zenflow.should_receive(:Log).with "Missing command", :color => :red
+        lambda {Zenflow::Help.new.unknown_command}.should raise_error(SystemExit)
+      end
+    end
+
+    describe "when the command is present" do
+      it "logs the error and exits" do
+        Zenflow.should_receive(:Log).with "Unknown command \"test-unknown_command\"", :color => :red
+        lambda {Zenflow::Help.new(:command => 'test-unknown_command').unknown_command}.should raise_error(SystemExit)
+      end
+    end
+  end
+
+end

data/spec/zenflow/helpers/log_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Zenflow do
+  describe 'Log' do
+    context 'with indentation' do
+      before(:each) do
+        Zenflow.stub(:LogToFile)
+      end
+
+      it 'indents the text' do
+        $stdout.should_receive(:puts).with(/\s+foo/)
+        Zenflow.Log('foo', indent: true)
+      end
+
+      it 'adds an arrow the text' do
+        $stdout.should_receive(:puts).with(/-----> foo/)
+        Zenflow.Log('foo', arrows: true)
+      end
+
+      it 'colorizes the text' do
+        $stdout.should_receive(:puts).with(/\e\[34mfoo/)
+        Zenflow.Log('foo', color: :blue, arrows: false)
+      end
+
+      it 'does not colorize the text' do
+        $stdout.should_receive(:puts).with('foo')
+        Zenflow.Log('foo', color: false, arrows: false)
+      end
+    end
+  end
+end

data/spec/zenflow/helpers/pull_request_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Zenflow::PullRequest do
+  before(:each){
+    Zenflow::Github.stub(:user).and_return('github-user')
+    Zenflow::Github.stub(:token).and_return('github-token')
+    Zenflow::Github.stub(:zenflow_token).and_return('zenflow-token')
+    Zenflow::GithubRequest.base_uri 'https://api.github.com/repos/zencoder/zenflow-example'
+  }
+
+  describe '.list', vcr: { cassette_name: "pull request list" } do
+    let(:pull_requests){Zenflow::PullRequest.list}
+    it{expect(pull_requests).to be_a_kind_of(Array)}
+    it{expect(pull_requests.first).to be_a_kind_of(Zenflow::PullRequest)}
+  end
+
+  describe '.find', vcr: { cassette_name: "pull request find" } do
+    let(:pull_request){Zenflow::PullRequest.find(1)}
+    it{expect(pull_request).to be_a_kind_of(Zenflow::PullRequest)}
+  end
+
+  describe '.find_by_ref' do
+    before(:each){Zenflow.should_receive(:Log).with(Regexp.new('Looking up'))}
+
+    context 'existing ref', vcr: { cassette_name: "pull request by ref" } do
+      let(:pull_request){Zenflow::PullRequest.find_by_ref('feature/example')}
+      it{expect(pull_request).to be_a_kind_of(Zenflow::PullRequest)}
+    end
+
+    context 'non-existant ref', vcr: { cassette_name: "pull request for non-existent ref" } do
+      let(:pull_request){Zenflow::PullRequest.find_by_ref('feature/foo')}
+      it{expect(pull_request).to be_nil}
+    end
+  end
+
+  describe '.find_by_ref!' do
+    before(:each){Zenflow.should_receive(:Log).with(Regexp.new('Looking up'))}
+
+    context 'existing ref', vcr: { cassette_name: "pull request by ref" } do
+      let(:pull_request){Zenflow::PullRequest.find_by_ref!('feature/example')}
+      it{expect(pull_request).to be_a_kind_of(Zenflow::PullRequest)}
+    end
+
+    context 'non-existent ref', vcr: { cassette_name: "pull request for non-existent ref" } do
+      let(:ref){'feature/foo'}
+
+      it 'logs the failure' do
+        Zenflow.should_receive(:Log).with(Regexp.new(ref), color: :red)
+        expect{Zenflow::PullRequest.find_by_ref!(ref)}.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe '.exist?' do
+    before(:each){Zenflow.should_receive(:Log).with(Regexp.new('Looking up'))}
+
+    context 'a valid pull', vcr: { cassette_name: "existing pull request" } do
+      it{expect(Zenflow::PullRequest.exist?('feature/example')).to be_true}
+    end
+
+    context 'an invalid pull', vcr: { cassette_name: "unexisting pull request" } do
+      it{expect(Zenflow::PullRequest.exist?('feature/foo')).to be_false}
+    end
+  end
+
+  describe '.create', vcr: { cassette_name: "create pull request" } do
+    let(:request_options) do
+      {
+        base: 'master',
+        head: 'feature/new-branch',
+        title: 'Feaure: new-branch',
+        body: 'making a new pull request'
+      }
+    end
+    it{ expect(Zenflow::PullRequest.create(request_options)).to(
+      be_a_kind_of(Zenflow::PullRequest)
+    ) }
+  end
+
+  describe '#valid?' do
+    context 'good request', vcr: { cassette_name: "create pull request" } do
+      let(:request){Zenflow::PullRequest.create({})}
+      it{expect(request.valid?).to be_true}
+    end
+
+    context 'bad request', vcr: { cassette_name: "create bad pull request" } do
+      let(:request_options) do
+        {
+          base: 'master',
+          head: 'feature/phoney',
+          title: 'this feature does not exist',
+          body: 'gonna fail'
+        }
+      end
+      let(:request){Zenflow::PullRequest.create()}
+      it{expect(request.valid?).to be_false}
+    end
+  end
+
+  describe '#[]' do
+    context 'good request', vcr: { cassette_name: "create pull request" } do
+      let(:request){Zenflow::PullRequest.create({})}
+      it{expect(request["comments"]).to_not be_nil}
+      it{expect(request["fdsfa"]).to be_nil}
+    end
+  end
+
+end