objectify 0.0.3 → 0.0.5

data/spec/config/context_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+require "objectify/config/context"
+
+describe "Objectify::Config::Context" do
+  before do
+    @policies = stub("Policies")
+    @policies_factory = stub("PoliciesFactory", :new => @policies)
+
+    @context = Objectify::Config::Context.new(@policies_factory)
+  end
+
+  context "appending policy responders" do
+    before do
+      @context.append_policy_responders :authenticated => :unauthenticated
+      @context.append_policy_responders :blocked_profile => :unauthorized
+    end
+    
+    it "is cumulative" do
+      responders = {:authenticated => :unauthenticated,
+                    :blocked_profile => :unauthorized}
+      @context.policy_responders.should == responders
+    end
+
+    it "retrieves responders by policy name" do
+      @context.policy_responder(:authenticated).should == :unauthenticated
+    end
+
+    it "raises an error when a responder is missing" do
+      f = lambda { @context.policy_responder(:missing) }
+      f.should raise_error
+    end
+  end
+
+  context "setting defaults" do
+    before do
+      @opts = {:policies => [:a, :b], :skip_policies => :c}
+      @context.append_defaults @opts
+    end
+    
+    it "uses the policies factory to create and store policies" do
+      @policies_factory.should have_received(:new).with(@opts)
+      @context.policies.should == @policies
+    end
+  end
+
+  context "appending actions" do
+    before do
+      @route = stub("Route")
+      @action = stub("Action", :route => @route)
+      @context.append_action(@action)
+    end
+
+    it "retrieves actions by route" do
+      @context.action(@route).should == @action
+    end
+
+    it "raises an error when no action for a route exists" do
+      lambda { @context.action(stub()) }.should raise_error
+    end
+  end
+  
+  context "when there are no default policies" do
+    before do
+      @context = Objectify::Config::Context.new
+    end
+
+    it "returns an empty policies objectify" do
+      @context.policies.policies.should be_empty
+      @context.policies.skip_policies.should be_empty
+    end
+  end
+
+  context "appending resolutions" do
+    before do
+      @locator = stub("ResolverLocator", :add => nil)
+      @context = Objectify::Config::Context.new(nil)
+      @context.locator = @locator
+      @context.append_resolutions :something => String.new
+    end
+
+    it "adds them to a locator it has" do
+      @locator.should have_received(:add).with(:something, String.new)
+    end
+  end
+
+  context "the legacy_action" do
+    before do
+      @action = stub("Action")
+      @action_factory = stub("ActionFactory", :new => @action)
+      @policies = stub("Policies")
+      @policies_factory = stub("PoliciesFactory", :new => @policies)
+      @route = stub("Route", :resource => :controller, :action => :action)
+
+      @context = Objectify::Config::Context.new(@policies_factory, @action_factory)
+    end
+
+    context "when there's no legacy action config" do
+      before do
+        @result = @context.legacy_action(@route)
+      end
+
+      it "creates a new action with the controller and action name and its policies" do
+        @action_factory.should have_received(:new).
+                                with(:controller, :action, {}, @policies)
+      end
+    end
+
+    context "when there is a legacy action config" do
+      before do
+        @action = stub("Action", :route => @route)
+        @context.append_action(@action)
+        @result = @context.legacy_action(@route)
+      end
+
+      it "returns the existing action" do
+        @result.should == @action
+      end
+    end
+  end
+
+  context "objectify_controller" do
+    it "defaults to objectify/rails/objectify" do
+      @context.objectify_controller.should == "objectify/rails/objectify"
+    end
+
+    it "is overridable" do
+      @context.objectify_controller = "asdf"
+      @context.objectify_controller.should == "asdf"
+    end
+
+    it "isn't affected by reloading" do
+      @context.objectify_controller = "asdf"
+      @context.reload
+      @context.objectify_controller.should == "asdf"
+    end
+  end
+end

