git_helper 3.3.0 → 3.6.6

data/lib/git_helper/octokit_client.rb

@@ -1,11 +0,0 @@
-module GitHelper
-  class OctokitClient
-    def client
-      Octokit::Client.new(access_token: git_config_reader.github_token)
-    end
-
-    private def git_config_reader
-      @git_config_reader ||= GitHelper::GitConfigReader.new
-    end
-  end
-end

data/spec/git_helper/change_remote_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::ChangeRemote do
-  let(:remote1) { "git@github.com:#{old_owner}/#{project}.git" }
-  let(:project) { Faker::Lorem.word }
-  let(:cli) { double(:highline_cli, ask_yes_no: true) }
-  let(:old_owner) { Faker::Internet.username }
-  let(:new_owner) { Faker::Internet.username }
-  let(:directory_entries) { [ '.', '..', project, Faker::Lorem.word, Faker::Lorem.word ] }
-
-  let(:local_code) do
-    double(:local_code,
-      remotes: [remote1],
-      remote_name: Faker::Lorem.word,
-      ssh_remote?: true,
-      https_remote?: false,
-      remote_project: project,
-      remote_source: 'github.com',
-      change_remote: true
-    )
-  end
-
-  subject { GitHelper::ChangeRemote.new(old_owner, new_owner) }
-
-  before do
-    allow(GitHelper::HighlineCli).to receive(:new).and_return(cli)
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    allow(subject).to receive(:puts)
-  end
-
-  describe '#execute' do
-    before do
-      allow(Dir).to receive(:pwd).and_return("/Users/#{Faker::Name.first_name}/#{project}")
-      allow(Dir).to receive(:entries).and_return(directory_entries)
-      allow(File).to receive(:join).and_return("/Users/#{Faker::Name.first_name}/#{project}/#{Faker::Lorem.word}")
-      allow(File).to receive(:directory?).and_return(true)
-      allow(subject).to receive(:process_dir)
-    end
-
-    it 'should call to process at least one directory' do
-      expect(subject).to receive(:process_dir).at_least(:once)
-      subject.execute
-    end
-
-    it 'should definitely look in the file structure' do
-      expect(Dir).to receive(:pwd)
-      expect(Dir).to receive(:entries)
-      expect(File).to receive(:join)
-      expect(File).to receive(:directory?)
-      subject.execute
-    end
-  end
-
-  describe '#process_dir' do
-    before do
-      allow(Dir).to receive(:chdir).and_return(nil)
-      allow(File).to receive(:exist?).and_return(true)
-      allow(subject).to receive(:process_git_repository)
-    end
-
-    it 'should definitely look in the file structure' do
-      expect(Dir).to receive(:chdir)
-      expect(File).to receive(:exist?)
-      subject.send(:process_dir, "/Users/#{Faker::Name.first_name}/#{project}", "/Users/#{Faker::Name.first_name}/#{project}/#{Faker::Lorem.word}")
-    end
-
-    context 'when the user says to process the directory' do
-      it 'should call to process the git repository at least once' do
-        expect(subject).to receive(:process_git_repository).at_least(:once)
-        subject.send(:process_dir, "/Users/#{Faker::Name.first_name}/#{project}", "/Users/#{Faker::Name.first_name}/#{project}/#{Faker::Lorem.word}")
-      end
-    end
-
-    context 'when the user says not to process the directory' do
-      let(:cli) { double(:highline_cli, ask_yes_no: false) }
-
-      it 'should not call to process the directory' do
-        expect(subject).not_to receive(:process_git_repository)
-        subject.send(:process_dir, "/Users/#{Faker::Name.first_name}/#{project}", "/Users/#{Faker::Name.first_name}/#{project}/#{Faker::Lorem.word}")
-      end
-    end
-  end
-
-  describe '#process_git_repository' do
-    before do
-      allow(subject).to receive(:process_remote).and_return(nil)
-    end
-
-    it 'should call local_code' do
-      expect(GitHelper::LocalCode).to receive(:new)
-      subject.send(:process_git_repository)
-    end
-
-    context 'when the remote includes the old owner' do
-      it 'should call to process the remote' do
-        expect(subject).to receive(:process_remote)
-        subject.send(:process_git_repository)
-      end
-    end
-
-    context 'when the remote does not include the old owner' do
-      let(:remote1) { "git@github.com:#{new_owner}/#{project}.git" }
-
-      it 'should not call to process the remote' do
-        expect(subject).not_to receive(:process_remote)
-        subject.send(:process_git_repository)
-      end
-    end
-  end
-
-  describe '#process_remote' do
-    it 'should always get the remote name' do
-      expect(local_code).to receive(:remote_name)
-      subject.send(:process_remote, remote1)
-    end
-
-    it 'should always attempt to change the remote' do
-      expect(local_code).to receive(:change_remote)
-      subject.send(:process_remote, remote1)
-    end
-
-    it 'should attempt to get the remote repo exactly once' do
-      expect(local_code).to receive(:remote_project).exactly(:once)
-      subject.send(:process_remote, remote1)
-    end
-
-    it 'should attempt to get the remote source exactly once' do
-      expect(local_code).to receive(:remote_source).exactly(:once)
-      subject.send(:process_remote, remote1)
-    end
-
-    it 'should ask if the remote is SSH' do
-      expect(local_code).to receive(:ssh_remote?)
-      subject.send(:process_remote, remote1)
-    end
-
-    context 'https remote' do
-      let(:local_code) do
-        double(:local_code,
-          remotes: [remote1],
-          remote_name: Faker::Lorem.word,
-          ssh_remote?: false,
-          https_remote?: false,
-          remote_project: project,
-          remote_source: 'github.com',
-          change_remote: true
-        )
-      end
-
-      it 'should ask if the remote is SSH' do
-        expect(local_code).to receive(:ssh_remote?)
-        subject.send(:process_remote, remote1)
-      end
-
-      it 'should ask if the remote is https' do
-        expect(local_code).to receive(:https_remote?)
-        subject.send(:process_remote, remote1)
-      end
-    end
-  end
-
-  describe '#local_code' do
-    it 'should create a new local code instance' do
-      expect(GitHelper::LocalCode).to receive(:new)
-      subject.send(:local_code)
-    end
-  end
-
-  describe '#cli' do
-    it 'should create a new highline CLI instance' do
-      expect(GitHelper::HighlineCli).to receive(:new)
-      subject.send(:cli)
-    end
-  end
-end

