shamu 0.0.1 → 0.0.2

data/spec/lib/shamu/services/active_record_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "shamu/services"
+require "shamu/services/active_record"
+
+describe Shamu::Services::ActiveRecord do
+  use_active_record
+
+  let( :klass ) do
+    Class.new( Shamu::Services::Service ) do
+      include Shamu::Services::ActiveRecord
+      public :wrap_not_found, :scope_relation, :with_transaction
+    end
+  end
+  let( :service ) { scorpion.new klass }
+
+  describe "#wrap_not_found" do
+    it "re-raises AR not found as shamu not found" do
+      expect do
+        service.wrap_not_found do
+          raise ActiveRecord::RecordNotFound
+        end
+      end.to raise_error Shamu::NotFoundError
+    end
+  end
+
+  describe "#scope_relation" do
+
+    it "short-circuits if no relation" do
+      expect( service.scope_relation( nil, nil ) ).to be_nil
+    end
+
+    it "invokes by_list_scope if available" do
+      scope    = ActiveRecordSpec::FavoriteScope.new
+      relation = ActiveRecordSpec::Favorite.all
+
+      expect( relation ).to receive( :by_list_scope )
+      service.scope_relation( relation, scope )
+    end
+
+    it "it raises helpful error if relation isn't scopable" do
+      scope    = ActiveRecordSpec::FavoriteScope.new
+      relation = ActiveRecordSpec::Favorite.all
+
+      expect( relation ).to receive( :respond_to? ).and_return false
+
+      expect do
+        service.scope_relation( relation, scope )
+      end.to raise_error /by_list_scope/
+    end
+  end
+
+  describe "#with_transaction" do
+    it "returns the result on success" do
+      result = service.with_transaction do
+        Shamu::Services::Result.new
+      end
+
+      expect( result ).to be_a Shamu::Services::Result
+    end
+
+
+    it "returns the result on failure" do
+      result = service.with_transaction do
+        Shamu::Services::Result.new.tap do |r|
+          r.errors.add :base, "Failure"
+        end
+      end
+
+      expect( result ).to be_a Shamu::Services::Result
+      expect( result ).not_to be_valid
+    end
+
+    it "does not modify the database on failures" do
+      expect do
+        service.with_transaction do
+          ActiveRecordSpec::Favorite.create! name: "Example"
+          Shamu::Services::Result.new.tap do |r|
+            r.errors.add :base, "Failure"
+          end
+        end
+      end.not_to change( ActiveRecordSpec::Favorite, :count )
+    end
+
+    it "raises nested exceptions" do
+      expect do
+        service.with_transaction do
+          raise NotImplementedError
+        end
+      end.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/lib/shamu/services/lazy_association_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Shamu::Services::LazyAssociation do
+  it "calls block to look up association" do
+    assoc = double
+    expect( assoc ).to receive( :label )
+    lazy = Shamu::Services::LazyAssociation.new( 1 ) { assoc }
+    lazy.label
+  end
+
+  it "delegates ==" do
+    assoc = double
+    lazy = Shamu::Services::LazyAssociation.new( 1 ) { assoc }
+    expect( lazy ).to eq assoc
+  end
+
+  it "does not delegate id" do
+    assoc = double
+    expect( assoc ).not_to receive( :id )
+    lazy = Shamu::Services::LazyAssociation.new( 1 ) { assoc }
+    lazy.id
+  end
+
+  it "has the same class as original object" do
+    assoc = double
+    expect( assoc ).to receive( :to_entity ).and_return assoc
+    lazy = Shamu::Services::LazyAssociation.new( 1 ) { assoc }
+
+    expect( lazy.to_entity ).to be_kind_of assoc.class
+  end
+end

