pgit 0.0.4 → 1.0.0

data/spec/pgit/command/add_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Add' do
+  describe 'when the command already exist' do
+    it 'should raise an error since it already exists' do
+      name = 'existent_command'
+      steps = ['existent_step']
+      global_opts = {}
+      opts = { name: name, steps: steps }
+      args = []
+      expected_message = "Command 'existent_command' already exists in the current project. If you want to update the command, see `pgit cmd edit --help`"
+      new_command = instance_double('PGit::Command', name: name, steps: steps)
+      fake_command = instance_double('PGit::Command', name: name, steps: steps)
+      fake_project = instance_double('PGit::CurrentProject')
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 command: new_command,
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: fake_project)
+
+      add = PGit::Command::Add.new(fake_app)
+
+      expect{ add.execute! }.to raise_error PGit::Error::User, expected_message
+    end
+  end
+
+  describe 'when there the command does not exist' do
+    it 'should show the success message' do
+      non_existent_name = 'non_existent_command'
+      non_existent_steps = ['existent_step']
+      existent_name = 'existent_name'
+      existent_steps= 'existent_steps'
+      global_opts = {}
+      opts = { name: non_existent_name, steps: non_existent_steps }
+      args = []
+      expected_message = "Successfully added command 'non_existent_command' to the current project!"
+      fake_project = instance_double('PGit::CurrentProject')
+      fake_command = instance_double('PGit::Command',
+                                     name: existent_name,
+                                     steps: existent_steps,
+                                     save!: nil)
+
+      new_fake_command = instance_double('PGit::Command',
+                                     name: non_existent_name,
+                                     steps: non_existent_steps,
+                                     save!: nil)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 command: new_fake_command,
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: fake_project)
+
+      add = PGit::Command::Add.new(fake_app)
+      allow(add).to receive(:puts)
+
+      add.execute!
+
+      expect(new_fake_command).to have_received(:save!)
+      expect(add).to have_received(:puts).with(expected_message)
+    end
+  end
+end

data/spec/pgit/command/application_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Application' do
+  class SomeCommandApp < PGit::Command::Application
+  end
+
+  before do
+    existent_name = 'existent_name'
+    some_other_existent_name = 'some_other_existent_name'
+    new_name = 'new_name'
+    new_steps = ['echo step1', 'echo step2']
+    @global_opts, @opts, @args = {}, { 'name' => new_name, 'steps' => new_steps}, [existent_name]
+
+    fake_steps = ["git fetch origin master",
+                  "git push origin :STORY_BRANCH"]
+    fake_command_string = double('fake_command_string')
+    @new_command = instance_double('PGit::Command', name: new_name, steps: new_steps)
+    @fake_command = instance_double('PGit::Command', to_s: fake_command_string, name: existent_name)
+    @fake_commands = [@fake_command]
+    fake_yaml = double('fake_yaml')
+    fake_configuration = instance_double('PGit::Configuration', to_yaml: fake_yaml)
+    @fake_current_project = instance_double('PGit::CurrentProject',
+                                            commands: @fake_commands)
+
+    allow(PGit::Configuration).to receive(:new).
+      and_return(fake_configuration)
+    allow(PGit::CurrentProject).to receive(:new).
+      with(fake_configuration).and_return(@fake_current_project)
+    allow(PGit::Command).to receive(:new).
+      with(existent_name, fake_steps, @fake_current_project).and_return(@fake_command)
+    allow(PGit::Command).to receive(:new).
+      with(new_name, new_steps, @fake_current_project).and_return(@new_command)
+
+    @app = SomeCommandApp.new(@global_opts, @opts, @args)
+  end
+
+  describe '#commands' do
+    it 'returns the commands' do
+      expect(@app.commands).to eq @fake_commands
+    end
+  end
+
+  describe '#global_opts' do
+    it 'returns the global_opts' do
+      expect(@app.global_opts).to eq @global_opts
+    end
+  end
+
+  describe '#opts' do
+    it 'returns the opts' do
+      expect(@app.opts).to eq @opts
+    end
+  end
+
+  describe '#args' do
+    it 'returns the args' do
+      expect(@app.args).to eq @args
+    end
+  end
+
+  describe '#current_project' do
+    it 'return the current project' do
+      expect(@app.current_project).to eq @fake_current_project
+    end
+  end
+
+  describe '#command' do
+    it 'returns the command' do
+      expect(@app.command).to eq @new_command
+    end
+  end
+
+  describe 'passing in opts without steps' do
+    it 'should default steps of the command to [:no_steps_provided]' do
+      class SomeOtherCommandApp < PGit::Command::Application
+      end
+
+      existent_name = 'existent_name'
+      some_other_existent_name = 'some_other_existent_name'
+      new_name = 'new_name'
+      new_steps = [:no_steps_provided]
+      @global_opts, @opts, @args = {}, { 'name' => new_name }, [existent_name]
+
+      fake_steps = ["git fetch origin master",
+                    "git push origin :STORY_BRANCH"]
+      fake_command_string = double('fake_command_string')
+      @new_command = instance_double('PGit::Command', name: new_name, steps: new_steps)
+      @fake_command = instance_double('PGit::Command', to_s: fake_command_string, name: existent_name)
+      @fake_commands = [@fake_command]
+      fake_yaml = double('fake_yaml')
+      fake_configuration = instance_double('PGit::Configuration', to_yaml: fake_yaml)
+      @fake_current_project = instance_double('PGit::CurrentProject',
+                                              commands: @fake_commands)
+      allow(PGit::Configuration).to receive(:new).
+        and_return(fake_configuration)
+      allow(PGit::CurrentProject).to receive(:new).
+        with(fake_configuration).and_return(@fake_current_project)
+      allow(PGit::Command).to receive(:new).
+        with(existent_name, fake_steps, @fake_current_project).and_return(@fake_command)
+      allow(PGit::Command).to receive(:new).
+        with(new_name, new_steps, @fake_current_project).and_return(@new_command)
+
+
+      @app = SomeOtherCommandApp.new(@global_opts, @opts, @args)
+      expect(@app.command).to eq @new_command
+    end
+  end
+end
+
+

