tzu 0.0.2.0 → 0.1.0.0

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'byebug'
 require 'rspec'
 require 'active_record'
+require 'virtus'
 require 'bundler/setup'
 Bundler.setup
 

data/spec/step_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Tzu::Step do
+  let(:dummy_mutator) { proc { 'Dummy!' } }
+
+  context '#name' do
+    context 'when name is symbol' do
+      let(:step) { Tzu::Step.new(:step_name) }
+
+      it 'returns name' do
+        expect(step.name).to eq :step_name
+      end
+    end
+
+    context 'when name is a class' do
+      let(:step) { Tzu::Step.new(StandardError) }
+      let(:outcome) { ControlledOutcome.run(result: :success) }
+
+      it 'returns underscored name' do
+        expect(step.name).to eq :standard_error
+      end
+    end
+  end
+end

data/spec/tzu_spec.rb

@@ -1,39 +1,214 @@
 require 'spec_helper'
 
+class ControlledOutcome
+  include Tzu
+
+  def call(params)
+    result = params[:result]
+    return 123 if result == :success
+    return invalid!('Invalid Message') if result == :invalid
+    return fail!(:falure_type, 'Failure Message') if result == :failure
+  end
+end
+
+class MyRequestObject
+  attr_reader :value, :errors
+
+  def initialize(params)
+    @params = params
+    @value = params[:value]
+    @errors = 'Error Message'
+  end
+
+  def valid?
+    @params[:valid]
+  end
+end
+
+class VirtusRequestObject
+  include Virtus.model
+  include ActiveModel::Validations
+
+  validates :name, :age, presence: :true
+
+  attribute :name, String
+  attribute :age, Integer
+end
+
+class ValidatedCommand
+  include Tzu
+
+  request_object MyRequestObject
+
+  def call(request)
+    request.value
+  end
+end
+
+class VirtusValidatedCommand
+  include Tzu
+
+  request_object VirtusRequestObject
+
+  def call(request)
+    "Name: #{request.name}, Age: #{request.age}"
+  end
+end
+
 describe Tzu do
+  context '#run' do
+    context 'when command succeeds' do
+      let(:outcome) { ControlledOutcome.run(result: :success) }
 
-  context 'command fails' do
-    subject do
-      Class.new do
-        include Tzu
+      it 'correctly returns sets pass/fail flags' do
+        expect(outcome.success?).to be true
+        expect(outcome.failure?).to be false
+      end
 
-        def call(params)
-          fail! :something
-        end
+      it 'returns result' do
+        expect(outcome.result).to eq(123)
       end
     end
 
-    it 'returns failure' do
-      result = subject.run(nil)
-      expect(result).to have_attributes(success: false, type: :something)
+    context 'when command is invalid' do
+      let(:outcome) { ControlledOutcome.run(result: :invalid) }
+
+      it 'correctly returns sets pass/fail flags' do
+        expect(outcome.success?).to be false
+        expect(outcome.failure?).to be true
+      end
+
+      it 'returns error string as errors hash' do
+        expect(outcome.result).to eq(errors: 'Invalid Message')
+      end
+
+      it 'sets type to validation' do
+        expect(outcome.type).to eq(:validation)
+      end
+    end
+
+    context 'when command fails' do
+      let(:outcome) { ControlledOutcome.run(result: :failure) }
+
+      it 'correctly returns sets pass/fail flags' do
+        expect(outcome.success?).to be false
+        expect(outcome.failure?).to be true
+      end
+
+      it 'returns error string as errors hash' do
+        expect(outcome.result).to eq(errors: 'Failure Message')
+      end
+
+      it 'sets type to falure_type' do
+        expect(outcome.type).to eq(:falure_type)
+      end
     end
   end
 
-  context 'command succeeds' do
-    subject do
-      Class.new do
-        include Tzu
+  context '#run with block' do
+    let(:success_spy) { spy('success') }
+    let(:invalid_spy) { spy('invalid') }
+    let(:failure_spy) { spy('failure') }
 
