methodmissing-scrooge 1.0.0

data/spec/units/scrooge/framework/base_spec.rb

@@ -0,0 +1,154 @@
+require 'spec/spec_helper'
+
+describe "Scrooge::Framework::Base singleton" do
+  
+  before(:each) do
+    @base = Scrooge::Framework::Base
+  end
+
+  it "should be able to track all available frameworks" do
+    @base.frameworks.should include( Scrooge::Framework::Rails )
+  end
+  
+  it "should be able to infer the current active framework" do
+    lambda{ @base.which_framework? }.should raise_error( Scrooge::Framework::Base::NoSupportedFrameworks )
+    with_rails do
+      @base.which_framework?().should equal( Scrooge::Framework::Rails )
+    end
+  end
+  
+  it "should be able to instantiate the active framework" do
+    with_rails do
+      @base.instantiate.class.should equal( Scrooge::Framework::Rails )
+    end
+  end
+  
+end
+
+describe Scrooge::Framework::Base do
+  
+  before(:each) do
+    @base = Scrooge::Framework::Base.new
+  end
+  
+  it "should be able to yield it's environment" do
+    lambda{ @base.environment }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to yield it's root path" do
+    lambda{ @base.root }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end  
+  
+  it "should be able to setup a resource tracker instance from given status, headers and body" do
+    lambda{ @base.resource( {} ) }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end  
+  
+  it "should be able to yield it's temp path" do
+    lambda{ @base.tmp }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end  
+  
+  it "should be able to yield it's configuration path" do
+    lambda{ @base.config }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to yield it's logger" do
+    lambda{ @base.logger }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end    
+
+  it "should be able to read from the framework's cache store" do
+    lambda{ @base.read_cache( 'storage' ) }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end    
+
+  it "should be able to write to the framework's cache store" do
+    lambda{ @base.write_cache( 'storage', 'payload' ) }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end    
+  
+  it "should be able to yield a scopes path" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.scopes_path.should match( /config\/scrooge\/scopes/ )  
+    end  
+  end 
+  
+  it "should be able to infer all available scopes" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.send( :ensure_scopes_path )
+      @signature = Time.now.to_i.to_s
+      FileUtils.mkdir_p( File.join( @base.scopes_path, @signature ) )
+      @base.scopes.should include( @signature )   
+    end
+  end
+  
+  it "should be able to determine if there's any previously persisted scopes" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.send( :ensure_scopes_path )
+      @base.scopes?().should eql( true )
+    end
+  end
+  
+  it "should be able to infer the path to a given scope" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.scope_path( '1234567891' ).should match( /scopes\/1234567891/ ) 
+    end
+  end
+  
+  it "should be able to determine if a given scope is defined" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.scope?( 9876543211 ).should equal( false )
+    end
+  end
+  
+  it "should be able to dump the current application tracker to a scope" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      ::Rails.stub!(:env).and_return( "test" )
+      lambda{ @base.to_scope! }.should change( @base.scopes, :size )
+    end
+  end
+  
+  it "should be able to restore a previous scope to the current app tracker" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      ::Rails.stub!(:env).and_return( "test" )
+      @scope = @base.to_scope!
+      lambda{ @base.from_scope!( @scope ) }.should change( Scrooge::Base.profile.tracker, :object_id )     
+    end
+  end  
+  
+  it "should be able to validate previously saved scope signatures" do
+    @base.stub!(:scope?).and_return(false)
+    lambda{ @base.from_scope!( 'undefined' ) }.should raise_error( Scrooge::Framework::Base::InvalidScopeSignature )
+  end
+  
+  it "should be able to interact with the framework's Rack middleware" do
+    lambda{ @base.middleware }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to install tracking middleware" do
+    lambda{ @base.install_tracking_middleware() }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to install scoping middleware" do
+    lambda{ @base.install_scope_middleware( 'tracker' ) }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end  
+  
+  it "should be able to register code blocks to run after the framework has been initialized" do
+    lambda{ @base.initialized() }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to map a resource instance to a controller constant" do
+    lambda{ @base.controller( 'resource' ) }.should raise_error( Scrooge::Framework::Base::NotImplemented )
+  end
+  
+  it "should be able to return a full path to the scrooge configuration file" do
+    with_rails do
+      @base.stub!(:config).and_return( CONFIG )
+      @base.configuration_file.should match( /scrooge.yml/ )
+    end
+  end
+  
+end  