data/spec/pgit/command/edit_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Edit' do
+  describe 'when the command already exists' do
+    it 'should be successful' do
+      name = 'existent_command'
+      steps = ['existent_step']
+      global_opts = {}
+      opts = { name: name, steps: steps }
+      args = []
+      expected_message = "Successfully edited command 'existent_command' of the current project!"
+      fake_command = instance_double('PGit::Command', name: name, steps: steps, save!: nil)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 command: fake_command,
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+
+      edit = PGit::Command::Edit.new(fake_app)
+      allow(edit).to receive(:puts).with(expected_message)
+      edit.execute!
+
+      expect(edit).to have_received(:puts).with(expected_message)
+    end
+  end
+
+  describe 'when there the command does not exist' do
+    it 'should raise an error' do
+      non_existent_name = 'non_existent_command'
+      non_existent_steps = ['existent_step']
+      existent_name = 'existent_name'
+      existent_steps= 'existent_steps'
+      global_opts = {}
+      opts = { name: non_existent_name, steps: non_existent_steps }
+      args = []
+      expected_message = "Cannot edit a command that does not exist in the current project. See `pgit cmd add --help` if you want to add a new command"
+      fake_command = instance_double('PGit::Command',
+                                     name: existent_name,
+                                     steps: existent_steps,
+                                     save!: nil)
+
+      new_fake_command = instance_double('PGit::Command',
+                                     name: non_existent_name,
+                                     steps: non_existent_steps,
+                                     save!: nil)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 command: new_fake_command,
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+
+      edit = PGit::Command::Edit.new(fake_app)
+
+      expect{ edit.execute! }.to raise_error(PGit::Error::User, expected_message)
+    end
+  end
+end

data/spec/pgit/command/remove_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Remove' do
+  describe 'when the command already exists' do
+    it 'should be successful' do
+      name = 'existent_command'
+      steps = ['existent_step']
+      global_opts = {}
+      opts = { name: name }
+      args = []
+      expected_message = "Successfully removed command 'existent_command' from the current project!"
+      fake_command = instance_double('PGit::Command', name: name,
+                                                      steps: steps,
+                                                      save!: nil,
+                                                      remove!: nil)
+      new_command = instance_double('PGit::Command', name: name,
+                                                      steps: steps,
+                                                      save!: nil,
+                                                      remove!: nil)
+
+      project = instance_double('PGit::CurrentProject')
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 command: new_command,
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: project)
+
+      allow(PGit::Command).to receive(:new).with(name, ['fake_steps'], project).and_return(fake_command)
+      remove = PGit::Command::Remove.new(fake_app)
+      allow(remove).to receive(:puts)
+      remove.execute!
+
+      expect(remove).to have_received(:puts).with(expected_message)
+    end
+  end
+
+  describe 'when there the command does not exist' do
+    it 'should raise an error' do
+      non_existent_name = 'non_existent_command'
+      non_existent_steps = ['existent_step']
+      existent_name = 'existent_name'
+      existent_steps= 'existent_steps'
+      global_opts = {}
+      opts = { name: non_existent_name }
+      args = []
+      expected_message = "Cannot remove a command that does not exist in the current project. See `pgit cmd add --help` if you want to add a new command"
+      project = instance_double('PGit::CurrentProject')
+      fake_command = instance_double('PGit::Command',
+                                     name: existent_name,
+                                     steps: existent_steps,
+                                     save!: nil)
+
+      new_fake_command = instance_double('PGit::Command',
+                                     name: non_existent_name,
+                                     steps: non_existent_steps,
+                                     save!: nil)
+
+      allow(PGit::Command).to receive(:new).with(opts[:name], ['fake_steps'], project).and_return(new_fake_command)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 command: new_fake_command,
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: project)
+
+      remove = PGit::Command::Remove.new(fake_app)
+
+      expect{ remove.execute! }.to raise_error(PGit::Error::User, expected_message)
+    end
+  end
+end