-        def call(params)
-          1234
-        end
+    before do
+      ControlledOutcome.run(result: result) do
+        success { |_| success_spy.call }
+        invalid { |_| invalid_spy.call }
+        failure { |_| failure_spy.call }
       end
     end
 
-    it 'returns result' do
-      result = subject.run(nil)
-      expect(result).to have_attributes(success: true, result: 1234)
+    context 'when command succeeds' do
+      let(:result) { :success }
+      it 'executes success block' do
+        expect(success_spy).to have_received(:call)
+      end
+    end
+
+    context 'when command is invalid' do
+      let(:result) { :invalid }
+      it 'executes invalid block' do
+        expect(invalid_spy).to have_received(:call)
+      end
+    end
+
+    context 'when command fails' do
+      let(:result) { :failure }
+      it 'executes failure block' do
+        expect(failure_spy).to have_received(:call)
+      end
     end
   end
 
+  context '#run with request object' do
+    context 'when request is valid' do
+      let(:outcome) { ValidatedCommand.run(value: 1111, valid: true) }
+
+      it 'executes successfully' do
+        expect(outcome.success?).to be true
+      end
+
+      it 'returns value' do
+        expect(outcome.result).to eq 1111
+      end
+    end
+
+    context 'when request is invalid' do
+      let(:outcome) { ValidatedCommand.run(value: 2222, valid: false) }
+
+      it 'does not execute successfully' do
+        expect(outcome.failure?).to be true
+      end
+
+      it 'has outcome type :validation' do
+        expect(outcome.type).to eq :validation
+      end
+
+      it 'returns error string as errors hash' do
+        expect(outcome.result).to eq(errors: 'Error Message')
+      end
+    end
+
+    context 'with virtus/active_model request object' do
+      let(:outcome) { VirtusValidatedCommand.run(params) }
+
+      context 'when request is valid' do
+        let(:params) { { name: 'Young Tzu', age: '19' } }
+
+        it 'executes successfully' do
+          expect(outcome.success?).to be true
+        end
+      end
+
+      context 'when request is invalid' do
+        let(:params) { { name: 'My Name' } }
+
+        it 'does not execute successfully' do
+          expect(outcome.failure?).to be true
+        end
+
+        it 'returns ActiveModel error object' do
+          expect(outcome.result).to eq(age: ["can't be blank"])
+        end
+      end
+    end
+  end
+
+  context '#run!' do
+    context 'when command is invalid' do
+      let(:outcome) { ControlledOutcome.run!(result: :invalid) }
+
+      it 'raises Tzu::Invalid' do
+        expect { outcome }.to raise_error Tzu::Invalid, 'Invalid Message'
+      end
+    end
+
+    context 'when command fails' do
+      let(:outcome) { ControlledOutcome.run!(result: :failure) }
+
+      it 'raises Tzu::Failure' do
+        expect { outcome }.to raise_error Tzu::Failure, 'Failure Message'
+      end
+    end
+  end
 end

data/spec/validation_spec.rb

@@ -6,7 +6,6 @@ describe Tzu::Validation do
     subject do
       Class.new do
         include Tzu
-        include Tzu::Validation
       end
     end
 
@@ -24,29 +23,10 @@ describe Tzu::Validation do
     end
   end
 
-  context 'command defines valid? method' do
-    subject do
-      Class.new do
-        include Tzu
-        include Tzu::Validation
-
-        def valid?(params)
-          Tzu::ValidationResult.new(false, [])
-        end
-      end
-    end
-
-    it 'returns validation result' do
-      result = subject.run(nil)
-      expect(result).to have_attributes(success: false, type: :validation)
-    end
-  end
-
-  context 'error message is string' do
-    let(:str) { 'error_message' }
-    subject { Tzu::Invalid.new(str) }
-
-    context 'invoked directly' do
+  context 'invoked directly' do
+    context 'error message is string' do
+      let(:str) { 'error_message' }
+      subject { Tzu::Invalid.new(str) }
       it 'has string as #message' do
         expect(subject.message).to eq str
       end
