orange-more 0.5.7

data/spec/orange-core/magick_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Orange::DefaultHash do
+  it "should be a kind of Hash" do
+    Orange::DefaultHash.new.should be_a_kind_of Hash
+  end
+  it "should handle setting default" do
+    x = Orange::DefaultHash.new
+    y = Orange::DefaultHash.new
+    x.default = true
+    y.default = false
+    x[:not_there].should be_true
+    y[:not_there].should be_false
+  end
+  
+  it "should handle default in key access []" do
+    x = Orange::DefaultHash.new
+    x.default = 'baz'
+    x[:not_there].should == 'baz'
+    x[:not_there, 'bar'].should == 'bar'
+  end
+end
+
+describe Orange::Ignore do
+  it "should silently accept method" do
+    o = Orange::Ignore.new 
+    lambda {
+      o.banana
+      o.args
+      o.foo.bar('banana').baz
+    }.should_not raise_error
+  end
+end
+
+describe "Orange::Options" do
+  it "should give a hash on hash" do
+    Orange::Options.new.hash.should be_an_instance_of(Hash)
+  end
+  
+  it "should accept hash key options" do
+    hash1 = Orange::Options.new(:one => '1', :two => ['foo']).hash
+    hash2 = Orange::Options.new(:one => '1').hash
+    hash3 = Orange::Options.new({:one => '1', :two => ['foo']}).hash
+    hash4 = Orange::Options.new({:one => '1'}).hash
+    hash5 = Orange::Options.new(1,2, {:one => '1', :two => ['foo']}).hash
+    hash6 = Orange::Options.new(1,2, {:one => '1'}).hash
+    [hash2, hash4, hash6].each{ |hash|
+      hash.should have_key(:one)
+      hash.should_not have_key(:three)
+      hash[:one].should == '1'
+    }
+    [hash1, hash3, hash5].each{ |hash|
+      hash.should have_key(:one)
+      hash.should have_key(:two)
+      hash.should_not have_key(:three)
+      hash[:one].should == '1'
+      hash[:two].should == ['foo']
+    }
+  end
+  
+  it "should accept block options" do
+    hash = Orange::Options.new {
+      one '1'
+      two ['foo']
+    }.hash
+    hash.should have_key(:one)
+    hash.should have_key(:two)
+    hash.should_not have_key(:three)
+    hash[:one].should == '1'
+    hash[:two].should == ['foo']
+  end
+  
+  it "should accept both kinds of options" do
+    hash = Orange::Options.new(:one => '1'){
+      two ['foo']
+    }.hash
+    
+    hash.should have_key(:one)
+    hash.should have_key(:two)
+    hash.should_not have_key(:three)
+    hash[:one].should == '1'
+    hash[:two].should == ['foo']
+  end
+  
+  it "should override hash key options with block options" do
+    hash = Orange::Options.new(:one => '1', :two => [:baz]){
+      two ['foo']
+    }.hash
+    
+    hash.should have_key(:one)
+    hash.should have_key(:two)
+    hash.should_not have_key(:three)
+    hash[:one].should == '1'
+    hash[:two].should == ['foo']
+  end
+end

data/spec/orange-core/middleware/base_spec.rb

@@ -0,0 +1,38 @@
+describe Orange::Middleware::Base do
+  it "should call init after initializing" do
+    lambda{
+      mid = MockOrangeDeathMiddleware.new(nil, Orange::Core.new, :foo => 'bar')
+    }.should raise_error(RuntimeError, "middleware_init with foo=bar")
+  end
+  
+  it "should create a packet and call packet call" do
+    mid = MockOrangeBasedMiddlewareTwo.new(nil, Orange::Core.new)
+    mid.should_receive(:packet_call).with(an_instance_of(Orange::Packet))
+    mid.call({})
+  end
+  
+  it "should pass the packet on by default for packet_call" do
+    mid = MockOrangeBasedMiddlewareTwo.new(nil, Orange::Core.new)
+    mid.should_receive(:pass).with(an_instance_of(Orange::Packet))
+    mid.packet_call(empty_packet)
+  end
+  
+  it "should call the downstream app on pass" do
+    app = mock("downstream")
+    app2 = mock("downstream_orange")
+    my_hash = {:foo => :bar}
+    app.should_receive(:call).with(my_hash).and_return([{},200,[]])
+    app2.should_receive(:packet_call).with(an_instance_of(Orange::Packet))
+    mid = MockOrangeBasedMiddlewareTwo.new(app, Orange::Core.new)
+    mid2 = MockOrangeBasedMiddlewareTwo.new(app2, Orange::Core.new)
+    mid.call(my_hash)
+    mid2.call(my_hash)
+  end
+  
+  it "should give access to the orange core on calling orange" do
+    c = Orange::Core.new
+    mid = MockOrangeBasedMiddlewareTwo.new(nil, c)
+    mid.orange.should equal c
+  end
+
+end

data/spec/orange-core/middleware/globals_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::Globals do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/rerouter_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::Rerouter do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/restful_router_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::RestfulRouter do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/route_context_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::RouteContext do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/route_site_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::RouteSite do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/show_exceptions_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::ShowExceptions do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/static_file_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::StaticFile do
+  it "should be spec'ed"
+end

data/spec/orange-core/middleware/static_spec.rb

@@ -0,0 +1,3 @@
+describe Orange::Middleware::Static do
+  it "should be spec'ed"
+end

data/spec/orange-core/mock/mock_app.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+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/orange-core/mock/mock_carton.rb

