methodmissing-scrooge 1.0.4 → 2.0.0

data/spec/fixtures/config/scrooge.yml

@@ -1,20 +0,0 @@
-production:
-  orm: :active_record
-  storage: :memory
-  verbose: false
-  scope: 1234567891 
-  on_missing_attribute: :reload
-  strategy: :track_then_scope
-  warmup: 600 # warmup / track for 10 minutes
-  logged_in_session: :user_id # session key that represents the logged in user   
-  enabled: true  
-test:
-  orm: :active_record
-  storage: :memory
-  verbose: true
-  scope: 
-  on_missing_attribute: :reload      
-  strategy: :track_then_scope
-  warmup: 600 # warmup / track for 10 minutes
-  logged_in_session: :user_id # session key that represents the logged in user  
-  enabled: true  

data/spec/helpers/framework/rails/cache.rb

@@ -1,25 +0,0 @@
-module Spec
-  module Helpers
-    module Framework
-      module Rails
-        class Cache
-          
-          attr_reader :storage
-          
-          def initialize
-            @storage = {}
-          end
-          
-          def read( key )
-            @storage[key]
-          end
-          
-          def write( key, value )
-            @storage[key] = value
-          end
-          
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,55 +0,0 @@
-$:.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'fileutils'
-require 'logger'
-require 'stringio'
-require 'lib/scrooge'
-require 'spec/helpers/framework/rails/cache'
-
-#ActiveRecord::Base.logger = Logger.new(StringIO.new)
-
-Spec::Runner.configure do |config|
-  
-  def self.set_constant( const, value )
-    eval( "Kernel.const_set :#{const.to_s}, #{value.inspect} unless defined?( #{const.to_s} )" )
-  end
-  
-  set_constant( :FIXTURES, "#{Dir.pwd}/spec/fixtures" )
-  set_constant( :TMP, "#{Dir.pwd}/spec/tmp" )
-  set_constant( :CONFIG, "#{Dir.pwd}/spec/config" )
-  
-  config.before :all do
-    [TMP, CONFIG].each do |dir|
-      FileUtils.mkdir_p dir
-    end
-  end
-  
-  config.before :each do
-  end
-  
-  config.after :each do
-  end    
-  
-  config.after :all do
-    [TMP, CONFIG].each do |dir|
-      FileUtils.rm_r( dir ) rescue nil
-    end
-  end
-  
-  def with_rails
-    begin
-      Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/spec" unless defined?(RAILS_ROOT)
-      Kernel.const_set :Rails, Class.new unless defined?(Rails)
-      Kernel.const_set :RAILS_ENV, "test" unless defined?(RAILS_ENV)
-      ::Rails.stub!(:cache).and_return( Spec::Helpers::Framework::Rails::Cache.new )
-      ::Rails.stub!(:root).and_return( RAILS_ROOT )
-      yield
-    ensure
-      [:RAILS_ROOT, :RAILS_ENV, :Rails].each do |const|  
-        Kernel.send( :remove_const, const )
-      end
-    end
-  end
-  
-end

data/spec/units/scrooge/core/string_spec.rb

@@ -1,21 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Core::String do
-  
-  before(:each) do
-    @string = 'scrooge/base'
-  end
-  
-  it "should be able to convert itself to a constant" do
-    @string.to_const().should == 'Scrooge::Base'
-  end
-  
-  it "should be able to convert itself to a class" do
-    @string.to_const!( false ).should == Scrooge::Base
-  end
-  
-  it "should return self if it's not able to constantize" do
-    'not/defined'.to_const!( false ).should == 'not/defined'
-  end
-  
-end

data/spec/units/scrooge/core/symbol_spec.rb

@@ -1,13 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Core::Symbol do
-  
-  before(:each) do
-    @symbol = :active_record
-  end
-  
-  it "should be able to convert itself to a constant" do
-    @symbol.to_const().should == 'ActiveRecord'
-  end
-  
-end

data/spec/units/scrooge/core/thread_spec.rb

@@ -1,15 +0,0 @@
-require 'spec/spec_helper'
-
-describe "Scrooge::Core::Thread singleton" do
-  
-  it "should be able to yield the current scrooge resource" do
-    Thread.scrooge_resource.class.should equal( Scrooge::Tracker::Resource )
-  end
-  
-  it "should be able to reset the current scrooge resource" do
-    @resource = Thread.scrooge_resource
-    Thread.reset_scrooge_resource!
-    @resource.object_id.should_not equal( Thread.scrooge_resource.object_id )
-  end
-  
-end

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