@@ -55,36 +35,40 @@ describe Tzu::Validation do
         expect(subject.errors).to eq(errors: str)
       end
     end
+  end
 
-    context 'rescued' do
-      subject do
-        Class.new do
-          include Tzu
-          include Tzu::Validation
+  context 'rescued' do
+    subject do
+      Class.new do
+        include Tzu
 
-          def call(params)
-            raise StandardError.new(params)
-          rescue StandardError => e
-            invalid! e
-          end
+        def call(params)
+          raise StandardError.new(params[:message])
+        rescue StandardError => e
+          invalid! e
         end
       end
+    end
+
+    context 'error message is string' do
+      let(:str) { 'error_message' }
+      let(:params) { { message: str } }
 
       describe '#run' do
         it 'returns error hash as result' do
-          outcome = subject.run(str)
+          outcome = subject.run(params)
           expect(outcome.result).to eq(errors: str)
         end
       end
 
       describe '#run!' do
         it 'has string as #message' do
-          expect { subject.run!(str) }.to raise_error Tzu::Invalid, str
+          expect { subject.run!(params) }.to raise_error Tzu::Invalid, str
         end
 
         it 'has string as #errors' do
           begin
-            subject.run!(str)
+            subject.run!(params)
             expect(false).to be true # Should never reach this
           rescue Tzu::Invalid => e
             expect(e.errors).to eq(errors: str)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tzu
 version: !ruby/object:Gem::Version
-  version: 0.0.2.0
+  version: 0.1.0.0
 platform: ruby
 authors:
 - Morgan Bruce
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-01 00:00:00.000000000 Z
+date: 2015-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Encapsulate your database queries with dynamically generated classes
 email: morgan@onfido.com
 executables: []
@@ -104,18 +118,22 @@ files:
 - LICENSE.txt
 - README.md
 - lib/tzu.rb
+- lib/tzu/core_extensions/string.rb
 - lib/tzu/failure.rb
 - lib/tzu/hooks.rb
 - lib/tzu/invalid.rb
 - lib/tzu/match.rb
-- lib/tzu/organizer.rb
 - lib/tzu/outcome.rb
+- lib/tzu/run_methods.rb
+- lib/tzu/sequence.rb
+- lib/tzu/step.rb
 - lib/tzu/validation.rb
 - lib/tzu/validation_result.rb
 - spec/hooks_spec.rb
-- spec/organizer_spec.rb
 - spec/outcome_spec.rb
+- spec/sequence_spec.rb
 - spec/spec_helper.rb
+- spec/step_spec.rb
 - spec/tzu_spec.rb
 - spec/validation_spec.rb
 homepage: https://github.com/onfido/tzu
@@ -145,9 +163,10 @@ summary: Get is a library designed to encapsulate Rails database queries and pre
   query pollution in the view layer.
 test_files:
 - spec/hooks_spec.rb
-- spec/organizer_spec.rb
 - spec/outcome_spec.rb
+- spec/sequence_spec.rb
 - spec/spec_helper.rb
+- spec/step_spec.rb
 - spec/tzu_spec.rb
 - spec/validation_spec.rb
 has_rdoc: 

data/lib/tzu/organizer.rb

@@ -1,35 +0,0 @@
-require 'ostruct'
-
-module Tzu
-  module Organizer
-    def self.included(base)
-      base.class_eval do
-        include Tzu
-      end
-    end
-
-    Step = Struct.new(:command, :transform)
-
-    def steps
-      @steps ||= []
-    end
-
-    def add_step(command, &transform)
-      steps << Step.new(command, transform)
-    end
-
-    def call(params)
-      result = call_steps(params)
-      self.respond_to?(:parse) ? parse(result) : result
-    end
-
-    def call_steps(params)
-      result = ::OpenStruct.new
-      steps.each do |step|
-        call_with = step.transform ? step.transform(params, result) : params
-        result[step.command.command_name] = step.command.run!(call_with)
-      end
-      result
-    end
-  end
-end