@@ -0,0 +1,43 @@
+class MockCarton < Orange::Carton
+  def self.scaffold_properties
+    @scaffold_properties
+  end
+  id
+  admin do
+    text :admin
+  end
+  orange do
+    text :orange
+  end
+  front do
+    text :front
+  end
+end
+
+class MockCartonTwo < Orange::Carton
+  id
+  def self.get(id)
+    'mock_get'
+  end
+  def self.all
+    'mock_all'
+  end
+  def save
+    raise 'mock_save'
+  end
+  def destroy!
+    raise 'mock_destroy'
+  end
+  def update(*args)
+    raise 'mock_update'
+  end
+end
+
+class MockCartonBlank < Orange::Carton
+  def self.levels
+    @levels
+  end
+end
+
+class MockCartonBlankTwo < Orange::Carton
+end

data/spec/orange-core/mock/mock_core.rb

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

data/spec/orange-core/mock/mock_middleware.rb

@@ -0,0 +1,25 @@
+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
+
+class MockOrangeBasedMiddlewareTwo < Orange::Middleware::Base; end
+class MockOrangeBasedMiddlewareThree < Orange::Middleware::Base
+  def stack_init
+  end
+end
+class MockOrangeDeathMiddleware < Orange::Middleware::Base
+  def init(*args)
+    opts = args.extract_options!
+    raise "middleware_init with foo=#{opts[:foo]}"
+  end
+end

data/spec/orange-core/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/orange-core/mock/mock_model_resource.rb

@@ -0,0 +1,47 @@
+class MockModelResource < Orange::ModelResource
+  use MockCarton
+end
+
+class MockModelResourceOne < Orange::ModelResource
+  use MockCarton
+  def index(packet, *args)
+    raise 'I see you\'re using index'
+  end
+  def show(packet, *args)
+    raise 'I see you\'re using show'
+  end
+  def other(packet, *args)
+    raise 'I see you\'re using other'
+  end
+  def find_one(packet, mode, resource_id =false)
+    raise 'calling find_one'
+  end
+  def find_list(packet, mode)
+    raise 'calling find_list'
+  end
+end
+
+class MockModelResourceTwo < Orange::ModelResource
+  use MockCartonTwo
+end
+
+class MockModelResourceThree < Orange::ModelResource
+  use MockCarton
+  def find_extras(packet, mode)
+    raise 'calling find_extras'
+  end
+end
+
+class MockModelResourceFour < Orange::ModelResource
+  use MockCarton
+  def find_one(packet, mode, resource_id =false)
+    'mock_one'
+  end
+  def find_list(packet, mode)
+    'mock_list'
+  end
+end
+
+class MockModelResourceExtreme < Orange::ModelResource
+  
+end

data/spec/orange-core/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/orange-core/mock/mock_resource.rb

@@ -0,0 +1,26 @@
+class MockResource < Orange::Resource
+  def mock_method
+    'MockResource#mock_method'
+  end
+  def afterLoad
+    @options[:mocked] = true
+  end
+end
+
+class MockResourceTwo < Orange::Resource
+  def mock_method
+    'MockResource#mock_method'
+  end
+  def afterLoad
+    @options[:mocked] = true
+  end
+  def stack_init
+    true
+  end
+end
+
+class MockHamlParser < Orange::Resource
+  def haml(template, packet, opts)
+    [template, packet, opts]
+  end
+end

data/spec/orange-core/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/orange-core/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/orange-core/packet_spec.rb

@@ -0,0 +1,203 @@
+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' => {'foo' => 'banana'}})
+    p.session.should have_key 'foo'
+    p.session.should have_key 'flash'
+  end
+  
+  it "should give always have a flash" do
+    p= Orange::Packet.new(Orange::Core.new, {'rack.session' => {}})
+    p.session.should have_key 'flash'
+    p.flash.should == {}
+  end
+  
+  it "should destruct a flash value upon reading" do    
+    p= Orange::Packet.new(Orange::Core.new, {'rack.session' => {}})
+    p.session.should have_key 'flash'
+    p.session["flash"]["foo"] = "bar"
+    p.flash("foo").should == "bar"
+    p.flash("foo").should be_nil
+    p.session["flash"].should_not have_key("foo")
+    p.flash("foo", "bar")
+    p.flash("foo").should == "bar"
+    p.flash("foo").should be_nil
+    p.session["flash"].should_not have_key("foo")
+    p.flash["foo"] = "bar"
+    p.flash("foo").should == "bar"
+    p.flash("foo").should be_nil
+    p.flash.should_not have_key("foo")
+  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
+  
+  it "should store method matchers for extending method_missing handlers" do
+    class Orange::Packet 
+      meta_methods(/pretend_method_we_dont_want/) do |match, args|
+        "my mock meta method"
+      end
+      
+      meta_methods(/pretend_method_we_dont_want(\w+)/) do |match, args|
+        "my mock meta method"
+      end
+    end
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.matchers.size.should >= 2
+  end
+  
+  it "should have method_missing capabilities" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.should respond_to(:method_missing)
+    lambda {
+      p.my_mock_meta_method
+      p.mock_meta_test
+      p.mock_meta_test_with_args
+    }.should raise_error(NoMethodError)
+    class Orange::Packet 
+      meta_methods(/my_mock_meta_method/) do 
+        "my mock meta method"
+      end
+      
+      meta_methods(/mock_meta_(\w+)/) do |packet, match|
+        "my mock #{match[1]} method"
+      end
+      
+      meta_methods(/mock_meta_(\w+)_with_args/) do |packet, match, args|
+        "my mock #{match[1]} method args0 = #{args[0]}"
+      end
+    end
+    lambda {
+      p.my_mock_meta_method
+      p.mock_meta_test
+      p.mock_meta_test_with_args 'test'
+    }.should_not raise_error(NoMethodError)
+    p.my_mock_meta_method.should == "my mock meta method"
+    p.mock_meta_test.should == "my mock test method"
+    p.mock_meta_test_with_args('test').should == "my mock test method args0 = test"
+  end
+end