data/spec/config/policies_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "objectify/config/policies"
+
+describe "Objectify::Config::Policies" do
+  before do
+    @opts = {:policies => [:a, :b, :c], :skip_policies => :b}
+    @policies = Objectify::Config::Policies.new(@opts)
+    @policies2 = Objectify::Config::Policies.new(:skip_policies => :c)
+  end
+
+  it "extracts the policies from the options" do
+    @policies.policies.should == [:a, :b, :c]
+  end
+
+  it "extracts the skip policies from the options" do
+    @policies.skip_policies.should == [:b]
+  end
+
+  it "can merge with hashes of policy configs (ignoring nils)" do
+    @policies.merge({:skip_policies => :c},
+                    {:policies => :b}, nil).should == [:a, :b]
+  end
+end

data/spec/executor_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "objectify/executor"
+
+describe "Objectify::Executor" do
+  before do
+    @instance = stub("Instance")
+    @instantiator = stub("Instantiator", :call => @instance)
+    @injector = stub("Injector", :call => true)
+    @executor = Objectify::Executor.new(@injector, @instantiator)
+  end
+
+  context "with a service" do
+    before do
+      @result = @executor.call(:some, :service)
+    end
+
+    it "creates an instance with the instantiator" do
+      @instantiator.should have_received(:call).with(:some, :service)
+    end
+
+    it "calls :call on the instance with the injector" do
+      @injector.should have_received(:call).with(@instance, :call)
+    end
+
+    it "returns the result of Injector#call" do
+      @result.should be_true
+    end
+  end
+
+  context "with a policy" do
+    before do
+      @result = @executor.call(:some, :policy)
+    end
+
+    it "creates an instance with the instantiator" do
+      @instantiator.should have_received(:call).with(:some, :policy)
+    end
+
+    it "calls :allowed? on the instance with the injector" do
+      @injector.should have_received(:call).with(@instance, :allowed?)
+    end
+
+    it "returns the result of Injector#call" do
+      @result.should be_true
+    end
+  end
+end

data/spec/injector_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+require "objectify/injector"
+
+describe "Objectify::Injector" do
+  class MyInjectedClass
+    attr_reader :some_dependency
+
+    def initialize(some_dependency)
+      @some_dependency = some_dependency
+    end
+
+    def call(some_dependency)
+      some_dependency
+    end
+
+    def requires_params(params)
+      params
+    end
+
+    def optional_arg(asdf=true)
+    end
+  end
+
+  # gotta use a fake resolver here because mocha sucks balls lolruby
+  class SimpleResolver
+    attr_accessor :name
+
+    def initialize(something)
+      @something = something
+    end
+
+    def call
+      @something
+    end
+  end
+
+  describe "the simple case" do
+    before do
+      @dependency       = stub("Dependency")
+      @resolver         = SimpleResolver.new(@dependency)
+      @resolver_locator = stub("ResolverLocator", :call => @resolver)
+      @injector         = Objectify::Injector.new(@resolver_locator)
+    end
+
+    it "can constructor inject based on method name using a simple resolver" do
+      @injector.call(MyInjectedClass, :new).some_dependency.should == @dependency
+    end
+
+    it "can method inject based on method name using a simple resolver" do
+      object = MyInjectedClass.new(nil)
+      @injector.call(object, :call).should == @dependency
+    end
+
+    it "calls the resolver_locator to get the resolver" do
+      @injector.call(MyInjectedClass, :new)
+      @resolver_locator.should have_received(:call).with(:some_dependency)
+    end
+
+    it "supports optional arguments" do
+      obj = MyInjectedClass.new("Asdf")
+      lambda { @injector.call(obj, :optional_arg) }.should_not raise_error
+    end
+  end
+
+  class ParamsResolver
+    def name
+      :params
+    end
+
+    def call
+      {:some => "params"}
+    end
+  end
+
+  context "recursive injection in to resolvers" do
+    before do
+      @resolver         = ParamsResolver.new
+      @resolver_locator = stub("ResolverLocator", :call => @resolver)
+      @injector         = Objectify::Injector.new(@resolver_locator)
+    end
+
+    it "can inject into resolvers" do
+      object = MyInjectedClass.new(nil)
+      @injector.call(object, :requires_params).should ==
+        {:some => "params"}
+    end
+  end
+end