data/spec/git_helper/checkout_default_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::CheckoutDefault do
-  let(:local_code) { double(:local_code, checkout_default: :done) }
-
-  subject { GitHelper::CheckoutDefault.new }
-
-  it 'should call GitHelper::LocalCode' do
-    expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    subject.execute
-  end
-
-  it 'should call the checkout_default method from the local code class' do
-    allow(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-    expect(local_code).to receive(:checkout_default)
-    subject.execute
-  end
-end

data/spec/git_helper/clean_branches_spec.rb

@@ -1,19 +0,0 @@
-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,263 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::CodeRequest do
-  let(:highline_cli) { double(:highline_cli) }
-  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(GitHelper::HighlineCli).to receive(:new).and_return(highline_cli)
-    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_cli).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_cli).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_cli).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_cli).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_cli).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_cli).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_cli).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once).and_return(false)
-        expect(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once).and_return(true)
-        expect(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once)
-      allow(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once).and_return(false)
-        expect(highline_cli).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_cli).to receive(:ask_yes_no).at_least(:once).and_return(true)
-        expect(highline_cli).not_to receive(:ask)
-        subject.send(:new_code_request_title)
-      end
-    end
-  end
-
-  describe '#local_code' do
-    it 'should call the octokit client' do
-      expect(GitHelper::LocalCode).to receive(:new).and_return(local_code)
-      subject.send(:local_code)
-    end
-  end
-
-  describe '#cli' do
-    it 'should call the octokit client' do
-      expect(GitHelper::HighlineCli).to receive(:new).and_return(highline_cli)
-      subject.send(:cli)
-    end
-  end
-end

data/spec/git_helper/empty_commit_spec.rb

@@ -1,19 +0,0 @@
-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,19 +0,0 @@
-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,62 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::GitConfigReader do
-  let(:github_token) { Faker::Internet.password(max_length: 10) }
-  let(:gitlab_token) { Faker::Internet.password(max_length: 10) }
-
-  let(:config_file) {
-    {
-      github_user: Faker::Internet.username,
-      github_token: github_token,
-      gitlab_user: Faker::Internet.username,
-      gitlab_token: gitlab_token
-    }
-  }
-
-  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 '#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/gitlab_client_spec.rb

@@ -1,26 +0,0 @@
-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 '#client' do
-    it 'should call the GitLab client to make a new client' do
-      expect(Gitlab).to receive(:client)
-      subject.client
-    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/highline_cli_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'git_helper'
-
-describe GitHelper::HighlineCli do
-  let(:response) { double(:response, readline: true, to_i: 3) }
-  let(:highline_client) { double(:highline_cli, ask: response) }
-
-  subject { GitHelper::HighlineCli.new }
-
-  before do
-    allow(HighLine).to receive(:new).and_return(highline_client)
-  end
-
-  describe '#ask' do
-    it 'should ask the highline client ask'do
-      expect(highline_client).to receive(:ask)
-      subject.ask(Faker::Lorem.sentence)
-    end
-
-    it 'should return a string' do
-      expect(subject.ask(Faker::Lorem.sentence)).to be_a(String)
-    end
-  end
-
-  describe '#ask_yes_no' do
-    it 'should ask the highline client ask'do
-      expect(highline_client).to receive(:ask)
-      subject.ask_yes_no(Faker::Lorem.sentence)
-    end
-
-    it 'should return a boolean' do
-      expect(subject.ask_yes_no(Faker::Lorem.sentence)).to be_falsey
-    end
-
-    it 'should return true if we say yes' do
-      allow(response).to receive(:to_s).and_return('y')
-      expect(subject.ask_yes_no(Faker::Lorem.sentence)).to be_truthy
-    end
-  end
-
-  describe '#ask_options' do
-    it 'should ask the highline client ask'do
-      expect(highline_client).to receive(:ask)
-      subject.ask_options(Faker::Lorem.sentence, ['one', 'two', 'three'])
-    end
-
-    it 'should return a string from the options' do
-      expect(subject.ask_options(Faker::Lorem.sentence, ['one', 'two', 'three'])).to be_a(String)
-    end
-  end
-end