octopolo 0.0.1

data/spec/octopolo/github/user_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/github/user"
+
+module Octopolo
+  module GitHub
+    describe User do
+      context ".new login" do
+        it "remembers the given login" do
+          user = User.new "foo"
+          user.login.should == "foo"
+        end
+      end
+
+      context "#author_name" do
+        let(:octo) { stub }
+        let(:login) { "joeuser" }
+        let(:user) { User.new login }
+
+        before do
+          user.stub(user_data: octo)
+        end
+
+        it "fetches the real name from GitHub" do
+          octo.stub(name: "Joe User")
+          user.author_name.should == octo.name
+        end
+
+        it "returns the login if GitHub user has no name" do
+          octo.stub(name: nil)
+          user.author_name.should == user.login
+        end
+      end
+
+      context "#user_data" do
+        let(:login) { "joeuser" }
+        let(:user) { User.new login }
+        let(:octo) { stub }
+
+        it "fetches the data from the User class" do
+          User.should_receive(:user_data).with(login) { octo }
+          user.user_data.should == octo
+        end
+      end
+
+      context ".user_data login" do
+        let(:base_login) { "joeuser" }
+        let(:octo) { stub }
+
+        it "fetches the data from GitHub" do
+          login = "#{base_login}#{rand(100000)}"
+          GitHub.should_receive(:user).with(login) { octo }
+          User.user_data(login).should == octo
+        end
+
+        it "caches the data" do
+          login = "#{base_login}#{rand(100000)}"
+          GitHub.should_receive(:user).once { octo }
+          User.user_data(login)
+          User.user_data(login)
+        end
+      end
+
+    end
+  end
+end

