pra 1.6.0 → 1.7.0

data/spec/lib/pra/curses_pull_request_presenter_spec.rb

@@ -1,136 +0,0 @@
-require_relative '../../../lib/pra/curses_pull_request_presenter'
-
-describe Pra::CursesPullRequestPresenter do
-  describe '.new' do
-    it 'construct given pull request' do
-      pull_request = double('pull request')
-      Pra::CursesPullRequestPresenter.new(pull_request)
-    end
-
-    it 'assigns pull request to an instance variable' do
-      pull_request = double('pull request')
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(pull_request)
-      expect(curses_pull_request.instance_variable_get(:@pull_request)).to eq pull_request
-    end
-  end
-
-  describe '#force_length' do
-    it 'right pads the given string up to the specified length' do
-      pull_request = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(pull_request)
-      expect(curses_pull_request.send(:force_length, 'capture_api', 15)).to eq 'capture_api    '
-    end
-
-    it 'truncates the given string down to the specified length' do
-      pull_request = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(pull_request)
-      expect(curses_pull_request.send(:force_length, 'capture_api_012345678912345', 15)).to eq 'capture_api_012'
-    end
-  end
-
-  describe '#repository' do
-    it 'forces the repository length to 15' do
-      repository = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', repository: repository))
-      expect(curses_pull_request).to receive(:force_length).with(repository, 15)
-      curses_pull_request.repository
-    end
-  end
-
-  describe '#title' do
-    it 'forces the title length to 20' do
-      title = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', title: title))
-      expect(curses_pull_request).to receive(:force_length).with(title, 20)
-      curses_pull_request.title
-    end
-  end
-
-  describe '#from_reference' do
-    it 'forces the from_reference length to 20' do
-      from_reference = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', from_reference: from_reference))
-      expect(curses_pull_request).to receive(:force_length).with(from_reference, 20)
-      curses_pull_request.from_reference
-    end
-  end
-
-  describe '#to_reference' do
-    it 'forces the to_reference length to 20' do
-      to_reference = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', to_reference: to_reference))
-      expect(curses_pull_request).to receive(:force_length).with(to_reference, 20)
-      curses_pull_request.to_reference
-    end
-  end
-
-  describe '#author' do
-    it 'forces the author length to 20' do
-      author = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', author: author))
-      expect(curses_pull_request).to receive(:force_length).with(author, 20)
-      curses_pull_request.author
-    end
-  end
-
-  describe '#assignee' do
-    context 'when assignee is nil' do
-      it 'returns an empty string with length of 20' do
-        curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull_request', assignee: nil))
-        expect(curses_pull_request.assignee).to eq(' '*20)
-      end
-    end
-
-    context 'when assignee is NOT nil' do
-      context 'when assignee is blacklisted' do
-        it 'returns an empty string with length of 20' do
-          curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull_request', assignee: nil))
-          expect(curses_pull_request.assignee).to eq(' '*20)
-        end
-      end
-    end
-
-    context 'when assignee is NOT blacklisted' do
-      it 'returns assignee with a length of 20' do
-        curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull_request', assignee: 'IPT-Capture'))
-        allow(curses_pull_request).to receive(:assignee_blacklist).and_return(['IPT'])
-        expect(curses_pull_request.assignee).to eq('IPT-Capture         ')
-      end
-    end
-
-    context 'when assignee IS blacklisted' do
-      it 'returns an empty string with length of 20' do
-        curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull_request', assignee: 'IPT-Capture'))
-        allow(curses_pull_request).to receive(:assignee_blacklist).and_return(['IPT-Capture'])
-        expect(curses_pull_request.assignee).to eq(' '*20)
-      end
-    end
-  end
-
-  describe '#service_id' do
-    it 'forces the service_id length to 20' do
-      service_id = double
-      curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', service_id: service_id))
-      expect(curses_pull_request).to receive(:force_length).with(service_id, 10)
-      curses_pull_request.service_id
-    end
-  end
-
-  describe '#blacklisted?' do
-    context 'when assignee IS blacklisted' do
-      it 'returns true' do
-        curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', assignee: 'IPT-Capture'))
-        allow(curses_pull_request).to receive(:assignee_blacklist).and_return(['IPT-Capture'])
-        expect(curses_pull_request.send(:blacklisted?, 'IPT-Capture')).to eq true
-      end
-    end
-
-    context 'when assignee IS not blacklisted' do
-      it 'returns false' do
-        curses_pull_request = Pra::CursesPullRequestPresenter.new(double('pull request', assignee: 'IPT-Capture'))
-        allow(curses_pull_request).to receive(:assignee_blacklist).and_return(['IPT'])
-        expect(curses_pull_request.send(:blacklisted?, 'IPT-Capture')).to eq false
-      end
-    end
-  end
-end

