scorpion-ioc 0.3.1 → 0.4.0

data/spec/lib/scorpion/hunt_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+
+module Test
+  module Hunt
+    class Logger; end
+
+    class Target
+      include ::Scorpion::Object
+
+      depend_on do
+        logger Logger, public: true
+        sailor Logger, public: true, lazy: true
+      end
+    end
+
+  end
+end
+
+describe Scorpion::Hunt do
+  
+  let( :scorpion ){ double Scorpion }
+  let( :hunt ){ Scorpion::Hunt.new scorpion, String, nil }
+
+  describe "#fetch_by_traits" do
+    it "changes context" do
+      expect( scorpion ).to receive( :execute ) do |hunt|
+        expect( hunt.contract ).to eq Regexp
+      end
+
+      hunt.fetch_by_traits Regexp, nil
+    end
+
+    it "restores context" do
+      expect( scorpion ).to receive( :execute )
+
+      hunt.fetch_by_traits Numeric, nil
+      expect( hunt.contract ).to eq String
+    end
+
+    it "finds matching argument in parent" do
+      hunt.arguments << "Hello"
+
+      expect( hunt.fetch String ).to eq "Hello"
+    end
+
+    it "finds matching argument in grandparent" do
+      hunt = Scorpion::Hunt.new scorpion, String, nil, "Hello"
+      hunt.send :push, Regexp, nil, [], nil
+
+      expect( scorpion ).to receive( :execute ) do |hunt|
+        next if hunt.contract == String
+
+        expect( hunt.fetch String ).to eq "Hello"
+      end.at_least(:once)
+
+      hunt.fetch Numeric
+    end
+  end
+
+  describe "#inject" do
+    let( :target )  do
+      Test::Hunt::Target.new
+    end
+
+    before( :each ) do
+      allow( scorpion ).to receive( :execute ) do |hunt|
+        Test::Hunt::Logger.new if hunt.contract == Test::Hunt::Logger
+      end
+    end
+
+    it "injects attributes" do
+      hunt.inject target
+
+      expect( target.logger? ).to be_truthy
+      expect( target.logger  ).to be_a Test::Hunt::Logger
+    end
+
+    it "does not overwrite existing attributes" do
+      logger = Test::Hunt::Logger.new
+      target.logger = logger
+      hunt.inject target
+
+      expect( target.logger ).to be logger
+    end
+
+    it "does not fetch lazy attributes" do
+      hunt.inject target
+      expect( target.sailor? ).to be_falsy
+    end
+  end
+
+end

data/spec/lib/scorpion/hunter_spec.rb

@@ -15,12 +15,35 @@ module Test
     class Implicit; end
 
     class Zoo
-      include Scorpion::King
+      include Scorpion::Object
 
-      feed_on do
+      depend_on do
         bear Bear
       end
     end
+
+    class City; end
+
+    class Park
+      include Scorpion::Object
+
+      depend_on do
+        city City
+      end
+
+      initialize( zoo: Test::Hunter::Zoo )
+    end
+
+    class City
+      include Scorpion::Object
+
+      depend_on do
+        park Park
+      end
+
+      initialize( zoo: Test::Hunter::Zoo )
+    end
+
   end
 end
 
@@ -39,36 +62,52 @@ describe Scorpion::Hunter do
     end
   end
 
-  it "spawns prey" do
-    expect( hunter.hunt Test::Hunter::Beast ).to be_a Test::Hunter::Beast
+  it "spawns dependency" do
+    expect( hunter.fetch Test::Hunter::Beast ).to be_a Test::Hunter::Beast
   end
 
   it "spawns a new instance for multiple requests" do
-    first = hunter.hunt Test::Hunter::Beast
-    expect( hunter.hunt Test::Hunter::Beast ).not_to be first
+    first = hunter.fetch Test::Hunter::Beast
+    expect( hunter.fetch Test::Hunter::Beast ).not_to be first
   end
 
