orange-more 0.5.7

data/spec/orange-core/resource_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Orange::Resource do
+  it "should allow options" do
+    r= Orange::Resource.new(:opt_1 => true){ opt_2 true }
+    r.options[:opt_1].should == true
+    r.options[:opt_2].should == true
+    r.options.should have_key(:opt_1)
+    r.options.should_not have_key(:opt_3)
+  end
+  
+  it "should accept an orange core on set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange.should equal(c)
+    r.orange.should be_a_kind_of(Orange::Core)
+  end
+  
+  it "should call afterLoad after calling set_orange" do
+    c= Orange::Core.new 
+    r= MockResource.new
+    r.options.should_not have_key(:mocked)
+    r.set_orange(c, :name)
+    r.options.should have_key(:mocked)
+    r.options[:mocked].should == true
+  end
+  
+  it "should set the orange_name after calling set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r2= Orange::Resource.new
+    r.set_orange(c, :name)
+    r2.set_orange(c, 'name')
+    r.orange_name.should == :name
+    r2.orange_name.should_not == :name
+    r2.orange_name.should == 'name'
+  end
+  
+  it "should return self after set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    me = r.set_orange(c, :name)
+    me.should equal r
+  end
+  
+  it "should register for stack_loaded iff stack_init method present" do
+    c = Orange::Core.new
+    c.should_receive(:register).with(:stack_loaded).once
+    mid1 = c.load MockResource.new
+    mid2 = c.load MockResourceTwo.new
+  end
+  
+  it "should return an error if setting orange on a class" do
+    lambda {
+      Orange::Resource.set_orange(Orange::Core.new, :mock)
+    }.should raise_error(RuntimeError, "instantiate the resource before calling set orange")
+  end
+  
+  it "should give access to the core through orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange.should equal(c)
+    r.orange.should be_a_kind_of(Orange::Core)
+  end
+  
+  it "should respond to routable" do
+    r = Orange::Resource.new
+    r.should respond_to(:routable)
+    r.routable.should be_false
+  end
+  
+  it "should return an empty string on calling view" do
+    r = Orange::Resource.new
+    r.view.should == ''
+    r.view(Orange::Packet.new(Orange::Core.new, {})).should == ''
+  end
+  
+  it "should accept an options hash to view" do
+    p = Orange::Packet.new(Orange::Core.new, {})
+    r = Orange::Resource.new
+    lambda{
+      r.view(p, :opts => 'foo', :test => 'bar')
+    }.should_not raise_error
+  end
+  
+  it "should give access to the orange name attribute" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange_name.should == :name
+  end
+  
+  
+end

data/spec/orange-core/resources/mapper_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Orange::Mapper do
+  it "should be spec'ed" 
+end

data/spec/orange-core/resources/model_resource_spec.rb