data/spec/octopolo/github_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+require_relative "../../lib/octopolo/github"
+
+module Octopolo
+  describe GitHub do
+    context ".client" do
+      let(:octokit_client) { stub(:github_client) }
+      let(:user_config) { stub(:user_config, github_user: "foo", github_token: "bar") }
+
+      before do
+        GitHub.stub(user_config: user_config)
+      end
+
+      it "logs in with the configured authentication values" do
+        Octokit::Client.should_receive(:new).with(login: user_config.github_user, access_token: user_config.github_token) { octokit_client }
+        GitHub.client.should == octokit_client
+      end
+
+      it "uses additional given parameters" do
+        Octokit::Client.should_receive(:new).with(login: user_config.github_user, access_token: user_config.github_token, auto_traversal: true) { octokit_client }
+        GitHub.client(auto_traversal: true).should == octokit_client
+      end
+
+      it "properly handles if the github authentication isn't configured" do
+        user_config.should_receive(:github_user).and_raise(UserConfig::MissingGitHubAuth)
+        Scripts::GithubAuth.should_not_receive(:invoke)
+        expect { GitHub.client }.to raise_error(GitHub::TryAgain, "No GitHub API token stored. Please run `bundle exec github-auth` to generate your token.")
+      end
+    end
+
+    context ".crawling_client" do
+      let(:client) { stub }
+
+      it "instantiates a client with auto_traversal" do
+        GitHub.should_receive(:client).with(auto_traversal: true) { client }
+        GitHub.crawling_client.should == client
+      end
+    end
+
+    context "having convenience methods" do
+      let(:client) { stub(:github_client) }
+      let(:crawling_client) { stub(:github_crawling_client) }
+      let(:data) { stub }
+
+      before do
+        GitHub.stub(client: client, crawling_client: crawling_client)
+      end
+
+      context ".pull_request *args" do
+        it "sends onto the client wrapper" do
+          client.should_receive(:pull_request).with("a", "b") { data }
+          result = GitHub.pull_request("a", "b")
+          result.should == data
+        end
+      end
+
+      context ".pull_request_commits *args" do
+        it "sends onto the client wrapper" do
+          client.should_receive(:pull_request_commits).with("a", "b") { data }
+          result = GitHub.pull_request_commits("a", "b")
+          result.should == data
+        end
+      end
+
+      context ".issue_comments *args" do
+        it "sends onto the client wrapper" do
+          client.should_receive(:issue_comments).with("a", "b") { data }
+          result = GitHub.issue_comments("a", "b")
+          result.should == data
+        end
+      end
+
+      context ".pull_requests *args" do
+        it "sends onto the crawling client wrapper" do
+          crawling_client.should_receive(:pull_requests).with("a", "b") { data }
+          GitHub.pull_requests("a", "b").should == data
+        end
+      end
+
+      context ".tst_repos" do
+        it "fetches the sportngin organization repos" do
+          crawling_client.should_receive(:organization_repositories).with("sportngin") { data }
+          GitHub.org_repos.should == data
+        end
+
+        it "fetches another organization's repos if requested" do
+          crawling_client.should_receive(:organization_repositories).with("foo") { data }
+          GitHub.org_repos("foo").should == data
+        end
+      end
+
+      context ".create_pull_request" do
+        it "sends the pull request to the API" do
+          client.should_receive(:create_pull_request).with("repo", "destination_branch", "source_branch", "title", "body") { data }
+          GitHub.create_pull_request("repo", "destination_branch", "source_branch", "title", "body").should == data
+        end
+      end
+
+      context ".add_comment" do
+        it "sends the comment to the API" do
+          client.should_receive(:add_comment).with("repo", 123, "contents of comment")
+          GitHub.add_comment "repo", 123, "contents of comment"
+        end
+      end
+
+      context ".user username" do
+        let(:username) { "foo" }
+        let(:valid_user) { stub(login: "foo", name: "Joe Foo")}
+
+        it "fetches the user data from GitHub" do
+          client.should_receive(:user).with(username) { valid_user }
+          GitHub.user(username).should == valid_user
+        end
+
+        it "returns a generic Unknown user if none is found" do
+          client.should_receive(:user).with(username).and_raise(Octokit::NotFound)
+          GitHub.user(username).should == Hashie::Mash.new(name: GitHub::UNKNOWN_USER)
+        end
+      end
+
+      context ".check_connection" do
+        it "performs a request against the API which requires authentication" do
+          client.should_receive(:user)
+          GitHub.check_connection
+        end
+
+        it "raises BadCredentials if testing the connection raises Octokit::Unauthorized" do
+          client.should_receive(:user).and_raise(Octokit::Unauthorized)
+          expect { GitHub.check_connection }.to raise_error(GitHub::BadCredentials)
+        end
+      end
+
+      context ".connect &block" do
+        let(:thing) { stub }
+        let(:try_again) { GitHub::TryAgain.new("try-again message") }
+        let(:bad_credentials) { GitHub::BadCredentials.new("bad-credentials message") }
+
+        it "performs the block if GitHub.check_connection does not raise an exception" do
+          GitHub.should_receive(:check_connection)
+          thing.should_receive(:foo)
+
+          GitHub.connect do
+            thing.foo
+          end
+        end
+
+        it "does not perform the block if GitHub.check_connection raises TryAgain" do
+          GitHub.should_receive(:check_connection).and_raise(try_again)
+          thing.should_not_receive(:foo)
+          CLI.should_receive(:say).with(try_again.message)
+
+          GitHub.connect do
+            thing.foo
+          end
+        end
+
+        it "does not perform the block if GitHub.check_connection raises BadCredentials" do
+          GitHub.should_receive(:check_connection).and_raise(bad_credentials)
+          thing.should_not_receive(:foo)
+          CLI.should_receive(:say).with(bad_credentials.message)
+
+          GitHub.connect do
+            thing.foo
+          end
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/jira/stor_commenter_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/jira/story_commenter"
+
+module Octopolo
+  module Jira
+    describe StoryCommenter do
+      let(:comments) { stub }
+      let(:issue) { stub(:comments => comments) }
+      context ".new" do
+        it "finds the issue via the jira api" do
+          Jiralicious.should_receive(:configure)
+          Jiralicious::Issue.should_receive(:find).with(:id).and_return(issue)
+          StoryCommenter.new(:id, 'text')
+        end
+      end
+
+      context "#perform" do
+        let(:comment) { "test comment" }
+        before do
+          Jiralicious::Issue.stub(:find).with(:id).and_return(issue)
+        end
+
+        it "creates a new note for the story" do
+          comments.should_receive(:add).with(comment)
+          StoryCommenter.new(:id, comment).perform
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/pivotal/story_commenter_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require_relative "../../../lib/octopolo/pivotal/story_commenter"
+
+module Octopolo
+  module Pivotal
+    describe StoryCommenter do
+      let(:client) { stub }
+      before do
+        Pivotal::Client.stub(:new) { client }
+      end
+
+      context ".new" do
+        it "finds the story via the pivotal api" do
+          client.should_receive(:find_story).with(:id)
+          StoryCommenter.new(:id, 'text')
+        end
+      end
+
+      context "#perform" do
+        let(:notes) { stub }
+        let(:story) { stub(notes: notes) }
+        let(:comment) { "test comment" }
+
+        it "creates a new note for the story" do
+          client.stub(:find_story) { story }
+          note = stub
+          notes.should_receive(:new).with(owner: story, text: comment) { note }
+          note.should_receive(:create)
+          StoryCommenter.new(story, comment).perform
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/pivotal_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require_relative "../../lib/octopolo/pivotal"
+
+module Octopolo
+  module Pivotal
+    describe Client do
+
+      let(:user_config) { stub(:user_config, pivotal_token: "token") }
+
+      before do
+        Client.any_instance.stub(user_config: user_config)
+      end
+
+      context ".new" do
+        it "forces the PivotalTracker gem to use SSL" do
+          ::PivotalTracker::Client.should_receive(:use_ssl=).with(true)
+          Pivotal::Client.new
+        end
+      end
+
+      context ".fetch_token(email, password)" do
+        let(:email) { "example@example.com" }
+        let(:password) { "sekret" }
+        let(:token) { "dead-beef" }
+
+        it "passes down to the PivotalTracker gem" do
+          ::PivotalTracker::Client.should_receive(:token).with(email, password) { token }
+          expect(Client.fetch_token email, password).to eq(token)
+        end
+
+        it "raises BadCredentials if given invalid credentials" do
+          ::PivotalTracker::Client.should_receive(:token).and_raise(RestClient::Unauthorized)
+          expect { Client.fetch_token email, password }.to raise_error(BadCredentials)
+        end
+      end
+
+      context "#find_story(story_id)" do
+        let(:project) { PivotalTracker::Project.new }
+        let(:story) { PivotalTracker::Story.new }
+
+        it "gets all of the PT projects" do
+          project.stub_chain(:stories, :find).with(:id) { story }
+          PivotalTracker::Project.should_receive(:all) { [project] }
+          subject.find_story(:id)
+        end
+
+        it "finds the story that matches the id" do
+          PivotalTracker::Project.stub(:all) { [project] }
+          project.stub_chain(:stories, :find).with(:id) { story }
+          expect(subject.find_story(:id)).to eq(story)
+        end
+
+        it "raises StoryNoteFound if no story is found" do
+          PivotalTracker::Project.stub(:all) { [] }
+          project.stub_chain(:stories, :find).with(:id) { nil }
+          expect { subject.find_story(:id) }.to raise_error(StoryNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/octopolo/pull_request_merger_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+require "octopolo/pull_request_merger"
+
+module Octopolo
+  module Scripts
+    describe PullRequestMerger do
+      let(:cli) { stub(:CLI) }
+      let(:config) { stub(:Config, github_repo: "tstmedia/foo") }
+      let(:pull_request_id) { 42 }
+      let(:pull_request) { stub(:PullRequest, branch: "cool-feature", url: "http://example.com/") }
+      let(:branch_type) { Git::DEPLOYABLE_PREFIX }
+      let(:git) { stub(:git, deployable_branch: "deployable") }
+      let(:options) { { :user_notifications => ['NickLaMuro', 'anfleene'] } }
+
+      subject { PullRequestMerger.new(Git::DEPLOYABLE_PREFIX, 42, options) }
+
+      before do
+        subject.git = git
+        subject.config = config
+        subject.cli = cli
+      end
+
+      context "#pull_request" do
+        before do
+          subject.pull_request_id = pull_request_id
+        end
+
+        it "finds the PullRequest for the given ID" do
+          GitHub::PullRequest.should_receive(:new).with(config.github_repo, pull_request_id) { pull_request }
+          subject.pull_request.should == pull_request
+        end
+
+        it "caches the PullRequest" do
+          GitHub::PullRequest.should_receive(:new).once { pull_request }
+          subject.pull_request
+          subject.pull_request
+        end
+      end
+
+      context "#perform" do
+        before do
+          subject.pull_request_id = pull_request_id
+          subject.pull_request = pull_request
+        end
+
+        it "checks out branch, merges the pull request's branch, and writes a comment" do
+          git.stub(:if_clean).and_yield # do not yield, index is dirty
+          subject.should_receive(:check_out_branch)
+          subject.should_receive(:merge_pull_request)
+          subject.should_receive(:comment_about_merge)
+
+          subject.perform
+        end
+
+        it "does nothing if the index is dirty" do
+          git.stub(:if_clean) # do not yield, index is dirty
+          subject.should_not_receive(:check_out_branch)
+          subject.should_not_receive(:merge_pull_request)
+          subject.should_not_receive(:comment_about_merge)
+
+          subject.perform
+        end
+
+        it "properly handles an invalid pull request ID" do
+          git.should_receive(:if_clean).and_raise(GitHub::PullRequest::NotFound)
+          cli.should_receive(:say).with("Unable to find pull request #{pull_request_id}. Please retry with a valid ID.")
+
+          subject.perform
+        end
+
+        it "properly handles a failed merge" do
+          git.should_receive(:if_clean).and_raise(Git::MergeFailed)
+          cli.should_receive(:say).with("Merge failed. Please identify the source of this merge conflict resolve this conflict in your pull request's branch. NOTE: Merge conflicts resolved in the deployable branch are NOT used when deploying.")
+
+          subject.perform
+        end
+
+        it "properly handles a failed checkout of branch" do
+          git.should_receive(:if_clean).and_raise(Git::CheckoutFailed)
+          git.should_receive(:latest_branch_for).with("deployable").and_return("deployable")
+          cli.should_receive(:say).with("Checkout of #{git.deployable_branch} failed. Please contact Infrastructure to determine the cause.")
+
+          subject.perform
+        end
+
+        it "properly handles a failed comment" do
+          git.should_receive(:if_clean).and_raise(GitHub::PullRequest::CommentFailed)
+          git.should_receive(:latest_branch_for).with("deployable").and_return("deployable")
+          cli.should_receive(:say).with("Unable to write comment. Please navigate to #{pull_request.url} and add the comment, '#{subject.comment_body}'")
+          subject.perform
+        end
+      end
+
+      context "#check_out_branch" do
+        let(:creator) { stub(:dated_branch_creator, branch_name: "new-deployable") }
+
+        it "checks out the project's deployable branch" do
+          git.should_receive(:check_out).with(git.deployable_branch)
+          git.should_receive(:latest_branch_for).with("deployable").and_return("deployable")
+          subject.check_out_branch
+        end
+
+        it "creates a new deployable branch if none exists, and checks it out" do
+          git.should_receive(:latest_branch_for).with(Git::DEPLOYABLE_PREFIX).and_raise(Git::NoBranchOfType)
+          DatedBranchCreator.should_receive(:perform).with(Git::DEPLOYABLE_PREFIX) { creator }
+          git.should_receive(:check_out).with(creator.branch_name)
+          cli.should_receive(:say).with("No deployable branch available. Creating one now.")
+          subject.check_out_branch
+        end
+      end
+
+      context "#merge_pull_request" do
+        before do
+          subject.pull_request = pull_request
+        end
+
+        it "merges the pull request into the checked-out branch" do
+          git.should_receive(:merge).with(pull_request.branch)
+          subject.merge_pull_request
+        end
+      end
+
+      context "#comment_about_merge" do
+        before do
+          subject.pull_request = pull_request
+        end
+
+        it "submits a comment that the pull request was merged into the branch" do
+          git.should_receive(:latest_branch_for).with("deployable").and_return("deployable")
+          pull_request.should_receive(:write_comment).with(subject.comment_body)
+
+          subject.comment_about_merge
+        end
+      end
+
+      context "#comment_body" do
+        it "contains the default comment body" do
+          git.should_receive(:latest_branch_for).with("deployable").and_return("deployable")
+          subject.comment_body.should == "Merged into #{git.deployable_branch}. /cc @NickLaMuro @anfleene"
+        end
+      end
+    end
+  end
+end