lita-service 0.1.0

data/spec/lita/helpers/messages_helper_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Helpers::MessagesHelper do
+  let(:subject) { Object.new }
+  let(:service) { 'TheService' }
+
+  before do
+    subject.extend(Lita::Helpers::MessagesHelper)
+  end
+
+  it '#duplicated' do
+    msg = I18n.t('lita.handlers.service.errors.duplicated', service_name: service)
+    expect(subject.msg_duplicated(service_name: service)).to eq msg
+  end
+
+  it '#not_found' do
+    msg = I18n.t('lita.handlers.service.errors.not_found', service_name: service)
+    expect(subject.msg_not_found(service_name: service)).to eq msg
+  end
+
+  it '#customer_not_found' do
+    msg = I18n.t('lita.handlers.service.customer.not_found', service_name: service,
+                                                             customer_name: 'erlinis')
+    expect(subject.msg_customer_not_found(service_name: service,
+                                          customer_name: 'erlinis')).to eq msg
+  end
+  it '#customer_duplicated' do
+    msg = I18n.t('lita.handlers.service.customer.duplicated', service_name: service,
+                                                              customer_name: 'erlinis')
+    expect(subject.msg_customer_duplicated(service_name: service,
+                                           customer_name: 'erlinis')).to eq msg
+  end
+end

data/spec/lita/interactors/add_all_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Interactors::AddAll do
+  let(:data) { ['the-service add all', name, 'add', nil] }
+  let(:interactor) { described_class.new(handler, data) }
+  let(:handler) { double('handler') }
+  let(:fake_repository) { double('redis-repository') }
+
+  before do
+    allow(interactor).to receive(:repository).and_return(fake_repository)
+  end
+
+  describe '#perform' do
+    let(:name) { 'the-service' }
+
+    describe 'when the service does not exist' do
+      let(:error_message) do
+        I18n.t('lita.handlers.service.errors.not_found', service_name: name)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(false)
+      end
+
+      it 'shows an error message' do
+        interactor.perform
+        expect(interactor.success?).to eq false
+        expect(interactor.error).to eq error_message
+      end
+    end
+
+    describe 'when service exists' do
+      let(:service) do
+        { name: name,
+          value: 2000,
+          state: 'active',
+          customers: {
+            erlinis: { quantity: 3, value: 2000 },
+            khal: { quantity: 2, value: 2000 }
+          } }
+      end
+
+      let(:service_quantities_updated) do
+        { name: name,
+          value: 2000,
+          state: 'active',
+          customers: {
+            erlinis: { quantity: (3 + quantity), value: 2000 },
+            khal: { quantity: (2 + quantity), value: 2000 }
+          } }
+      end
+
+      let(:success_message) do
+        I18n.t('lita.handlers.service.add_all.success',
+               quantity: quantity)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+        allow(fake_repository).to receive(:find).with(name).and_return(service)
+      end
+
+      describe 'with a given quantity' do
+        let(:data) { ['the-service add all 3', name, 'add', '3'] }
+        let(:quantity) { 3 }
+
+        it 'increments the quantity to all' do
+          expect(fake_repository).to receive(:update).with(service_quantities_updated)
+          interactor.perform
+          expect(interactor.success?).to eq true
+          expect(interactor.message).to eq success_message
+        end
+      end
+
+      describe 'with a negative quantity' do
+        let(:data) { ['the-service add all -1', name, 'add', '-1'] }
+        let(:quantity) { -1 }
+
+        it 'decrease the quantity to all' do
+          expect(fake_repository).to receive(:update).with(service_quantities_updated)
+          interactor.perform
+          expect(interactor.success?).to eq true
+          expect(interactor.message).to eq success_message
+        end
+      end
+
+      describe 'without a quantity' do
+        let(:quantity) { 1 }
+
+        it 'increments the quantity to all with default value' do
+          expect(fake_repository).to receive(:update).with(service_quantities_updated)
+          interactor.perform
+          expect(interactor.success?).to eq true
+          expect(interactor.message).to eq success_message
+        end
+      end
+    end
+  end
+end