@@ -0,0 +1,246 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Orange::ModelResource do
+
+  it "should extend class inheritable attributes" do
+    Orange::ModelResource.should be_a_kind_of(ClassInheritableAttributes)
+  end
+  
+  it "should have a model class when calling use" do
+    a = MockModelResourceOne.new
+    b = MockModelResourceTwo.new
+    MockModelResourceOne.model_class.should equal MockCarton
+    a.model_class.should equal MockCarton
+    MockModelResourceTwo.model_class.should equal MockCartonTwo
+    b.model_class.should equal MockCartonTwo
+  end
+  
+  it "have a usable view method" do
+     a = MockModelResource.new
+     a.should respond_to(:view)
+  end
+  
+  it "should call index or show by default for an orange packet" do
+    c = Orange::Core.new
+    c.load(MockModelResourceOne.new, :mocked)
+    p = Orange::Packet.new(c, {})
+    p2 = Orange::Packet.new(c, {})
+    p2['route.resource_id'] = 1
+    lambda {
+      c[:mocked].view(p)
+    }.should raise_error(RuntimeError, "I see you're using index")
+    lambda {
+      c[:mocked].view(p2)
+    }.should raise_error(RuntimeError, "I see you're using show")
+  end
+  
+  it "should send the mode to the appropriate method" do
+    c = Orange::Core.new
+    c.load(MockModelResourceOne.new, :mocked)
+    p = Orange::Packet.new(c, {})
+    lambda {
+      c[:mocked].view(p, :mode => :other)
+    }.should raise_error(RuntimeError, "I see you're using other")
+  end
+  
+  it "shouldn't give a shit" do
+    lambda{
+      MockModelResource.shit
+    }.should raise_error(NoMethodError)
+  end
+  
+  it "should call find_one if calling view_opts with is_list false" do
+    a= MockModelResourceOne.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, false)
+    }.should raise_error(RuntimeError, "calling find_one")
+  end
+  
+  it "should call find_list if calling view_opts with is_list true" do
+    a= MockModelResourceOne.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, true)
+    }.should raise_error(RuntimeError, "calling find_list")
+  end
+  
+  it "should return a hash of options on calling view_opts" do
+    a= MockModelResourceFour.new
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    lambda{
+      a.view_opts(p, :list, true)
+    }.should_not raise_error(RuntimeError)
+    opts = a.view_opts(p, :list, true, :extra => 'foo')
+    opts3 = a.view_opts(p, :list, false, :extra => 'foo')
+    opts2 = a.view_opts(p, :list, true, :list => 'banana')
+    opts[:props].should == MockCarton.form_props(p['route.context'])
+    opts.should have_key(:list)
+    opts3.should_not have_key(:list)
+    opts.should have_key(:resource)
+    opts.should have_key(:model_name)
+    opts.should_not have_key(:model)
+    opts3.should have_key(:model)
+    opts.should have_key(:extra)
+    opts3.should have_key(:extra)
+    opts[:extra].should == 'foo'
+    opts3[:extra].should == 'foo'
+    opts[:list].should_not == opts2[:list]
+    opts2[:list].should == 'banana'
+    opts[:list].should == 'mock_list'
+  end
+  
+  it "should call view_extras after during view_opts" do
+    a= MockModelResourceThree.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, true)
+    }.should raise_error(RuntimeError, "calling find_extras")
+  end
+  
+  it "should call haml parser with opts on do_view" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    c.load(MockHamlParser.new, :parser)
+    c.load(MockModelResourceFour.new, :mocked)
+    parsed = c[:mocked].do_view(p, :test, :extra => 'foo')
+    parsed.first.should == 'test.haml'
+    parsed.last.should == c[:mocked].view_opts(p, :test, false, :extra => 'foo')
+    parsed.last.should_not == c[:mocked].view_opts(p, :test, true, :extra => 'foo')
+    parsed.last.should have_key(:extra)
+    parsed[1].should equal(p)
+  end
+  
+  it "should call haml parser with opts on do_list_view" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    c.load(MockHamlParser.new, :parser)
+    c.load(MockModelResourceFour.new, :mocked)
+    parsed = c[:mocked].do_list_view(p, :test, :extra => 'foo')
+    parsed.first.should == 'test.haml'
+    parsed.last.should == c[:mocked].view_opts(p, :test, true, :extra => 'foo')
+    parsed.last.should_not == c[:mocked].view_opts(p, :test, false, :extra => 'foo')
+    parsed.last.should have_key(:extra)
+    parsed[1].should equal(p)
+  end
+  
+  it "should call carton's get on find_one(packet, mode, id)" do
+    a= MockModelResourceTwo.new
+    a.find_one(Orange::Packet.new(Orange::Core.new, {}), :show).should == false
+    a.find_one(Orange::Packet.new(Orange::Core.new, {}), :show, 1).should == 'mock_get'
+  end
+  
+  it "should call carton's all on find_list(packet, mode)" do
+    a= MockModelResourceTwo.new
+    a.find_list(Orange::Packet.new(Orange::Core.new, {}), :show).should == 'mock_all'
+  end
+  
+  it "should return an empty hash by default for find_extras" do
+    a= MockModelResourceTwo.new
+    a.find_extras(Orange::Packet.new(Orange::Core.new, {}), :show).should == {}
+  end
+  
+  it "should have the view_list method in packet" do
+    c = Orange::Core.new
+    c.load(MockModelResourceOne.new, :mocked)
+    p = Orange::Packet.new(c, {})
+    lambda {
+      p.view_index(:mocked)
+    }.should raise_error(RuntimeError, "I see you're using index")
+    lambda {
+      p.view_show(:mocked)
+    }.should raise_error(RuntimeError, "I see you're using show")
+    lambda {
+      p.view_other(:mocked)
+    }.should raise_error(RuntimeError, "I see you're using other")
+  end
+  
+  it "should call carton's save on POST new and reroute" do
+    a= MockModelResourceTwo.new
+    m= mock("carton", :null_object => true)
+    m.should_receive(:save)
+    a.stub!(:model_class).and_return(m)
+    p2 = mock("packet", :null_object => true)
+    p2.should_receive(:reroute)
+    p2.stub!(:request).and_return(mock_post)
+    lambda{
+      a.new(Orange::Packet.new(Orange::Core.new, {}))
+    }.should raise_error(Orange::Reroute, 'Unhandled reroute')
+    a.new(p2)
+  end
+  
+  it "should call carton's destroy! on DELETE delete and reroute" do
+    a= MockModelResourceTwo.new
+    m= mock("carton", :null_object => true)
+    m.should_receive(:destroy)
+    a.stub!(:model_class).and_return(m)
+    p2 = mock("packet", :null_object => true)
+    p2.should_receive(:reroute)
+    p2.stub!(:request).and_return(mock_delete)
+    lambda{
+      a.delete(Orange::Packet.new(Orange::Core.new, {}))
+    }.should raise_error(Orange::Reroute, 'Unhandled reroute')
+    a.delete(p2)
+  end
+  
+  it "should call carton's update on POST save and reroute" do
+    a= MockModelResourceTwo.new
+    m= mock("carton", :null_object => true)
+    m.should_receive(:update)
+    a.stub!(:model_class).and_return(m)
+    p2 = mock("packet", :null_object => true)
+    p2.should_receive(:reroute)
+    p2.stub!(:request).and_return(mock_post)
+    lambda{
+      a.delete(Orange::Packet.new(Orange::Core.new, {}))
+    }.should raise_error(Orange::Reroute, 'Unhandled reroute')
+    a.save(p2)
+  end
+  
+  it "should call do_view with mode = :show for show" do
+    a= MockModelResource.new
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :show)
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :show, {})
+    a.show(empty_packet)
+    a.show(empty_packet, {})
+  end
+  it "should call do_view with mode = :edit for edit" do
+    a= MockModelResource.new
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :edit)
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :edit, {})
+    a.edit(empty_packet)
+    a.edit(empty_packet, {})
+  end
+  it "should call do_view with mode = :create for create" do
+    a= MockModelResource.new
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :create)
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :create, {})
+    a.create(empty_packet)
+    a.create(empty_packet, {})
+  end
+  
+  it "should call do_view with mode = :table_row for table_row" do
+    a= MockModelResource.new
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :table_row)
+    a.should_receive(:do_view).with(an_instance_of(Orange::Packet), :table_row, {})
+    a.table_row(empty_packet)
+    a.table_row(empty_packet, {})
+  end
+  
+  it "should call do_list_view with mode = :list for list" do
+    a= MockModelResource.new
+    a.should_receive(:do_list_view).with(an_instance_of(Orange::Packet), :list)
+    a.should_receive(:do_list_view).with(an_instance_of(Orange::Packet), :list, {})
+    a.list(empty_packet)
+    a.list(empty_packet, {})
+  end
+  
+  
+  it "should call do_list_view with mode = :list for index" do
+    a= MockModelResource.new
+    a.should_receive(:do_list_view).with(an_instance_of(Orange::Packet), :list)
+    a.should_receive(:do_list_view).with(an_instance_of(Orange::Packet), :list, {})
+    a.index(empty_packet)
+    a.index(empty_packet, {})
+  end
+  
+  
+end