-  it "spawns the same instance for captured prey" do
-    first = hunter.hunt_by_traits Test::Hunter::Beast, :tame
-    expect( hunter.hunt_by_traits Test::Hunter::Beast, :tame ).to be first
+  it "spawns the same instance for captured dependency" do
+    first = hunter.fetch_by_traits Test::Hunter::Beast, :tame
+    expect( hunter.fetch_by_traits Test::Hunter::Beast, :tame ).to be first
   end
 
-  it "injects nested kings" do
-    zoo = hunter.hunt Test::Hunter::Zoo
+  it "injects nested objects" do
+    zoo = hunter.fetch Test::Hunter::Zoo
     expect( zoo.bear ).to be_a Test::Hunter::Bear
   end
 
   it "accepts arguments that are passed to constructor" do
-    obj = hunter.hunt Test::Hunter::Argumented, :awesome
+    obj = hunter.fetch Test::Hunter::Argumented, :awesome
     expect( obj.arg ).to eq :awesome
   end
 
   it "implicitly spawns Class contracts" do
-    expect( hunter.hunt Test::Hunter::Implicit ).to be_a Test::Hunter::Implicit
+    expect( hunter.fetch Test::Hunter::Implicit ).to be_a Test::Hunter::Implicit
   end
 
   it "implicitly spawns Class contracts with empty traits" do
-    expect( hunter.hunt_by_traits Test::Hunter::Implicit, [] ).to be_a Test::Hunter::Implicit
+    expect( hunter.fetch_by_traits Test::Hunter::Implicit, [] ).to be_a Test::Hunter::Implicit
+  end
+
+  context "child dependencies" do
+    it "passes initializer args to child dependencies" do
+      zoo  = Test::Hunter::Zoo.new
+      city = hunter.fetch Test::Hunter::City, zoo
+
+      expect( city.park.zoo ).to be zoo
+    end
+
+    it "passes self to child dependencies" do
+      zoo  = Test::Hunter::Zoo.new
+      city = hunter.fetch Test::Hunter::City, zoo
+
+      expect( city.park.city ).to be city
+    end
   end
 
 end

data/spec/lib/scorpion/object_constructor_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Scorpion::ObjectConstructor do
+   it 'defined an initializer' do
+      klass = Class.new do
+        include Scorpion::Object
+
+        initialize logger: String
+      end
+
+      expect( klass.instance_method(:initialize).arity ).to eq 1
+    end
+
+    it "executes initializer code" do
+      expect do |b|
+        klass = Class.new do
+          include Scorpion::Object
+
+          initialize label: String, &b
+        end
+
+        klass.new "home"
+      end.to yield_control
+    end
+
+    it "creates an initializer that accepts a block" do
+      klass = Class.new do
+        include Scorpion::Object
+
+        initialize label: String do |&block|
+          block.call
+        end
+      end
+
+      expect do |b|
+        klass.new "apples", &b
+      end.to yield_control
+    end
+
+    it "it defines matching attributes" do
+      klass = Class.new do
+        include Scorpion::Object
+
+        initialize label: String
+      end
+
+      expect( klass.new( "apples" ).label ).to eq "apples"
+    end
+end