data/spec/units/scrooge/framework/rails_spec.rb

@@ -0,0 +1,40 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Framework::Rails do
+  
+  before(:each) do
+    @framework = Scrooge::Framework::Rails.new
+  end
+
+  it "should be able to yield it's current environment" do
+    with_rails do
+      @framework.environment.should eql( 'test' )
+    end
+  end
+
+  it "should be able to yield a logger" do
+    with_rails do
+      ::Rails.stub!(:logger).and_return('')
+      ( @framework.logger << 'entry' ).should eql( 'entry' )
+    end
+  end
+  
+  it "should be able to yield it's configuration" do
+    with_rails do
+      @framework.config.should match( /scrooge\/spec\/config/ )
+    end
+  end  
+  
+  it "should be able to yield it's root path" do
+    with_rails do
+      @framework.root.should match( /scrooge\/spec/ )
+    end
+  end  
+  
+  it "should be able to yield it's tmp path" do
+    with_rails do
+      @framework.tmp.should match( /scrooge\/spec\/tmp/ )
+    end
+  end  
+  
+end

data/spec/units/scrooge/orm/base_spec.rb

@@ -0,0 +1,61 @@
+require 'spec/spec_helper'
+
+describe "Scrooge::Orm::Base singleton" do
+  
+  before(:each) do
+    @base = Scrooge::Orm::Base
+  end
+  
+  it "should be able to instantiate a supported ORM from a given ORM signature" do
+    @base.instantiate( :active_record ).class.should equal(Scrooge::Orm::ActiveRecord)
+  end
+  
+end
+
+describe Scrooge::Orm::Base do
+  
+  before(:each) do
+    @tracker = mock('tracker')
+    @tracker.stub!(:signature).and_return( 'tracker' )
+    @base = Scrooge::Orm::Base.new
+  end
+  
+  it "should be able to scope to a given resource tracker" do
+    lambda{ @base.scope_to( 'resource_tracker_instance' ) }.should raise_error( Scrooge::Orm::Base::NotImplemented )
+  end
+  
+  it "should be able to generate a name for a given model" do
+    lambda{ @base.name( 'model' ) }.should raise_error( Scrooge::Orm::Base::NotImplemented )
+  end
+  
+  it "should be able to generate a table name for a given model" do
+    lambda{ @base.table_name( 'model' ) }.should raise_error( Scrooge::Orm::Base::NotImplemented )
+  end  
+  
+  it "should be able to generate a primary key for a given model" do
+    lambda{ @base.primary_key( 'model' ) }.should raise_error( Scrooge::Orm::Base::NotImplemented )
+  end  
+  
+  it "should be able to generate a per resource scope method" do
+    @base.resource_scope_method( @tracker ).should eql( :scope_to_tracker )
+  end
+  
+  it "should be able to determine if a given scope method has already been defined" do
+    @base.resource_scope_method?( @tracker, @tracker.class ).should equal( false )
+  end
+  
+  it "should be able to infer the current trackable resource" do
+    Thread.current[:scrooge_resource] = 'resource'
+    @base.resource().should eql( 'resource' )
+    Thread.current[:scrooge_resource] = nil
+  end
+  
+  it "should be able to determine if it's within the context of a trackable resource" do
+    @base.resource?().should eql( false )
+  end
+  
+  it "should be able to determine if it should track attribute access" do
+    @base.track?().should equal( false )
+  end
+  
+end  

data/spec/units/scrooge/profile_spec.rb