data/spec/lib/pra/curses_window_system_spec.rb

@@ -1,4 +0,0 @@
-require_relative "../../../lib/pra/curses_window_system"
-
-describe Pra::CursesWindowSystem do
-end

data/spec/lib/pra/error_log_spec.rb

@@ -1,30 +0,0 @@
-require 'pra/error_log'
-
-describe Pra::ErrorLog do
-  describe '.log' do
-    let(:log_path) { double('log path') }
-    let(:file) { double('file object', puts: nil) }
-    let(:message) { double('error message') }
-    let(:backtrace) { ['backtrace line 1', 'backtrace line 2'] }
-    let(:error) { double('error', message: message, backtrace: backtrace) }
-
-    it 'opens the log file for appending' do
-      allow(Pra::Config).to receive(:error_log_path).and_return(log_path)
-      expect(File).to receive(:open).with(log_path, 'a')
-      Pra::ErrorLog.log(double)
-    end
-
-    it 'prints the error message to the file' do
-      allow(File).to receive(:open).and_yield(file)
-      expect(file).to receive(:puts).with(message)
-      Pra::ErrorLog.log(error)
-    end
-
-    it 'prints the backtrace to the file' do
-      allow(File).to receive(:open).and_yield(file)
-      expect(file).to receive(:puts).with('backtrace line 1')
-      expect(file).to receive(:puts).with('backtrace line 2')
-      Pra::ErrorLog.log(error)
-    end
-  end
-end

data/spec/lib/pra/github_pull_source_spec.rb

@@ -1,140 +0,0 @@
-require_relative "../../../lib/pra/github_pull_source"
-
-describe Pra::GithubPullSource do
-  describe "#pull_requests" do
-    it "gets all the repositories" do
-      subject.should_receive(:repositories).and_return([])
-      subject.pull_requests
-    end
-
-    it "gets the pull requests for each repository" do
-      config = {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" }
-        ]
-      }
-      pull_source = Pra::GithubPullSource.new(config)
-      pull_source.should_receive(:get_repo_pull_requests).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return([])
-      pull_source.pull_requests
-    end
-
-    it "returns the collection of all of the pull requests for the configured repos" do
-      config = {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" },
-          { "owner" => "realpractice", "repository" => "rliapi" }
-        ]
-      }
-      pull_request_one = double('pull request one')
-      pull_request_two = double('pull request two')
-      pull_source = Pra::GithubPullSource.new(config)
-      pull_source.stub(:get_repo_pull_requests).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return([pull_request_one])
-      pull_source.stub(:get_repo_pull_requests).with({ "owner" => "realpractice", "repository" => "rliapi" }).and_return([pull_request_two])
-      pull_source.pull_requests.should eq([pull_request_one, pull_request_two])
-    end
-  end
-
-  describe "#repositories" do
-    it "returns the repositories segment of the config" do
-      config = {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" }
-        ]
-      }
-      pull_source = Pra::GithubPullSource.new(config)
-      pull_source.repositories.should eq([{ "owner" => "reachlocal", "repository" => "snapdragon" }])
-    end
-  end
-  
-  describe "#get_repo_pull_requests" do
-    it "requests the pull requests for the given repo" do
-      config = {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" }
-        ]
-      }
-      pull_source = Pra::GithubPullSource.new(config)
-      pull_source.stub(:rest_api_pull_request_resource).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return('[]')
-      pull_source.get_repo_pull_requests({ "owner" => "reachlocal", "repository" => "snapdragon" })
-    end
-  end
-
-  describe "#rest_api_pull_request_url" do
-    let(:config) do
-      {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" }
-        ]
-      }
-    end
-
-    it "returns the pull request url compiled from the config options" do
-      pull_source = Pra::GithubPullSource.new(config)
-      pull_source.rest_api_pull_request_url({ "owner" => "reachlocal", "repository" => "snapdragon" }).should eq("https://my.github.instance/repos/reachlocal/snapdragon/pulls")
-    end
-  end
-
-  describe "#rest_api_pull_request_resource" do
-    let(:config) do
-      {
-        "protocol" => "https",
-        "host" => "my.github.instance",
-        "username" => "foo",
-        "password" => "bar",
-        "repositories" => [
-          { "owner" => "reachlocal", "repository" => "snapdragon" }
-        ]
-      }
-    end
-
-    let(:repo_config) { {"owner" => "reachlocal", "repository" => "snapdragon"} }
-
-    subject { Pra::GithubPullSource.new(config) }
-
-    it "creates a Faraday connection" do
-      expect(Faraday).to receive(:new).and_return(double.as_null_object)
-      subject.rest_api_pull_request_resource(repo_config)
-    end
-
-    it "set the http basic auth credentials" do
-      conn = double('faraday connection').as_null_object
-      allow(Faraday).to receive(:new).and_return(conn)
-      expect(conn).to receive(:basic_auth).with("foo", "bar")
-      subject.rest_api_pull_request_resource(repo_config)
-    end
-
-    it "makes request using faraday connection" do
-      conn = double('faraday connection').as_null_object
-      allow(Faraday).to receive(:new).and_return(conn)
-      expect(conn).to receive(:get)
-      subject.rest_api_pull_request_resource(repo_config)
-    end
-
-    it "returns the responses body" do
-      conn = double('faraday connection').as_null_object
-      allow(Faraday).to receive(:new).and_return(conn)
-      expect(conn).to receive(:get).and_return(double('response', body: 'hoopytbody'))
-      expect(subject.rest_api_pull_request_resource(repo_config)).to eq('hoopytbody')
-    end
-  end
-end

