orange 0.5.5 → 0.5.7

data/spec/orange-core/resource_spec.rb

@@ -1,96 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

data/spec/orange-core/stack_spec.rb

@@ -1,232 +0,0 @@
-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