@@ -0,0 +1,73 @@
+require 'spec/spec_helper'
+
+describe "Scrooge::Profile singleton" do
+  
+  before(:each) do
+    @profile = Scrooge::Profile
+  end
+  
+  it "should be able to instantiate it self from a given config path and environment" do
+    @profile.setup( File.join( FIXTURES, 'config', 'scrooge.yml' ), :production ).class.should equal( Scrooge::Profile )
+    @profile.setup( File.join( FIXTURES, 'config', 'scrooge.yml' ), :test ).options['orm'].should equal( :active_record )
+  end
+  
+end
+
+describe "Scrooge::Profile instance" do
+ 
+  before(:each) do
+    @profile = Scrooge::Profile.setup( File.join( FIXTURES, 'config', 'scrooge.yml' ), :production )
+    @profile.framework.stub!(:scopes).and_return( %w(1234567891) )
+    @profile.options = { 'scope' => '1234567891'}
+  end  
+  
+  it "should return a valid ORM instance" do
+    @profile.orm.class.should equal( Scrooge::Orm::ActiveRecord )
+  end
+  
+  it "should return a valid storage instance" do
+    @profile.storage.class.should equal( Scrooge::Storage::Memory )
+  end
+  
+  it "should return a valid framework instance" do
+    with_rails do
+      @profile.framework.class.should equal( Scrooge::Framework::Rails )
+    end
+  end
+    
+  it "should return a valid tracker instance" do
+    @profile.tracker.class.should equal( Scrooge::Tracker::App )
+  end    
+   
+  it "should be able to determine if the active profile should track or scope" do
+    @profile.track?().should equal( false )
+    @profile.scope?().should equal( false )
+  end 
+  
+  it "should be able to infer the current scope" do
+    @profile.scope_to.should eql( "1234567891" )
+  end
+    
+  it "should be able to determine if it's enabled" do
+    @profile.enabled?().should eql( false )  
+  end  
+    
+  it "should neither track or scope if not enabled" do
+    @profile.should_receive(:track!).never
+    @profile.should_receive(:scope!).never
+    @profile.stub!(:enabled?).and_return(false)
+    @profile.track_or_scope!  
+  end  
+    
+  it "should be able to determine if it should raise on missing attributes" do    
+    @profile.raise_on_missing_attribute?().should equal( false )  
+  end  
+    
+  it "should be able to fallback to scope from the environment if none given" do
+    @profile.framework.stub!(:scopes).and_return( [] )
+    ENV['scope'] = 'scope_from_env'
+    @profile.send(:configure!)
+    @profile.scope_to.should eql( 'scope_from_env' )   
+  end  
+    
+end

data/spec/units/scrooge/storage/base_spec.rb

@@ -0,0 +1,35 @@
+require 'spec/spec_helper'
+
+describe "Scrooge::Storage::Base singleton" do
+  
+  before(:each) do
+    @base = Scrooge::Storage::Base
+  end
+  
+  it "should be able to instantiate a storage backend from a given storage signature" do
+    @base.instantiate( :memory ).class.should equal(Scrooge::Storage::Memory)
+  end
+  
+end
+
+describe Scrooge::Storage::Base do
+  
+  before(:each) do
+    @base = Scrooge::Storage::Base.new
+    @tracker = mock('tracker')
+    @tracker.stub!(:signature).and_return('signature')
+  end
+
+  it "should be able to read from the storage backend" do
+    lambda{ @base.read( @tracker ) }.should raise_error( Scrooge::Storage::Base::NotImplemented )
+  end
+  
+  it "should be able to write to the storage backend" do
+    lambda{ @base.write( @tracker ) }.should raise_error( Scrooge::Storage::Base::NotImplemented )
+  end    
+  
+  it "should be able to yield a namespaced storage key" do
+    @base.expand_key( "signature" ).should eql( "scrooge_storage/signature" )
+  end
+  
+end  

data/spec/units/scrooge/storage/memory_spec.rb