data/spec/lita/interactors/add_quantity_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Interactors::AddQuantity do
+  let(:data) { ['the-service add @erlinis', name, 'add', '@erlinis', nil] }
+  let(:interactor) { described_class.new(handler, data) }
+  let(:handler) { double('handler') }
+  let(:fake_repository) { double('redis-repository') }
+
+  before do
+    allow(interactor).to receive(:repository).and_return(fake_repository)
+  end
+
+  describe '#perform' do
+    let(:name) { 'the-service' }
+
+    describe 'when the service does not exist' do
+      let(:error_message) do
+        I18n.t('lita.handlers.service.errors.not_found', service_name: name)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(false)
+      end
+
+      it 'shows an error message' do
+        interactor.perform
+        expect(interactor.success?).to eq false
+        expect(interactor.error).to eq error_message
+      end
+    end
+
+    describe 'when service exists' do
+      describe 'when customer is not in the service' do
+        let(:data) { ['the-service add erlinis 1', name, 'add', 'erlinis', 1] }
+
+        let(:service) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: { khal: { quantity: 1, value: 2000 } } }
+        end
+
+        let(:error_message) do
+          I18n.t('lita.handlers.service.customer.not_found',
+                 service_name: name, customer_name: 'erlinis')
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name).and_return(service)
+        end
+
+        it 'shows an error message' do
+          interactor.perform
+          expect(interactor.success?).to eq false
+          expect(interactor.error).to eq error_message
+        end
+      end
+
+      describe 'when customer is in service' do
+        let(:service) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: { erlinis: { quantity: 3, value: 2000 } } }
+        end
+
+        let(:service_customer_updated) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: {
+              erlinis: { quantity: customer_quantity, value: 2000 }
+            } }
+        end
+
+        let(:success_message) do
+          I18n.t('lita.handlers.service.add.success',
+                 customer_name: 'erlinis',
+                 customer_quantity: customer_quantity,
+                 quantity: quantity)
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name).and_return(service)
+          allow(fake_repository).to receive(:update).with(service_customer_updated)
+        end
+
+        describe 'with a given quantity' do
+          let(:data) { ['the-service add @erlinis 3', name, 'add', '@erlinis', '3'] }
+          let(:customer_quantity) { 6 }
+          let(:quantity) { 3 }
+
+          it 'increments the customer quantity' do
+            interactor.perform
+            expect(interactor.success?).to eq true
+            expect(interactor.message).to eq success_message
+          end
+        end
+
+        describe 'with a negative quantity' do
+          let(:data) { ['the-service add @erlinis -1', name, 'add', '@erlinis', '-1'] }
+          let(:customer_quantity) { 2 }
+          let(:quantity) { -1 }
+
+          it 'decrease the customer quantity' do
+            interactor.perform
+            expect(interactor.success?).to eq true
+            expect(interactor.message).to eq success_message
+          end
+        end
+
+        describe 'without a quantity' do
+          let(:data) { ['the-service add @erlinis', name, 'add', '@erlinis', nil] }
+          let(:customer_quantity) { 4 }
+          let(:quantity) { 1 }
+
+          it 'increments the customer quantity with default value' do
+            interactor.perform
+            expect(interactor.success?).to eq true
+            expect(interactor.message).to eq success_message
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lita/interactors/change_value_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Interactors::ChangeValue do
+  let(:data) { ['the-service value @erlinis 2000', name, '@erlinis', '2000'] }
+  let(:interactor) { described_class.new(handler, data) }
+  let(:handler) { double('handler') }
+  let(:fake_repository) { double('redis-repository') }
+
+  before do
+    allow(interactor).to receive(:repository).and_return(fake_repository)
+  end
+
+  describe '#perform' do
+    let(:name) { 'the-service' }
+
+    describe 'when the service does not exist' do
+      let(:error_message) do
+        I18n.t('lita.handlers.service.errors.not_found', service_name: name)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(false)
+      end
+
+      it 'shows an error message' do
+        interactor.perform
+        expect(interactor.success?).to eq false
+        expect(interactor.error).to eq error_message
+      end
+    end
+
+    describe 'when service exists' do
+      describe 'when customer is not in the service' do
+        let(:service) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: { khal: { quantity: 1, value: 2000 } } }
+        end
+
+        let(:error_message) do
+          I18n.t('lita.handlers.service.customer.not_found',
+                 service_name: name, customer_name: 'erlinis')
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name).and_return(service)
+        end
+
+        it 'shows an error message' do
+          interactor.perform
+          expect(interactor.success?).to eq false
+          expect(interactor.error).to eq error_message
+        end
+      end
+
+      describe 'when customer is in service' do
+        let(:service) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: { erlinis: { quantity: 1, value: 1000 } } }
+        end
+
+        let(:service_customer_updated) do
+          { name: name,
+            value: 2000,
+            state: 'active',
+            customers: { erlinis: { quantity: 1, value: 2000 } } }
+        end
+
+        let(:success_message) do
+          I18n.t('lita.handlers.service.set_value.success',
+                 customer_name: 'erlinis',
+                 customer_value: customer_value,
+                 old_value: 1000)
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name).and_return(service)
+          allow(fake_repository).to receive(:update).with(service_customer_updated)
+        end
+
+        describe 'updates customer value' do
+          let(:customer_value) { 2000 }
+
+          it 'update users value' do
+            interactor.perform
+            expect(interactor.success?).to eq true
+            expect(interactor.message).to eq success_message
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lita/interactors/create_service_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Interactors::CreateService do
+  let(:interactor) { described_class.new(handler, data) }
+  let(:handler) { double('handler') }
+  let(:data) { ['create new-service', name, 2000] }
+  let(:name) { 'new-service' }
+  let(:fake_repository) { double('redis-repository') }
+
+  before do
+    allow(interactor).to receive(:repository).and_return(fake_repository)
+  end
+
+  describe '#perform' do
+    describe 'when the service does not exist' do
+      let(:service) do
+        { name: name,
+          value: 2000,
+          state: 'active',
+          customers: {} }
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(false)
+      end
+
+      it 'creates the service' do
+        expect(fake_repository).to receive(:add).with(service)
+        interactor.perform
+        expect(interactor.success?).to eq true
+        expect(interactor.message).to eq service
+      end
+    end
+
+    describe 'when service exists' do
+      let(:error_message) do
+        I18n.t('lita.handlers.service.errors.duplicated', service_name: name)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+      end
+
+      it 'does not create the service' do
+        interactor.perform
+        expect(interactor.success?).to eq false
+        expect(interactor.error).to eq error_message
+      end
+    end
+  end
+end