data/spec/lib/shamu/services/lazy_transform_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe Shamu::Services::LazyTransform do
+  let( :source ) { [ 1, 2, 3 ] }
+
+  it "short-circuits count" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      expect( transformed.count ).to eq source.count
+    end.not_to yield_control
+  end
+
+  it "delegates when count has an arg" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      expect( transformed.count( 1000 ) ).to eq 0
+    end.to yield_control
+  end
+
+  it "delegates when count has a block given" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      expect( transformed.count { true } ).to eq source.count
+    end.to yield_control
+  end
+
+  it "short-circuits first" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.first
+    end.to yield_control.once
+  end
+
+  it "doesn't short-circuit first(n)" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.first( 2 )
+    end.to yield_control.exactly(3)
+  end
+
+  it "short-circuits empty?" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      expect( transformed ).not_to be_empty
+    end.not_to yield_control
+  end
+
+  it "short-circuits present?" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.present?
+    end.not_to yield_control
+  end
+
+  it "transforms when enumerated" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.to_a
+    end.to yield_control.exactly( 3 )
+  end
+
+  it "yields transformed values" do
+    transformed = Shamu::Services::LazyTransform.new( source ) { |v| v * v }
+    expect( transformed.to_a ).to eq [ 1, 4, 9 ]
+  end
+
+  it "short-circuits drop" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.drop( 2 ).to_a
+    end.to yield_control.exactly( 1 )
+  end
+
+  it "uses existing transformed on drop if avaialable" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.to_a
+      transformed.drop( 2 ).to_a
+    end.to yield_control.exactly( 3 )
+  end
+
+  it "short-circuits take" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.take( 2 ).to_a
+    end.to yield_control.exactly( 2 )
+  end
+
+  it "users existing transformed on take if avaialable" do
+    expect do |block|
+      transformed = Shamu::Services::LazyTransform.new( source, &block )
+      transformed.to_a
+      transformed.take( 2 ).to_a
+    end.to yield_control.exactly( 3 )
+  end
+end

data/spec/lib/shamu/services/request_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+
+describe Shamu::Services::Request do
+  describe ".model_name" do
+    {
+      "Users::UserRequest::Create" => "Users::User",
+      "Users::UserRequest::New" => "Users::User",
+      "Users::UserRequest::Change" => "Users::User",
+      "Users::UserRequest::Update" => "Users::User",
+      "Users::Request::Change" => "Users::User",
+      "Users::FavoritesUpdate" => "Users::Favorite",
+      "Users::FavoritesCreate" => "Users::Favorite",
+      "Users::FavoritesChange" => "Users::Favorite",
+      "Users::FavoritesNew" => "Users::Favorite",
+      "UserUpdateRequest" => "User"
+    }.each do |name, model_name|
+      it "formats '#{ name }' as '#{ model_name }'" do
+        klass = Class.new( Shamu::Services::Request )
+        klass.define_singleton_method :name do
+          name
+        end
+
+        expect( klass.model_name.name ).to eq model_name
+      end
+    end
+  end
+
+  describe "#apply_to" do
+    let( :klass ) do
+      Class.new( Shamu::Services::Request ) do
+        attribute :name
+        attribute :label
+      end
+    end
+    let( :request ) { klass.new name: "Example" }
+
+    it "returns the model" do
+      model = double
+      expect( Shamu::Services::Request.new.apply_to( model ) ).to be model
+    end
+
+    it "assigns attributes that have been set" do
+      model = double( name: "", label: "" )
+      expect( model ).to receive( :name= ).with( any_args )
+
+      request.apply_to( model )
+    end
+
+    it "skips attributes that haven't been set" do
+      model = double( name: "", label: "" )
+      expect( model ).not_to receive( :label= )
+
+      request.apply_to( model )
+    end
+  end
+
+end