data/spec/lib/scorpion/object_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+module Test
+  module Object
+    class UserService; end
+    class Logger; end
+    class BackLogger; end
+    class ColorLogger; end
+
+    class Mamal
+      include Scorpion::Object
+
+      def initialize( family, parent = nil, options={}, &block )
+        @family    = family
+        @parent    = parent
+        @options   = inject_from! options
+
+
+        yield if block_given?
+      end
+
+      depend_on do
+        user_service Test::Object::UserService
+        logger       Test::Object::Logger
+        manager      Test::Object::Logger, public: true
+        executive_manager Test::Object::Logger, private: true
+      end
+
+      attr_accessor :family
+      attr_accessor :parent
+      attr_accessor :options
+    end
+
+    class Mouse < Mamal
+
+      depend_on do
+        cheese  Test::Object::Logger
+        logger  Test::Object::BackLogger
+      end
+      def initialize( options = {} )
+        super 'mouse', nil, options
+      end
+    end
+
+    class Bear < Mamal
+      depend_on do
+        logger Test::Object::ColorLogger
+      end
+    end
+
+  end
+end
+
+describe Scorpion::Object do
+
+  let( :scorpion ){ double Scorpion }
+  let( :hunt )    { double Scorpion::Hunt }
+
+  before( :each ) do
+    allow( scorpion ).to receive( :prepare )
+
+    allow( hunt ).to receive( :inject )
+    allow( hunt ).to receive( :scorpion ).and_return scorpion
+  end
+
+  describe ".spawn" do
+
+    it "can spawn" do
+      mamal = Test::Object::Mamal.spawn hunt, 'mouse', 'rodent', name: 'name'
+      expect( mamal ).to be_a Test::Object::Mamal
+    end
+
+    it "calls inject" do
+      expect( hunt ).to receive( :inject )
+      Test::Object::Mouse.spawn hunt
+    end
+
+    it "can inherit" do
+      mouse = Test::Object::Mouse.spawn hunt, name: 'name'
+      expect( mouse.family ).to eq 'mouse'
+      expect( mouse.options ).to include name: 'name'
+    end
+
+    it "yields to constructor" do
+      expect do |b|
+        Test::Object::Mouse.spawn hunt, name: 'name', &b
+      end.to yield_control
+    end
+
+    it "invokes on_injected" do
+      expect_any_instance_of( Test::Object::Mouse ).to receive( :on_injected )
+      Test::Object::Mouse.spawn hunt
+    end
+  end
+
+  describe "accessors" do
+    let( :object ) do
+      Test::Object::Mamal.spawn hunt, 'harry', 'jim', name: 'name', manager: double
+    end
+
+    subject{ object }
+
+    it "defines accessors" do
+      expect( object ).to     respond_to :user_service
+      expect( object ).not_to respond_to :user_service=
+    end
+
+    it "supports private reader" do
+      expect( object.respond_to? :executive_manager, false ).to be_falsy
+      expect( object.respond_to? :executive_manager, true ).to be_truthy
+    end
+
+    it "supports public writer" do
+      expect( object.respond_to? :manager=, false ).to be_truthy
+    end
+
+    describe "#attr_dependency" do
+      it "defines attributes" do
+        klass = Class.new do
+          include Scorpion::Object
+
+          attr_dependency :logger, Test::Object::Logger
+        end
+
+        expect( klass.new ).to respond_to :logger
+      end
+    end
+
+    describe  "inheritance" do
+      let( :object ) do
+        Test::Object::Mouse.spawn hunt
+      end
+
+      it "inherits attributes" do
+        expect( object.injected_attributes[:user_service].contract ).to be Test::Object::UserService
+      end
+
+      it "overrides attributes" do
+        expect( object.injected_attributes[:logger].contract ).to be Test::Object::BackLogger
+      end
+
+      it "doesn't effect other classes" do
+        expect( Test::Object::Bear.spawn( hunt, 'Yogi' ).injected_attributes[:logger].contract ).to be Test::Object::ColorLogger
+      end
+
+    end
+
+  end
+
+  describe "feasting" do
+    let( :logger )  { Test::Object::Logger.new }
+    let( :options ) { { manager: logger, color: :red } }
+    let( :object )    { Test::Object::Mouse.new name: 'mighty' }
+
+
+    describe "#inject_from" do
+      it "assigns attributes" do
+        object.send :inject_from, options
+        expect( object.manager ).to be logger
+      end
+
+      it "doesn't overwrite" do
+        object.manager = Test::Object::Logger.new
+        object.send :inject_from, options
+        expect( object.manager ).not_to be logger
+      end
+
+      it "overwrites when asked" do
+        object.manager = Test::Object::Logger.new
+        object.send :inject_from, options, true
+        expect( object.manager ).to be logger
+      end
+    end
+
+    describe "inject_from!" do
+      it "assigns attributes" do
+        object.send :inject_from!, options
+        expect( object.manager ).to be logger
+      end
+
+      it "doesn't overwrite" do
+        object.manager = Test::Object::Logger.new
+        object.send :inject_from!, options
+        expect( object.manager ).not_to be logger
+      end
+
+      it "overwrites when asked" do
+        object.manager = Test::Object::Logger.new
+        object.send :inject_from!, options, true
+        expect( object.manager ).to be logger
+      end
+
+      it "removes injected attributes" do
+        expect( options ).to have_key :manager
+        object.send :inject_from!, options
+        expect( options ).not_to have_key :manager
+      end
+
+      it "removes injected attribute even if already set" do
+        expect( options ).to have_key :manager
+        object.manager = Test::Object::Logger.new
+        object.send :inject_from!, options
+        expect( options ).not_to have_key :manager
+      end
+
+      it "doesn't remove other options" do
+        object.send :inject_from!, options
+        expect( options ).to have_key :color
+      end
+
+    end
+  end
+
+end

