orange 0.0.2

data/spec/mock/mock_app.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'orange'
+require 'rack/abstract_format'
+
+class MockApplication < Orange::Application
+  
+end
+
+class MockApplication2 < Orange::Application
+  
+end
+
+class MockExitware
+  def call(env)
+    raise 'Mock Exitware'
+  end
+end

data/spec/mock/mock_core.rb

@@ -0,0 +1,2 @@
+class MockCoreSubclass < Orange::Core
+end

data/spec/mock/mock_middleware.rb

@@ -0,0 +1,13 @@
+class MockOrangeBasedMiddleware < Orange::Middleware::Base
+  def packet_call(packet)
+    raise "It's over 9000 #{@core.class.to_s}s!"
+  end
+end
+
+class MockMiddleware 
+  def initialize(app)
+  end
+  def call(env)
+    raise "I'm in ur #{env[:test]}"
+  end
+end

data/spec/mock/mock_mixins.rb

@@ -0,0 +1,19 @@
+module MockMixinOrange1 
+  def mixin_orange_one
+  end
+end
+
+module MockMixinOrange2
+  def mixin_orange_two
+  end
+end
+
+module MockMixinCore1
+  def mixin_core_one
+  end
+end
+
+module MockMixinCore2
+  def mixin_core_two
+  end
+end

data/spec/mock/mock_pulp.rb

@@ -0,0 +1,24 @@
+module MockPulpOrange1
+  def pulp_orange_one
+  end
+end
+
+module MockPulpOrange2
+  def pulp_orange_two
+  end
+end
+
+module MockPulpCore1
+  def pulp_core_one
+  end
+end
+
+module MockPulpCore2
+  def pulp_core_two
+  end
+end
+
+module MockPulp
+  def my_new_mock_method
+  end
+end

data/spec/mock/mock_resource.rb

@@ -0,0 +1,5 @@
+class MockResource < Orange::Resource
+  def mock_method
+    'MockResource#mock_method'
+  end
+end

data/spec/mock/mock_router.rb

@@ -0,0 +1,10 @@
+
+class TestRouter
+  attr_accessor :x
+  def initialize
+   @x = 0
+  end
+  def route(packet)
+    @x += 1
+  end
+end

data/spec/model_resource_spec.rb

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

data/spec/orange_spec.rb

@@ -0,0 +1,19 @@
+describe Orange do
+  it "should allow core mixin via mixin method" do
+    c= Orange::Core.new
+    c.should_not respond_to(:mixin_orange_one)
+    Orange.mixin MockMixinOrange1
+    c2= Orange::Core.new
+    c.should respond_to(:mixin_orange_one)
+    c2.should respond_to(:mixin_orange_one)
+  end
+  it "should allow pulp mixin via pulp method" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    p.should_not respond_to(:pulp_orange_one)
+    Orange.add_pulp MockPulpOrange1
+    p2= Orange::Packet.new(c, {})
+    p.should respond_to(:pulp_orange_one)
+    p2.should respond_to(:pulp_orange_one)
+  end
+end

