git_helper 3.0.1 → 3.2.1

data/spec/git_helper/local_code_spec.rb

@@ -4,11 +4,24 @@ 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(:ssh_remote) { 'origin\tgit@github.com:emmasax4/git_helper.git (fetch)' }
-  let(:https_remote) { 'origin\thttps://github.com/emmasax4/git_helper.git (fetch)' }
-  let(:github_remotes) { ['origin\tgit@github.com:emmasax4/git_helper.git (fetch)', 'origin\thttps://github.com/emmasax4/git_helper.git (fetch)' ] }
-  let(:gitlab_remotes) { ['origin\tgit@gitlab.com:emmasax4/git_helper.git (fetch)', 'origin\thttps://gitlab.com/emmasax4/git_helper.git (fetch)' ] }
+  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 }
 
@@ -51,13 +64,14 @@ describe GitHelper::LocalCode do
   describe '#new_branch' do
     it 'should make a system call' do
       expect(subject).to receive(:system).exactly(4).times
-      subject.new_branch('branch_name')
+      subject.new_branch(Faker::Lorem.word)
     end
   end
 
   describe '#change_remote' do
     it 'should return a string' do
-      expect(subject.change_remote('name', 'url')).to be_a(String)
+      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
 
@@ -96,11 +110,11 @@ describe GitHelper::LocalCode do
 
   describe '#remote_project' do
     it 'should return just the plain project if ssh' do
-      expect(subject.remote_project(ssh_remote)).to eq('git_helper')
+      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('git_helper')
+      expect(subject.remote_project(https_remote)).to eq(project_name)
     end
   end
 
@@ -144,8 +158,8 @@ describe GitHelper::LocalCode do
     end
 
     it 'should equal this project name' do
-      allow_any_instance_of(String).to receive(:scan).and_return([['emmasax4/git_helper']])
-      expect(subject.project_name).to eq('emmasax4/git_helper')
+      allow_any_instance_of(String).to receive(:scan).and_return([["#{owner}/#{project_name}"]])
+      expect(subject.project_name).to eq("#{owner}/#{project_name}")
     end
   end
 
@@ -190,43 +204,65 @@ describe GitHelper::LocalCode do
 
   describe '#generate_title' do
     it 'should return a title based on the branch' do
-      branch = 'jira-123-test-branch'
-      expect(subject.generate_title(branch)).to eq('JIRA-123 Test branch')
+      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
-      branch = 'jira_123_test_branch'
-      expect(subject.generate_title(branch)).to eq('JIRA-123 Test branch')
+      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
-      branch = 'jira-123_test_branch'
-      expect(subject.generate_title(branch)).to eq('JIRA-123 Test branch')
+      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
-      branch = 'test_branch'
-      expect(subject.generate_title(branch)).to eq('Test branch')
+      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 = 'test-branch'
-      expect(subject.generate_title(branch)).to eq('Test branch')
+      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 = 'test'
-      expect(subject.generate_title(branch)).to eq('Test')
+      branch = Faker::Lorem.word
+      expect(subject.generate_title(branch)).to eq(branch.capitalize)
     end
 
     it 'should return a title based on the branch' do
-      branch = 'some_other_words_in_this_test_branch'
-      expect(subject.generate_title(branch)).to eq('Some other words in this test branch')
+      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
-      branch = 'some-other-words-in-this-test-branch'
-      expect(subject.generate_title(branch)).to eq('Some other words in this test branch')
+      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

@@ -2,23 +2,34 @@ require 'spec_helper'
 require 'git_helper'
 
 describe GitHelper::GitLabMergeRequest do
-  let(:local_code) { double(:local_code, read_template: 'template') }
+  let(:local_code) { double(:local_code, read_template: Faker::Lorem.word) }
   let(:highline_cli) { double(:highline_cli) }
   let(:gitlab_client_client) { double(:gitlab_client_client, project: :project, merge_request: :merge_request, create_merge_request: :created) }
   let(:gitlab_client) { double(:gitlab_client, client: gitlab_client_client) }
+  let(:diff_refs) { double(:diff_refs, base_sha: :base, head_sha: :head) }
+
+  let(:merge_request) do
+    double(:merge_request,
+      diff_refs: diff_refs,
+      web_url: Faker::Internet.url,
+      merge_commit_sha: Faker::Internet.password
+    )
+  end
+
   let(:options) do
     {
-      local_project: 'emmasax4/git_helper',
-      local_branch: 'main',
+      local_project: Faker::Lorem.word,
+      local_branch: Faker::Lorem.word,
       local_code: local_code,
       cli: highline_cli
     }
   end
 
