caperoma 4.0.1 → 5.0.0

data/spec/factories/accounts.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-FactoryBot.define do
+FactoryGirl.define do
   factory :account do
     sequence(:email) { |n| "email#{n}@example.com" }
     sequence(:password) { |n| "password#{n}" }

data/spec/factories/projects.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-FactoryBot.define do
+FactoryGirl.define do
   factory :project do
     sequence(:name) { |n| "Refactoring some thunk of code ##{n}" }
     sequence(:jira_project_id) { |n| 123_456 + n }

data/spec/factories/report_recipients.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-FactoryBot.define do
+FactoryGirl.define do
   factory :report_recipient do
     email 'dude@example.com'
   end

data/spec/factories/reports.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-FactoryBot.define do
+FactoryGirl.define do
   factory :report do
     content 'did this and that'
   end

data/spec/factories/tasks.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-FactoryBot.define do
+FactoryGirl.define do
   factory :task do
     project
 
@@ -20,7 +20,6 @@ FactoryBot.define do
   end
 
   factory :task_with_commit, parent: :task, class: 'TaskWithCommit' do
-    branch
   end
 
   factory :fix, parent: :task_with_commit, class: 'Fix' do

data/spec/features/command_unknown_spec.rb

@@ -5,7 +5,6 @@ ENV['spec_type'] = 'feature'
 
 describe 'Command unknown' do
   let!(:project) { create :project }
-  let!(:current_branch) { create :branch, project: project }
 
   it 'submits a chore' do
     result = `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma boogie woogie`

data/spec/features/feature_spec.rb

@@ -6,55 +6,75 @@ ENV['spec_type'] = 'feature'
 describe 'Feature' do
   let!(:project) { create :project, jira_project_id: '123' }
 
-  before { create_capefile('123') }
-
-  context 'pivotal id blank' do
-    it 'submits a feature' do
-      expect do
-        `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature -t "awesome feature" --description "some description" `
-      end.to change {
-        Feature.where(
-          title: 'awesome feature',
-          description: 'some description',
-          project_id: project.id
-        ).count
-      }.by(1)
+  context 'capefile with only git repo' do
+    before { create_incomplete_capefile }
+
+    context 'creating from data' do
+      it 'submits a feature' do
+        expect do
+          `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature -t "awesome feature" --description "some description" `
+        end.to change {
+          Feature.where(
+            title: 'awesome feature',
+            description: 'some description',
+            project_id: project.id
+          ).count
+        }.by(1)
+      end
     end
   end
 
-  context 'pivotal id present' do
-    it 'submits a feature' do
-      expect do
-        `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature --title "awesome feature" -d "some description" --pivotal_task_id 12345678`
-      end.to change {
-        Feature.where(
-          title: 'awesome feature',
-          description: 'some description',
-          project_id: project.id,
-          pivotal_id: '12345678'
-        ).count
-      }.by(1)
+  context 'full capefile' do
+    before { create_capefile('123') }
+
+    context 'pivotal id blank' do
+      it 'submits a feature' do
+        expect do
+          `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature -t "awesome feature" --description "some description" `
+        end.to change {
+          Feature.where(
+            title: 'awesome feature',
+            description: 'some description',
+            project_id: project.id
+          ).count
+        }.by(1)
+      end
     end
-  end
 
-  context 'pivotal id present, additional_time present', :unstub_time_now do
-    it 'submits a feature' do
-      expect do
-        `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature -t "awesome feature" --description "some description" -ptid 12345678 --additional_time 23`
-      end.to change {
-        Feature.where(
-          title: 'awesome feature',
-          description: 'some description',
-          project_id: project.id,
-          pivotal_id: '12345678'
-        ).count
-      }.by(1)
-
-      time = Time.now
-      created = Feature.first.started_at
-      time_difference = TimeDifference.between(time, created).in_minutes.to_i
-
-      expect(time_difference).to eq 23
+    context 'pivotal id present' do
+      it 'submits a feature' do
+        expect do
+          `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature --title "awesome feature" -d "some description" --pivotal_task_id 12345678`
+        end.to change {
+          Feature.where(
+            title: 'awesome feature',
+            description: 'some description',
+            project_id: project.id,
+            pivotal_id: '12345678'
+          ).count
+        }.by(1)
+      end
+    end
+
+    context 'pivotal id present, additional_time present', :unstub_time_now do
+      it 'submits a feature' do
+        expect do
+          `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma feature -t "awesome feature" --description "some description" -ptid 12345678 --additional_time 23`
+        end.to change {
+          Feature.where(
+            title: 'awesome feature',
+            description: 'some description',
+            project_id: project.id,
+            pivotal_id: '12345678'
+          ).count
+        }.by(1)
+
+        time = Time.now
+        created = Feature.first.started_at
+        time_difference = TimeDifference.between(time, created).in_minutes.to_i
+
+        expect(time_difference).to eq 23
+      end
     end
   end
 end

