git_helper 3.3.0 → 3.6.6

data/spec/git_helper/pull_request_spec.rb

@@ -1,254 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitHubPullRequest do
-  let(:local_code) { double(:local_code, read_template: Faker::Lorem.word) }
-  let(:highline_cli) { double(:highline_cli) }
-  let(:octokit_client_client) { double(:octokit_client_client, project: :project, merge_request: :merge_request, create_merge_request: :created) }
-  let(:octokit_client) { double(:octokit_client, client: octokit_client_client) }
-
-  let(:options) do
-    {
-      local_project: Faker::Lorem.word,
-      local_branch: Faker::Lorem.word,
-      local_code: local_code,
-      cli: highline_cli
-    }
-  end
-
-  subject { GitHelper::GitHubPullRequest.new(options) }
-
-  before do
-    allow(GitHelper::OctokitClient).to receive(:new).and_return(octokit_client)
-    allow(subject).to receive(:puts)
-  end
-
-  describe '#create' do
-    it 'should call the octokit client to create' do
-      allow(subject).to receive(:new_pr_body).and_return('')
-      expect(octokit_client_client).to receive(:create_pull_request).and_return(double(html_url: Faker::Internet.url))
-      subject.create({base_branch: Faker::Lorem.word, new_title: Faker::Lorem.word})
-    end
-
-    it 'should call various other methods' do
-      expect(subject).to receive(:new_pr_body).and_return('').at_least(:once)
-      allow(octokit_client_client).to receive(:create_pull_request).and_return(double(html_url: Faker::Internet.url))
-      subject.create({base_branch: Faker::Lorem.word, new_title: Faker::Lorem.word})
-    end
-
-    it 'should catch the raised error if the creation does not work' do
-      allow(subject).to receive(:new_pr_body).and_return('')
-      allow(octokit_client_client).to receive(:create_pull_request).and_raise(StandardError)
-      expect(subject.create({base_branch: Faker::Lorem.word, new_title: Faker::Lorem.word})).to eq(nil)
-    end
-  end
-
-  describe '#merge' do
-    it 'should call the octokit client to merge' do
-      allow(subject).to receive(:existing_pr).and_return(double(title: Faker::Lorem.word))
-      allow(subject).to receive(:merge_method).and_return('rebase')
-      allow(subject).to receive(:pr_id).and_return(Faker::Number.number)
-      expect(octokit_client_client).to receive(:merge_pull_request).and_return(double(sha: Faker::Internet.password))
-      subject.merge
-    end
-
-    it 'should call various other methods' do
-      expect(subject).to receive(:existing_pr).and_return(double(title: Faker::Lorem.word)).at_least(:once)
-      expect(subject).to receive(:merge_method).and_return('rebase').at_least(:once)
-      expect(subject).to receive(:pr_id).and_return(Faker::Number.number).at_least(:once)
-      allow(octokit_client_client).to receive(:merge_pull_request).and_return(double(sha: Faker::Internet.password))
-      subject.merge
-    end
-
-    it 'should catch the raised error if the merge does not work' do
-      allow(subject).to receive(:existing_pr).and_return(double(title: Faker::Lorem.word))
-      allow(subject).to receive(:merge_method).and_return('rebase')
-      allow(subject).to receive(:pr_id).and_return(Faker::Number.number)
-      allow(octokit_client_client).to receive(:merge_pull_request).and_raise(StandardError)
-      expect(subject.merge).to eq(nil)
-    end
-  end
-
-  describe '#new_pr_body' do
-    it 'should call the local code if the template to apply exists' do
-      allow(subject).to receive(:template_name_to_apply).and_return('')
-      expect(local_code).to receive(:read_template)
-      subject.send(:new_pr_body)
-    end
-
-    it 'should not call the local code if the template is nil' do
-      allow(subject).to receive(:template_name_to_apply).and_return(nil)
-      expect(local_code).not_to receive(:read_template)
-      subject.send(:new_pr_body)
-    end
-
-    it 'should return an empty string if the template is nil' do
-      allow(subject).to receive(:template_name_to_apply).and_return(nil)
-      expect(subject.send(:new_pr_body)).to eq('')
-    end
-  end
-
-  describe '#template_name_to_apply' do
-    context 'if PR template options are empty' do
-      it 'should return nil' do
-        allow(subject).to receive(:pr_template_options).and_return([])
-        expect(subject.send(:template_name_to_apply)).to eq(nil)
-      end
-    end
-
-    context 'if there is one template option' do
-      let(:template) { Faker::Lorem.word }
-
-      it 'should call the CLI to ask about a single template' do
-        allow(subject).to receive(:pr_template_options).and_return([template])
-        expect(highline_cli).to receive(:ask_yes_no).and_return(true)
-        subject.send(:template_name_to_apply)
-      end
-
-      it 'should return the single template if the user says yes' do
-        allow(subject).to receive(:pr_template_options).and_return([template])
-        allow(highline_cli).to receive(:ask_yes_no).and_return(true)
-        expect(subject.send(:template_name_to_apply)).to eq(template)
-      end
-
-      it 'should return nil if the user says no' do
-        allow(subject).to receive(:pr_template_options).and_return([template])
-        allow(highline_cli).to receive(:ask_yes_no).and_return(false)
-        expect(subject.send(:template_name_to_apply)).to eq(nil)
-      end
-    end
-
-    context 'if there are multiple template options' do
-      let(:template1) { Faker::Lorem.word }
-      let(:template2) { Faker::Lorem.word }
-
-      it 'should call the CLI to ask which of multiple templates to apply' do
-        allow(subject).to receive(:pr_template_options).and_return([template1, template2])
-        expect(highline_cli).to receive(:ask_options).and_return(template1)
-        subject.send(:template_name_to_apply)
-      end
-
-      it 'should return the answer template if the user says yes' do
-        allow(subject).to receive(:pr_template_options).and_return([template1, template2])
-        allow(highline_cli).to receive(:ask_options).and_return(template1)
-        expect(subject.send(:template_name_to_apply)).to eq(template1)
-      end
-
-      it 'should return nil if the user says no' do
-        allow(subject).to receive(:pr_template_options).and_return([template1, template2])
-        allow(highline_cli).to receive(:ask_options).and_return('None')
-        expect(subject.send(:template_name_to_apply)).to eq(nil)
-      end
-    end
-  end
-
-  describe '#pr_template_options' do
-    it 'should call the local code' do
-      expect(local_code).to receive(:template_options)
-      subject.send(:pr_template_options)
-    end
-  end
-
-  describe '#pr_id' do
-    it 'should ask the CLI for the code request ID' do
-      expect(highline_cli).to receive(:ask).and_return(Faker::Number.number)
-      subject.send(:pr_id)
-    end
-
-    it 'should equal an integer' do
-      pr_id = Faker::Number.number
-      expect(highline_cli).to receive(:ask).and_return(pr_id)
-      expect(subject.send(:pr_id)).to eq(pr_id)
-    end
-  end
-
-  describe '#merge_method' do
-    let(:project) { double(:project, allow_merge_commit: true, allow_squash_merge: true, allow_rebase_merge: true) }
-
-    before do
-      allow(subject).to receive(:existing_project).and_return(project)
-      allow(highline_cli).to receive(:ask_options)
-    end
-
-    it 'should ask the CLI for the merge_method' do
-      expect(highline_cli).to receive(:ask_options).and_return('merge')
-      subject.send(:merge_method)
-    end
-
-    it 'should be a string' do
-      allow(highline_cli).to receive(:ask_options).and_return('merge')
-      expect(subject.send(:merge_method)).to be_a(String)
-    end
-
-    context 'if theres only one item' do
-      let(:project) { double(:project, allow_merge_commit: true, allow_squash_merge: false, allow_rebase_merge: false) }
-
-      it 'should not ask the CLI anything' do
-        expect(highline_cli).not_to receive(:merge_method)
-        subject.send(:merge_method)
-      end
-    end
-  end
-
-  describe '#merge_options' do
-    let(:project) { double(:project, allow_merge_commit: true, allow_squash_merge: true, allow_rebase_merge: true) }
-
-    before do
-      allow(subject).to receive(:existing_project).and_return(project)
-    end
-
-    it 'should return an array' do
-      expect(subject.send(:merge_options)).to be_a(Array)
-    end
-
-    it 'should have three items' do
-      expect(subject.send(:merge_options).length).to eq(3)
-    end
-
-    context 'when two options are present' do
-      let(:project) { double(:project, allow_merge_commit: false, allow_squash_merge: true, allow_rebase_merge: true) }
-
-      it 'should have two items' do
-        expect(subject.send(:merge_options).length).to eq(2)
-      end
-    end
-
-    context 'when one option is present' do
-      let(:project) { double(:project, allow_merge_commit: false, allow_squash_merge: false, allow_rebase_merge: true) }
-
-      it 'should have one item' do
-        expect(subject.send(:merge_options).length).to eq(1)
-      end
-    end
-
-    context 'when no options are present' do
-      let(:project) { double(:project, allow_merge_commit: false, allow_squash_merge: false, allow_rebase_merge: false) }
-
-      it 'should have no items' do
-        expect(subject.send(:merge_options).length).to eq(0)
-      end
-    end
-  end
-
-  describe '#existing_project' do
-    it 'should call the octokit client' do
-      expect(octokit_client_client).to receive(:repository).and_return(:repository)
-      subject.send(:existing_project)
-    end
-  end
-
-  describe '#existing_pr' do
-    it 'should call the octokit client' do
-      allow(highline_cli).to receive(:ask).and_return(Faker::Number.number)
-      expect(octokit_client_client).to receive(:pull_request).and_return(:pull_request)
-      subject.send(:existing_pr)
-    end
-  end
-
-  describe '#octokit_client' do
-    it 'should call the octokit client' do
-      expect(GitHelper::OctokitClient).to receive(:new).and_return(octokit_client)
-      subject.send(:octokit_client)
-    end
-  end
-end

