orange 0.0.3 → 0.0.4

data/spec/{core_spec.rb → orange/core_spec.rb}

@@ -228,4 +228,14 @@ describe Orange::Core do
     c[:mock].should be_an_kind_of(Orange::Resource)
     c[:mock].mock_method.should eql 'MockResource#mock_method'
   end
+  
+  it "should have option to silently ignore resource calls" do
+    c= Orange::Core.new
+    lambda {
+      c[:mock].test
+    }.should raise_error
+    lambda {
+      c[:mock, true].test
+    }.should_not raise_error
+  end
 end

data/spec/{magick_spec.rb → orange/magick_spec.rb}

@@ -21,6 +21,17 @@ describe Orange::DefaultHash do
   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)

data/spec/orange/middleware/access_control_spec.rb

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

data/spec/orange/middleware/base_spec.rb

@@ -0,0 +1,37 @@
+describe Orange::Middleware::Base do
+  it "should call init after initializing" do
+    lambda{
+      mid = MockOrangeDeathMiddleware.new(nil, nil, :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, nil)
+    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, nil)
+    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)
+    app2.should_receive(:packet_call).with(an_instance_of(Orange::Packet))
+    mid = MockOrangeBasedMiddlewareTwo.new(app, nil)
+    mid2 = MockOrangeBasedMiddlewareTwo.new(app2, nil)
+    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/middleware/database_spec.rb

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

data/spec/orange/middleware/globals_spec.rb

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

data/spec/orange/middleware/recapture_spec.rb

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

data/spec/orange/middleware/rerouter_spec.rb

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

data/spec/orange/middleware/restful_router_spec.rb

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

data/spec/orange/middleware/route_context_spec.rb

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

data/spec/orange/middleware/route_site_spec.rb

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

data/spec/orange/middleware/show_exceptions_spec.rb

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

data/spec/orange/middleware/site_load_spec.rb

@@ -0,0 +1,26 @@
+describe Orange::Middleware::SiteLoad do
+  it "should load Orange::SiteResource when used in stack" do
+    c = Orange::Core.new
+    c.should_receive(:load).with(an_instance_of(Orange::SiteResource), an_instance_of(Symbol))
+    app = Orange::Middleware::SiteLoad.new(nil, c)
+    
+  end
+  
+  it "should load the site object into the packet, if available" do
+    Orange::Site.should_receive(:first).with(an_instance_of(Hash)).and_return('foo')
+    app = Orange::Middleware::SiteLoad.new(return_env_app, Orange::Core.new)
+    ret = app.call({})
+    ret['orange.env'].should have_key('site')
+    ret['orange.env']['site'].should == 'foo'
+  end
+  
+  it "should create a new site object, if one doesn't exist" do
+    Orange::Site.should_receive(:first).with(an_instance_of(Hash)).and_return(false)
+    m = mock("site")
+    Orange::Site.should_receive(:new).with(an_instance_of(Hash)).and_return(m)
+    m.should_receive(:save).and_return(true)
+    app = Orange::Middleware::SiteLoad.new(return_env_app, Orange::Core.new)
+    ret = app.call({})
+    ret['orange.env'].should have_key('site')
+  end
+end

data/spec/orange/middleware/static_file_spec.rb

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

data/spec/orange/middleware/static_spec.rb

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

data/spec/orange/middleware/template_spec.rb

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

data/spec/orange/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/{mock → orange/mock}/mock_middleware.rb

@@ -10,4 +10,12 @@ class MockMiddleware
   def call(env)
     raise "I'm in ur #{env[:test]}"
   end
+end
+
+class MockOrangeBasedMiddlewareTwo < Orange::Middleware::Base; end
+class MockOrangeDeathMiddleware < Orange::Middleware::Base
+  def init(*args)
+    opts = args.extract_options!
+    raise "middleware_init with foo=#{opts[:foo]}"
+  end
 end

data/spec/{mock → orange/mock}/mock_model_resource.rb

@@ -40,4 +40,8 @@ class MockModelResourceFour < Orange::ModelResource
   def find_list(packet, mode)
     'mock_list'
   end
+end
+
+class MockModelResourceExtreme < Orange::ModelResource
+  
 end

data/spec/orange/resources/admin_resource_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Orange::AdminResource do
+  before(:all) do
+  end
+  it "should have a function for returning list of links" do
+    a = Orange::AdminResource.new
+    a.set_orange(Orange::Core.new, :admin)
+    a.links(empty_packet)
+  end
+  it "should be have an add_link function" do
+    a = Orange::AdminResource.new
+    a.set_orange(Orange::Core.new, :admin)
+    a.add_link('Content', {})
+  end
+end

data/spec/{resources → orange/resources}/model_resource_spec.rb

@@ -138,5 +138,109 @@ describe Orange::ModelResource do
     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/resources/singleton_model_resource_spec.rb

@@ -0,0 +1,4 @@
+describe Orange::SingletonModelResource do
+  
+  it "should be spec'ed" 
+end

data/spec/{resources/flex_router_spec.rb → orange/resources/sitemap_resource_spec.rb}

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

data/spec/orange/spec_helper.rb

@@ -0,0 +1,51 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'orange'
+
+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
+end
+
+def mock_delete
+  p= mock("request", :null_object => true)
+  p.stub!(:delete?).and_return(true)
+  p.stub!(:params).and_return({})
+  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
+  }
+end