git_helper 3.6.1 → 3.6.2

data/spec/git_helper/local_code_spec.rb

@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::LocalCode do
-  let(:response) { double(:response, readline: true, to_i: 5) }
-  let(:local_codeent) { double(:local_code, ask: response) }
-  let(:project_name) { Faker::Lorem.word }
-  let(:owner) { Faker::Name.first_name }
-  let(:ssh_remote) { "origin\tgit@github.com:#{owner}/#{project_name}.git (fetch)" }
-  let(:https_remote) { "origin\thttps://github.com/#{owner}/#{project_name}.git (fetch)" }
-
-  let(:github_remotes) do
-    [
-      "origin\tgit@github.com:#{owner}/#{project_name}.git (fetch)",
-      "origin\thttps://github.com/#{owner}/#{project_name}.git (fetch)"
-    ]
-  end
-
-  let(:gitlab_remotes) do
-    [
-      "origin\tgit@gitlab.com:#{owner}/#{project_name}.git (fetch)",
-      "origin\thttps://gitlab.com/#{owner}/#{project_name}.git (fetch)"
-    ]
-  end
-
-  subject { GitHelper::LocalCode.new }
-
-  before do
-    allow(subject).to receive(:system).and_return(nil)
-  end
-
-  describe '#checkout_default' do
-    it 'should make a system call' do
-      expect(subject).to receive(:system)
-      subject.checkout_default
-    end
-  end
-
-  describe '#forget_local_commits' do
-    it 'should make a system call' do
-      expect(subject).to receive(:system).exactly(2).times
-      subject.forget_local_commits
-    end
-
-    it 'should return nil' do
-      expect(subject.forget_local_commits).to eq(nil)
-    end
-  end
-
-  describe '#empty_commit' do
-    it 'should make a system call' do
-      expect(subject).to receive(:system)
-      subject.empty_commit
-    end
-  end
-
-  describe '#clean_branches' do
-    it 'should make a system call' do
-      expect(subject).to receive(:system).exactly(4).times
-      subject.clean_branches
-    end
-  end
-
-  describe '#new_branch' do
-    it 'should make a system call' do
-      expect(subject).to receive(:system).exactly(4).times
-      subject.new_branch(Faker::Lorem.word)
-    end
-  end
-
-  describe '#change_remote' do
-    it 'should return a string' do
-      allow(subject).to receive(:`).and_return(Faker::Lorem.word)
-      expect(subject.change_remote(Faker::Lorem.word, Faker::Internet.url)).to be_a(String)
-    end
-  end
-
-  describe '#remotes' do
-    it 'should return an array of strings' do
-      expect(subject.remotes).to be_a(Array)
-      expect(subject.remotes.first).to be_a(String)
-    end
-  end
-
-  describe '#remote_name' do
-    it 'should be a string' do
-      expect(subject.remote_name(ssh_remote)).to be_a(String)
-    end
-  end
-
-  describe '#ssh_remote' do
-    it 'should come out true if ssh' do
-      expect(subject.ssh_remote?(ssh_remote)).to eq(true)
-    end
-
-    it 'should come out false if https' do
-      expect(subject.ssh_remote?(https_remote)).to eq(false)
-    end
-  end
-
-  describe '#https_remote' do
-    it 'should come out false if ssh' do
-      expect(subject.https_remote?(ssh_remote)).to eq(false)
-    end
-
-    it 'should come out true if https' do
-      expect(subject.https_remote?(https_remote)).to eq(true)
-    end
-  end
-
-  describe '#remote_project' do
-    it 'should return just the plain project if ssh' do
-      expect(subject.remote_project(ssh_remote)).to eq(project_name)
-    end
-
-    it 'should return just the plain project if https' do
-      expect(subject.remote_project(https_remote)).to eq(project_name)
-    end
-  end
-
-  describe '#remote_source' do
-    it 'should return just the plain project if ssh' do
-      expect(subject.remote_source(ssh_remote)).to eq('github.com')
-    end
-
-    it 'should return just the plain project if https' do
-      expect(subject.remote_source(https_remote)).to eq('github.com')
-    end
-  end
-
-  describe '#github_repo' do
-    it 'should return true if github' do
-      allow(subject).to receive(:remotes).and_return(github_remotes)
-      expect(subject.github_repo?).to eq(true)
-    end
-
-    it 'should return false if gitlab' do
-      allow(subject).to receive(:remotes).and_return(gitlab_remotes)
-      expect(subject.github_repo?).to eq(false)
-    end
-  end
-
-  describe '#gitlab_project' do
-    it 'should return true if gitlab' do
-      allow(subject).to receive(:remotes).and_return(gitlab_remotes)
-      expect(subject.gitlab_project?).to eq(true)
-    end
-
-    it 'should return false if github' do
-      allow(subject).to receive(:remotes).and_return(github_remotes)
-      expect(subject.gitlab_project?).to eq(false)
-    end
-  end
-
-  describe '#project_name' do
-    it 'should return a string' do
-      expect(subject.project_name).to be_a(String)
-    end
-
-    it 'should equal this project name' do
-      allow_any_instance_of(String).to receive(:scan).and_return([["#{owner}/#{project_name}"]])
-      expect(subject.project_name).to eq("#{owner}/#{project_name}")
-    end
-  end
-
-  describe '#branch' do
-    it 'should return a string' do
-      expect(subject.branch).to be_a(String)
-    end
-  end
-
-  describe '#default_branch' do
-    it 'should return a string' do
-      expect(subject.default_branch).to be_a(String)
-    end
-  end
-
-  describe '#template_options' do
-    let(:template_identifiers) do
-      {
-        template_directory: '.github',
-        nested_directory_name: 'PULL_REQUEST_TEMPLATE',
-        non_nested_file_name: 'pull_request_template'
-      }
-    end
-
-    it 'should return an array' do
-      expect(subject.template_options(template_identifiers)).to be_a(Array)
-    end
-
-    it 'should call Dir.glob and File.join' do
-      expect(Dir).to receive(:glob).and_return(['.github/pull_request_template.md']).at_least(:once)
-      expect(File).to receive(:join).at_least(:once)
-      subject.template_options(template_identifiers)
-    end
-  end
-
-  describe '#read_template' do
-    it 'should call File.open' do
-      expect(File).to receive(:open).and_return(double(read: true))
-      subject.read_template('.gitignore')
-    end
-  end
-
-  describe '#generate_title' do
-    it 'should return a title based on the branch' do
-      prefix = Faker::Lorem.word
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      description = [word1, word2].join('-')
-      branch = "#{prefix}-123-#{description}"
-      expect(subject.generate_title(branch)).to eq("#{prefix.upcase}-123 #{[word1.capitalize, word2].join(' ')}")
-    end
-
-    it 'should return a title based on the branch' do
-      prefix = Faker::Lorem.word
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      description = [word1, word2].join('_')
-      branch = "#{prefix}_123_#{description}"
-      expect(subject.generate_title(branch)).to eq("#{prefix.upcase}-123 #{[word1.capitalize, word2].join(' ')}")
-    end
-
-    it 'should return a title based on the branch' do
-      prefix = Faker::Lorem.word
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      description = [word1, word2].join('_')
-      branch = "#{prefix}-123_#{description}"
-      expect(subject.generate_title(branch)).to eq("#{prefix.upcase}-123 #{[word1.capitalize, word2].join(' ')}")
-    end
-
-    it 'should return a title based on the branch' do
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      branch = [word1, word2].join('_')
-      expect(subject.generate_title(branch)).to eq([word1.capitalize, word2].join(' '))
-    end
-
-    it 'should return a title based on the branch' do
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      branch = [word1, word2].join('-')
-      expect(subject.generate_title(branch)).to eq([word1.capitalize, word2].join(' '))
-    end
-
-    it 'should return a title based on the branch' do
-      branch = Faker::Lorem.word
-      expect(subject.generate_title(branch)).to eq(branch.capitalize)
-    end
-
-    it 'should return a title based on the branch' do
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      word3 = Faker::Lorem.word
-      branch = [word1, word2, word3].join('_')
-      expect(subject.generate_title(branch)).to eq([word1.capitalize, word2, word3].join(' '))
-    end
-
-    it 'should return a title based on the branch' do
-      word1 = Faker::Lorem.word
-      word2 = Faker::Lorem.word
-      word3 = Faker::Lorem.word
-      branch = [word1, word2, word3].join('-')
-      expect(subject.generate_title(branch)).to eq([word1.capitalize, word2, word3].join(' '))
-    end
-  end
-end

data/spec/git_helper/merge_request_spec.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitLabMergeRequest do
-  let(:local_code) { double(:local_code, read_template: Faker::Lorem.word) }
-  let(:highline_wrapper) { double(:highline_wrapper) }
-  let(:gitlab_client) { double(:gitlab_client) }
-
-  let(:merge_request) do
-    double(:merge_request,
-           message: Faker::Lorem.sentence,
-           diff_refs: { base_sha: Faker::Lorem.word, head_sha: Faker::Lorem.word },
-           web_url: Faker::Internet.url,
-           merge_commit_sha: Faker::Internet.password)
-  end
-
-  let(:options) do
-    {
-      local_project: Faker::Lorem.word,
-      local_branch: Faker::Lorem.word,
-      local_code: local_code,
-      highline: highline_wrapper
-    }
-  end
-
-  subject { described_class.new(options) }
-
-  before do
-    allow(GitHelper::GitLabClient).to receive(:new).and_return(gitlab_client)
-    allow(subject).to receive(:puts)
-  end
-
-  describe '#create' do
-    it 'should call the gitlab client to create' do
-      allow(subject).to receive(:squash_merge_request).and_return(true)
-      allow(subject).to receive(:remove_source_branch).and_return(false)
-      allow(subject).to receive(:new_mr_body).and_return('')
-      expect(gitlab_client).to receive(:create_merge_request).and_return(merge_request)
-      subject.create({ base_branch: Faker::Lorem.word, new_title: Faker::Lorem.word })
-    end
-
-    it 'should call various other methods' do
-      expect(subject).to receive(:squash_merge_request).and_return(true)
-      expect(subject).to receive(:remove_source_branch).and_return(false)
-      expect(subject).to receive(:new_mr_body).and_return('')
-      allow(gitlab_client).to receive(:create_merge_request).and_return(merge_request)
-      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(:squash_merge_request).and_return(true)
-      allow(subject).to receive(:remove_source_branch).and_return(false)
-      allow(subject).to receive(:new_mr_body).and_return('')
-      allow(gitlab_client).to receive(:create_merge_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 gitlab client to merge' do
-      allow(subject).to receive(:existing_mr).and_return(double(should_remove_source_branch: true, squash: false, title: 'title'))
-      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
-      expect(gitlab_client).to receive(:accept_merge_request).and_return(merge_request)
-      subject.merge
-    end
-
-    it 'should call various other methods' do
-      expect(subject).to receive(:existing_mr).and_return(double(should_remove_source_branch: true, squash: false, title: 'title')).at_least(:once)
-      expect(subject).to receive(:mr_id).and_return(Faker::Number.number).at_least(:once)
-      allow(gitlab_client).to receive(:accept_merge_request).and_return(merge_request)
-      subject.merge
-    end
-
-    it 'should catch the raised error if the merge does not work' do
-      allow(subject).to receive(:existing_mr).and_return(double(should_remove_source_branch: true, squash: false, title: 'title'))
-      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
-      allow(gitlab_client).to receive(:accept_merge_request).and_raise(StandardError)
-      expect(subject.merge).to eq(nil)
-    end
-
-    it 'should try to merge multiple times if the first merge errors' do
-      allow(subject).to receive(:existing_mr).and_return(double(should_remove_source_branch: true, squash: false, title: 'title'))
-      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
-      expect(gitlab_client).to receive(:accept_merge_request).and_return(double(merge_commit_sha: nil, merge_error: Faker::Lorem.word, message: Faker::Lorem.sentence)).exactly(2).times
-      expect(subject.merge).to eq(nil)
-    end
-  end
-
-  describe '#new_mr_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_mr_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_mr_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_mr_body)).to eq('')
-    end
-  end
-
-  describe '#template_name_to_apply' do
-    context 'if MR template options are empty' do
-      it 'should return nil' do
-        allow(subject).to receive(:mr_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(:mr_template_options).and_return([template])
-        expect(highline_wrapper).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(:mr_template_options).and_return([template])
-        allow(highline_wrapper).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(:mr_template_options).and_return([template])
-        allow(highline_wrapper).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(:mr_template_options).and_return([template1, template2])
-        expect(highline_wrapper).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(:mr_template_options).and_return([template1, template2])
-        allow(highline_wrapper).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(:mr_template_options).and_return([template1, template2])
-        allow(highline_wrapper).to receive(:ask_options).and_return('None')
-        expect(subject.send(:template_name_to_apply)).to eq(nil)
-      end
-    end
-  end
-
-  describe '#mr_template_options' do
-    it 'should call the local code' do
-      expect(local_code).to receive(:template_options)
-      subject.send(:mr_template_options)
-    end
-  end
-
-  describe '#mr_id' do
-    it 'should ask the CLI for the code request ID' do
-      expect(highline_wrapper).to receive(:ask).and_return(Faker::Number.number)
-      subject.send(:mr_id)
-    end
-
-    it 'should equal an integer' do
-      pr_id = Faker::Number.number
-      expect(highline_wrapper).to receive(:ask).and_return(pr_id)
-      expect(subject.send(:mr_id)).to eq(pr_id)
-    end
-  end
-
-  describe '#squash_merge_request' do
-    let(:existing_project) { double(squash_option: 'default_off') }
-
-    it 'should return true if the squash is set to always on the project' do
-      allow(subject).to receive(:existing_project).and_return(existing_project)
-      allow(existing_project).to receive(:squash_option).and_return('always')
-      expect(highline_wrapper).not_to receive(:ask_yes_no)
-      expect(subject.send(:squash_merge_request)).to eq(true)
-    end
-
-    it 'should return true if the squash is set to default_on on the project' do
-      allow(subject).to receive(:existing_project).and_return(existing_project)
-      allow(existing_project).to receive(:squash_option).and_return('default_on')
-      expect(highline_wrapper).not_to receive(:ask_yes_no)
-      expect(subject.send(:squash_merge_request)).to eq(true)
-    end
-
-    it 'should return false if the squash is set to never on the project' do
-      allow(subject).to receive(:existing_project).and_return(existing_project)
-      allow(existing_project).to receive(:squash_option).and_return('never')
-      expect(highline_wrapper).not_to receive(:ask_yes_no)
-      expect(subject.send(:squash_merge_request)).to eq(false)
-    end
-
-    it 'should ask the user for their response to the squash question' do
-      allow(subject).to receive(:existing_project).and_return(existing_project)
-      allow(existing_project).to receive(:squash_option).and_return(nil)
-      expect(highline_wrapper).to receive(:ask_yes_no).and_return(true)
-      subject.send(:squash_merge_request)
-    end
-
-    it 'should be a boolean' do
-      allow(subject).to receive(:existing_project).and_return(existing_project)
-      allow(existing_project).to receive(:squash_option).and_return(nil)
-      expect(highline_wrapper).to receive(:ask_yes_no).and_return(false)
-      expect([true, false]).to include(subject.send(:squash_merge_request))
-    end
-  end
-
-  describe '#remove_source_branch' do
-    before do
-      allow(subject).to receive(:existing_project).and_return(double(remove_source_branch_after_merge: nil))
-    end
-
-    context 'when the existing project has no setting' do
-      it 'should ask the CLI for the code request ID' do
-        expect(highline_wrapper).to receive(:ask_yes_no).and_return(true)
-        subject.send(:remove_source_branch)
-      end
-
-      it 'should be a boolean' do
-        allow(highline_wrapper).to receive(:ask_yes_no).and_return(false)
-        expect([true, false]).to include(subject.send(:remove_source_branch))
-      end
-    end
-
-    it 'should ask the existing project' do
-      expect(subject).to receive(:existing_project).and_return(double(remove_source_branch_after_merge: true))
-      subject.send(:remove_source_branch)
-    end
-
-    it 'should return the existing projects setting if it exists' do
-      allow(subject).to receive(:existing_project).and_return(double(remove_source_branch_after_merge: true))
-      expect(subject.send(:remove_source_branch)).to eq(true)
-    end
-
-    it 'should return the existing projects setting if it exists' do
-      allow(subject).to receive(:existing_project).and_return(double(remove_source_branch_after_merge: false))
-      allow(highline_wrapper).to receive(:ask_yes_no).and_return(true)
-      expect(subject.send(:remove_source_branch)).to eq(true)
-    end
-  end
-
-  describe '#existing_project' do
-    it 'should call the gitlab client' do
-      expect(gitlab_client).to receive(:project).and_return(:project)
-      subject.send(:existing_project)
-    end
-  end
-
-  describe '#existing_mr' do
-    it 'should call the gitlab client' do
-      allow(highline_wrapper).to receive(:ask).and_return(Faker::Number.number)
-      expect(gitlab_client).to receive(:merge_request).and_return(:merge_request)
-      subject.send(:existing_mr)
-    end
-  end
-
-  describe '#gitlab_client' do
-    it 'should call the gitlab client' do
-      expect(GitHelper::GitLabClient).to receive(:new).and_return(gitlab_client)
-      subject.send(:gitlab_client)
-    end
-  end
-end

data/spec/git_helper/new_branch_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::NewBranch do
-  let(:new_branch_name) { 'new-branch-name' }
-  let(:local_code) { double(:local_code, new_branch: :commit) }
-  let(:highline) { double(:highline_wrapper, ask: new_branch_name) }
-
-  subject { GitHelper::NewBranch.new }
-
-  before do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    allow(HighlineWrapper).to receive(:new).and_return(highline)
-    allow(subject).to receive(:puts)
-  end
-
-  it 'should call GitHelper::LocalCode' do
-    expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    subject.execute
-  end
-
-  it 'should call the new_branch method from the local code class' do
-    expect(local_code).to receive(:new_branch)
-    subject.execute
-  end
-
-  context 'when no branch name is passed in' do
-    it 'should call the highline client' do
-      expect(HighlineWrapper).to receive(:new).and_return(highline)
-      subject.execute
-    end
-
-    it 'should ask the highline client what the new branch name should be' do
-      expect(highline).to receive(:ask)
-      subject.execute
-    end
-  end
-
-  context 'when there is a branch name passed in' do
-    it 'should not create a highline_wrapper client' do
-      expect(HighlineWrapper).not_to receive(:new)
-      subject.execute(new_branch_name)
-    end
-  end
-end