data/spec/packet_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Orange::Packet do
+  it "should return a default header content type of html" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.finish[1].should have_key("Content-Type")
+    p.finish[1]["Content-Type"].should eql("text/html")
+  end
+  
+  it "should not create a new object for env if one already exists" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    env = p.env
+    p2= Orange::Packet.new(Orange::Core.new, env)
+    p.should equal p2 # Exact equality - same instances
+  end
+  
+  it "should save core passed to it on initialization" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    p.orange.should equal c
+  end
+  
+  it "should save the env passed to it on init" do
+    p= Orange::Packet.new(Orange::Core.new, {:test => :foo})
+    p.env.should have_key(:test)
+    p.env[:test].should == :foo
+    p.env.should_not be_empty
+  end
+  
+  it "should add orange.packet and orange.env to env on init" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.env.should have_key('orange.packet')
+    p.env['orange.packet'].should equal p
+    p.env.should have_key('orange.env')
+    p.env['orange.env'].should have_key(:request)
+    p.env['orange.env'][:request].should be_an_instance_of(Rack::Request)
+    p.env['orange.env'].should have_key(:headers)
+    p.env['orange.env'][:headers].should be_an_instance_of(Hash)
+  end
+  
+  it "should have access to the orange.env through []" do
+    p= Orange::Packet.new(Orange::Core.new, {'orange.env' => {'foo' => :true}})
+    p['foo'].should == :true
+    p['foo'] = 'banana'
+    p.env['orange.env']['foo'].should == 'banana'
+    p['foo'].should == 'banana'
+  end
+  
+  it "should allow defaults through [] calls" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p['nonexistent'].should be_false
+    p['nonexistent', true].should be_true
+    p['nonexistent', true].should_not be_an_instance_of Hash
+    p['nonexistent', {}].should be_an_instance_of Hash
+  end
+  
+  it "should give access to the rack.session env" do
+    p= Orange::Packet.new(Orange::Core.new, {'rack.session' => 'banana'})
+    p.session.should == 'banana'
+  end
+  
+  it "should give headers by combining :headers with defaults" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.headers.should == p[:headers, {}].with_defaults(Orange::Packet::DEFAULT_HEADERS)
+  end
+  
+  it "should allow setting headers via header(key, val)" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.header('Content-Type', 'text/plain')
+    p.headers['Content-Type'].should == 'text/plain'
+  end
+  
+  it "should allow adding headers with add_header" do
+    p1= Orange::Packet.new(Orange::Core.new, {})
+    p2= Orange::Packet.new(Orange::Core.new, {})
+    p1.add_header('Content-Type', 'text/plain')
+    p2.header('Content-Type', 'text/plain')
+    p1.headers['Content-Type'].should == p2.headers['Content-Type']
+  end
+  
+  it "should give access to the core object via orange" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    p.orange.should equal c
+    p.orange.should be_an_instance_of(Orange::Core)
+  end
+  
+  it "should create a triple according to rack standards on #finish" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    fin = p.finish
+    fin[0].should be_a_kind_of Integer
+    fin[1].should be_a_kind_of Hash
+    fin[2].should be_a_kind_of Array
+  end
+  
+  it "should give self when using packet" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.packet.should equal p
+  end
+  
+  it "should mixin when calling mixin" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.should_not respond_to(:pulp_orange_two)
+    Orange::Packet.mixin MockPulpOrange2
+    p.should respond_to(:pulp_orange_two)
+  end
+  
+  it "should raise an error if no router set" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    lambda{
+      p.route
+    }.should raise_error(RuntimeError, 'Router not found')
+  end
+  
+  it "should pass self to assigned router's route method" do
+    class MockDeathRouter
+      def route(p); raise "die, die, death, #{p[:lame]}"; end
+    end
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p['route.router'] = MockDeathRouter.new
+    p[:lame] = 'death'
+    lambda{
+      p.route
+    }.should_not raise_error(RuntimeError, 'Router not found')
+    lambda{
+      p.route
+    }.should raise_error(RuntimeError, 'die, die, death, death')
+  end
+  
+  it "should give a request object" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.request.should be_an_instance_of Rack::Request
+  end
+end

data/spec/resource_spec.rb

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

data/spec/resources/flex_router_spec.rb

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

data/spec/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/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/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/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'spec/mock/mock_app'
+require 'spec/mock/mock_pulp'
+require 'spec/mock/mock_core'
+require 'spec/mock/mock_mixins'
+require 'spec/mock/mock_router'
+require 'spec/mock/mock_resource'
+require 'spec/mock/mock_middleware'
+require 'rack/test'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'orange'
+Spec::Runner.configure do |config|
+  config.include(Rack::Test::Methods)
+end

data/spec/stack_spec.rb

@@ -0,0 +1,202 @@
+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 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 rebuild stack if auto_reload! set" do
+    x= Orange::Stack.new do
+      auto_reload!
+      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(6).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 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(5).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 add middleware when calling restful_routing" do
+    x= Orange::Stack.new do
+      no_recapture
+      run MockExitware.new
+    end
+    x.middlewarez.should have(1).middlewares
+    x.restful_routing
+    x.middlewarez.should have(2).middlewares
+    restfuls = x.middlewarez.select{|y| y.instance_of?(Orange::Middleware::RestfulRouter)}
+    restfuls.should_not be_empty
+    restfuls.should have(1).items
+  end
+  
+  it "should have not have recapture middleware for a default stack" do
+    x= Orange::Stack.new MockApplication
+    x.middlewarez.should have(1).middlewares
+  end
+  
+  it "should have recapture middleware by default if stack created with block" do
+    x= Orange::Stack.new do
+      run MockExitware.new
+    end
+    x.middlewarez.should have(2).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