data/spec/lib/pra/pull_request_service/fetch_status_spec.rb

@@ -1,127 +0,0 @@
-require 'pra/pull_request_service/fetch_status'
-
-describe Pra::PullRequestService::FetchStatus do
-  describe '.new' do
-    it 'assigns the status' do
-      status = double
-      fetch = Pra::PullRequestService::FetchStatus.new(status, double)
-      expect(fetch.status).to eq(status)
-    end
-
-    it 'assigns the pull requests' do
-      pulls = [double]
-      fetch = Pra::PullRequestService::FetchStatus.new(double, pulls)
-      expect(fetch.pull_requests).to eq(pulls)
-    end
-
-    it 'assigns the error' do
-      error = double
-      fetch = Pra::PullRequestService::FetchStatus.new(double, double, error)
-      expect(fetch.error).to eq(error)
-    end
-  end
-
-  describe '.success' do
-    let(:pulls) { double }
-    subject { Pra::PullRequestService::FetchStatus.success(pulls) }
-
-    it 'sets the status to success' do
-      expect(subject.status).to eq(:success)
-    end
-
-    it 'assigns the pull requests' do
-      expect(subject.pull_requests).to eq(pulls)
-    end
-  end
-
-  describe '.error' do
-    let(:error) { double }
-    subject { Pra::PullRequestService::FetchStatus.error(error) }
-
-    it 'sets the status to error' do
-      expect(subject.status).to eq(:error)
-    end
-
-    it 'sets the pull requests to a dummy value' do
-      expect(subject.pull_requests).to eq(:no_pull_requests)
-    end
-  end
-
-  describe '#success?' do
-    context 'when status is :success' do
-      subject { Pra::PullRequestService::FetchStatus.new(:success, double) }
-
-      it 'returns true' do
-        expect(subject.success?).to be_truthy
-      end
-    end
-
-    context 'when status is not :success' do
-      subject { Pra::PullRequestService::FetchStatus.new(double, double) }
-
-      it 'returns false' do
-        expect(subject.success?).to be_falsey
-      end
-    end
-  end
-
-  describe '#error?' do
-    context 'when status is :error' do
-      subject { Pra::PullRequestService::FetchStatus.new(:error, double) }
-
-      it 'returns true' do
-        expect(subject.error?).to be_truthy
-      end
-    end
-
-    context 'when status is not :error' do
-      subject { Pra::PullRequestService::FetchStatus.new(double, double) }
-
-      it 'returns false' do
-        expect(subject.error?).to be_falsey
-      end
-    end
-  end
-
-  describe '#on_success' do
-    let(:pulls) { double }
-    let(:error) { double }
-
-    context 'when status is success' do
-      subject { Pra::PullRequestService::FetchStatus.success(pulls) }
-
-      it 'yields the pull requests to the block' do
-        expect { |success_block| subject.on_success(&success_block) }.to yield_with_args(pulls)
-      end
-    end
-
-    context 'when status is not success' do
-      subject { Pra::PullRequestService::FetchStatus.error(double) }
-
-      it 'does not yield' do
-        expect {|success_block| subject.on_success(&success_block) }.not_to yield_control
-      end
-    end
-  end
-
-  describe '#on_error' do
-    let(:pulls) { double }
-    let(:error) { double }
-
-    context 'when status is error' do
-      subject { Pra::PullRequestService::FetchStatus.error(error) }
-
-      it 'yields the error to the block' do
-        expect { |error_block| subject.on_error(&error_block) }.to yield_with_args(error)
-      end
-    end
-
-    context 'when status is not error' do
-      subject { Pra::PullRequestService::FetchStatus.success(double) }
-
-      it 'does not yield' do
-        expect {|error_block| subject.on_error(&error_block) }.not_to yield_control
-      end
-    end
-  end
-end