@@ -0,0 +1,20 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Storage::Memory do
+  
+  before(:each) do
+    @memory = Scrooge::Storage::Memory.new
+    @tracker = mock('tracker')
+    @tracker.stub!(:signature).and_return('signature')
+  end
+  
+   it "should be able to write a tracker to memory" do
+     lambda { @memory.write( @tracker ) }.should change( @memory.storage, :size ).from(0).to(1)
+   end
+   
+   it "should be able to read itself from memory" do
+      @memory.write( @tracker )
+      @memory.read( @tracker ).should eql( @tracker )
+   end
+   
+end  

data/spec/units/scrooge/tracker/app_spec.rb

@@ -0,0 +1,62 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Tracker::App do
+  
+  before(:each) do
+    @app = Scrooge::Tracker::App.new
+    @resource = Scrooge::Tracker::Resource.new do |resource|
+                  resource.controller = 'products'
+                  resource.action = 'show'
+                  resource.method = :get
+                  resource.format = :html
+                end
+  end
+  
+  it "should be able to determine if any resources has been tracked" do
+    @app.any?().should equal( false )
+  end
+  
+  it "should initialize with an empty set of resources" do
+    @app.resources.should eql( Set.new )
+  end
+  
+  it "should be able to accept resources" do
+    lambda { @app << 'a_resource' }.should change( @app.resources, :size ).from(0).to(1)
+  end
+  
+  it "should be able to dump itself to a serializeable representation" do
+    @app << @resource
+    with_rails do
+      @app.marshal_dump().should eql( [ { "products_show_get" => { :method => :get,
+                                                                   :models => [],
+                                                                   :format => :html,
+                                                                   :action => "show",
+                                                                   :controller => "products" } } ] )
+    end
+  end
+
+  it "should be able to restore itself from a serialized representation" do
+    @app << @resource
+    with_rails do
+      Marshal.load( Marshal.dump( @app ) ).should eql( @app )
+    end  
+  end
+
+  it "should be able to compare itself to other app trackers" do
+    with_rails do
+      @app.should eql( @app )
+    end  
+  end
+  
+  it "should implemented a custom Object#inspect" do  
+    @app << @resource
+    @app.inspect().should match( /GET/ )  
+    @app.inspect().should match( /products/ )
+  end
+  
+  it "should be able to determine if a resource's been seen before" do
+    @app << @resource
+    @app.resource_for( @resource ).should eql( @resource )
+  end
+  
+end

data/spec/units/scrooge/tracker/base_spec.rb

@@ -0,0 +1,21 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Tracker::Base do
+  
+  before(:each) do
+    @base = Scrooge::Tracker::Base.new
+  end
+  
+  it "should have a numeric representation" do
+    @base.to_i.should equal(0)
+  end
+  
+  it "should be able to dump itself to serializeable representation" do
+    lambda{ @base.marshal_dump }.should raise_error( Scrooge::Tracker::Base::NotImplemented )
+  end
+  
+  it "should be able to restore itself from a serializeable representation" do
+    lambda{ @base.marshal_load( '' ) }.should raise_error( Scrooge::Tracker::Base::NotImplemented )
+  end  
+  
+end

data/spec/units/scrooge/tracker/model_spec.rb

@@ -0,0 +1,50 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Tracker::Model do
+  
+  before(:each) do
+    @model = Scrooge::Tracker::Model.new( 'Post' )
+    @model.stub!(:name).and_return( 'Product' )
+    @model.stub!(:table_name).and_return( 'products' )
+    @model.stub!(:primary_key).and_return( 'id' )    
+  end
+
+  it "should be able to determine if any attributes has been tracked" do
+    @model.any?().should equal( false )
+  end
+  
+  it "should initialize with an empty set of attributes" do
+    @model.attributes.should eql( Set.new )
+  end
+  
+  it "should be able to accept attributes" do
+    lambda { @model << :name }.should change( @model.attributes, :size ).from(0).to(1)
+  end
+  
+  it "should be able to dump itself to a serializeable representation" do
+    @model << [:name, :description, :price]
+    @model.marshal_dump().should eql( { "Product" => [:price, :description, :name] } )
+  end
+  
+  it "should be able to restore itself from a serialized representation" do
+    @model << [:name, :description, :price]
+    lambda{ @model.marshal_load( { "Product" => [:price] } ) }.should change( @model.attributes, :size ).from(3).to(1)
+  end
+  
+  it "should be able to render a attribute selection SQL snippet from it's referenced attributes" do
+    @model << [:name, :description, :price]
+    @model.to_sql().should eql( "products.id, products.price, products.description, products.name" )
+  end
+  
+  it "should be able to compare itself to other model trackers" do
+    @model << [:name, :description, :price]
+    @model.should eql( @model )
+  end
+  
+  it "should implemented a custom Object#inspect" do
+    @model << [:name, :description]
+    @model.inspect().should match( /Product/ )
+    @model.inspect().should match( /:name/ )
+  end
+  
+end