-  subject { GitHelper::GitLabMergeRequest.new(options) }
+  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
@@ -26,16 +37,16 @@ describe GitHelper::GitLabMergeRequest 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_client).to receive(:create_merge_request)
-      subject.create({base_branch: 'base', new_title: 'title'})
+      expect(gitlab_client_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_client).to receive(:create_merge_request)
-      subject.create({base_branch: 'base', new_title: 'title'})
+      allow(gitlab_client_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
@@ -43,36 +54,36 @@ describe GitHelper::GitLabMergeRequest do
       allow(subject).to receive(:remove_source_branch).and_return(false)
       allow(subject).to receive(:new_mr_body).and_return('')
       allow(gitlab_client_client).to receive(:create_merge_request).and_raise(StandardError)
-      expect(subject.create({base_branch: 'base', new_title: 'title'})).to eq(nil)
+      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(123)
-      expect(gitlab_client_client).to receive(:accept_merge_request)
+      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
+      expect(gitlab_client_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(123).at_least(:once)
-      allow(gitlab_client_client).to receive(:accept_merge_request)
+      expect(subject).to receive(:mr_id).and_return(Faker::Number.number).at_least(:once)
+      allow(gitlab_client_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(123)
+      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
       allow(gitlab_client_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(123)
-      expect(gitlab_client_client).to receive(:accept_merge_request).and_return(double(merge_commit_sha: nil)).exactly(2).times
+      allow(subject).to receive(:mr_id).and_return(Faker::Number.number)
+      expect(gitlab_client_client).to receive(:accept_merge_request).and_return(double(merge_commit_sha: nil, merge_error: Faker::Lorem.word)).exactly(2).times
       expect(subject.merge).to eq(nil)
     end
   end
@@ -105,41 +116,46 @@ describe GitHelper::GitLabMergeRequest do
     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(['template1'])
-        expect(highline_cli).to receive(:apply_template?).and_return(true)
+        allow(subject).to receive(:mr_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(:mr_template_options).and_return(['template1'])
-        allow(highline_cli).to receive(:apply_template?).and_return(true)
-        expect(subject.send(:template_name_to_apply)).to eq('template1')
+        allow(subject).to receive(:mr_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(:mr_template_options).and_return(['template1'])
-        allow(highline_cli).to receive(:apply_template?).and_return(false)
+        allow(subject).to receive(:mr_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(:mr_template_options).and_return(['template1', 'template2'])
-        expect(highline_cli).to receive(:template_to_apply).and_return('template1')
+        allow(subject).to receive(:mr_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(:mr_template_options).and_return(['template1', 'template2'])
-        allow(highline_cli).to receive(:template_to_apply).and_return('template1')
-        expect(subject.send(:template_name_to_apply)).to eq('template1')
+        allow(subject).to receive(:mr_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(:mr_template_options).and_return(['template1', 'template2'])
-        allow(highline_cli).to receive(:template_to_apply).and_return('None')
+        allow(subject).to receive(:mr_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
@@ -154,24 +170,25 @@ describe GitHelper::GitLabMergeRequest do
 
   describe '#mr_id' do
     it 'should ask the CLI for the code request ID' do
-      expect(highline_cli).to receive(:code_request_id).and_return(123)
+      expect(highline_cli).to receive(:ask).and_return(Faker::Number.number)
       subject.send(:mr_id)
     end
 
     it 'should equal an integer' do
-      expect(highline_cli).to receive(:code_request_id).and_return(123)
-      expect(subject.send(:mr_id)).to eq(123)
+      pr_id = Faker::Number.number
+      expect(highline_cli).to receive(:ask).and_return(pr_id)
+      expect(subject.send(:mr_id)).to eq(pr_id)
     end
   end
 
   describe '#squash_merge_request' do
     it 'should ask the CLI for the code request ID' do
-      expect(highline_cli).to receive(:squash_merge_request?).and_return(true)
+      expect(highline_cli).to receive(:ask_yes_no).and_return(true)
       subject.send(:squash_merge_request)
     end
 
     it 'should be a boolean' do
-      expect(highline_cli).to receive(:squash_merge_request?).and_return(false)
+      expect(highline_cli).to receive(:ask_yes_no).and_return(false)
       expect([true, false]).to include(subject.send(:squash_merge_request))
     end
   end
@@ -183,12 +200,12 @@ describe GitHelper::GitLabMergeRequest do
 
     context 'when the existing project has no setting' do
       it 'should ask the CLI for the code request ID' do
-        expect(highline_cli).to receive(:remove_source_branch?).and_return(true)
+        expect(highline_cli).to receive(:ask_yes_no).and_return(true)
         subject.send(:remove_source_branch)
       end
 
       it 'should be a boolean' do
-        allow(highline_cli).to receive(:remove_source_branch?).and_return(false)
+        allow(highline_cli).to receive(:ask_yes_no).and_return(false)
         expect([true, false]).to include(subject.send(:remove_source_branch))
       end
     end
@@ -198,14 +215,14 @@ describe GitHelper::GitLabMergeRequest do
       subject.send(:remove_source_branch)
     end
 
-    it "should return the existing project's setting if it exists" do
+    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 project's setting if it exists" do
+    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_cli).to receive(:remove_source_branch?).and_return(true)
+      allow(highline_cli).to receive(:ask_yes_no).and_return(true)
       expect(subject.send(:remove_source_branch)).to eq(true)
     end
   end
@@ -219,7 +236,7 @@ describe GitHelper::GitLabMergeRequest do
 
   describe '#existing_mr' do
     it 'should call the gitlab client' do
-      allow(highline_cli).to receive(:code_request_id).and_return(123)
+      allow(highline_cli).to receive(:ask).and_return(Faker::Number.number)
       expect(gitlab_client_client).to receive(:merge_request).and_return(:merge_request)
       subject.send(:existing_mr)
     end

data/spec/git_helper/new_branch_spec.rb

@@ -4,13 +4,14 @@ require 'git_helper'
 describe GitHelper::NewBranch do
   let(:new_branch_name) { 'new-branch-name' }
   let(:local_code) { double(:local_code, new_branch: :commit) }
-  let(:cli) { double(:highline_cli, new_branch_name: new_branch_name) }
+  let(:cli) { double(:highline_cli, ask: new_branch_name) }
 
   subject { GitHelper::NewBranch.new }
 
   before do
     allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
     allow(GitHelper::HighlineCli).to receive(:new).and_return(cli)
+    allow(subject).to receive(:puts)
   end
 
   it 'should call GitHelper::LocalCode' do
@@ -30,7 +31,7 @@ describe GitHelper::NewBranch do
     end
 
     it 'should ask the highline cli what the new branch name should be' do
-      expect(cli).to receive(:new_branch_name)
+      expect(cli).to receive(:ask)
       subject.execute
     end
   end

data/spec/git_helper/pull_request_spec.rb

@@ -2,14 +2,15 @@ require 'spec_helper'
 require 'git_helper'
 
 describe GitHelper::GitHubPullRequest do
-  let(:local_code) { double(:local_code, read_template: 'template') }
+  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: 'emmasax4/git_helper',
-      local_branch: 'main',
+      local_project: Faker::Lorem.word,
+      local_branch: Faker::Lorem.word,
       local_code: local_code,
       cli: highline_cli
     }
@@ -19,49 +20,50 @@ describe GitHelper::GitHubPullRequest do
 
   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)
-      subject.create({base_branch: 'base', new_title: 'title'})
+      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)
-      subject.create({base_branch: 'base', new_title: 'title'})
+      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: 'base', new_title: 'title'})).to eq(nil)
+      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: 'title'))
+      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(123)
-      expect(octokit_client_client).to receive(:merge_pull_request)
+      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: 'title')).at_least(:once)
+      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(123).at_least(:once)
-      allow(octokit_client_client).to receive(:merge_pull_request)
+      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: 'title'))
+      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(123)
+      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
@@ -95,41 +97,46 @@ describe GitHelper::GitHubPullRequest do
     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(['template1'])