data/spec/lib/pra/pull_request_service_spec.rb

@@ -1,118 +0,0 @@
-require_relative '../../../lib/pra/pull_request_service'
-
-describe Pra::PullRequestService do
-  describe ".fetch_pull_requests" do
-    let(:pull_request_one) { double('pull request one') }
-    let(:pull_request_two) { double('pull request two') }
-    let(:pull_source_one) { double('good pull source one', :pull_requests => [pull_request_one]) }
-    let(:pull_source_two) { double('good pull source two', :pull_requests => [pull_request_two]) }
-
-    it "gets all the pull-request sources" do
-      subject.should_receive(:pull_sources).and_return([])
-      subject.fetch_pull_requests
-    end
-
-    it "gets the pull requests from each pull-request source" do
-      allow(subject).to receive(:pull_sources).and_return([pull_source_one, pull_source_two])
-      expect(subject).to receive(:fetch_with_status).with(pull_source_one)
-      expect(subject).to receive(:fetch_with_status).with(pull_source_two)
-      subject.fetch_pull_requests {}
-    end
-
-    it "yields each pull source with its fetch status object" do
-      status1 = double
-      status2 = double
-      allow(subject).to receive(:pull_sources).and_return([pull_source_one, pull_source_two])
-      allow(subject).to receive(:fetch_with_status).with(pull_source_one).and_return(status1)
-      allow(subject).to receive(:fetch_with_status).with(pull_source_two).and_return(status2)
-      expect { |b| subject.fetch_pull_requests(&b) }.to yield_successive_args(status1, status2)
-    end
-  end
-
-  describe '.fetch_with_status' do
-    let(:pulls) { double('pull requests') }
-    let(:error) { Exception.new('error fetching pull requests') }
-    let(:good_source) { double('good pull source', :pull_requests => pulls) }
-    let(:bad_source) { double('bad pull source') }
-
-    before do
-      allow(bad_source).to receive(:pull_requests).and_raise(error)
-    end
-
-    context 'when it fetches successfully' do
-      it 'builds a success status object for the requests from each pull source' do
-        expect(Pra::PullRequestService::FetchStatus).to receive(:success).with(pulls)
-        subject.fetch_with_status(good_source)
-      end
-
-      it 'returns the status object' do
-        status = double('success status object')
-        allow(Pra::PullRequestService::FetchStatus).to receive(:success).with(pulls).and_return(status)
-        expect(subject.fetch_with_status(good_source)).to eq(status)
-      end
-    end
-
-    context 'when fetching raises an exception' do
-      it 'builds an error status object with the error' do
-        expect(Pra::PullRequestService::FetchStatus).to receive(:error).with(error)
-        subject.fetch_with_status(bad_source)
-      end
-
-      it 'returns the status object' do
-        status = double('error status object')
-        allow(Pra::PullRequestService::FetchStatus).to receive(:error).and_return(status)
-        expect(subject.fetch_with_status(bad_source)).to eq(status)
-      end
-    end
-  end
-
-  describe "#pull_sources" do
-    it "gets the users config" do
-      subject.stub(:map_config_to_pull_sources)
-      Pra::Config.should_receive(:load_config)
-      subject.pull_sources
-    end
-
-    it "maps the pull-request sources from the config to PullSource objects" do
-      config = double('users config')
-      Pra::Config.stub(:load_config).and_return(config)
-      subject.should_receive(:map_config_to_pull_sources).with(config)
-      subject.pull_sources
-    end
-
-    it "returns the mapped pull-request sources" do
-      Pra::Config.stub(:load_config)
-      sources = double('pull sources')
-      subject.stub(:map_config_to_pull_sources).and_return(sources)
-      subject.pull_sources.should eq(sources)
-    end
-  end
-
-  describe "#map_config_to_pull_sources" do
-    it "gets the pull sources from the config" do
-      config = double('config')
-      config.should_receive(:pull_sources).and_return([])
-      subject.map_config_to_pull_sources(config)
-    end
-
-    it "creates a PullSource based object for each configured pull source" do
-      pull_source_config_one = double('pull source config one')
-      pull_source_config_two = double('pull source config two')
-      config = double('config', pull_sources: [pull_source_config_one, pull_source_config_two])
-      Pra::PullSourceFactory.should_receive(:build_pull_source).with(pull_source_config_one)
-      Pra::PullSourceFactory.should_receive(:build_pull_source).with(pull_source_config_two)
-      subject.map_config_to_pull_sources(config)
-    end
-
-    it "returns an array of the constructed PullSource based objects" do
-      pull_source_one = double('pull source one')
-      pull_source_two = double('pull source two')
-      pull_source_config_one = double('pull source config one')
-      pull_source_config_two = double('pull source config two')
-      config = double('config', pull_sources: [pull_source_config_one, pull_source_config_two])
-      Pra::PullSourceFactory.stub(:build_pull_source).with(pull_source_config_one).and_return(pull_source_one)
-      Pra::PullSourceFactory.stub(:build_pull_source).with(pull_source_config_two).and_return(pull_source_two)
-      subject.map_config_to_pull_sources(config).should eq([pull_source_one, pull_source_two])
-    end
-  end
-end