data/spec/units/scrooge/tracker/resource_spec.rb

@@ -0,0 +1,83 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Tracker::Resource do
+  
+  before(:each) do
+    @resource = Scrooge::Tracker::Resource.new do |resource|
+                  resource.controller = 'products'
+                  resource.action = 'show'
+                  resource.method = :get
+                  resource.format = :html
+                end
+    @model = Scrooge::Tracker::Model.new( 'Class' )
+    @model.stub!(:name).and_return( 'Product' )
+    @model.stub!(:table_name).and_return( 'products' )  
+    @model.stub!(:primary_key).and_return( 'id' )      
+  end
+  
+  it "should be able to determine if any models has been tracked" do
+    @resource.any?().should equal( false )
+  end
+    
+  it "should initialize with an empty set of models" do
+    @resource.models.should eql( Set.new )
+  end
+  
+  it "should be able to accept models" do
+    lambda { @resource << @model }.should change( @resource.models, :size ).from(0).to(1)
+  end
+  
+  it "should be able to wrap model objects" do
+    @resource << 'Model'
+    @resource.models.all?{|m| m.is_a?( Scrooge::Tracker::Model ) }.should equal( true )
+  end
+  
+  it "should be able to log an attribute access for a given model" do
+    @resource << ['Post', :title]
+    @resource.models.first.attributes.should eql( Set[:title] )
+  end
+  
+  it "should be able to determine if it's trackable" do
+    @resource.trackable?().should equal( true )
+    @resource.stub!(:method).and_return( :put )
+    @resource.trackable?().should equal( false )
+  end
+  
+  it "should be able to generate a lookup signature" do
+    @resource.signature().should eql( "products_show_get" )
+  end
+  
+  it "should be able to dump itself to a serializeable representation" do
+    @resource.marshal_dump().should eql( { "products_show_get" => { :models => [],
+                                                                    :method => :get,   
+                                                                    :format => :html,
+                                                                    :action => "show",   
+                                                                    :controller => "products"} } )
+  end
+  
+  it "should be able to restore itself from a serialized representation" do
+    Marshal.load( Marshal.dump( @resource ) ).should eql( @resource )
+  end  
+  
+  it "should be able to compare itself to other resource trackers" do
+    @resource.should eql( @resource )
+  end
+  
+  it "should be able to setup Rack middleware" do
+    @resource.profile.orm.stub!(:resource_scope_method).and_return(:scoped_to_resource_method)
+    @resource << @model
+    @resource.middleware().class.should equal( Array )
+    @resource.middleware().first.class.should equal( Class )
+    @resource.middleware().first.inspect.should match( /Middleware/ )
+    @resource.middleware().first.inspect.should match( /Product/ )
+    @resource.middleware().first.new( @model ).should respond_to( :call )
+  end
+  
+  it "should implemented a custom Object#inspect" do
+    @resource << @model
+    @resource.inspect().should match( /GET/ )
+    @resource.inspect().should match( /products/ )
+    @resource.inspect().should match( /Product/ )
+  end  
+  
+end

data/spec/units/scrooge_spec.rb

@@ -0,0 +1,13 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Base do
+  
+  before(:each) do
+    @base = Scrooge::Base
+  end
+  
+  it "should be able to instantiate it's profile" do
+    @base.profile.class.should == Scrooge::Profile
+  end
+  
+end