git_helper 3.6.1 → 3.6.3

data/spec/git_helper/clean_branches_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::CleanBranches do
-  let(:local_code) { double(:local_code, clean_branches: :commit) }
-
-  subject { GitHelper::CleanBranches.new }
-
-  it 'should call GitHelper::LocalCode' do
-    expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    subject.execute
-  end
-
-  it 'should call the clean_branches method from the local code class' do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    expect(local_code).to receive(:clean_branches)
-    subject.execute
-  end
-end

data/spec/git_helper/code_request_spec.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::CodeRequest do
-  let(:highline_wrapper) { double(:highline_wrapper) }
-  let(:local_code) { double(:local_code, project_name: Faker::Lorem.word, branch: Faker::Lorem.word) }
-  let(:process_project) { double(:process_project, create: :created, merge: :merged) }
-  let(:base_branch) { Faker::Lorem.word }
-  let(:title) { Faker::Lorem.sentence }
-
-  subject { GitHelper::CodeRequest.new }
-
-  before do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    allow(HighlineWrapper).to receive(:new).and_return(highline_wrapper)
-    allow(subject).to receive(:puts)
-  end
-
-  describe '#create' do
-    before do
-      allow(subject).to receive(:base_branch).and_return(base_branch)
-      allow(subject).to receive(:new_code_request_title).and_return(title)
-    end
-
-    it 'should call to process the project' do
-      expect(subject).to receive(:process_project).and_return(process_project)
-      subject.create
-    end
-
-    it 'should call create' do
-      allow(subject).to receive(:process_project).and_return(process_project)
-      expect(process_project).to receive(:create)
-      subject.create
-    end
-
-    it 'should call base_branch and new_code_request_title' do
-      expect(subject).to receive(:base_branch).and_return(base_branch)
-      expect(subject).to receive(:new_code_request_title).and_return(title)
-      allow(subject).to receive(:process_project).and_return(process_project)
-      allow(process_project).to receive(:create)
-      subject.create
-    end
-  end
-
-  describe '#merge' do
-    it 'should call to process the project' do
-      expect(subject).to receive(:process_project).and_return(process_project)
-      subject.merge
-    end
-
-    it 'should call merge' do
-      allow(subject).to receive(:process_project).and_return(process_project)
-      expect(process_project).to receive(:merge)
-      subject.merge
-    end
-  end
-
-  describe '#process_project' do
-    it 'should call the local code to see if it is a github or gitlab project' do
-      expect(local_code).to receive(:gitlab_project?).and_return(false)
-      expect(local_code).to receive(:github_repo?).and_return(true)
-      subject.send(:process_project)
-    end
-
-    context 'when github and gitlab remotes are found' do
-      it 'should ask for clarification' do
-        allow(local_code).to receive(:gitlab_project?).and_return(true)
-        allow(local_code).to receive(:github_repo?).and_return(true)
-        expect(subject).to receive(:ask_for_clarification)
-        subject.send(:process_project)
-      end
-    end
-
-    context 'when github' do
-      it 'should call the github_pull_request' do
-        allow(local_code).to receive(:gitlab_project?).and_return(false)
-        allow(local_code).to receive(:github_repo?).and_return(true)
-        expect(subject).to receive(:github_pull_request)
-        subject.send(:process_project)
-      end
-    end
-
-    context 'when gitlab' do
-      it 'should call the gitlab_merge_request' do
-        allow(local_code).to receive(:gitlab_project?).and_return(true)
-        allow(local_code).to receive(:github_repo?).and_return(false)
-        expect(subject).to receive(:gitlab_merge_request)
-        subject.send(:process_project)
-      end
-    end
-
-    context 'when no github or gitlab remotes are found' do
-      it 'should raise error' do
-        allow(local_code).to receive(:gitlab_project?).and_return(false)
-        allow(local_code).to receive(:github_repo?).and_return(false)
-        expect(subject).to receive(:exit)
-        subject.send(:process_project)
-      end
-    end
-  end
-
-  describe '#ask_for_clarification' do
-    it 'should ask the CLI' do
-      expect(highline_wrapper).to receive(:ask).and_return('github')
-      subject.send(:ask_for_clarification)
-    end
-
-    context 'when response is github' do
-      it 'should return github_pull_request' do
-        allow(highline_wrapper).to receive(:ask).and_return('github')
-        expect(subject).to receive(:github_pull_request)
-        subject.send(:ask_for_clarification)
-      end
-
-      it 'should return github_pull_request' do
-        allow(highline_wrapper).to receive(:ask).and_return('Github')
-        expect(subject).to receive(:github_pull_request)
-        subject.send(:ask_for_clarification)
-      end
-    end
-
-    context 'when response is gitlab' do
-      it 'should return gitlab_merge_request' do
-        allow(highline_wrapper).to receive(:ask).and_return('gitlab')
-        expect(subject).to receive(:gitlab_merge_request)
-        subject.send(:ask_for_clarification)
-      end
-
-      it 'should return gitlab_merge_request' do
-        allow(highline_wrapper).to receive(:ask).and_return('Gitlab')
-        expect(subject).to receive(:gitlab_merge_request)
-        subject.send(:ask_for_clarification)
-      end
-    end
-
-    # Unfortunately this test sometimes fails... just rerun the tests if it does
-    context 'when response is neither' do
-      it 'should raise an error' do
-        allow(highline_wrapper).to receive(:ask).and_return(Faker::Lorem.word)
-        expect(subject).to receive(:exit)
-        subject.send(:ask_for_clarification)
-      end
-    end
-  end
-
-  describe '#github_pull_request' do
-    it 'should call the GitHelper::GitHubPullRequest' do
-      expect(GitHelper::GitHubPullRequest).to receive(:new)
-      subject.send(:github_pull_request)
-    end
-  end
-
-  describe '#gitlab_merge_request' do
-    it 'should call the GitHelper::GitLabMergeRequest' do
-      expect(GitHelper::GitLabMergeRequest).to receive(:new)
-      subject.send(:gitlab_merge_request)
-    end
-  end
-
-  describe '#local_project' do
-    it 'should call the name of the local_code' do
-      expect(local_code).to receive(:project_name)
-      subject.send(:local_project)
-    end
-  end
-
-  describe '#default_branch' do
-    it 'should call the name of the local_code' do
-      expect(local_code).to receive(:default_branch)
-      subject.send(:default_branch)
-    end
-  end
-
-  describe '#base_branch' do
-    it 'should call the default branch' do
-      expect(subject).to receive(:default_branch)
-      allow(highline_wrapper).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_wrapper).to receive(:ask).at_least(:once).and_return(base_branch)
-      subject.send(:base_branch)
-    end
-
-    it 'should ask the CLI to ask the user' do
-      allow(subject).to receive(:default_branch)
-      expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_wrapper).to receive(:ask).at_least(:once).and_return(base_branch)
-      subject.send(:base_branch)
-    end
-
-    context 'if the user says no' do
-      it 'definitely asks for the users base branch' do
-        allow(subject).to receive(:default_branch)
-        expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once).and_return(false)
-        expect(highline_wrapper).to receive(:ask).at_least(:once).and_return(base_branch)
-        subject.send(:base_branch)
-      end
-    end
-
-    context 'if the user says yes' do
-      it 'does not ask for the users base branch' do
-        allow(subject).to receive(:default_branch)
-        expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once).and_return(true)
-        expect(highline_wrapper).not_to receive(:base_branch)
-        subject.send(:base_branch)
-      end
-    end
-  end
-
-  describe '#autogenerated_title' do
-    it 'should generate a title based on the branch' do
-      expect(subject).to receive(:local_branch).and_return(Faker::Lorem.word)
-      expect(local_code).to receive(:generate_title)
-      subject.send(:autogenerated_title)
-    end
-  end
-
-  describe '#new_code_request_title' do
-    it 'should call autogenerated title method' do
-      expect(subject).to receive(:autogenerated_title)
-      allow(highline_wrapper).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_wrapper).to receive(:ask).at_least(:once).and_return(title)
-      subject.send(:new_code_request_title)
-    end
-
-    it 'should ask the CLI to ask the user' do
-      allow(subject).to receive(:autogenerated_title).and_return(Faker::Lorem.sentence)
-      expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_wrapper).to receive(:ask).at_least(:once).and_return(title)
-      subject.send(:new_code_request_title)
-    end
-
-    context 'if the user says no' do
-      it 'definitely asks for the users title' do
-        allow(subject).to receive(:autogenerated_title).and_return(Faker::Lorem.sentence)
-        expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once).and_return(false)
-        expect(highline_wrapper).to receive(:ask).at_least(:once).and_return(title)
-        subject.send(:new_code_request_title)
-      end
-    end
-
-    context 'if the user says yes to original title' do
-      it 'does not ask for the users chosen title' do
-        allow(subject).to receive(:autogenerated_title).and_return(Faker::Lorem.sentence)
-        expect(highline_wrapper).to receive(:ask_yes_no).at_least(:once).and_return(true)
-        expect(highline_wrapper).not_to receive(:ask)
-        subject.send(:new_code_request_title)
-      end
-    end
-  end
-
-  describe '#local_code' do
-    it 'should call the GitHub client' do
-      expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-      subject.send(:local_code)
-    end
-  end
-
-  describe '#highline' do
-    it 'should create a highline_wrapper client' do
-      expect(HighlineWrapper).to receive(:new).and_return(highline_wrapper)
-      subject.send(:highline)
-    end
-  end
-end