data/spec/lita/interactors/delete_customer_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: false
+require 'spec_helper'
+
+describe Lita::Interactors::DeleteCustomer do
+  let(:data) { ['the-service delete @erlinis', name, 'delete', '@erlinis', nil] }
+  let(:interactor) { described_class.new(handler, data) }
+  let(:handler) { double('handler') }
+  let(:fake_repository) { double('redis-repository') }
+
+  before do
+    allow(interactor).to receive(:repository).and_return(fake_repository)
+  end
+
+  describe '#perform' do
+    let(:name) { 'the-service' }
+
+    describe 'when the service does not exist' do
+      let(:error_message) do
+        I18n.t('lita.handlers.service.errors.not_found', service_name: name)
+      end
+
+      before do
+        allow(fake_repository).to receive(:exists?).with(name).and_return(false)
+      end
+
+      it 'shows an error message' do
+        interactor.perform
+        expect(interactor.success?).to eq false
+        expect(interactor.error).to eq error_message
+      end
+    end
+
+    describe 'when service exists' do
+      let(:service) do
+        { name: name,
+          value: 2000,
+          state: 'active',
+          customers: { erlinis: { quantity: 1, value: 2000 } } }
+      end
+
+      let(:service_without_customer) do
+        { name: name,
+          value: 2000,
+          state: 'active',
+          customers: {} }
+      end
+
+      describe 'customer is in service' do
+        let(:success_message) do
+          I18n.t('lita.handlers.service.delete_customer.success',
+                 service_name: name, customer_name: 'erlinis')
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name).and_return(service)
+        end
+
+        it 'removes customer from service' do
+          expect(fake_repository).to receive(:update).with(service_without_customer)
+          interactor.perform
+          expect(interactor.success?).to eq true
+          expect(interactor.message).to eq success_message
+        end
+      end
+
+      describe 'customer not in service' do
+        let(:error_message) do
+          I18n.t('lita.handlers.service.customer.not_found',
+                 service_name: name, customer_name: 'erlinis')
+        end
+
+        before do
+          allow(fake_repository).to receive(:exists?).with(name).and_return(true)
+          allow(fake_repository).to receive(:find).with(name)
+            .and_return(service_without_customer)
+        end
+
+        it 'shows a customer not found error' do
+          interactor.perform
+          expect(interactor.success?).to eq false
+          expect(interactor.error).to eq error_message
+        end
+      end
+    end
+  end
+end