data/spec/orange-core/resources/parser_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Orange::Parser do
+  it "should be spec'ed" 
+end

data/spec/orange-core/resources/routable_resource_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__)  + '/../spec_helper')
+
+describe Orange::RoutableResource do
+  it "should be spec'ed" 
+end

data/spec/orange-core/spec_helper.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'orange-core'
+require 'rubygems'
+
+require 'mock/mock_app'
+require 'mock/mock_pulp'
+require 'mock/mock_core'
+require 'mock/mock_carton'
+require 'mock/mock_model_resource'
+require 'mock/mock_mixins'
+require 'mock/mock_router'
+require 'mock/mock_resource'
+require 'mock/mock_middleware'
+require 'rack/test'
+
+
+Spec::Runner.configure do |config|
+  config.include(Rack::Test::Methods)
+end
+
+def mock_post
+  p= mock("request", :null_object => true)
+  p.stub!(:post?).and_return(true)
+  p.stub!(:params).and_return({})
+  p.stub!(:xhr?).and_return(false)
+  p
+end
+
+def mock_delete
+  p= mock("request", :null_object => true)
+  p.stub!(:delete?).and_return(true)
+  p.stub!(:params).and_return({})
+  p.stub!(:xhr?).and_return(false)
+  p
+end
+
+def empty_packet(c = Orange::Core.new)
+  Orange::Packet.new(c, {})
+end
+
+def packet_finish_app
+  lambda { |env|
+    Orange::Packet.new(env).finish
+  }
+end
+
+def return_env_app
+  lambda { |env|
+    [env, 200, ["ok"]]
+  }
+end

