tradesman 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db5c2d7076e95ba6d615b720841bd7060498fd41
-  data.tar.gz: 8e3c89647d347d22d91f8b6674b97365ce0615b9
+  metadata.gz: 88a8291acc6f38c6d19ff311c2c2ab950c755288
+  data.tar.gz: dca95fa986b0e498bec27f5205fbec416d547c78
 SHA512:
-  metadata.gz: 7fda495879e02cc5199b8327879fae9fa7acbacd1aa2f6e3b94a8391482d3fb82b2a3a1e130006e3df9fcf0ddeeefdb423ad4f1b2e7b597d7c7fefeb473e3d9b
-  data.tar.gz: d6868892dc9f4441426dbe234e3bafe40c38f83788e592b34e5a7caba9410071f280156e7466babd790c8989fcd3cd6ae86dae11d19d467c988d8d92f676a8aa
+  metadata.gz: e403a3da8460e086194e472c92d2827e2e132da3f2150dc26b7a7d248b476f851289f70e6fc95959efd7ee90646981eaaf29bd12a78c94c111fe918893b8563d
+  data.tar.gz: c601b711e3e59ae362c9fed58870c1b5e3f92e488963d49a9a956c27c0156e9869ce7520bdfc50e55d46643f4cd9ca67006efb26253523e3972fa2f4b178ba4e

data/README.md

@@ -1,19 +1,28 @@
 # Tradesman
 
-Encapsulate common application behaviour with dynamically generated classes.
-
-Tradesman dynamically generates classes with human-readble names that handle the pass, fail, and invalid results of common create, update, and delete actions.
+Tradesman lets you invoke human-readble classes that handle the pass, fail, and invalid cases of common create, update, and delete actions without having to write the code!
 
 ## Usage
 
 ```ruby
-# Simple - Returns an Outcome
-outcome = Tradesman::CreateUser.run(user_params)
+# Simple - Returns a successful Outcome
+outcome = Tradesman::CreateUser.go(user_params)
 outcome.success? #=> true
+outcome.failure? #=> false
 outcome.result #=> User Entity
 
+# With invalid parameters - returns an invalid Outcome
+outcome = Tradesman::CreateUser.go(invalid_user_params)
+outcome.success? #=> false
+outcome.failure? #=> true
+outcome.result #=> Error Class
+outcome.type #=> :validation
+
+# With invalid parameters - fail loudly!
+outcome = Tradesman::CreateUser.go!(invalid_user_params) #=> raises Tradesman::Invalid or Tradesman::Failure
+
 # Passing a block - Well-suited for Controllers
-Tradesman::UpdateUser.run({ id: params[:id] }.merge(user_update_params)) do
+Tradesman::UpdateUser.go(params[:id], user_update_params) do
   success do |result|
     render(text: 'true', status: 200)
   end
@@ -22,18 +31,70 @@ Tradesman::UpdateUser.run({ id: params[:id] }.merge(user_update_params)) do
     render(text: 'false', status: 404)
   end
 
-  failure do |result|
+  failure do |error|
     render(text: 'false', status: 400)
   end
 end
 
-# Can also Delete
-Tradesman::DeleteUser.run(id: params[:id])
+# Delete
+Tradesman::DeleteUser.go(params[:id])
+
+# Create as a child of an existing record
+Tradesman::CreateUserForEmployer.go(employer, user_params)
+
+# Create multiple records
+Tradesman::CreateUser.go([user_params, user_params, user_params])
+
+# Create multiple for a single parent
+Tradesman::CreateUserForEmployer.go(employer, [user_params, user_params, user_params])
+
+# Update multiple records with 1 set of parameters
+Tradesman::UpdateUser.go([user1, user2, user3], update_params)
 
-# Or Create as a child of an existing record
-Tradesman::CreateUserForEmployer.run({ parent_id: employer_id }.merge(user_params))
+# Update n records with n sets of parameters
+# Whenever you pass an id, you can either pass the id itself,
+# or an object that response to :id
+update_params = {
+  user1.id => user1_params,
+  user2.id => user2_params,
+  user3.id => user3_params
+}
+Tradesman::UpdateUser.go(update_params.keys, update_params.values)
+
+
+# Delete multiple records
+Tradesman::DeleteUser.go([id1, id2, id3])
 ```
 
