simple_service 1.4.1 → 2.1.0

data/spec/lib/command_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::Command do
-
-  class ValidCommand < SimpleService::Command
-    expects :foo, :bar
-    optional :stuff
-    returns :bar, :baz
-    def call
-      context.merge!(
-        bar: ['modified', self.stuff].compact.join(' '),
-        baz: 'blah'
-      )
-    end
-  end
-
-  class InvalidReturnCommand < SimpleService::Command
-    expects :foo
-    returns :foo, :baz
-    def call; true; end
-  end
-
-
-  class CallNotDefinedCommand < SimpleService::Command
-  end
-
-  describe '.call' do
-
-    it 'returns the correct keys when using class method' do
-      expect(
-        ValidCommand.call(foo: 'blah', bar: 'meh')
-      ).to eql(bar: 'modified', baz: 'blah')
-    end
-
-    it 'provides optional arguments as getters' do
-      expect(
-        ValidCommand.call(foo: 'blah', bar: 'meh', stuff: 'something')
-      ).to eql(bar: 'modified something', baz: 'blah')
-    end
-
-  end
-
-  describe '#call' do
-
-    context 'when #returns is not empty' do
-      it 'returns the correct keys from the context' do
-        expect(
-          ValidCommand.new(foo: 'blah', bar: 'meh').call
-        ).to eql(bar: 'modified', baz: 'blah')
-      end
-    end
-
-    context 'raises error' do
-
-      it 'when command does not define an call method' do
-        expect {
-          CallNotDefinedCommand.new.call
-        }.to raise_error(SimpleService::CallNotDefinedError)
-      end
-
-      it 'when command attempts to return a key that doesnt exist' do
-        expect {
-          InvalidReturnCommand.new.call
-        }.to raise_error(SimpleService::ReturnKeyError)
-      end
-
-    end
-
-  end
-
-  describe 'context' do
-
-    it 'defines getters for each expected key' do
-      expect(
-        ValidCommand.new(foo: 'blah', bar: 'meh')
-      ).to respond_to :foo
-    end
-
-    it 'defines setters for each expected key' do
-      command = ValidCommand.new(foo: 'blah', bar: 'meh')
-      command.foo = 'changed'
-      command.bar = 'changed'
-
-      expect(command.context).to eql({ foo: 'changed', bar: 'changed' })
-    end
-
-    it 'getter updates @context' do
-      command = ValidCommand.new(foo: 'blah', bar: 'meh')
-      command.foo = 'changed'
-      expect(command.context).to eql({ foo: 'changed', bar: 'meh'})
-    end
-
-  end
-
-  describe '.get_expects' do
-
-    it 'returns an array of expected keys' do
-      expect(ValidCommand.get_expects.sort).to eql([:foo, :bar].sort)
-    end
-
-  end
-
-  describe '.get_returns' do
-
-    it 'returns an array of keys to return' do
-      expect(ValidCommand.get_returns.sort).to eql([:baz, :bar].sort)
-    end
-
-  end
-
-end

data/spec/lib/commands/validates_commands_not_empty_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::ValidatesCommandsNotEmpty do
-
-  class DummyCommand < SimpleService::Command
-    def call; true; end
-  end
-
-  context '#call' do
-
-    it 'raises error when commands are not defined' do
-      expect {
-        SimpleService::ValidatesCommandsNotEmpty.new(provided_commands: nil).call
-      }.to raise_error(
-        SimpleService::OrganizerCommandsNotDefinedError,
-        'This Organizer class does not contain any command definitions'
-      )
-    end
-
-    it 'does not raise error when commands are defined' do
-      expect {
-        SimpleService::ValidatesCommandsNotEmpty.new(provided_commands: [DummyCommand]).call
-      }.to_not raise_error
-    end
-
-  end
-
-end

