orange 0.5.5 → 0.5.7

data/spec/orange-core/magick_spec.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/spec/orange-core/orange_spec.rb

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

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