data/spec/features/init_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+ENV['spec_type'] = 'feature'
+
+describe 'Init' do
+  context 'project not set up' do
+    before { remove_capefile }
+
+    it 'should say Capefile is created' do
+      result = `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma init`
+      expect(result).to match /Capefile successfully created/
+    end
+
+    it 'should create Capefile' do
+      result = `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma init`
+      expect(File).to exist 'Capefile.test'
+    end
+  end
+end

data/spec/features/status_spec.rb

@@ -4,30 +4,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 ENV['spec_type'] = 'feature'
 
 describe 'Status' do
-
-  context "not working on anything" do
-    it "should say I am not working" do
+  context 'not working on anything' do
+    it 'should say I am not working' do
       result = `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma status`
       expect(result).to eq "You are not working on anything now.\n"
     end
   end
 
-  context "working on a feature", :unstub_time_now do
+  context 'working on a feature', :unstub_time_now do
     let!(:account) { create :account }
-    let!(:project) { create :project }
-    let!(:task) { create :feature, project: project, title: 'my title', jira_key: 'PBO-2', pivotal_id: 12345678, finished_at: nil }
+    let!(:project) { create :project, jira_url: 'https://test.atlassian.com/' }
+    let!(:task) { create :feature, project: project, title: 'my title', jira_key: 'PBO-2', pivotal_id: 12_345_678, finished_at: nil }
 
     before { task.update_column :started_at, 2.hours.ago }
-    before { task.update_column :parent_branch, 'master' }
+    before { task.update_column :branch, 'pbo-2-my-title' }
+    before { task.update_column :parent_branch, 'develop' }
 
-    it "should say I am not working" do
+    it 'should say I am not working' do
       result = `CAPEROMA_INTEGRATION_TEST=true ruby -I./lib bin/caperoma status`
       expect(result).to match /Type: Feature/
       expect(result).to match /Title: my title/