data/spec/git_helper/empty_commit_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::EmptyCommit do
-  let(:local_code) { double(:local_code, empty_commit: :commit) }
-
-  subject { GitHelper::EmptyCommit.new }
-
-  it 'should call GitHelper::LocalCode' do
-    expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    subject.execute
-  end
-
-  it 'should call the empty_commit method from the local code class' do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    expect(local_code).to receive(:empty_commit)
-    subject.execute
-  end
-end

data/spec/git_helper/forget_local_commits_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::ForgetLocalCommits do
-  let(:local_code) { double(:local_code, forget_local_commits: :commit) }
-
-  subject { GitHelper::ForgetLocalCommits.new }
-
-  it 'should call GitHelper::LocalCode' do
-    expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    subject.execute
-  end
-
-  it 'should call the forget_local_commits method from the local code class' do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    expect(local_code).to receive(:forget_local_commits)
-    subject.execute
-  end
-end

data/spec/git_helper/git_config_reader_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitConfigReader do
-  let(:github_user) { Faker::Internet.username }
-  let(:github_token) { Faker::Internet.password(max_length: 10) }
-  let(:gitlab_user) { Faker::Internet.username }
-  let(:gitlab_token) { Faker::Internet.password(max_length: 10) }
-
-  let(:config_file) do
-    {
-      github_user: github_user,
-      github_token: github_token,
-      gitlab_user: gitlab_user,
-      gitlab_token: gitlab_token
-    }
-  end
-
-  subject { GitHelper::GitConfigReader.new }
-
-  describe '#gitlab_token' do
-    it 'should locate the gitlab_token' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      expect(subject.gitlab_token).to eq(gitlab_token)
-    end
-
-    it 'should call the config file' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      subject.gitlab_token
-    end
-  end
-
-  describe '#github_token' do
-    it 'should locate the github_token' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      expect(subject.github_token).to eq(github_token)
-    end
-
-    it 'should call the config file' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      subject.github_token
-    end
-  end
-
-  describe '#github_user' do
-    it 'should locate the github_user' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      expect(subject.github_user).to eq(github_user)
-    end
-
-    it 'should call the config file' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      subject.github_user
-    end
-  end
-
-  describe '#gitlab_user' do
-    it 'should locate the gitlab_user' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      expect(subject.gitlab_user).to eq(gitlab_user)
-    end
-
-    it 'should call the config file' do
-      expect(subject).to receive(:config_file).and_return(config_file)
-      subject.gitlab_user
-    end
-  end
-
-  describe '#config_file' do
-    it 'should yaml load the file path' do
-      expect(YAML).to receive(:load_file)
-      subject.send(:config_file)
-    end
-  end
-
-  describe '#git_config_file_path' do
-    it 'should look in the current directory' do
-      expect(Dir).to receive(:pwd).and_return("/Users/#{Faker::Name.first_name}/#{Faker::Lorem.word}")
-      subject.send(:git_config_file_path)
-    end
-
-    it 'should return the base path with the git config file at the end' do
-      user = Faker::Name.first_name
-      allow(Dir).to receive(:pwd).and_return("/Users/#{user}/#{Faker::Lorem.word}")
-      expect(subject.send(:git_config_file_path)).to eq("/Users/#{user}/.git_helper/config.yml")
-    end
-  end
-end