data/spec/instantiator_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "objectify/instantiator"
+
+describe "Objectify::Instantiator" do
+  class MyService
+  end
+
+  before do
+    @service      = MyService.new
+    @injector     = stub("Injector", :call => @service)
+    @instantiator = Objectify::Instantiator.new(@injector)
+    @result       = @instantiator.call(:my, :service)
+  end
+
+  it "returns the result of injector#call" do
+    @result.should == @service
+  end
+
+  it "calls the injector with the generated constant" do
+    @injector.should have_received(:call).with(MyService, :new)
+  end
+end

data/spec/policy_chain_executor_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "objectify/policy_chain_executor"
+
+describe "Objectify::PolicyChainExecutor" do
+  before do
+    @policies       = [:x, :y, :z]
+    @action         = stub("Action", :policies => @policies)
+    @executor       = stub("Executor", :call => true)
+    @responder      = :an_responder
+    @context        = stub("Context", :policy_responder => @responder)
+
+    @chain_executor = Objectify::PolicyChainExecutor.new(@executor, @context)
+  end
+
+  context "when all the policies execute successfully" do
+    before do
+      @result = @chain_executor.call(@action)
+    end
+
+    it "calls each of the policies with the executor" do
+      @policies.each do |policy|
+        @executor.should have_received(:call).with(policy, :policy)
+      end
+    end
+
+    it "doesn't call any responders" do
+      @executor.should_not have_received(:call).with(anything, :responder)
+    end
+
+    it "returns true" do
+      @result.should be_true
+    end
+  end
+
+  context "when one of the policies returns false" do
+    before do
+      @executor.stubs(:call).with(:y, :policy).returns(false)
+      @result = @chain_executor.call(@action)
+    end
+
+    it "calls each of the policies with the executor" do
+      @policies[0..1].each do |policy|
+        @executor.should have_received(:call).with(policy, :policy)
+      end
+    end
+
+    it "doesn't call any the policies after the one that failed" do
+      @executor.should_not have_received(:call).with(:z, :policy)
+    end
+
+    it "fetches and calls the policy responder for that policy" do
+      @context.should have_received(:policy_responder).with(:y)
+      @executor.should have_received(:call).with(:an_responder, :responder)
+    end
+
+    it "returns false" do
+      @result.should be_false
+    end
+  end
+end

data/spec/rails/renderer_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "objectify/rails/renderer"
+
+describe "Objectify::Rails::Renderer" do
+  before do
+    @controller = stub("Controller", :render => nil,
+                                     :redirect_to => nil,
+                                     :instance_variable_set => nil) # yeah, well.
+    @renderer = Objectify::Rails::Renderer.new(@controller)
+  end
+
+  it "delegates template rendering" do
+    @renderer.template("something.html.erb", :some => :option)
+    @controller.should have_received(:render).with(:template => "something.html.erb",
+                                                   :some     => :option)
+  end
+
+  it "delegates action rendering" do
+    @renderer.action("something.html.erb", :some => :option)
+    @controller.should have_received(:render).with(:action => "something.html.erb",
+                                                   :some   => :option)
+  end
+
+  it "delegates partial rendering" do
+    @renderer.partial("something.html.erb", :some => :option)
+    @controller.should have_received(:render).with(:partial => "something.html.erb",
+                                                   :some    => :option)
+  end
+
+  it "delegates rendering nothing" do
+    @renderer.nothing(:some => :option)
+    @controller.should have_received(:render).with(:nothing => true,
+                                                   :some => :option)
+  end
+
+  it "exposes the full render method" do
+    @renderer.render(:json => "asdf")
+    @controller.should have_received(:render).with(:json => "asdf")
+  end
+
+  it "delegates the respond_to method" do
+    @responder = stub("Responder")
+    @responder.stubs(:html).yields
+    @controller.stubs(:respond_to).yields(@responder)
+
+    @renderer.respond_to do |format|
+      format.html { }
+    end
+
+    @responder.should have_received(:html)
+  end
+
+  it "delegates the redirect_to method" do
+    @renderer.redirect_to :somewhere
+    @controller.should have_received(:redirect_to).with(:somewhere)
+  end
+
+  it "can set the data on the controller" do
+    @renderer.data("asdf")
+    @controller.should have_received(:instance_variable_set).
+                        with(:@objectify_data, "asdf")
+  end
+end