data/spec/lib/pra/pull_request_spec.rb

@@ -1,4 +0,0 @@
-require_relative "../../../lib/pra/pull_request"
-
-describe Pra::PullRequest do
-end

data/spec/lib/pra/pull_source_factory_spec.rb

@@ -1,40 +0,0 @@
-require_relative "../../../lib/pra/pull_source_factory"
-
-describe Pra::PullSourceFactory do
-  describe ".build_pull_source" do
-    it "maps the pull source type to class" do
-      pull_source_type_specific_configs = double('pull source type specific configs')
-      pull_source_config = { "type" => "stash", "config" => pull_source_type_specific_configs }
-      subject.should_receive(:map_type_to_klass).with("stash").and_return(Pra::StashPullSource)
-      subject.build_pull_source(pull_source_config)
-    end
-
-    it "constructs the mapped PullSource based object using the given pull source type specific config" do
-      pull_source_type_specific_configs = double('pull source type specific configs')
-      pull_source_config = { "type" => "stash", "config" => pull_source_type_specific_configs }
-      Pra::StashPullSource.should_receive(:new).with(pull_source_type_specific_configs)
-      subject.build_pull_source(pull_source_config)
-    end
-
-    it "returns the instance of the previously constructed PullSource based object" do
-      pull_source = double('the constructed pull source')
-      pull_source_config = { "type" => "stash", "config" => {} }
-      Pra::StashPullSource.should_receive(:new).and_return(pull_source)
-      subject.build_pull_source(pull_source_config).should eq(pull_source)
-    end
-  end
-
-  describe ".map_type_to_klass" do
-    context "when given type is 'stash'" do
-      it "returns the StashPullSource class" do
-        subject.map_type_to_klass("stash").should eq(Pra::StashPullSource)
-      end
-    end
-
-    context "When given type is 'github'" do
-      it "returns the GithubPullSource class" do
-        subject.map_type_to_klass("github").should eq(Pra::GithubPullSource)
-      end
-    end
-  end
-end

data/spec/lib/pra/pull_source_spec.rb

@@ -1,17 +0,0 @@
-require_relative "../../../lib/pra/pull_source"
-
-describe Pra::PullSource do
-  describe "#initialize" do
-    it "assigns the given config hash to an instance variable" do
-      config = double('config hash')
-      pull_source = Pra::PullSource.new(config)
-      pull_source.instance_variable_get(:@config).should eq(config)
-    end
-  end
-
-  describe "#pull_requests" do
-    it "raises an exception forcing inheriting classes to implement this method" do
-      expect { subject.pull_requests }.to raise_error(Pra::PullSource::NotImplemented)
-    end
-  end
-end