@@ -1,160 +0,0 @@
-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 )   
-      FileUtils.rm_r( File.join( @base.scopes_path, @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( false )
-    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" )
-      @base.to_scope!()
-      @base.scopes.size.should == 1
-    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{ Scrooge::Base.profile.scope = @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 uninstall tracking middleware" do
-    lambda{ @base.uninstall_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

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

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

@@ -1,79 +0,0 @@
-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 )
-    with_rails do
-      @profile.framework.stub!(:scopes).and_return( %w(1234567891) )
-    end
-    @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 infer the current scope" do
-    @profile.scope.should eql( "1234567891" )
-  end
-    
-  it "should be able to determine if it's enabled" do
-    @profile.enabled?().should eql( false )  
-  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.should eql( 'scope_from_env' )   
-  end  
-    
-  it "should be able to yield a stategy instance" do
-    @profile.strategy.class.should == Scrooge::Strategy::Track 
-  end  
-    
-  it "should be able to expose it's warmup tracking period" do
-    @profile.warmup.should == 0
-  end  
-  
-  it "should be able to return a session key that indicates a logged in session" do
-    @profile.logged_in_session.should == :user_id
-  end  
-  
-  it "should be able to determine if logging should be verbose" do
-    @profile.verbose?().should == false
-  end
-  
-end

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

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

@@ -1,20 +0,0 @@
-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/strategy/base_spec.rb

@@ -1,62 +0,0 @@
-require 'spec/spec_helper'
-
-describe 'Scrooge::Strategy::Base singleton' do
- 
-  after(:each) do
-    Scrooge::Strategy::Base.flush!
-  end
-  
-  it "should be able to determine if it has any stages" do
-    Scrooge::Strategy::Base.stages?().should equal( false )
-    Scrooge::Strategy::Base.stage( :stage ) do
-      'payload'
-    end
-    Scrooge::Strategy::Base.stages?().should equal( true )
-  end
-  
-  it "should be able to yield all it's defined stages" do
-    Scrooge::Strategy::Base.stages.should eql( [] )
-  end
-  
-  it "should be able to register one or more execution stages" do
-    lambda do 
-      Scrooge::Strategy::Base.stage( :stage ) do
-        'payload'
-      end
-    end.should change( Scrooge::Strategy::Base.stages, :size ).from(0).to(1)
-  end
-  
-  it "should require at least one defined stage" do
-    lambda{ @base.scope_to( Scrooge::Strategy::Base.new ) }.should raise_error( Scrooge::Strategy::Base::NoStages )
-  end
-  
-end  
-
-describe Scrooge::Strategy::Base do
-  
-  before(:each) do
-    Scrooge::Strategy::Base.stage( :stage ) do
-      'payload'
-    end
-    @base = Scrooge::Strategy::Base.new
-    Scrooge::Base.profile.stub!(:enabled?).and_return(true)
-  end
-  
-  after(:each) do
-    Scrooge::Strategy::Base.flush!
-  end  
-  
-  it "should be able to infer all defined stages" do
-    @base.stages.first.class.should eql( Scrooge::Strategy::Stage )
-  end
-  
-  it "should be able to execute itself" do
-    @base.execute!().class.should == Thread
-  end
-  
-  it "should provide access to it's controller Thread" do
-    @base.execute!
-    @base.thread.class.should == Thread
-  end
-  
-end

data/spec/units/scrooge/strategy/controller_spec.rb

@@ -1,26 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Strategy::Base do
-  
-  before(:each) do
-    Scrooge::Strategy::Base.stage( :stage ) do
-      'payload'
-    end
-    @base = Scrooge::Strategy::Base.new
-    @controller = Scrooge::Strategy::Controller.new( @base )
-  end
-  
-  after(:each) do
-    Scrooge::Strategy::Base.flush!
-  end
-  
-  it "should be able to execute a given strategy" do
-    @controller.run!().value.should include( 'payload' )
-  end
-  
-  it "should be able to provide access to the background thread" do
-    @controller.run!()
-    @controller.thread.class.should == Thread
-  end  
-  
-end  

data/spec/units/scrooge/strategy/scope_spec.rb

@@ -1,18 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Strategy::Scope do
-  
-  before(:each) do
-    @scope = Scrooge::Strategy::Scope.new
-    @controller = Scrooge::Strategy::Controller.new( @scope )
-    Scrooge::Base.profile.framework.stub!(:install_scope_middleware).and_return('installed')
-    Scrooge::Base.profile.stub!(:scope).and_return( '1234567891' )    
-  end
-  
-  it "should be able to execute a given strategy" do
-    with_rails do
-      lambda{ @controller.run!().value }.should raise_error( SystemExit )
-    end
-  end
-  
-end