-      expect(result).to match /Jira ID: PBO-2/
-      expect(result).to match /Pivotal ID: 12345678/
+      expect(result).to match %r{Jira ID: PBO-2 \(https://test.atlassian.com/browse/PBO-2\)}
+      expect(result).to match %r{Pivotal ID: 12345678 \(https://www.pivotaltracker.com/story/show/12345678\)}
+      expect(result).to match /Branch with the task: pbo-2-my-title/
       expect(result).to match /Time spent at the moment: 2h/
-      expect(result).to match /Pull request will be sent to this branch: master/
+      expect(result).to match /Pull request will be sent to this branch: develop/
     end
   end
 end

data/spec/models/project_spec.rb

@@ -3,7 +3,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 RSpec.describe Project, type: :model do
-  it { expect(subject).to have_many :branches }
   it { expect(subject).to have_many :chores }
   it { expect(subject).to have_many :bugs }
   it { expect(subject).to have_many :features }

data/spec/models/task_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Task, type: :model do
   describe 'validations' do
     it { expect(subject).to validate_presence_of(:title) }
 
-    describe 'length' do
+    describe 'pivotal_id' do
       it { expect(subject).to allow_value(nil).for(:pivotal_id) }
       it { expect(subject).to allow_value('123456').for(:pivotal_id) }
       it { expect(subject).to allow_value('1234567').for(:pivotal_id) }
@@ -23,6 +23,14 @@ RSpec.describe Task, type: :model do
       it { expect(subject).not_to allow_value('12').for(:pivotal_id) }
       it { expect(subject).not_to allow_value('123.45678').for(:pivotal_id) }
     end
+
+    describe 'additional_time' do
+      it { expect(subject).to allow_value(nil).for(:additional_time) }
+      it { expect(subject).to allow_value('12').for(:additional_time) }
+      it { expect(subject).to allow_value('123456').for(:additional_time) }
+      it { expect(subject).not_to allow_value('#12345678').for(:additional_time) }
+      it { expect(subject).not_to allow_value('123.45678').for(:additional_time) }
+    end
   end
 
   describe 'scopes' do
@@ -46,6 +54,12 @@ RSpec.describe Task, type: :model do
   end
 
   describe 'class_methods' do
+    let!(:account) { create :account, type: '--jira' }
+    let(:faraday) { double('Faraday', post: response) }
+    let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
+
+    before { expect(Faraday).to receive(:new).and_return faraday }
+
     describe '::finish_started' do
       let!(:started) { create :task, finished_at: nil }
 
@@ -88,8 +102,11 @@ RSpec.describe Task, type: :model do
   end
 
   describe 'methods' do
+    let!(:jira_account) { create :account, type: '--jira' }
+    let!(:pivotal_account) { create :account, type: '--pivotal' }
+
     context 'pivotal_id present' do
-      let!(:task) { create :task, finished_at: nil, pivotal_id: '12345678' }
+      let!(:task) { create :task, finished_at: nil, pivotal_id: '12345678', additional_time: 5 }
       describe '#finish' do
         it 'should finish it and log time' do
           expect(task).to receive :close_issue_on_jira
@@ -132,7 +149,7 @@ RSpec.describe Task, type: :model do
     end
 
     context 'pivotal_id blank' do
-      let!(:task) { create :task, finished_at: nil, pivotal_id: nil }
+      let!(:task) { create :task, finished_at: nil, pivotal_id: nil, additional_time: 5 }
       describe '#finish' do
         it 'should finish it and log time' do
           expect(task).to receive :close_issue_on_jira
@@ -216,7 +233,7 @@ RSpec.describe Task, type: :model do
         let(:task) { create :task }
         let!(:account) { create :account, type: '--jira' }
         let(:faraday) { double('Faraday', post: response) }
-        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
 
         it 'should create task in Jira after create' do
           expect(Faraday).to receive(:new).and_return faraday
@@ -231,10 +248,168 @@ RSpec.describe Task, type: :model do
         end
       end
 
+      context 'jira account present but no internet connection' do
+        let(:task) { create :task }
+        let!(:account) { create :account, type: '--jira' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
+
+        before do
+          expect(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'give an error that there is no connection' do
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Jira./
+          task.save
+        end
+
+        it 'should still create the task' do
+          expect do
+            task.save
+          end.to change {
+            Task.count
+          }.by(1)
+        end
+      end
+
+      context 'jira account present but the returned status was "forbidden"' do
+        let(:task) { create :task, jira_key: nil }
+        let!(:account) { create :account, type: '--jira' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 401, reason_phrase: 'not authorized') }
+
+        before do
+          expect(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        it 'give an error that there is no connection' do
+          expect(STDOUT).to receive(:puts).with /Forbidden access/
+          task.save
+        end
+
+        it 'should still create the task' do
+          expect do
+            task.save
+          end.to change {
+            Task.count
+          }.by(1)
+        end
+
+        it 'should keep jira_key blank' do
+          task.save
+          expect(task.reload.jira_key).to be_nil
+        end
+      end
+
+      context 'jira account present but the returned status was "forbidden"' do
+        let(:task) { create :task, jira_key: nil }
+        let!(:account) { create :account, type: '--jira' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 403, reason_phrase: 'not authorized') }
+
+        before do
+          expect(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        it 'give an error that there is no connection' do
+          expect(STDOUT).to receive(:puts).with /Forbidden access/
+          task.save
+        end
+
+        it 'should still create the task' do
+          expect do
+            task.save
+          end.to change {
+            Task.count
+          }.by(1)
+        end
+
+        it 'should keep jira_key blank' do
+          task.save
+          expect(task.reload.jira_key).to be_nil
+        end
+      end
+
+      context 'jira account present but the returned status was "not found"' do
+        let(:task) { create :task, jira_key: nil }
+        let!(:account) { create :account, type: '--jira' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 404, reason_phrase: 'not found') }
+
+        before do
+          expect(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        it 'give an error that there is no connection' do
+          expect(STDOUT).to receive(:puts).with /Not found/
+          task.save
+        end
+
+        it 'should still create the task' do
+          expect do
+            task.save
+          end.to change {
+            Task.count
+          }.by(1)
+        end
+
+        it 'should keep jira_key blank' do
+          task.save
+          expect(task.reload.jira_key).to be_nil
+        end
+      end
+
+      context 'jira account present but the returned status was unknown error' do
+        let(:task) { create :task, jira_key: nil }
+        let!(:account) { create :account, type: '--jira' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 500, reason_phrase: 'server error') }
+
+        before do
+          expect(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        it 'give an error that there is no connection' do
+          expect(STDOUT).to receive(:puts).with /Could not/
+          expect(STDOUT).to receive(:puts).with /500/
+          expect(STDOUT).to receive(:puts).with /server error/
+
+          task.save
+        end
+
+        it 'should still create the task' do
+          expect do
+            task.save
+          end.to change {
+            Task.count
+          }.by(1)
+        end
+
+        it 'should keep jira_key blank' do
+          task.save
+          expect(task.reload.jira_key).to be_nil
+        end
+      end
+
       context 'jira account not present' do
         let(:task) { create :task }
         let(:faraday) { double('Faraday', post: response) }
-        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
 
         it 'should not create task in Jira after create' do
           allow(Faraday).to receive(:new).and_return faraday
@@ -259,6 +434,83 @@ RSpec.describe Task, type: :model do
         end
       end
 
+      context 'jira id present, account present, no internet connection' do
+        let!(:account) { create :account, type: '--jira' }
+        let!(:jira_key) { 'OK-1' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'should give the no connection error', :unstub_jira_starting do
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Jira./
+          task.save
+        end
+      end
+
+      describe 'error codes', :unstub_jira_starting do
+        let!(:account) { create :account, type: '--jira' }
+        let!(:jira_key) { 'OK-1' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+        let(:status) { 200 }
+        let(:reason_phrase) { 'OK' }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        context 'jira id present, account present, but server gave "unouthorized" error' do
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.save
+          end
+        end
+
+        context 'jira id present, account present, but server gave "unouthorized" error' do
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.save
+          end
+        end
+
+        context 'jira id present, account present, but server gave "not found" error' do
+          let(:status) { 404 }
+          let(:reason_phrase) { 'not found' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /not found/
+            task.save
+          end
+        end
+
+        context 'jira id present, account present, but server gave "unknown" error' do
+          let(:status) { 500 }
+          let(:reason_phrase) { 'server error' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /server error/
+            task.save
+          end
+        end
+      end
+
       context 'account not present, jira id not present' do
         let!(:jira_key) { 'OK-1' }
 
@@ -296,7 +548,9 @@ RSpec.describe Task, type: :model do
         let(:task) { build :task, pivotal_id: pt_id }
         let!(:account) { create :account, type: '--pivotal' }
         let(:faraday) { double('Faraday', post: response) }
-        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE) }
+        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+        let(:status) { 200 }
+        let(:reason_phrase) { 'OK' }
 
         before { allow(task).to receive(:this_is_a_type_a_user_wants_to_create?).and_return(should_create) }
 
@@ -313,7 +567,7 @@ RSpec.describe Task, type: :model do
           end
         end
 
-        context 'PT id present but should create' do
+        context 'PT id present and should create' do
           let(:pt_id) { '567890123' }
           let(:should_create) { true }
 
@@ -326,6 +580,39 @@ RSpec.describe Task, type: :model do
           end
         end
 
+        context 'PT id present and should create but there is no internet connection' do
+          let(:pt_id) { nil }
+          let(:should_create) { true }
+
+          before do
+            allow(Faraday).to receive(:new).and_return faraday
+            allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+            allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+            allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+          end
+
+          it 'should still be nil' do
+            task.save
+
+            task.reload.tap do |task|
+              expect(task.pivotal_id).to be_blank
+            end
+          end
+
+          it 'should say there is no connection' do
+            expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Pivotal./
+            task.save
+          end
+
+          it 'should still create the task' do
+            expect do
+              task.save
+            end.to change {
+              Task.count
+            }.by(1)
+          end
+        end
+
         context 'PT id blank but should not create' do
           let(:pt_id) { nil }
           let(:should_create) { false }
@@ -352,12 +639,154 @@ RSpec.describe Task, type: :model do
             end
           end
         end
+
+        context 'PT id blank and should create but got "unauthorized error' do
+          let(:pt_id) { nil }
+          let(:should_create) { true }
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          before do
+            allow(Faraday).to receive(:new).and_return faraday
+            allow(faraday).to receive(:post).and_return response
+            allow(faraday).to receive(:get).and_return response
+            allow(faraday).to receive(:put).and_return response
+          end
+
+          it 'should create task in Pivotal' do
+            expect do
+              task.save
+            end.to change {
+              Task.count
+            }.by(1)
+          end
+
+          it 'should keep pivotal id blank' do
+            task.save
+            task.reload.tap do |task|
+              expect(task.pivotal_id).to eq nil
+            end
+          end
+
+          it 'should say it got an error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+
+            task.save
+          end
+        end
+
+        context 'PT id blank and should create but got "unauthorized error' do
+          let(:pt_id) { nil }
+          let(:should_create) { true }
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          before do
+            allow(Faraday).to receive(:new).and_return faraday
+            allow(faraday).to receive(:post).and_return response
+            allow(faraday).to receive(:get).and_return response
+            allow(faraday).to receive(:put).and_return response
+          end
+
+          it 'should create task in Pivotal' do
+            expect do
+              task.save
+            end.to change {
+              Task.count
+            }.by(1)
+          end
+
+          it 'should keep pivotal id blank' do
+            task.save
+            task.reload.tap do |task|
+              expect(task.pivotal_id).to eq nil
+            end
+          end
+
+          it 'should say it got an error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+
+            task.save
+          end
+        end
+
+        context 'PT id blank and should create but got "not found" error' do
+          let(:pt_id) { nil }
+          let(:should_create) { true }
+          let(:status) { 404 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          before do
+            allow(Faraday).to receive(:new).and_return faraday
+            allow(faraday).to receive(:post).and_return response
+            allow(faraday).to receive(:get).and_return response
+            allow(faraday).to receive(:put).and_return response
+          end
+
+          it 'should create task in Pivotal' do
+            expect do
+              task.save
+            end.to change {
+              Task.count
+            }.by(1)
+          end
+
+          it 'should keep pivotal id blank' do
+            task.save
+            task.reload.tap do |task|
+              expect(task.pivotal_id).to eq nil
+            end
+          end
+
+          it 'should say it got an error' do
+            expect(STDOUT).to receive(:puts).with /not found/
+
+            task.save
+          end
+        end
+
+        context 'PT id blank and should create but got "some other" error' do
+          let(:pt_id) { nil }
+          let(:should_create) { true }
+          let(:status) { 500 }
+          let(:reason_phrase) { 'server error' }
+
+          before do
+            allow(Faraday).to receive(:new).and_return faraday
+            allow(faraday).to receive(:post).and_return response
+            allow(faraday).to receive(:get).and_return response
+            allow(faraday).to receive(:put).and_return response
+          end
+
+          it 'should create task in Pivotal' do
+            expect do
+              task.save
+            end.to change {
+              Task.count
+            }.by(1)
+          end
+
+          it 'should keep pivotal id blank' do
+            task.save
+            task.reload.tap do |task|
+              expect(task.pivotal_id).to eq nil
+            end
+          end
+
+          it 'should say it got an error' do
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /server error/
+
+            task.save
+          end
+        end
       end
 
       context 'pivotal account blank' do
         let(:task) { build :task, pivotal_id: pt_id }
         let(:faraday) { double('Faraday', post: response) }
-        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE) }
+        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE, status: 200) }
 
         before { allow(task).to receive(:this_is_a_type_a_user_wants_to_create?).and_return(should_create) }
 
@@ -418,7 +847,6 @@ RSpec.describe Task, type: :model do
 
     describe '::start_issue_on_pivotal' do
       let(:task) { build :task, pivotal_id: pivotal_id }
-      # before { allow(task).to receive(:this_is_a_type_a_user_wants_to_create?).and_return should_create_this_type }
 
       context 'pt id present, pt account present' do
         let(:pivotal_id) { '12345678' }
@@ -431,6 +859,83 @@ RSpec.describe Task, type: :model do
         end
       end
 
+      context 'pt id present, pt account present, no internet connection' do
+        let(:pivotal_id) { '12345678' }
+        let!(:account) { create :account, type: '--pivotal' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE, status: 200) }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'should give the no connection error', :unstub_pivotal_starting do
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Pivotal./
+          task.save
+        end
+      end
+
+      describe 'error codes', :unstub_pivotal_starting do
+        let(:pivotal_id) { '12345678' }
+        let!(:account) { create :account, type: '--pivotal' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+        let(:status) { 200 }
+        let(:reason_phrase) { 'OK' }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        context 'pt id present, pt account present, "unauthorized" server error' do
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the no auth error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.save
+          end
+        end
+
+        context 'pt id present, pt account present, "unauthorized" server error' do
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the no auth error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.save
+          end
+        end
+
+        context 'pt id present, pt account present, "not found" server error' do
+          let(:status) { 404 }
+          let(:reason_phrase) { 'not found' }
+
+          it 'should give the not found error' do
+            expect(STDOUT).to receive(:puts).with /not found/
+            task.save
+          end
+        end
+
+        context 'pt id present, pt account present, "unknown" server error' do
+          let(:status) { 500 }
+          let(:reason_phrase) { 'error' }
+
+          it 'should give the error' do
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /error/
+            task.save
+          end
+        end
+      end
+
       context 'pt id blank, pt account present' do
         let(:pivotal_id) { nil }
         let!(:account) { create :account, type: '--pivotal' }
@@ -491,16 +996,38 @@ RSpec.describe Task, type: :model do
     let!(:account) { create :account, type: '--jira', username: 'someuser' }
 
     describe '#create_issue_on_jira_data' do
-      let!(:task) { create :task, title: 'dupis', description: 'bamis', project: project }
+      let!(:task) { create :task, title: 'dupis', description: description, project: project }
+
+      context 'description present' do
+        let(:description) { 'bamis' }
+
+        it 'should format hash' do
+          allow(task).to receive(:issue_type).and_return '492'
+          result = task.send(:create_issue_on_jira_data)
+          JSON.parse(result).tap do |format|
+            expect(format['fields']['project']['id']).to eq '123'
+            expect(format['fields']['issuetype']['id']).to eq '492'
+            expect(format['fields']['summary']).to eq 'dupis'
+            expect(format['fields']['description']['content'][0]['content'][0]['text']).to eq 'bamis'
+            expect(format['fields']['assignee']['name']).to eq 'someuser'
+          end
+        end
+      end
 
-      it 'should format hash' do
-        allow(task).to receive(:issue_type).and_return '492'
-        result = task.send(:create_issue_on_jira_data)
-        JSON.parse(result).tap do |format|
-          expect(format['fields']['project']['id']).to eq '123'
-          expect(format['fields']['issuetype']['id']).to eq '492'
-          expect(format['fields']['summary']).to eq 'dupis'
-          expect(format['fields']['assignee']['name']).to eq 'someuser'
+      context 'description not' do
+        let(:description) { nil }
+
+        it 'should format hash' do
+          allow(task).to receive(:issue_type).and_return '492'
+          result = task.send(:create_issue_on_jira_data)
+          JSON.parse(result).tap do |format|
+            expect(format['fields']['project']['id']).to eq '123'
+            expect(format['fields']['issuetype']['id']).to eq '492'
+            expect(format['fields']['summary']).to eq 'dupis'
+            expect(format['fields']['assignee']['name']).to eq 'someuser'
+
+            expect(format['fields']['description']).to be_nil
+          end
         end
       end
     end
@@ -531,6 +1058,82 @@ RSpec.describe Task, type: :model do
       end
     end
 
+    describe '::close_issue_on_jira' do
+      let(:task) { build :task, jira_key: jira_key }
+
+      let!(:account) { create :account, type: '--jira' }
+      let!(:jira_key) { 'OK-1' }
+      let(:faraday) { double('Faraday', post: response) }
+      let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+      let(:status) { 200 }
+      let(:reason_phrase) { 'OK' }
+
+      before { allow(Faraday).to receive(:new).and_return faraday }
+
+      context 'no internet connection' do
+        before do
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'should give the no connection error' do
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Jira./
+          task.send(:close_issue_on_jira)
+        end
+      end
+
+      describe 'error codes', :unstub_jira_starting do
+        before do
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        context 'server gave "unouthorized" error' do
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:close_issue_on_jira)
+          end
+        end
+
+        context 'server gave "unouthorized" error' do
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauthorized' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:close_issue_on_jira)
+          end
+        end
+
+        context 'server gave "not found" error' do
+          let(:status) { 404 }
+          let(:reason_phrase) { 'not found' }
+
+          it 'should say it could not start' do
+            expect(STDOUT).to receive(:puts).with /not found/
+            task.send(:close_issue_on_jira)
+          end
+        end
+
+        context 'server gave "unknown" error' do
+          let(:status) { 500 }
+          let(:reason_phrase) { 'server error' }
+
+          it 'should say it could not finish' do
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /server error/
+            task.send(:close_issue_on_jira)
+          end
+        end
+      end
+    end
+
     describe '#log_work_to_jira_data' do
       let!(:task) { create :task }
 
@@ -547,17 +1150,123 @@ RSpec.describe Task, type: :model do
       end
     end
 
+    describe '#log_work_to_jira' do
+      let(:task) { build :task, jira_key: jira_key }
+
+      context 'no internet connection' do
+        let!(:account) { create :account, type: '--jira' }
+        let(:jira_key) { 'OK-1' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: 200) }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'should give the no connection error', :unstub_jira_starting do
+          task.save
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Jira./
+          task.send(:log_work_to_jira)
+        end
+      end
+
+      describe 'errors', :unstub_jira_starting do
+        let!(:account) { create :account, type: '--jira' }
+        let(:jira_key) { 'OK-1' }
+        let(:faraday) { double('Faraday', post: response) }
+        let(:response) { double('Faraday', body: JIRA_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+        let(:status) { 200 }
+        let(:reason_phrase) { 'OK' }
+
+        before do
+          allow(Faraday).to receive(:new).and_return faraday
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        context 'server gave the "unauth" error' do
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the "unauth" error' do
+            task.save
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:log_work_to_jira)
+          end
+        end
+
+        context 'server gave the "unauth" error' do
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the "unauth" error' do
+            task.save
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:log_work_to_jira)
+          end
+        end
+
+        context 'server gave the "not found" error' do
+          let(:status) { 404 }
+          let(:reason_phrase) { 'not found' }
+
+          it 'should give the "unauth" error' do
+            task.save
+            expect(STDOUT).to receive(:puts).with /not found/
+            task.send(:log_work_to_jira)
+          end
+        end
+
+        context 'server gave the "unknown" error' do
+          let(:status) { 500 }
+          let(:reason_phrase) { 'unknown' }
+
+          it 'should give the "unknown" error' do
+            task.save
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /unknown/
+            task.send(:log_work_to_jira)
+          end
+        end
+      end
+    end
+
     describe '#create_issue_on_pivotal_data' do
-      let!(:task) { create :task, title: 'dupis', description: 'bamis', project: project }
+      let!(:task) { create :task, title: 'dupis', description: 'bamis', project: project, pivotal_estimate: estimate }
+
+      context 'estimate is present' do
+        let(:estimate) { 5 }
+
+        it 'should format hash' do
+          allow(task).to receive(:story_type).and_return 'chore'
+          result = task.send(:create_issue_on_pivotal_data)
+          JSON.parse(result).tap do |format|
+            expect(format['current_state']).to eq 'unstarted'
+            expect(format['estimate']).to eq 5
+            expect(format['name']).to eq 'dupis'
+            expect(format['description']).to eq 'bamis'
+            expect(format['story_type']).to eq 'chore'
+          end
+        end
+      end
 
-      it 'should format hash' do
-        allow(task).to receive(:story_type).and_return 'chore'
-        result = task.send(:create_issue_on_pivotal_data)
-        JSON.parse(result).tap do |format|
-          expect(format['current_state']).to eq 'unstarted'
-          expect(format['estimate']).to eq 1
-          expect(format['name']).to eq 'dupis'
-          expect(format['story_type']).to eq 'chore'
+      context 'estimate is not present' do
+        let(:estimate) { 0 }
+
+        it 'should format hash' do
+          allow(task).to receive(:story_type).and_return 'chore'
+          result = task.send(:create_issue_on_pivotal_data)
+          JSON.parse(result).tap do |format|
+            expect(format['current_state']).to eq 'unstarted'
+            expect(format['estimate']).to eq 1
+            expect(format['name']).to eq 'dupis'
+            expect(format['story_type']).to eq 'chore'
+          end
         end
       end
     end
@@ -574,6 +1283,81 @@ RSpec.describe Task, type: :model do
       end
     end
 
+    describe '#finish_on_pivotal' do
+      let(:task) { build :task, pivotal_id: pivotal_id }
+      let(:pivotal_id) { '12345678' }
+      let!(:account) { create :account, type: '--pivotal' }
+      let(:faraday) { double('Faraday', post: response) }
+      let(:response) { double('Faraday', body: PIVOTAL_ISSUE_CREATION_RESPONSE, status: status, reason_phrase: reason_phrase) }
+      let(:status) { 200 }
+      let(:reason_phrase) { 'OK' }
+
+      before { allow(Faraday).to receive(:new).and_return faraday }
+
+      context 'pt id present, pt account present, no internet connection' do
+        before do
+          allow(faraday).to receive(:post).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:get).and_raise Faraday::ConnectionFailed, [404]
+          allow(faraday).to receive(:put).and_raise Faraday::ConnectionFailed, [404]
+        end
+
+        it 'should give the no connection error', :unstub_pivotal_starting do
+          expect(STDOUT).to receive(:puts).with /Connection failed. Performing the task without requests to Pivotal./
+          task.send(:finish_on_pivotal)
+        end
+      end
+
+      describe 'error codes', :unstub_pivotal_starting do
+        before do
+          allow(faraday).to receive(:post).and_return response
+          allow(faraday).to receive(:get).and_return response
+          allow(faraday).to receive(:put).and_return response
+        end
+
+        context 'pt id present, pt account present, "unauthorized" server error' do
+          let(:status) { 401 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the no auth error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:finish_on_pivotal)
+          end
+        end
+
+        context 'pt id present, pt account present, "unauthorized" server error' do
+          let(:status) { 403 }
+          let(:reason_phrase) { 'unauth' }
+
+          it 'should give the no auth error' do
+            expect(STDOUT).to receive(:puts).with /No access/
+            task.send(:finish_on_pivotal)
+          end
+        end
+
+        context 'pt id present, pt account present, "not found" server error' do
+          let(:status) { 404 }
+          let(:reason_phrase) { 'not found' }
+
+          it 'should give the not found error' do
+            expect(STDOUT).to receive(:puts).with /not found/
+            task.send(:finish_on_pivotal)
+          end
+        end
+
+        context 'pt id present, pt account present, "unknown" server error' do
+          let(:status) { 500 }
+          let(:reason_phrase) { 'error' }
+
+          it 'should give the error' do
+            expect(STDOUT).to receive(:puts).with /Could not/
+            expect(STDOUT).to receive(:puts).with /500/
+            expect(STDOUT).to receive(:puts).with /error/
+            task.send(:finish_on_pivotal)
+          end
+        end
+      end
+    end
+
     describe '#start_issue_on_pivotal_data' do
       let!(:task) { create :task }