-        expect(highline_cli).to receive(:apply_template?).and_return(true)
+        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(['template1'])
-        allow(highline_cli).to receive(:apply_template?).and_return(true)
-        expect(subject.send(:template_name_to_apply)).to eq('template1')
+        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(['template1'])
-        allow(highline_cli).to receive(:apply_template?).and_return(false)
+        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(:template_to_apply).and_return('template1')
+        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(:template_to_apply).and_return('template1')
-        expect(subject.send(:template_name_to_apply)).to eq('template1')
+        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(:template_to_apply).and_return('None')
+        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
@@ -144,13 +151,14 @@ describe GitHelper::GitHubPullRequest do
 
   describe '#pr_id' do
     it 'should ask the CLI for the code request ID' do
-      expect(highline_cli).to receive(:code_request_id).and_return(123)
+      expect(highline_cli).to receive(:ask).and_return(Faker::Number.number)
       subject.send(:pr_id)
     end
 
     it 'should equal an integer' do
-      expect(highline_cli).to receive(:code_request_id).and_return(123)
-      expect(subject.send(:pr_id)).to eq(123)
+      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
 
@@ -159,20 +167,20 @@ describe GitHelper::GitHubPullRequest do
 
     before do
       allow(subject).to receive(:existing_project).and_return(project)
-      allow(highline_cli).to receive(:merge_method)
+      allow(highline_cli).to receive(:ask_options)
     end
 
     it 'should ask the CLI for the merge_method' do
-      expect(highline_cli).to receive(:merge_method).and_return('merge')
+      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(:merge_method).and_return('merge')
+      allow(highline_cli).to receive(:ask_options).and_return('merge')
       expect(subject.send(:merge_method)).to be_a(String)
     end
 
-    context "if there's only one item" do
+    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
@@ -231,7 +239,7 @@ describe GitHelper::GitHubPullRequest do
 
   describe '#existing_pr' do
     it 'should call the octokit client' do
-      allow(highline_cli).to receive(:code_request_id).and_return(123)
+      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