+## Parsing Rules
+
+Classes have the following structure:
+
+`Method` + `Record`
+
+```ruby
+# Examples:
+CreateUser
+UpdateEmployer
+DeleteBlogPost
+```
+
+Where **Method** is one of `Create`, `Update`, or `Delete`, and **Record** is your model classname, CamelCased.
+Note that model namespaces are ignored.
+
+The only exception is when you create a record for a parent. These classes have the following structure:
+
+`Method` + `Record` + `'For'` + `ParentRecord`
+
+```ruby
+# Examples
+CreateUserForEmployer
+CreateInvoiceForCustomer
+```
+
+Where 'For' is a string literal and **ParentRecord** is the parent model classname, CamelCased.
+
+
 ## Why is this necessary?
 
 At Onfido, we observed that many Create, Update and Delete actions we programmed were are simple and repeated (albeit with different records and parameter lists) in several locations. They can generally be broken in to the following steps:
@@ -51,7 +112,7 @@ def update
   return render(text: 'false', status: 404) unless @user
 
   @user.assign_attributes(user_params)
-  return render(text: 'false', status: 400) unless @user.save
+  return render(text: 'false', status: 422) unless @user.save
 
   render 'user'
 end
@@ -68,14 +129,14 @@ Tradesman is designed to handle the above and a few other common use-cases to re
 
 Tradesman version of the above:
 ```ruby
-Tradesman::UpdateUser.run(user_params) do
+Tradesman::UpdateUser.go(user_id, user_params) do
   success do |result|
     @user = result
     render 'user'
   end
 
   invalid do |error|
-    render(text: 'false', status: 404)
+    render(text: error.message, status: 422)
   end
 
   failure { |result| render(text: 'false', status: 400) } # If you prefer one-liners
@@ -84,7 +145,7 @@ end
 private
 
 def user_params
-  params.permit(:id, :first_name, :last_name)
+  params.permit(:first_name, :last_name, :email)
 end
 ```
 
@@ -94,8 +155,8 @@ The Tradesman version says exactly what it does, is cruft free, and is much quic
 
 **Define your adapter**
 
-_config/initializers/tradesman.rb_
 ```ruby
+# config/initializers/tradesman.rb
 Tradesman.configure { |config| config.adapter = :active_record }
 ```
 
@@ -120,8 +181,8 @@ end
 
 In order to help Tradesman lazy load these models, you need to enable development mode and configure any namespaces:
 