data/spec/lib/shamu/services/request_support_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+require "shamu/services"
+
+module RequestSupportSpec
+  class Service < Shamu::Services::Service
+    include Shamu::Services::RequestSupport
+
+    def process( params )
+      with_request( params, Request::Change ) do |request|
+        request_hook
+        next error( :base, "nope" ) if request.level < 0
+
+        record = OpenStruct.new( request.to_attributes )
+        scorpion.fetch RequestSupportSpec::Entity, { record: record }, {}
+      end
+    end
+
+    def request_hook
+    end
+
+  end
+
+  module Request
+    class Change < Shamu::Services::Request
+      attribute :level
+      attribute :amount, presence: true
+    end
+
+    class Custom < Change
+    end
+
+    class Create < Change
+    end
+
+    class Update < Change
+      attribute :id
+    end
+  end
+
+  class Entity < Shamu::Entities::Entity
+    model :record
+    attribute :id, on: :record
+    attribute :level, on: :record
+    attribute :amount, on: :record
+  end
+end
+
+describe Shamu::Services::RequestSupport do
+
+  let( :service ) { scorpion.new RequestSupportSpec::Service }
+
+  describe "#request_class" do
+
+    it "finds method specific class" do
+      expect( service.request_class( :custom ) ).to be RequestSupportSpec::Request::Custom
+    end
+
+    it "falls back to Change" do
+      expect( service.request_class( :open ) ).to be RequestSupportSpec::Request::Change
+    end
+
+    it "fails if no available class" do
+      expect do
+        Class.new( Shamu::Services::Service ) do
+          include Shamu::Services::RequestSupport
+        end.request_class( :change )
+      end.to raise_error Shamu::Services::IncompleteSetupError, /Request/
+    end
+
+    it "uses common alias fallback new -> create" do
+      expect( service.request_class( :new ) ).to be RequestSupportSpec::Request::Create
+    end
+
+    it "uses common alias fallback edit -> update" do
+      expect( service.request_class( :edit ) ).to be RequestSupportSpec::Request::Update
+    end
+
+    it "tries parent service namespace" do
+      klass = Class.new( RequestSupportSpec::Service )
+      expect( klass.request_class( :change ) ).to be RequestSupportSpec::Request::Change
+    end
+  end
+
+  describe "#with_request" do
+    let( :request_params ) { { level: 1, amount: 5 } }
+    let( :service ) { scorpion.new RequestSupportSpec::Service }
+
+    it "returns a Result" do
+      expect( service.process( request_params ) ).to be_a Shamu::Services::Result
+    end
+
+    it "returns validation errors" do
+      request_params.delete :amount
+      expect( service.process( request_params ) ).not_to be_valid
+    end
+
+    it "is valid without errors" do
+      expect( service.process( request_params ) ).to be_valid
+    end
+
+    it "yield with valid params" do
+      expect( service ).to receive( :request_hook )
+      service.process( request_params )
+    end
+
+    it "doesn't yield if params are invalid" do
+      request_params.delete :amount
+      expect( service ).not_to receive( :request_hook )
+      service.process( request_params )
+    end
+
+    it "captures returned entity into result" do
+      result = service.process( request_params )
+      expect( result.entity ).to be_a RequestSupportSpec::Entity
+    end
+
+    it "captures request_params into result" do
+      result = service.process( request_params )
+      expect( result.request ).to be_a RequestSupportSpec::Request::Change
+    end
+  end
+
+  describe "#request_for" do
+    it "returns request" do
+      request = service.request_for( :create )
+      expect( request ).to be_a Shamu::Services::Request
+    end
+  end
+end

data/spec/lib/shamu/services/result_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "shamu/services"
+
+describe Shamu::Services::Result do
+
+  it "detects Request in sources" do
+    request = Shamu::Services::Request.new
+    result  = Shamu::Services::Result.new request
+
+    expect( result.request ).to eq request
+  end
+
+  it "detects Entity in sources" do
+    entity = Shamu::Entities::Entity.new
+    result = Shamu::Services::Result.new entity
+
+    expect( result.entity ).to eq entity
+  end
+
+  it "copies errors from source" do
+    request = Shamu::Services::Request.new
+    request.errors.add :base, "something failed"
+    result  = Shamu::Services::Result.new request
+
+    expect( result ).not_to be_valid
+  end
+
+  it "doesn't set request if not found" do
+    result  = Shamu::Services::Result.new
+    expect( result.request ).to be_nil
+  end
+
+  it "doesn't set entity if not found" do
+    result  = Shamu::Services::Result.new
+    expect( result.entity ).to be_nil
+  end
+end