data/spec/git_helper/github_client_spec.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitHubClient do
-  let(:git_config_reader) { double(:git_config_reader, github_token: :token) }
-
-  subject { GitHelper::GitHubClient.new }
-
-  before do
-    allow(GitHelper::GitConfigReader).to receive(:new).and_return(git_config_reader)
-  end
-
-  describe '#repository' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.repository(Faker::Lorem.word)
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.repository(Faker::Lorem.word)).to eq(:command_complete)
-    end
-  end
-
-  describe '#pull_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.pull_request(Faker::Lorem.word, Faker::Number.number)
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.pull_request(Faker::Lorem.word, Faker::Number.number)).to eq(:command_complete)
-    end
-  end
-
-  describe '#create_pull_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.create_pull_request(Faker::Lorem.word, {})
-    end
-
-    it 'should generate a string list of options' do
-      expect(subject).to receive(:format_options).with({})
-      subject.create_pull_request(Faker::Lorem.word, {})
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.create_pull_request(Faker::Lorem.word, {})).to eq(:command_complete)
-    end
-  end
-
-  describe '#merge_pull_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.merge_pull_request(Faker::Lorem.word, Faker::Number.number, {})
-    end
-
-    it 'should generate a string list of options' do
-      expect(subject).to receive(:format_options).with({})
-      subject.merge_pull_request(Faker::Lorem.word, Faker::Number.number, {})
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.merge_pull_request(Faker::Lorem.word, Faker::Number.number, {})).to eq(:command_complete)
-    end
-  end
-
-  describe '#format_options' do
-    it 'will make a list of hash options into a JSON parsed chunk of key/value pairs as string' do
-      options = {
-        key1: 'value1',
-        key2: true,
-        key3: '',
-        key4: false,
-        key5: 'value5'
-      }
-      # rubocop:disable Style/StringLiterals
-      result = "{\"key1\":\"value1\",\"key2\":true,\"key4\":false,\"key5\":\"value5\"}"
-      # rubocop:enable Style/StringLiterals
-      expect(subject.send(:format_options, options)).to eq(result)
-    end
-
-    it 'will return an empty string if an empty hash is given' do
-      expect(subject.send(:format_options, {})).to eq('')
-    end
-
-    it 'will return an empty string if all values are empty strings' do
-      options = {
-        key1: '',
-        key2: '',
-        key3: ''
-      }
-      expect(subject.send(:format_options, options)).to eq('')
-    end
-  end
-
-  describe '#run' do
-    it 'should call CURL' do
-      expect(subject).to receive(:`).and_return('{}')
-      subject.send(:run, Faker::Lorem.word, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-
-    it 'should use JSON to parse the response' do
-      expect(JSON).to receive(:parse).and_return({})
-      subject.send(:run, Faker::Lorem.word, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-
-    it 'should use OpenStruct to turn the hash into an object' do
-      expect(OpenStruct).to receive(:new).and_return(OpenStruct.new)
-      subject.send(:run, Faker::Lorem.word, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-  end
-
-  describe '#github_token' do
-    it 'should return a token' do
-      expect(subject.send(:github_token)).to eq(:token)
-    end
-  end
-
-  describe '#git_config_reader' do
-    it 'should make a new git config reader' do
-      expect(GitHelper::GitConfigReader).to receive(:new)
-      subject.send(:git_config_reader)
-    end
-  end
-end

data/spec/git_helper/gitlab_client_spec.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitLabClient do
-  let(:git_config_reader) { double(:git_config_reader, gitlab_token: :token) }
-
-  subject { GitHelper::GitLabClient.new }
-
-  before do
-    allow(GitHelper::GitConfigReader).to receive(:new).and_return(git_config_reader)
-  end
-
-  describe '#project' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.project(Faker::Lorem.word)
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.project(Faker::Lorem.word)).to eq(:command_complete)
-    end
-  end
-
-  describe '#merge_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.merge_request(Faker::Lorem.word, Faker::Number.number)
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.merge_request(Faker::Lorem.word, Faker::Number.number)).to eq(:command_complete)
-    end
-  end
-
-  describe '#create_merge_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.create_merge_request(Faker::Lorem.word, {})
-    end
-
-    it 'should generate a string list of options' do
-      expect(subject).to receive(:format_options).with({})
-      subject.create_merge_request(Faker::Lorem.word, {})
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.create_merge_request(Faker::Lorem.word, {})).to eq(:command_complete)
-    end
-  end
-
-  describe '#accept_merge_request' do
-    it 'should call to run a query' do
-      expect(subject).to receive(:run)
-      subject.accept_merge_request(Faker::Lorem.word, Faker::Number.number, {})
-    end
-
-    it 'should generate a string list of options' do
-      expect(subject).to receive(:format_options).with({})
-      subject.accept_merge_request(Faker::Lorem.word, Faker::Number.number, {})
-    end
-
-    it "should return the run command's answer" do
-      expect(subject).to receive(:run).and_return(:command_complete)
-      expect(subject.accept_merge_request(Faker::Lorem.word, Faker::Number.number, {})).to eq(:command_complete)
-    end
-  end
-
-  describe '#format_options' do
-    it 'will make a list of hash options into a URL string' do
-      options = {
-        key1: 'value1',
-        key2: true,
-        key3: '',
-        key4: false,
-        key5: 'value5'
-      }
-      result = '?key1=value1&key2=true&key4=false&key5=value5'
-      expect(subject.send(:format_options, options)).to eq(result)
-    end
-
-    it 'will return an empty string if an empty hash is given' do
-      expect(subject.send(:format_options, {})).to eq('')
-    end
-
-    it 'will return an empty string if all values are empty strings' do
-      options = {
-        key1: '',
-        key2: '',
-        key3: ''
-      }
-      expect(subject.send(:format_options, options)).to eq('')
-    end
-  end
-
-  describe '#run' do
-    it 'should call CURL' do
-      expect(subject).to receive(:`).and_return('{}')
-      subject.send(:run, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-
-    it 'should use JSON to parse the response' do
-      expect(JSON).to receive(:parse).and_return({})
-      subject.send(:run, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-
-    it 'should use OpenStruct to turn the hash into an object' do
-      expect(OpenStruct).to receive(:new).and_return(OpenStruct.new)
-      subject.send(:run, 'GET', "/projects/#{Faker::Lorem.word}")
-    end
-  end
-
-  describe '#url_encode' do
-    let(:group_name) { Faker::Lorem.word }
-    let(:project_name) { Faker::Lorem.word }
-
-    it 'should return the same string as passed in but with no spaces' do
-      expect(subject.send(:url_encode, "#{group_name}/#{project_name}")).to eq("#{group_name}%2F#{project_name}")
-    end
-
-    it 'should never include a space or a slash' do
-      resp = subject.send(:url_encode, "#{group_name} #{Faker::Lorem.word}/#{project_name}")
-      expect(resp).not_to include(' ')
-      expect(resp).not_to include('/')
-    end
-  end
-
-  describe '#gitlab_token' do
-    it 'should return a token' do
-      expect(subject.send(:gitlab_token)).to eq(:token)
-    end
-  end
-
-  describe '#git_config_reader' do
-    it 'should make a new git config reader' do
-      expect(GitHelper::GitConfigReader).to receive(:new)
-      subject.send(:git_config_reader)
-    end
-  end
-end