data/spec/lib/commands/validates_commands_properly_inherit_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::ValidatesCommandsProperlyInherit do
-
-  class ValidDummyCommand < SimpleService::Command
-    def call; true; end
-  end
-
-  class InvalidDummyCommand
-    def call; true; end
-  end
-
-  context '#call' do
-    it 'raises error when commands do not inherit from SimpleService::Command' do
-      expect {
-        SimpleService::ValidatesCommandsProperlyInherit.new(
-          provided_commands: [InvalidDummyCommand]
-        ).call
-      }.to raise_error(
-        SimpleService::CommandParentClassInvalidError,
-        'InvalidDummyCommand - must inherit from SimpleService::Command'
-      )
-    end
-
-    it 'does not raises error when commands inherit from SimpleService::Command' do
-      expect {
-        SimpleService::ValidatesCommandsProperlyInherit.new(
-          provided_commands: [ValidDummyCommand]
-        ).call
-      }.to_not raise_error
-    end
-  end
-
-end

data/spec/lib/commands/validates_expected_keys_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::ValidatesExpectedKeys do
-
-  let(:valid_keys) {{
-    expected_keys: [:foo],
-    provided_keys: [:foo],
-    some_other_key: 'blah'
-  }}
-
-  context '#call' do
-
-    let(:with_valid_keys) {
-      SimpleService::ValidatesExpectedKeys.new(valid_keys)
-    }
-
-    let(:with_missing_keys) {
-      _keys = valid_keys.merge(expected_keys: [:foo, :baz])
-      SimpleService::ValidatesExpectedKeys.new(_keys)
-    }
-
-    let(:does_not_expect_any_keys) {
-      _keys = valid_keys.merge(expected_keys: [])
-      SimpleService::ValidatesExpectedKeys.new(_keys)
-    }
-
-    context 'when all arguments are valid' do
-
-      it 'does not raise error' do
-        expect {
-          with_valid_keys.call
-        }.to_not raise_error
-      end
-
-    end
-
-    context 'when there are expected keys missing from provided keys' do
-
-      it 'raises an error' do
-        expect { with_missing_keys.call }.to raise_error(
-          SimpleService::ExpectedKeyError,
-          'keys required by the organizer but not found in the context: baz'
-        )
-      end
-
-    end
-
-    context 'no expected keys are given' do
-
-      it 'does not raise error' do
-        expect {
-          does_not_expect_any_keys.call
-        }.to_not raise_error
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/ensure_organizer_is_valid_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::EnsureOrganizerIsValid do
-
-  context '#call' do
-
-    class FooCommand < SimpleService::Command
-      def call; true; end
-    end
-
-    class BadInheritanceCommand
-      def call; true; end
-    end
-
-  end
-
-end