data/spec/lib/scorpion/rails/active_record/association_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Scorpion::Rails::ActiveRecord::Association, type: :model do
+  include Scorpion::Rspec::Helper
+
+  before( :each ) do
+    author = Author.create! name: "Pitbull"
+    todo   = Todo.create! name: "Be even more awesome", author: author
+  end
+
+  it "shares scorpion with associations" do
+    author = Author.with_scorpion( scorpion ).first
+    expect( author.todos.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with association results" do
+    author = Author.with_scorpion( scorpion ).first
+    expect( author.todos.first.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with single associations" do
+    todo = Todo.with_scorpion( scorpion ).first
+    expect( todo.author.scorpion ).to be scorpion
+  end
+
+end

data/spec/lib/scorpion/rails/active_record/model_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Scorpion::Rails::ActiveRecord::Model, type: :model do
+  include Scorpion::Rspec::Helper
+
+  before( :each ) do
+    author = Author.create! name: "Pitbull"
+    todo   = Todo.create! name: "Be even more awesome", author: author
+  end
+
+  it "shares scorpion with associations" do
+    author = Author.with_scorpion( scorpion ).first
+    expect( author.todos.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with single associations" do
+    todo = Todo.with_scorpion( scorpion ).first
+    expect( todo.author.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with custom scope" do
+    expect( Author.with_scorpion( scorpion ).named( "Pitbull" ).scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with custom scope results" do
+    expect( Author.with_scorpion( scorpion ).named( "Pitbull" ).first.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with custom scope extension results" do
+    expect( Author.with_scorpion( scorpion ).named( "Pitbull" ).alphabetical.first.scorpion ).to be scorpion
+  end
+
+end

data/spec/lib/scorpion/rails/active_record/relation_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'scorpion/rails'
+
+describe Scorpion::Rails::ActiveRecord::Relation, type: :model do
+  include Scorpion::Rspec::Helper
+
+  let( :criteria ) { Todo.with_scorpion( scorpion ) }
+
+  it "shares scorpion with fetched records" do
+    Todo.create! name: "Be awesome"
+
+    expect( criteria.first.scorpion ).to eq scorpion
+  end
+
+  it "shares scorpion with chained relations" do
+    expect( criteria.where( name: "" ).scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with new records" do
+    expect( criteria.new.scorpion ).to be scorpion
+    expect( criteria.build.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with new records builder block" do
+    criteria.new do |todo|
+      expect( todo.scorpion ).to be scorpion
+    end
+  end
+
+  it "shares scorpion with created records" do
+    expect( criteria.create.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with created records builder block" do
+    criteria.create do |todo|
+      expect( todo.scorpion ).to be scorpion
+    end
+  end
+
+  it "shares scorpion with created! records" do
+    expect( criteria.create!.scorpion ).to be scorpion
+  end
+
+  it "shares scorpion with created! records builder block" do
+    criteria.create! do |todo|
+      expect( todo.scorpion ).to be scorpion
+    end
+  end
+
+  context "find methods" do
+    let!( :todo ){ Todo.create! name: "Bill" }
+
+    it "shares scorpion with found records" do
+      expect( criteria.find( todo.id ).scorpion ).to be scorpion
+    end
+
+    it "shares scorpion with find_by records" do
+      expect( criteria.find_by( name: "Bill" ).scorpion ).to be scorpion
+    end
+
+    it "shares scorpion with first record" do
+      expect( criteria.first.scorpion ).to be scorpion
+    end
+
+    it "shares scorpion with enumerated records" do
+      criteria.each do |todo|
+        expect( todo.scorpion ).to be scorpion
+      end
+    end
+  end
+
+end

data/spec/lib/scorpion/rails/controller_spec.rb

@@ -12,14 +12,14 @@ describe Scorpion::Rails::Controller, type: :controller do
   controller ActionController::Base do
     include Scorpion::Rails::Controller
 
-    feed_on do
+    depend_on do
       service Test::Nest::Service
       cache   Test::Nest::Cache
     end
 
     def index
-      @guard1 = scorpion.hunt Test::Nest::Guard
-      @guard2 = scorpion.hunt Test::Nest::Guard
+      @guard1 = scorpion.fetch Test::Nest::Guard
+      @guard2 = scorpion.fetch Test::Nest::Guard
       render nothing: true
     end
   end
@@ -62,8 +62,8 @@ describe Scorpion::Rails::Controller, type: :controller do
 
     it "spawns the same service during the same request" do
       allow( subject ).to receive( :index ) do
-        service = subject.scorpion.hunt Test::Nest::Service
-        expect( subject.scorpion.hunt Test::Nest::Service ).to be service
+        service = subject.scorpion.fetch Test::Nest::Service
+        expect( subject.scorpion.fetch Test::Nest::Service ).to be service
         controller.render nothing: true
       end
 
@@ -74,7 +74,7 @@ describe Scorpion::Rails::Controller, type: :controller do
       service = subject.service
 
       allow( subject ).to receive( :index ) do
-        expect( subject.scorpion.hunt Test::Nest::Service ).not_to be service
+        expect( subject.scorpion.fetch Test::Nest::Service ).not_to be service
         controller.render nothing: true
       end
 
@@ -83,7 +83,7 @@ describe Scorpion::Rails::Controller, type: :controller do
 
     it "hunts for controller" do
       allow( subject ).to receive( :index ) do
-        expect( subject.scorpion.hunt( AbstractController::Base ) ).to be subject
+        expect( subject.scorpion.fetch( AbstractController::Base ) ).to be subject
         controller.render nothing: true
       end
 
@@ -92,7 +92,7 @@ describe Scorpion::Rails::Controller, type: :controller do
 
     it "hunts for response" do
       allow( subject ).to receive( :index ) do
-        expect( subject.scorpion.hunt( ActionDispatch::Response ) ).to be subject.response
+        expect( subject.scorpion.fetch( ActionDispatch::Response ) ).to be subject.response
         controller.render nothing: true
       end
 
@@ -101,7 +101,7 @@ describe Scorpion::Rails::Controller, type: :controller do
 
     it "hunts for request" do
       allow( subject ).to receive( :index ) do
-        expect( subject.scorpion.hunt( ActionDispatch::Request ).object_id ).to be subject.request.object_id
+        expect( subject.scorpion.fetch( ActionDispatch::Request ).object_id ).to be subject.request.object_id
         controller.render nothing: true
       end
 

data/spec/lib/scorpion/rails/job_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Test
+  module Job
+    class Compass
+      def directions; end
+    end
+
+    class Journey < ActiveJob::Base
+      include Scorpion::Rails::Job
+
+      depend_on do
+        compass Test::Job::Compass
+      end
+
+      def perform
+        compass.directions
+      end
+    end
+  end
+end
+
+describe Scorpion::Rails::Job do
+  it "perform has been feed" do
+    compass = Test::Job::Compass.new
+
+    Test::Job::Journey.scorpion_nest do |hunter|
+      hunter.hunt_for Test::Job::Compass, return: compass
+    end
+
+    expect( compass ).to receive( :directions )
+    Test::Job::Journey.perform_now
+  end
+end