data/spec/orange-core/stack_spec.rb

@@ -0,0 +1,232 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Orange::Stack do
+  before(:all) do
+    # allow deep introspection into rack builder
+    class Rack::Builder 
+      attr_accessor :ins
+      # introspection into the Builder object's list of items
+      # builder uses Proc magic to chain the middleware together,
+      # so we undo it.
+      def ins_no_procs
+        @ins.map{|x| x.instance_of?(Proc)? x.call(nil) : x }
+      end
+    end
+    class Orange::Stack 
+      attr_accessor :build
+      def middlewarez
+        build.ins_no_procs
+      end
+    end
+  end
+  
+  def app
+    MockApplication.app
+  end
+  
+  it "should create a default stack when called by Application" do
+    MockApplication2.app.should be_an_instance_of(Orange::Stack)
+    MockApplication2.app.main_app.should be_a_kind_of(Orange::Application)
+  end
+  
+  it "should have access to core" do
+    MockApplication.app.orange.should be_an_instance_of(Orange::Core)
+  end
+  
+  it "should have access to the main application instance" do
+    MockApplication2.app.main_app.should be_an_instance_of(MockApplication2)
+  end
+  
+  it "should have the run function" do
+    x= Orange::Stack.new do
+      run MockExitware.new
+    end
+    lambda {
+      x.call({:test => 'middlewarez'})
+    }.should raise_error(RuntimeError, "Mock Exitware")
+  end
+  
+  it "should accept a core object in initialization" do
+    c = Orange::Core.new
+    c2 = Orange::Core.new
+    
+    x = Orange::Stack.new(nil, c) do
+      run MockExitware.new
+    end
+    x.orange.should equal(c)
+    x.orange.should_not equal(c2)
+  end
+  
+  it "should have the use function" do
+    x= Orange::Stack.new do
+      use MockMiddleware
+      run MockExitware.new
+    end
+    lambda {
+      x.call({:test => 'middlewarez'})
+    }.should raise_error(RuntimeError, "I'm in ur middlewarez")
+    lambda {
+      x.call({:test => 'middlewarez'})
+    }.should_not raise_error(RuntimeError, "It's over 9000")
+  end
+  
+  it "should have the stack function" do
+    x= Orange::Stack.new do
+      stack MockOrangeBasedMiddleware
+      run MockExitware.new
+    end
+    lambda {
+      x.call({:test => 'middlewarez'})
+    }.should raise_error(RuntimeError, "It's over 9000 Orange::Cores!")
+  end
+  
+  it "should respect order of stack/use cases" do
+    x= Orange::Stack.new do
+      use MockMiddleware
+      stack MockOrangeBasedMiddleware
+      run MockExitware.new
+    end
+    y= Orange::Stack.new do
+      stack MockOrangeBasedMiddleware
+      use MockMiddleware
+      run MockExitware.new
+    end
+    lambda {
+      x.call({:test => 'middlewarez'})
+    }.should raise_error(RuntimeError, "I'm in ur middlewarez")
+    lambda {
+      y.call({:test => 'middlewarez'})
+    }.should raise_error(RuntimeError, "It's over 9000 Orange::Cores!")
+  end
+  
+  it "should load a resource when using load" do
+    x= Orange::Stack.new
+    x.load(MockResource.new, :test)
+    x.orange[:test].mock_method.should == 'MockResource#mock_method'
+  end
+  
+  it "should not rebuild stack if auto_reload not set" do
+    x= Orange::Stack.new do
+      run MockExitware.new
+    end
+    x.app.should eql(x.app)
+  end
+  
+  it "should fire the stack events" do
+    c = Orange::Core.new
+    c2 = Orange::Core.new
+    x= Orange::Stack.new(nil, c) do
+      run MockExitware.new
+    end
+    x2= Orange::Stack.new(nil, c2) do
+      auto_reload!
+      run MockExitware.new
+    end
+    c.should_receive(:fire).with(:stack_loaded, anything()).once
+    c.should_receive(:fire).with(:stack_reloading, anything()).exactly(0).times
+    x.app
+    x.app
+    c2.should_receive(:fire).with(:stack_loaded, anything()).exactly(3).times
+    c2.should_receive(:fire).with(:stack_reloading, anything()).twice
+    x2.app
+    x2.app
+    x2.app
+  end
+  
+  it "should rebuild stack if auto_reload! set" do
+    x= Orange::Stack.new do
+      auto_reload!
+      use MockMiddleware
+      run MockExitware.new
+    end
+    x.app.should_not eql(x.app)
+  end
+  
+  it "should include ShowExceptions in stack if use_exceptions called" do
+    x= Orange::Stack.new do
+      use_exceptions
+      run MockExitware.new
+    end
+    mapped = x.middlewarez
+    mapped.should_not eql([])
+    mapped.select{|x| x.instance_of?(Orange::Middleware::ShowExceptions)}.should_not be_empty
+    mapped.select{|x| x.instance_of?(Orange::Middleware::ShowExceptions)}.should have(1).items
+  end
+  
+  it "should add middleware when calling prerouting" do
+    x= Orange::Stack.new do
+      no_recapture
+      run MockExitware.new
+    end
+    x.middlewarez.should have(1).middlewares
+    x.prerouting
+    x.middlewarez.should have(9).middlewares
+    x.middlewarez.select{|y| y.instance_of?(Rack::AbstractFormat)}.should_not be_empty
+    x.middlewarez.select{|y| y.instance_of?(Orange::Middleware::RouteSite)}.should_not be_empty
+  end
+  
+  it "should have routing, postrouting and responder middleware hooks" do
+    x = Orange::Stack.new do
+      run MockExitware.new
+    end
+    x.should respond_to(:routing)
+    x.should respond_to(:postrouting)
+    x.should respond_to(:responders)
+    q = mock(:plugins)
+    plugin = mock(:plugin)
+    Orange.should_receive(:plugins).exactly(3).times.and_return(q)
+    q.should_receive(:each).exactly(3).times.and_return([plugin])
+    x.routing
+    x.postrouting
+    x.responders
+  end
+  
+  it "should add one less middleware when calling prerouting with opt :no_abstract_format" do
+    x= Orange::Stack.new do
+      no_recapture
+      run MockExitware.new
+    end
+    x.middlewarez.should have(1).middlewares
+    x.prerouting(:no_abstract_format => true)
+    x.middlewarez.should have(8).middlewares
+    x.middlewarez.select{|y| y.instance_of?(Rack::AbstractFormat)}.should be_empty
+    x.middlewarez.select{|y| y.instance_of?(Orange::Middleware::RouteSite)}.should_not be_empty
+  end
+  
+  
+  it "should have not have extra middleware for a default stack" do
+    x= Orange::Stack.new MockApplication
+    x.middlewarez.should have(1).middlewares
+  end
+    
+  # it "should not include Rack::OpenID unless openid_access_control enabled" do
+  #     defined?(Rack::OpenID).should be_nil
+  #     x= Orange::Stack.new do
+  #       openid_access_control
+  #       run MockExitware.new
+  #     end
+  #     defined?(Rack::OpenID).should == "constant"
+  #   end
+  
+  # it "should add middleware when calling openid_access_control" do
+  #     x= Orange::Stack.new do
+  #       no_recapture
+  #       run MockExitware.new
+  #     end
+  #     x.middlewarez.should have(1).middlewares
+  #     x.openid_access_control
+  #     x.middlewarez.should have(3).middlewares
+  #     x.middlewarez.select{|y| y.instance_of?(Rack::OpenID)}.should_not be_empty
+  #     x.middlewarez.select{|y| y.instance_of?(Orange::Middleware::AccessControl)}.should_not be_empty
+  #   end
+  
+  it "should include a module into Orange::Packet on add_pulp" do
+    x= Orange::Stack.new
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.should_not respond_to(:my_new_mock_method)
+    x.add_pulp(MockPulp)
+    p.should respond_to(:my_new_mock_method)
+    p.should be_a_kind_of(MockPulp)
+  end
+  
+end