data/spec/pgit/command/run_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Run' do
+  describe '#run' do
+    it 'raises a command not found exception if the item does not exist' do
+      global_opts = {}
+      opts = {}
+      args = ['non_existent_command']
+      project = instance_double('PGit::CurrentProject')
+
+      app = instance_double('PGit::Command::Application',
+                                 commands: [],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: project)
+
+      run = PGit::Command::Run.new(app)
+      error_message = "Command '#{args[0]}' does not exist. Run 'pgit cmd show' to see the available custom commands."
+
+      expect do
+        run.execute!
+      end.to raise_error(PGit::Error::User, error_message)
+    end
+
+    it 'calls execute on the command if it exists' do
+      existent_name = 'existent_command'
+      global_opts = {}
+      opts = {}
+      args = [existent_name]
+
+      fake_command = instance_double('PGit::Command', name: existent_name)
+      allow(fake_command).to receive(:execute)
+      project = instance_double('PGit::CurrentProject')
+      app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts,
+                                 current_project: project
+                           )
+
+      run = PGit::Command::Run.new(app)
+      run.execute!
+
+      expect(fake_command).to have_received(:execute)
+    end
+  end
+end

data/spec/pgit/command/show_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe 'PGit::Command::Show' do
+  before { Rainbow.enabled = false }
+  describe 'without any options' do
+    it 'raises an error if there are no commands' do
+      global_opts = []
+      opts = []
+      args = []
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+      app = PGit::Command::Show.new(fake_app)
+      message = "No commands are listed for this project. Run `pgit cmd add --help` for more info."
+      expect { app.execute! }.to raise_error(PGit::Error::User, message)
+    end
+
+    it 'lists the commands if there are commands' do
+      global_opts = []
+      opts = []
+      args = []
+
+      expected_message = "Listing custom commands of the current project..."
+      fake_formatted_command = instance_double('String')
+      fake_command = instance_double('PGit::Command', to_s: fake_formatted_command)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+      show = PGit::Command::Show.new(fake_app)
+      allow(show).to receive(:puts)
+
+      show.execute!
+
+      expect(show).to have_received(:puts).with(expected_message)
+      expect(show).to have_received(:puts).with(fake_formatted_command)
+    end
+  end
+
+  describe 'when a command_name is passed in' do
+    it 'should print the command if exists' do
+      existent_command_name = 'fake_command'
+      global_opts = []
+      opts = []
+      args = [existent_command_name]
+
+      expected_message = "Listing custom command '#{existent_command_name}' of the current project..."
+      fake_formatted_command = instance_double('String')
+      fake_command = instance_double('PGit::Command',
+                                     to_s: fake_formatted_command,
+                                     name: existent_command_name)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+      show = PGit::Command::Show.new(fake_app)
+      allow(show).to receive(:puts)
+
+      show.execute!
+
+      expect(show).to have_received(:puts).with(expected_message)
+      expect(show).to have_received(:puts).with(fake_formatted_command)
+    end
+
+    it 'should raise an error if the command does not exist' do
+      nonexistent_command_name = 'non_existent_fake_command'
+      existent_command_name = 'fake_command'
+      global_opts = []
+      opts = []
+      args = [nonexistent_command_name]
+
+      expected_message = "Command '#{nonexistent_command_name}' not found for this project"
+      fake_formatted_command = instance_double('String')
+      fake_command = instance_double('PGit::Command',
+                                     to_s: fake_formatted_command,
+                                     name: existent_command_name)
+
+      fake_app = instance_double('PGit::Command::Application',
+                                 commands: [fake_command],
+                                 args: args,
+                                 opts: opts,
+                                 global_opts: global_opts)
+      show = PGit::Command::Show.new(fake_app)
+
+      expect{ show.execute! }.to raise_error PGit::Error::User, expected_message
+    end
+  end
+end