-_config/initializers/tradesman.rb_
 ```ruby
+# config/initializers/tradesman.rb
 Tradesman.configure do |config|
   config.adapter = :active_record
   config.development_mode = Rails.env.development?

data/lib/tradesman/builders/base.rb

@@ -11,6 +11,10 @@ module Tradesman
         template_class(class_args)
       end
 
+      def template_class(class_args)
+        raise Tradesman::MethodNotImplemented.new('You must implement template_class in a child class')
+      end
+
       private
 
       def class_args

data/lib/tradesman/builders/create.rb

@@ -5,11 +5,22 @@ module Tradesman
 
       def template_class(args)
         Class.new(::Tradesman::Template) do
+          include ::Tradesman::NewRecordsMultipleExecute
           @store = Tradesman.adapter.context_for_entity(args[:subject])
 
+          class << self
+            def go(params, *context, &block)
+              run_and_convert_exceptions { run(params, *context, &block) }
+            end
+
+            def go!(params, *context)
+              run_and_convert_exceptions { run!(params, *context) }
+            end
+          end
+
           private
 
-          def execute(params)
+          def execute_single(params)
             self.class.adapter.create!(params)
           end
         end

data/lib/tradesman/builders/create_for_parent.rb

@@ -5,6 +5,7 @@ module Tradesman
 
       def template_class(args)
         Class.new(::Tradesman::Template) do
+          include ::Tradesman::ExistingRecordsMultipleExecute
           @store = Tradesman.adapter.context_for_entity(args[:subject])
           @parent_store = Tradesman.adapter.context_for_entity(args[:parent])
           @parent_key = args[:parent]
@@ -19,14 +20,26 @@ module Tradesman
 
           private
 
-          def execute(params)
-            parent = self.class.parent_adapter.get!(params[:parent_id])
-            self.class.adapter.create!(params.except(:parent_id).merge(relation_id => parent.id))
+          def execute_single(params)
+            parent = self.class.parent_adapter.get!(params[:id])
+            self.class.adapter.create!(params.except(:id).merge(relation_id => parent.id))
           end
 
           def relation_id
             "#{self.class.parent_key}_id"
           end
+
+          def execute_multiple(params_hash)
+            params = params_hash[:params] || params_hash.except(:id)
+
+            params.map do |params|
+              begin
+                execute_single({ id: params_hash[:id] }.merge(params))
+              rescue *self.class.expected_errors_map.keys => e
+                Horza::Entities::Single.new(id: params[:id], valid: false, message: e.message)
+              end
+            end
+          end
         end
       end
     end

data/lib/tradesman/builders/delete.rb

@@ -5,11 +5,22 @@ module Tradesman
 
       def template_class(args)
         Class.new(::Tradesman::Template) do
+          include ::Tradesman::ExistingRecordsMultipleExecute
           @store = Tradesman.adapter.context_for_entity(args[:subject])
 
+          class << self
+            def go(obj, *context, &block)
+              run_and_convert_exceptions { run(tzu_params(obj, {}), *context, &block) }
+            end
+
+            def go!(obj, *context)
+              run_and_convert_exceptions { run!(tzu_params(obj, {}), *context) }
+            end
+          end
+
           private
 
-          def execute(params)
+          def execute_single(params)
             self.class.adapter.delete!(params[:id])
           end
         end

data/lib/tradesman/builders/update.rb

@@ -5,11 +5,12 @@ module Tradesman
 
       def template_class(args)
         Class.new(::Tradesman::Template) do
+          include ::Tradesman::ExistingRecordsMultipleExecute
           @store = Tradesman.adapter.context_for_entity(args[:subject])
 
           private
 
-          def execute(params)
+          def execute_single(params)
             self.class.adapter.update!(params[:id], params.except(:id))
           end
         end

data/lib/tradesman/class_methods.rb

@@ -0,0 +1,37 @@
+module Tradesman
+  module ClassMethods
+    attr_reader :store
+
+    def adapter
+      Tradesman.adapter.new(store)
+    end
+
+    def go(obj, params, *context, &block)
+      run_and_convert_exceptions { run(tzu_params(obj, params), *context, &block) }
+    end
+
+    def go!(obj, params, *context)
+      run_and_convert_exceptions { run!(tzu_params(obj, params), *context) }
+    end
+
+    def tzu_params(obj, params)
+      { id: prepare_ids(obj) }.merge(prepare_params(params))
+    end
+
+    def prepare_ids(obj)
+      return id_from_obj(obj) unless obj.is_a? Array
+      obj.map { |object| id_from_obj(object) }
+    end
+
+    def id_from_obj(obj)
+      return obj.id if obj.respond_to? :id
+      raise Tradesman::InvalidId.new('ID must be an integer') unless obj.is_a? Integer
+      obj
+    end
+
+    def prepare_params(params)
+      return params unless params.is_a? Array
+      { params: params }
+    end
+  end
+end

data/lib/tradesman/configuration.rb

@@ -14,7 +14,7 @@ module Tradesman
     end
 
     def adapter
-      raise ::Tradesman::Errors::Base.new('Adapter has not been configured') unless configuration.adapter
+      raise ::Tradesman::Base.new('Adapter has not been configured') unless configuration.adapter
       @adapter ||= configuration.adapter
     end
   end
@@ -32,7 +32,7 @@ module Tradesman
     end
 
     def namespaces=(namespaces)
-      fail Tradesman::Errors::Base.new 'namespaces must be an array' unless namespaces.is_a? Array
+      fail Tradesman::Base.new 'namespaces must be an array' unless namespaces.is_a? Array
       Horza.configure { |config| config.namespaces = namespaces }
       @namespaces = namespaces
     end

data/lib/tradesman/error_handling.rb

@@ -0,0 +1,32 @@
+module Tradesman
+  module ErrorHandling
+    def run_and_convert_exceptions(&block)
+      block.call
+    rescue *expected_errors_map.keys => e
+      raise tradesman_error_from_gem_error(e.class)
+    end
+
+    def tradesman_error_from_gem_error(gem_error)
+      expected_errors_map[gem_error]
+    end
+
+    def expected_errors_map
+      expected_tzu_errors_map.merge(expected_horza_errors_map)
+    end
+
+    def expected_tzu_errors_map
+      {
+        Tzu::Invalid => Tradesman::Invalid,
+        Tzu::Failure => Tradesman::Failure,
+      }
+    end
+
+    def expected_horza_errors_map
+      {
+        Horza::Errors::RecordNotFound => Tradesman::RecordNotFound,
+        Horza::Errors::RecordInvalid => Tradesman::RecordInvalid,
+        Horza::Errors::UnknownAttributeError => Tradesman::UnknownAttributeError
+      }
+    end
+  end
+end

data/lib/tradesman/errors.rb

@@ -1,12 +1,25 @@
 module Tradesman
-  module Errors
-    class Base < StandardError
-    end
+  class Base < StandardError
+  end
+
+  class MethodNotImplemented < StandardError
+  end
+
+  class InvalidId < StandardError
+  end
+
+  class Invalid < StandardError
+  end
+
+  class Failure < StandardError
+  end
 
-    class MethodNotImplemented < StandardError
-    end
+  class RecordNotFound < StandardError
+  end
+
+  class RecordInvalid < StandardError
+  end
 
-    class RecordNotFound < StandardError
-    end
+  class UnknownAttributeError < StandardError
   end
 end

data/lib/tradesman/mixins/existing_records_multiple_execute.rb

@@ -0,0 +1,26 @@
+module Tradesman
+  module ExistingRecordsMultipleExecute
+    private
+
+    def execute_multiple(params_hash)
+      params = params_hash[:params] || params_hash.except(:id)
+
+      params_hash[:id].to_enum.with_index.map do |id, index|
+        begin
+          execute_single(single_params(id, params, index))
+        rescue *self.class.expected_errors_map.keys => e
+          Horza::Entities::Single.new(id: id, valid: false, message: e.message)
+        end
+      end
+    end
+
+    def single_params(id, params, index)
+      { id: id }.merge(params_at_index(params, index))
+    end
+
+    def params_at_index(params, index)
+      return params unless params.is_a? Array
+      params[index]
+    end
+  end
+end

data/lib/tradesman/mixins/new_records_multiple_execute.rb

@@ -0,0 +1,15 @@
+module Tradesman
+  module NewRecordsMultipleExecute
+    private
+
+    def execute_multiple(params_array)
+      params_array.map do |params|
+        begin
+          execute_single(params)
+        rescue *self.class.expected_errors_map.keys => e
+          Horza::Entities::Single.new(id: nil, valid: false, message: e.message)
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/template.rb

@@ -2,25 +2,24 @@ module Tradesman
   class Template
     include ::Tzu
     include ::Tzu::Validation
-
-    class << self
-      attr_reader :store
-
-      def adapter
-        Tradesman.adapter.new(store)
-      end
-    end
+    extend ::Tradesman::ClassMethods
+    extend ::Tradesman::ErrorHandling
 
     def call(params)
-      execute(params)
-    rescue Horza::Errors::RecordInvalid, Horza::Errors::RecordNotFound => e
+      return execute_single(params) unless (params.is_a?(Array) || params[:id].is_a?(Array) || params[:params].is_a?(Array))
+      execute_multiple(params)
+    rescue *self.class.expected_horza_errors_map.keys => e
       invalid! e
     end
 
     private
 
-    def execute(params)
-      raise Tradesman::Errors::MethodNotImplemented.new
+    def execute_single(params)
+      raise Tradesman::MethodNotImplemented.new('You must implement execute_single in a child class')
+    end
+
+    def execute_multiple(params_hash)
+      raise Tradesman::MethodNotImplemented.new('You must implement execute_multiple in a child class')
     end
   end
 end

data/lib/tradesman.rb

@@ -1,44 +1,30 @@
 require 'horza'
 require 'tzu'
+require 'tradesman/mixins/existing_records_multiple_execute'
+require 'tradesman/mixins/new_records_multiple_execute'
 require 'tradesman/builders'
 require 'tradesman/builders/base'
 require 'tradesman/builders/create'
 require 'tradesman/builders/create_for_parent'
 require 'tradesman/builders/delete'
 require 'tradesman/builders/update'
+require 'tradesman/class_methods'
 require 'tradesman/configuration'
 require 'tradesman/errors'
+require 'tradesman/error_handling'
 require 'tradesman/parser'
-require 'tradesman/run_methods'
 require 'tradesman/template'
 
 module Tradesman
-  extend Tradesman::Configuration
+  extend Configuration
 
   class << self
     attr_writer :configuration
 
-    def included(base)
-      base.class_eval do
-        extend ::Tradesman::RunMethods
-      end
-    end
-
     def const_missing(class_name)
       parser = ::Tradesman::Parser.new(class_name)
       return super(class_name) unless parser.match?
       Builders.generate_class(parser)
     end
   end
-
-  def run
-    run!
-  rescue ::Tradesman::Errors::Base
-  end
-
-  def run!
-    call
-  rescue *Tradesman.adapter.expected_errors => e
-    raise ::Tradesman::Errors::Base.new(e.message)
-  end
 end

data/spec/tradesman_spec.rb

@@ -51,7 +51,7 @@ describe Tradesman do
       after { Tradesman.reset }
 
       it 'throws error' do
-        expect { Tradesman.adapter }.to raise_error(Tradesman::Errors::Base)
+        expect { Tradesman.adapter }.to raise_error(Tradesman::Base)
       end
     end
   end
@@ -90,10 +90,10 @@ describe Tradesman do
     end
   end
 
-  context '#run' do
+  context '#go' do
     context 'Create' do
       context 'when parameters are valid' do
-        let(:outcome) { Tradesman::CreateUser.run(last_name: 'Turner') }
+        let(:outcome) { Tradesman::CreateUser.go(last_name: 'Turner') }
 
         it 'creates a new record' do
           expect(outcome.success?).to be true
@@ -106,16 +106,47 @@ describe Tradesman do
       end
 
       context 'when parameters are invalid' do
-        let(:outcome) { Tradesman::CreateStrictUser.run(first_name: 'Turner') }
+        let(:outcome) { Tradesman::CreateStrictUser.go(first_name: 'Turner') }
         it 'returns an invalid outcome' do
           expect(outcome.success?).to be false
           expect(outcome.type).to eq :validation
         end
       end
 
+      context 'multiple records' do
+        let(:outcome) { Tradesman::CreateStrictUser.go(param_list) }
+        context 'when all are valid' do
+          let(:param_list) { [{ last_name: 'Turner' }, { last_name: 'Smith' }, { last_name: 'Jones' }] }
+
+          it 'creates one record for each parameter set passed' do
+            expect(outcome.result.length).to eq param_list.length
+            outcome.result.each do |record|
+              expect(record.id.present?).to be true
+            end
+          end
+        end
+
+        context 'when one is valid' do
+          let(:param_list) { [{ first_name: 'Turner' }, { last_name: 'Smith' }, { age: 25 }] }
+
+          it 'creates invalid entities when params are invalid, valid entity otherwise' do
+            entities = outcome.result
+            expect(entities.length).to eq param_list.length
+
+            expect(entities.first.id).to be nil
+            expect(entities.first.valid?).to be false
+
+            expect(entities.second.id.is_a? Integer).to be true
+
+            expect(entities.third.id).to be nil
+            expect(entities.third.valid?).to be false
+          end
+        end
+      end
+
       context 'for parent' do
         let(:employer) { TradesmanSpec::Employer.create }
-        let(:outcome) { Tradesman::CreateUserForEmployer.run(parent_id: employer.id, last_name: 'Turner') }
+        let(:outcome) { Tradesman::CreateUserForEmployer.go(employer.id, last_name: 'Turner') }
 
         it 'creates a new record' do
           expect(outcome.success?).to be true
@@ -130,6 +161,38 @@ describe Tradesman do
           outcome
           expect(employer.users.first.id).to eq outcome.result.id
         end
+
+        context 'multiple records' do
+          let(:employer) { Tradesman::CreateEmployer.go({}).result }
+          let(:outcome) { Tradesman::CreateStrictUserForEmployer.go(employer, param_list) }
+          context 'when all are valid' do
+            let(:param_list) { [{ last_name: 'Turner' }, { last_name: 'Smith' }, { last_name: 'Jones' }] }
+
+            it 'creates one record for each parameter set passed' do
+              expect(outcome.result.length).to eq param_list.length
+              outcome.result.each do |record|
+                expect(record.id.present?).to be true
+              end
+            end
+          end
+
+          context 'when one is valid' do
+            let(:param_list) { [{ first_name: 'Turner' }, { last_name: 'Smith' }, { age: 25 }] }
+
+            it 'creates invalid entities when params are invalid, valid entity otherwise' do
+              entities = outcome.result
+              expect(entities.length).to eq param_list.length
+
+              expect(entities.first.id).to be nil
+              expect(entities.first.valid?).to be false
+
+              expect(entities.second.id.is_a? Integer).to be true
+
+              expect(entities.third.id).to be nil
+              expect(entities.third.valid?).to be false
+            end
+          end
+        end
       end
     end
   end
@@ -137,7 +200,7 @@ describe Tradesman do
   context 'Update' do
     let(:user) { TradesmanSpec::User.create(last_name: 'Smith') }
     context 'when parameters are valid' do
-      let(:outcome) { Tradesman::UpdateUser.run(id: user.id, last_name: 'Turner') }
+      let(:outcome) { Tradesman::UpdateUser.go(user.id, last_name: 'Turner') }
 
       it 'executes successfully' do
         expect(outcome.success?).to be true
@@ -151,19 +214,165 @@ describe Tradesman do
 
     context 'when parameters are invalid' do
       let(:strict_user) { TradesmanSpec::StrictUser.create(last_name: 'Smith') }
-      let(:outcome) { Tradesman::UpdateStrictUser.run(id: strict_user.id, last_name: nil) }
+      let(:outcome) { Tradesman::UpdateStrictUser.go(strict_user, last_name: nil) }
+
+      it 'returns an invalid outcome' do
+        expect(outcome.success?).to be false
+        expect(outcome.type).to eq :validation
+      end
+    end
+
+    context 'when id is invalid' do
+      it 'throws error' do
+        expect { Tradesman::UpdateStrictUser.go('not_an_integer', last_name: nil) }.to raise_error Tradesman::InvalidId
+      end
+    end
+
+    context 'multiple records' do
+      let(:valid_params) { { last_name: 'Turner' } }
+      let(:outcome) { Tradesman::UpdateStrictUser.go(records, params) }
+
+      # Hash of id => params
+      # Tradesman::UpdateStrictUser.go(hash.keys, hash.values)
 
+      context 'passing array of ids and one valid parameter set' do
+        let(:records) { Tradesman::CreateStrictUser.go([valid_params, valid_params, valid_params]).result }
+        let(:params) { { last_name: 'Smith' } }
+
+        it 'creates one record for each parameter set passed' do
+          expect(outcome.result.length).to eq records.length
+          outcome.result.each do |record|
+            expect(record.last_name).to eq 'Smith'
+            expect(record.id.present?).to be true
+          end
+        end
+      end
+
+      context 'passing array of ids and multiple valid parameters' do
+        let(:records) { Tradesman::CreateStrictUser.go([valid_params, valid_params, valid_params]).result }
+        let(:params) { [{ last_name: 'Smith' }, { last_name: 'Williams' }, { last_name: 'Jones' }] }
+
+        it 'creates one record for each parameter set passed' do
+          results = outcome.result
+          expect(results.length).to eq records.length
+          expect(results.first.last_name).to eq params.first[:last_name]
+          expect(results.second.last_name).to eq params.second[:last_name]
+          expect(results.last.last_name).to eq params.last[:last_name]
+        end
+      end
+    end
+  end
+
+  context 'Delete' do
+    context 'when parameters are valid' do
+      let!(:user) { TradesmanSpec::User.create }
+      let(:outcome) { Tradesman::DeleteUser.go(user) }
+
+      it 'executes successfully' do
+        expect(outcome.success?).to be true
+        expect(outcome.result).to be true
+      end
+
+      it 'deletes record' do
+        expect { outcome }.to change(TradesmanSpec::User, :count).by(-1)
+      end
+    end
+
+    context 'when input parameters are invalid' do
+      let(:outcome) { Tradesman::DeleteUser.go(999) }
       it 'returns an invalid outcome' do
         expect(outcome.success?).to be false
         expect(outcome.type).to eq :validation
       end
     end
+
+    context 'multiple records' do
+      let(:valid_params) { { last_name: 'Turner' } }
+      let(:outcome) { Tradesman::DeleteStrictUser.go(records) }
+
+      context 'passing array of ids' do
+        let(:records) { Tradesman::CreateStrictUser.go([valid_params, valid_params, valid_params]).result }
+
+        it 'deletes all records' do
+          expect(outcome.result.length).to eq records.length
+          expect(outcome.result.uniq.first).to eq true
+        end
+      end
+    end
+  end
+
+  context '#go!' do
+    context 'Create' do
+      context 'when parameters are valid' do
+        let(:outcome) { Tradesman::CreateUser.go!(last_name: 'Turner') }
+
+        it 'creates a new record' do
+          expect(outcome.success?).to be true
+          expect(outcome.result.id.is_a? Integer).to be true
+        end
+
+        it 'returns Horza Entity' do
+          expect(outcome.result.is_a? Horza::Entities::Single).to be true
+        end
+      end
+
+      context 'when parameters are invalid' do
+        let(:outcome) { Tradesman::CreateStrictUser.go!({}) }
+        it 'throws error' do
+          expect { outcome }.to raise_error Tradesman::Invalid
+        end
+      end
+
+      context 'for parent' do
+        let(:employer) { TradesmanSpec::Employer.create }
+        let(:outcome) { Tradesman::CreateUserForEmployer.go!(employer.id, last_name: 'Turner') }
+
+        it 'creates a new record' do
+          expect(outcome.success?).to be true
+          expect(outcome.result.id.is_a? Integer).to be true
+        end
+
+        it 'associates child with parent' do
+          expect(outcome.result.employer_id).to eq employer.id
+        end
+
+        it 'associates parent with child' do
+          outcome
+          expect(employer.users.first.id).to eq outcome.result.id
+        end
+      end
+    end
+  end
+
+  context 'Update' do
+    let(:user) { TradesmanSpec::User.create(last_name: 'Smith') }
+    context 'when parameters are valid' do
+      let(:outcome) { Tradesman::UpdateUser.go!(user.id, last_name: 'Turner') }
+
+      it 'executes successfully' do
+        expect(outcome.success?).to be true
+      end
+
+      it 'updates record' do
+        expect(outcome.result.last_name).to eq 'Turner'
+        expect(user.reload.last_name).to eq 'Turner'
+      end
+    end
+
+    context 'when parameters are invalid' do
+      let(:strict_user) { TradesmanSpec::StrictUser.create(last_name: 'Smith') }
+      let(:outcome) { Tradesman::UpdateStrictUser.go!(strict_user, last_name: nil) }
+
+      it 'throws error' do
+        expect { outcome }.to raise_error Tradesman::Invalid
+      end
+    end
   end
 
   context 'Delete' do
     context 'when parameters are valid' do
       let!(:user) { TradesmanSpec::User.create }
-      let(:outcome) { Tradesman::DeleteUser.run(id: user.id) }
+      let(:outcome) { Tradesman::DeleteUser.go!(user) }
 
       it 'executes successfully' do
         expect(outcome.success?).to be true
@@ -176,7 +385,7 @@ describe Tradesman do
     end
 
     context 'when input parameters are invalid' do
-      let(:outcome) { Tradesman::DeleteUser.run(id: 999) }
+      let(:outcome) { Tradesman::DeleteUser.go(999) }
       it 'returns an invalid outcome' do
         expect(outcome.success?).to be false
         expect(outcome.type).to eq :validation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tradesman
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Blake Turner
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2015-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: horza
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.3
+        version: 0.3.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.3
+        version: 0.3.5
 - !ruby/object:Gem::Dependency
   name: tzu
   requirement: !ruby/object:Gem::Requirement
@@ -138,10 +138,13 @@ files:
 - lib/tradesman/builders/create_for_parent.rb
 - lib/tradesman/builders/delete.rb
 - lib/tradesman/builders/update.rb
+- lib/tradesman/class_methods.rb
 - lib/tradesman/configuration.rb
+- lib/tradesman/error_handling.rb
 - lib/tradesman/errors.rb
+- lib/tradesman/mixins/existing_records_multiple_execute.rb
+- lib/tradesman/mixins/new_records_multiple_execute.rb
 - lib/tradesman/parser.rb
-- lib/tradesman/run_methods.rb
 - lib/tradesman/template.rb
 - spec/builders_spec.rb
 - spec/parser_spec.rb

data/lib/tradesman/run_methods.rb

@@ -1,11 +0,0 @@
-module Tradesman
-  module RunMethods
-    def run(*context)
-      new(*context).run
-    end
-
-    def run!(*context)
-      new(*context).run!
-    end
-  end
-end