data/spec/lib/organizer_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-
-describe SimpleService::Organizer do
-
-  context 'classes with .expects, .optional, and .returns' do
-
-    class TestCommandOne < SimpleService::Command
-      expects :foo
-      optional :blah
-      returns :foo, :bar
-      def call
-        context.merge!(bar: ['bar', self.blah].compact.join(' '))
-      end
-    end
-
-    class TestCommandTwo < SimpleService::Command
-      expects :foo, :bar
-      optional :blarg
-      returns :foo, :bar, :baz
-      def call
-        context.merge!(baz: ['baz', self.blarg].compact.join(' '))
-      end
-    end
-
-    class TestOrganizer < SimpleService::Organizer
-      expects :foo
-      optional :blah, :blarg
-      returns :foo, :bar, :baz
-      commands TestCommandOne, TestCommandTwo
-    end
-
-    describe '.call' do
-      it 'returns the correct hash' do
-        expect(
-          TestOrganizer.call(foo: 'foo')
-        ).to eql(foo: 'foo', bar: 'bar', baz: 'baz', success: true)
-      end
-
-      it 'returns the correct hash when optional arguments provided' do
-        expect(
-          TestOrganizer.call(foo: 'foo', blah: 'blah', blarg: 'blarg')
-        ).to eql(foo: 'foo', bar: 'bar blah', baz: 'baz blarg', success: true)
-      end
-    end
-
-    describe '#call' do
-      it 'returns the correct hash' do
-        expect(
-          TestOrganizer.new(foo: 'foo').call
-        ).to eql(foo: 'foo', bar: 'bar', baz: 'baz', success: true)
-      end
-
-      it 'accepts string keys in context hash' do
-        expect(
-          TestOrganizer.new('foo' => 'foo').call
-        ).to eql(foo: 'foo', bar: 'bar', baz: 'baz', success: true)
-      end
-
-    end
-
-  end
-
-  context 'classes with only expects' do
-
-    class TestCommandThree < SimpleService::Command
-      expects :foo
-      def call
-        context.merge!(bar: 'bar')
-      end
-    end
-
-    class TestCommandFour < SimpleService::Command
-      expects :foo, :bar
-      def call
-        context.merge!(baz: 'baz')
-      end
-    end
-
-    class TestOrganizerTwo < SimpleService::Organizer
-      expects :foo
-      commands TestCommandThree, TestCommandFour
-    end
-
-    describe '#call' do
-      it 'returns the entire context' do
-        expect(
-          TestOrganizerTwo.new(foo: 'foo', extra: 'extra').call
-        ).to eql(foo: 'foo', bar: 'bar', baz: 'baz', extra: 'extra', success: true)
-      end
-
-    end
-
-  end
-
-  context 'service using getters and setters' do
-
-    class GetterSetterCommand < SimpleService::Command
-      expects :foo, :bar
-      returns :baz
-      def call
-        self.baz = self.foo
-      end
-    end
-
-    class GetterSetterOrganizer < SimpleService::Organizer
-      expects :foo, :bar
-      returns :baz
-      commands GetterSetterCommand
-    end
-
-    it 'returns the correct hash' do
-      expect(
-        GetterSetterOrganizer.new(foo: 'baz', bar: 'bar').call
-      ).to eql({ baz: 'baz', success: true })
-    end
-
-    describe '.get_expects' do
-
-      it 'returns an array of expected keys' do
-        expect(GetterSetterOrganizer.get_expects.sort).to eql [:bar, :foo]
-      end
-
-    end
-
-  end
-
-  context 'service with command that calls failure!' do
-
-    class FailAndReturnErrorMessage < SimpleService::Command
-      def call
-        failure!('something went wrong and we need to abort')
-      end
-    end
-
-    class ShouldNotRun < SimpleService::Command
-      def call
-        raise 'should not have gotten here'
-      end
-    end
-
-    class FailAndReturn < SimpleService::Organizer
-      returns :something_not_set
-      commands FailAndReturnErrorMessage, ShouldNotRun
-    end
-
-    it 'returns a message' do
-      expect(FailAndReturn.call[:message]).to eql(
-        'something went wrong and we need to abort')
-    end
-
-    it 'returns success as false' do
-      expect(FailAndReturn.call[:success]).to eql(false)
-    end
-
-    it 'does not raise an exception' do
-      expect { FailAndReturn.call }.to_not raise_error
-    end
-
-  end
-
-  context 'service with command that calls success!' do
-
-    class SuccessAndReturnMessage < SimpleService::Command
-      returns :something
-      def call
-        context[:something] = 'yes!'
-        success!('success called prior to all commands being run')
-      end
-    end
-
-    class SuccessCalledThisShouldNotRun < SimpleService::Command
-      def call
-        raise 'should not have gotten here'
-      end
-    end
-
-    class SucceedAndReturn < SimpleService::Organizer
-      returns :something
-      commands SuccessAndReturnMessage, SuccessCalledThisShouldNotRun
-    end
-
-    it 'returns a message' do
-      expect(SucceedAndReturn.call[:message]).to eql(
-        'success called prior to all commands being run')
-    end
-
-    it 'returns success as true' do
-      expect(SucceedAndReturn.call[:success]).to eql(true)
-    end
-
-    it 'does not raise an exception' do
-      expect { SucceedAndReturn.call }.to_not raise_error
-    end
-  end
-
-  context 'when arguments are not a hash' do
-
-    class DoNothingCommand < SimpleService::Command
-      def call
-        'do nothing'
-      end
-    end
-
-    class DoNothingOrganizer < SimpleService::Organizer
-      commands DoNothingCommand
-    end
-
-    it 'raises an error' do
-      expect { DoNothingOrganizer.new('not a hash').call }.to raise_error(
-        SimpleService::InvalidArgumentError,
-        'Hash required as argument, but was given a String'
-      )
-    end
-  end
-
-end