data/spec/git_helper/setup_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::Setup do
-  let(:response) { double(:response, readline: true, to_s: Faker::Lorem.sentence) }
-  let(:highline_cli) { double(:highline_cli, ask: response, ask_yes_no: true) }
-
-  before do
-    allow(GitHelper::HighlineCli).to receive(:new).and_return(highline_cli)
-    allow(subject).to receive(:puts)
-  end
-
-  after do
-    GitHelper::Setup.instance_variable_set("@highline", nil)
-  end
-
-  describe '#execute' do
-    it 'should ask a question if the config file exists' do
-      allow(File).to receive(:exists?).and_return(true)
-      expect(highline_cli).to receive(:ask_yes_no).and_return(true)
-      allow(subject).to receive(:create_or_update_config_file).and_return(true)
-      allow(subject).to receive(:create_or_update_plugin_files)
-      subject.execute
-    end
-
-    it 'should call to create or update the config file' do
-      allow(File).to receive(:exists?).and_return(true)
-      allow(highline_cli).to receive(:ask_yes_no).and_return(true)
-      expect(subject).to receive(:create_or_update_config_file).and_return(true)
-      allow(subject).to receive(:create_or_update_plugin_files)
-      subject.execute
-    end
-
-    it 'should skip if the user opts not to continue' do
-      allow(File).to receive(:exists?).and_return(true)
-      allow(highline_cli).to receive(:ask_yes_no).and_return(false)
-      expect(subject).not_to receive(:create_or_update_config_file)
-      expect(subject).not_to receive(:create_or_update_plugin_files)
-      subject.execute
-    end
-  end
-
-  describe '#create_or_update_config_file' do
-    it 'should generate the file based on the answers to the questions' do
-      expect(subject).to receive(:generate_file_contents)
-      allow(File).to receive(:open).and_return(nil)
-      subject.send(:create_or_update_config_file)
-    end
-
-    it 'should open the file for writing' do
-      allow(subject).to receive(:generate_file_contents)
-      expect(File).to receive(:open).and_return(nil)
-      subject.send(:create_or_update_config_file)
-    end
-  end
-
-  describe '#config_file_exists?' do
-    it 'should return true if the file exists' do
-      allow(File).to receive(:exists?).and_return(true)
-      expect(subject.send(:config_file_exists?)).to eq(true)
-    end
-
-    it 'should return false if the file does not exist' do
-      allow(File).to receive(:exists?).and_return(false)
-      expect(subject.send(:config_file_exists?)).to eq(false)
-    end
-  end
-
-  describe '#ask_question' do
-    it 'should use highline to ask a question' do
-      expect(highline_cli).to receive(:ask).and_return(Faker::Lorem.word)
-      subject.send(:ask_question, Faker::Lorem.sentence)
-    end
-
-    it 'should recurse if the highline client gets an empty string' do
-      allow(highline_cli).to receive(:ask).and_return('', Faker::Lorem.word)
-      expect(subject).to receive(:ask_question).at_least(:twice).and_call_original
-      subject.send(:ask_question, Faker::Lorem.sentence)
-    end
-
-    it 'should return the answer if it is given' do
-      answer = Faker::Lorem.sentence
-      allow(highline_cli).to receive(:ask).and_return(answer)
-      expect(subject.send(:ask_question, Faker::Lorem.sentence)).to be(answer)
-    end
-  end
-
-  describe '#generate_file_contents' do
-    it 'should ask two yes/no questions' do
-      expect(highline_cli).to receive(:ask_yes_no).exactly(2).times.and_return(false)
-      subject.send(:generate_file_contents)
-    end
-
-    it 'should ask two additional questions for each time the user says yes' do
-      allow(highline_cli).to receive(:ask_yes_no).exactly(2).times.and_return(true, false)
-      expect(subject).to receive(:ask_question).exactly(2).times.and_return(Faker::Lorem.word)
-      subject.send(:generate_file_contents)
-    end
-
-    it 'should ask four additional questions for each time the user says yes' do
-      allow(highline_cli).to receive(:ask_yes_no).exactly(2).times.and_return(true)
-      expect(subject).to receive(:ask_question).exactly(4).times.and_return(Faker::Lorem.word)
-      subject.send(:generate_file_contents)
-    end
-
-    it 'should return a string no matter what' do
-      allow(highline_cli).to receive(:ask_yes_no).exactly(2).times.and_return(true)
-      allow(subject).to receive(:ask_question).exactly(4).times.and_return(Faker::Lorem.word)
-      expect(subject.send(:generate_file_contents)).to be_a(String)
-    end
-  end
-
-  describe '#create_or_update_plugin_files' do
-    let(:plugins) do
-      [
-        {
-          'name': 'plugin-file-one'
-        },
-        {
-          'name': 'plugin-file-two'
-        }
-      ]
-    end
-
-    let(:plugins_json) do
-      "[
-        {
-          \"name\": \"plugin-file-one\"
-        },
-        {
-          \"name\": \"plugin-file-two\"
-        }
-      ]"
-    end
-
-    it 'should create the directory if it does not exist' do
-      allow(File).to receive(:exists?).and_return(false)
-      allow(File).to receive(:open).and_return(nil)
-      expect(Dir).to receive(:mkdir)
-      allow(subject).to receive(:`).and_return(plugins_json)
-      allow(JSON).to receive(:parse).and_return(plugins)
-      subject.send(:create_or_update_plugin_files)
-    end
-
-    it 'should not create the directory if it already exists' do
-      allow(File).to receive(:exists?).and_return(true)
-      allow(File).to receive(:open).and_return(nil)
-      expect(Dir).not_to receive(:mkdir)
-      allow(subject).to receive(:`).and_return(plugins_json)
-      allow(JSON).to receive(:parse).and_return(plugins)
-      subject.send(:create_or_update_plugin_files)
-    end
-
-    it 'should curl the GitHub API' do
-      allow(File).to receive(:exists?).and_return(true)
-      allow(File).to receive(:open).and_return(nil)
-      allow(subject).to receive(:`).and_return(plugins_json)
-      expect(JSON).to receive(:parse).with(plugins_json).and_return(plugins)
-      subject.send(:create_or_update_plugin_files)
-    end
-
-    it 'should go through the loop for each plugin' do
-      allow(File).to receive(:exists?).and_return(true)
-      allow(File).to receive(:open).and_return(nil)
-      expect(subject).to receive(:`).exactly(3).times
-      allow(JSON).to receive(:parse).and_return(plugins)
-      subject.send(:create_or_update_plugin_files)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,47 +0,0 @@
-require 'faker'
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.filter_run :focus => true
-  config.run_all_when_everything_filtered = true
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-end