svenfuchs-stubby 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sven Fuchs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,242 @@
+## Stubby - lightweight and fast stubbing
+
+Stubby is a lightweight and fast stubbing framework that was 
+
+* designed to help with the repetitive work of setting up stub scenarios for specifying/testing and
+* optimized for speed and ease of use.
+ 
+Stubby does not track references to stubbed methods on real objects (like
+RSpec's `stub!` method does it which is used by `stub_model` & co).
+
+Instead it dynamically creates a Ruby class for every stub object once. These
+classes will then be instantiated for every specification (or test). This
+circumvents the overhead of adding, tracking and removing lots of methods
+and can - depending on your stubs and specs - result in significant speed
+improvements.
+
+## Stubs setup
+
+Stubby comes with a slick DSL to make it easy to describe stub setups. Basically
+there are three main statements:
+
+* `define Model &block` - defines a stub base class that camouflages as a model class
+* `instance :key`, methods - defines a concrete stub that inherits from a stub base class and will be instantiated on request
+* `scenario :key &block` - defines a code block that can be executed from your spec (e.g. in before :each blocks)
+
+Things are pretty much readable and self-explaining:
+
+    define Site do
+      methods :save => true, :destroy => true, :active? => true
+      instance :homepage, :id => 1
+      instance :customer, :id => 2, :active? => false
+    end
+
+This creates a stub base class that camouflages as your `Site` model (i.e. it
+behaves as this model when methods like `class`, `is_a?`, `===` etc. are sent to it).
+
+For the Site stub base class there are a couple of methods defined (stubbed)
+that you can call in your specs and that will return the given values (like
+`save` will return `true`).
+
+It also defines two stub instances for this class that can be accessed through
+the keys `:homepage` and `:customer`. These both respond to the `id` method. The 
+`:customer` instance additionally overwrites the `active?` value that's present
+in the base class.
+
+## Access stubs
+
+You can access these stubs from 
+
+* the stub base class definition block (like the one above)
+* scenario blocks (see below)
+* your specs
+
+To access them you can use the following method apis. With the Site stub base
+class above being defined:
+
+    stub_site             # returns the first defined stub instance (i.e. :homepage)
+    stub_site(:homepage)  # returns the :homepage stub instance
+    stub_sites            # returns an array with all defined stub instances
+    stub_sites(:homepage) # returns an array containing the :homepage stub instance
+
+You can also use the `lookup(:site, :homepage)` method in the same way in case you
+need it.
+
+These accessors can be used from within the stub base class definition like 
+this:
+
+    define Site do
+      instance :homepage, :next => stub_site(:customer)
+      instance :customer, :next => stub_site(:homepage)
+    end
+
+This creates a method `next` on both instances which return the respective 
+stub instances.
+
+For convenience you can pass arrays of method names as keys of method
+hashs:
+
+    define Site do
+      methods [:save, :destroy, :active?] => true # same result as above
+    end
+
+## Stubbing ActiveRecord associations
+
+To make stubbing of more complex ActiveRecord models easier there are also the
+following helpers:
+
+    define Site do
+      has_many :sections, [:find, :build] => stub_section,
+                          [:paginate] => stub_sections  
+    end
+
+This has the expected effects. With this definition in place the following 
+lines will now all return the same section stub object:
+
+    stub_site.sections.first
+    stub_site.sections.find
+    stub_site.sections.build
+    stub_site.sections.paginate.first
+
+Watch the first of these lines! As you can see the sections `has_many_proxy`
+will automatically be populated with the array stub_sections if you don't
+specify anything explicitely. I.e. that's the same as:
+
+    define Site do
+      has_many :sections, stub_sections,
+                          [:find, :build] => stub_section,
+                          [:paginate] => stub_sections  
+    end
+
+
+If you want the sections array to return something else, though you can specify 
+it:
+
+    define Site do
+      has_many :sections, stub_sections(:root),
+                          [:find, :build] => stub_section,
+                          [:paginate] => stub_sections  
+    end
+
+There are also the `has_one` and `belongs_to` statements which also behave in 
+the expected way:
+
+    define Site do
+      has_one :api_key
+      belongs_to :user
+    end
+
+The `belongs_to` statement implicitely defines the `user_id` method so that it
+returns the id defined for the `stub_user` stub.
+
+## Scenarios
+
+A scenario is simply a code block that can be accessed and executed from your
+specs. You can define a scenario like this:
+
+    scenario :default do
+      @site = stub_site
+      Site.stub!(:find).and_return @site 
+    end
+
+You can then invoke this scenario from your Spec like so:
+
+    before :each do
+      scenario :default # pass as many scenario names as you like
+    end
+
+Because the scenario code block is evaluated in the scope of the before :each
+block the @site instance variable is then accessible from within your specs.
+
+## Installation and Setup
+
+Install Stubby as a usual Rails plugin and add the following line somewhere 
+in your specs where it gets executed. The best place for this is probably
+your `spec/spec_helper.rb` file:
+
+    Stubby::Loader.load
+
+This requires the stubby code and loads the stub definition files once.
+
+## Stub definition files
+
+Stubby assumes that you have on directory where you store your stub definition
+files (and nothing else). A stub definition file is just a ruby file that contains
+all or some of your stub base class and scenario definitions like described above. 
+You can structure your files as you like.
+
+By default Stubby assumes that you 
+
+* use a directory named `stubs/`
+* that is located beneath the directory of your `spec_helper.rb` file
+* that starts requires the stubby code
+
+Stubby then tries to guess the correct directory location. If it gets things 
+wrong or if you want to use a different setup you can specify the directory
+where it looks for your stub definitions files like this:
+
+    Stubby.directory = 'path/to/stubs'
+
+## Limitations
+
+Be aware that Stubby is a framework for plain stubs. That means that it doesn't
+make a single attemp of looking at your model classes and trying to mimick 
+their behaviour. This is different from what other solutions do (which might
+instantiate full functional model objects, like fixtures, or at least mimick
+the model's attributes or similar).
+
+Thus you need to define every single method that your specs call. Personally
+I feel that this is an advantage because it makes visible *what* portions
+of the code my specs actually run (and what they shouldn't). But your mileage
+may vary.
+
+Also, with Stubby it is currently not possible:
+
+* define class methods in stub base classes. You still need to stub class methods manually. The scenario block is a good place to stub common methods though.
+* stub methods in a way so that they return different results depending on a certain parameter passed. You can still use RSpec `stub!(:method).with(:param).and_return(result)` for that though.
+
+If you want to help me with these, please let me know :)
+
+Also, this code is brand new. Consider this an alpha release. I have written
+this library to clean-up and speed-up the 1000+ specs of a project that I'm 
+currently working on. For me Stubby works quite well in this project's specs 
+and it runs these specs in less than 30 seconds (which is less then 50% of
+what a solution with `mock_model` needed).
+
+That doesn't mean that there aren't any major bugs or problems though. Please
+send me your pull requests, patches or just bug requests if so.
+
+## Similar solutions
+
+There are a couple of similar solutions that aim at the same problem but all
+go down different routes. I highly recommend to have a look at:
+
+* [Fixture Scenarios](http://code.google.com/p/fixture-scenarios/) by Tom Preston-Werner, extends Rails' native fixtures
+* [Model Stubbing](http://ar-code.svn.engineyard.com/plugins/model_stubbing/README) by Rick Olson, creates in-memory versions of your models
+* [Exemplar](http://www.bofh.org.uk/articles/2007/08/05/doing-the-fixture-thing) by Piers Cawley
+
+## The name
+
+I was told that in Canada a "stubby" is a certain kind of beer bottle. The
+[Wikipedia page](http://en.wikipedia.org/wiki/Beer_bottle) lists a couple of
+advantages that perfectly match the reasons why I've written this library in
+the first place:
+
+* easier to handle
+* chills faster
+* less breakage
+* lighter in weight
+* less storage space
+* lower center of gravity
+
+Now, given that I've thought of this name before I knew this page I think 
+that's pretty funny and a perfect name for the library.
+
+Also, I'm not a native English speaker but I've been informed on #rubyonrails
+that "Stubby" might also have some sexual connotations in some parts of the
+English speaking world.
+
+## Etc
+
+Authors: [Sven Fuchs](http://www.artweb-design.de) <svenfuchs at artweb-design dot de>  
+License: MIT 

data/lib/stubby.rb

@@ -0,0 +1,54 @@
+require 'stubby/handle'
+require 'stubby/instances'
+require 'stubby/loader'
+
+require 'stubby/base'
+require 'stubby/definition'
+require 'stubby/class_factory'
+require 'stubby/has_many_proxy'
+
+module Stubby
+  module Classes; end
+
+  mattr_accessor :directory  
+  mattr_accessor :scenarios, :base_definitions, :instance_definitions
+  @@scenarios = {}  
+  @@base_definitions = {}
+  @@instance_definitions = {}
+  
+  class << self
+    def included(base)
+      base.after :each do Stubby::Instances.clear! end    
+    end
+
+    def base_definition(name)
+      @@base_definitions[name]
+    end
+
+    def instance_definitions(name)
+      @@instance_definitions[name] ||= {}
+    end   
+  end
+  
+  def scenario(*names)
+    names.each do |name|
+      raise "scenario :#{name} is not defined" unless scenarios[name]
+      instance_eval &scenarios[name]
+    end
+  end
+    
+  def lookup(key, *args)
+    Stubby::Instances.lookup(key.to_s, *args)
+  end
+  
+  def method_missing(name, *args)
+    return lookup($1, *args) if name.to_s =~ /^stub_(.*)/
+    super
+  end
+end
+
+# trying to guess the stub definitions directory, overwrite this setting 
+# as needed in your spec_helper.rb
+if filename = caller.detect{|line| line !~ /rubygems|dependencies/ }
+  Stubby.directory = File.expand_path File.dirname(filename) + "/stubs"
+end

data/lib/stubby/base.rb

@@ -0,0 +1,38 @@
+module Stubby
+  class Base        
+    class << self
+      attr_accessor :original_class
+      
+      def new
+        returning super do |object|
+          object.instance_variable_set :@original_class, original_class
+        end  
+      end
+      
+      def base_class
+        original_class.base_class
+      end
+    end
+    
+    def to_param
+      id.to_s
+    end
+    
+    def class
+      @original_class
+    end
+    
+    def new_record?
+      id.nil?
+    end
+
+    def is_a?(klass)
+      @original_class.ancestors.include? klass
+    end
+    alias :kind_of? :is_a?
+  
+    def instance_of?(klass)
+      @original_class == klass
+    end
+  end
+end

data/lib/stubby/class_factory.rb

@@ -0,0 +1,76 @@
+module Stubby
+  class ClassFactory # too bad, we can't extend ::Class
+    class << self
+      def create(base_class, *args, &block)
+        klass = new(base_class, *args, &block).klass
+      end
+    end
+    
+    attr_reader :klass
+    
+    def initialize(base_class, name, original_class, methods = {}, &block)      
+      @klass = ::Class.new(base_class)
+      target = base_class == Stubby::Base ? Stubby::Classes : base_class
+      target.const_set name.sub('::', ''), @klass
+      
+      @klass.original_class = original_class
+      define_methods methods
+      instance_eval &block if block
+    end
+    
+    def has_many(names, *args)
+      methods = args.extract_options!
+      Array(names).each do |name|
+        values = args.last || lookup(name, :all)
+        as = methods.delete(:_as) || name
+        proxy = Handle.new{ HasManyProxy.new name, values, methods }
+        define_method (as || name), proxy
+      end
+    end
+    
+    def has_one(names, object = nil)
+      Array(names).each do |name|
+        object ||= lookup(name, :first)
+        define_method name, object
+      end
+    end
+    
+    def belongs_to(names, object = nil)
+      Array(names).each do |name|
+        object ||= lookup(name, :first)
+        define_method name, object
+        define_method :"#{name}_id", Handle.new{ object.resolve.id }
+      end
+    end
+    
+    def instance(*args)
+      definition = Definition.new :base_class => @klass, 
+                                  :methods => args.extract_options!, 
+                                  :name => args.shift.to_s.camelize
+      definition.create!                            
+    end
+    
+    def lookup(key, *args)
+      Handle.new{ Stubby::Instances.lookup(key.to_s, *args) }
+    end
+      
+    def method_missing(name, *args)
+      return lookup($1, *args) if name.to_s =~ /^stub_(.*)/
+      super
+    end
+    
+    def define_methods(methods)
+      methods.each do |names, value| 
+        Array(names).each{|name| define_method name, value}
+      end
+    end
+    alias :methods :define_methods
+    
+    def define_method(name, value)
+      @klass.send :define_method, name do |*args|
+        @__values ||= {}
+        @__values[name] ||= value.respond_to?(:resolve) ? value.resolve : value
+      end
+    end
+  end
+end

data/lib/stubby/definition.rb

@@ -0,0 +1,78 @@
+module Stubby
+  class Definition
+    attr_reader :name, :class, :original_class, :base_class, :methods
+    attr_accessor :default_instance_key
+    
+    def initialize(attributes = {})
+      attributes.each{|name, value| instance_variable_set :"@#{name}", value }
+      register
+    end
+    
+    def register
+      if base_class == Base
+        Stubby.base_definitions[key] = self
+      else
+        base_definition.default_instance_key ||= instance_key
+        Stubby.instance_definitions(base_key)[instance_key] = self
+      end
+    end
+    
+    def name
+      @name ||= original_class.name if original_class
+      @name
+    end
+    
+    def base_class
+      @base_class ||= Base
+    end
+    
+    def base_key
+      @base_key ||= base_class.name.demodulize
+    end
+    
+    def base_definition
+      @base_definition ||= Stubby.base_definitions[base_key]
+    end
+    
+    def key
+      @key ||= name.to_s.classify.sub('::', '')
+    end
+    
+    def instance_key
+      @instance_key ||= name.demodulize.underscore.to_sym
+    end
+    
+    def original_class
+      @original_class ||= base_class.original_class if base_class
+      @original_class
+    end
+    
+    def methods
+      @methods ||= {}
+    end
+    
+    def create!(&block)
+      @class = ClassFactory.create(base_class, name, original_class, methods, &block)
+    end
+      
+    def instantiate(key = nil)
+      if key == :all
+        instance_definitions.collect{|key, definition| definition.instantiate }
+      elsif key
+        key = default_instance_key if key == :first
+        instance_definition(key).instantiate
+      else
+        Instances.by_key(base_class)[instance_key] or
+        Instances.store(base_class, self.class.new, instance_key)
+      end
+    end
+
+    def instance_definitions
+      Stubby.instance_definitions(key)
+    end
+    
+    def instance_definition(instance_key)
+      Stubby.instance_definitions(key)[instance_key]
+    end
+  end  
+end

data/lib/stubby/handle.rb

@@ -0,0 +1,17 @@
+module Stubby
+  class Handle < Proc  
+    def initialize(&block)
+      super &block
+    end
+        
+    def resolve      
+      result = call
+      result = result.resolve if result.respond_to? :resolve
+      result
+    end
+      
+    def inspect
+      "<Stubby::Handle:#{__id__}>"
+    end
+  end    
+end

data/lib/stubby/has_many_proxy.rb

@@ -0,0 +1,37 @@
+module Stubby
+  class HasManyProxy < Array
+    attr_accessor :name
+  
+    def initialize(name, values, methods)
+      @name = name
+      @values = values
+      define_methods methods
+    end
+    
+    def resolve
+      if @values.respond_to?(:resolve)
+        replace @values.resolve
+      else
+        replace @values.collect{|object| object.resolve if object.respond_to?(:resolve) }
+      end
+    end
+  
+    def define_methods(methods)
+      methods.each do |names, value| 
+        Array(names).each{|name| define_method name, value}
+      end
+    end
+  
+    def define_method(name, value)
+      (class << self; self; end).send :define_method, name do |*args|
+        @__values ||= {}
+        @__values[name] ||= value.respond_to?(:resolve) ? value.resolve : value
+      end
+    end
+  
+    def inspect
+      "<HasManyProxy:#{name.to_s.camelize}:#{object_id} #{super}>"
+    end
+    alias :to_s :inspect
+  end
+end    

data/lib/stubby/instances.rb

@@ -0,0 +1,62 @@
+module Stubby
+  module Instances
+    class InstanceNotFound < RuntimeError; end
+    
+    class << self  
+      def lookup(klass, key = nil)
+        if (singular = klass.singularize) != klass
+          klass = singular
+          method = :find_all
+          key ||= :all
+        else
+          method = :find_one
+          key ||= :first
+        end
+        method = :find_all if key == :all
+
+        definition = Stubby.base_definition(klass.classify) or raise "could not find base_definition for #{klass.classify}"
+        send(method, definition, key)
+      end 
+      
+      def find_all(definition, key)
+        key = nil if key == :all
+        if key
+          [find_one(definition, key)].compact
+        else
+          definition.instantiate(:all) unless complete[definition.class]
+          complete[definition.class] = true
+          by_class(definition.class)
+        end
+      end
+    
+      def find_one(definition, key)
+        key = definition.default_instance_key if key == :first
+        by_key(definition.class)[key] || definition.instantiate(key)
+      end
+      
+      def by_class(klass)
+        @by_class ||= {}
+        @by_class[klass] ||= []
+      end
+  
+      def by_key(klass)
+        @by_key ||= {}
+        @by_key[klass] ||= {}
+      end
+      
+      def complete
+        @complete ||= {}
+      end
+      
+      def store(klass, object, key)
+        by_class(klass) << object
+        by_key(klass)[key] = object
+      end
+      
+      def clear!
+        @by_class = {}
+        @by_key = {}
+      end
+    end
+  end
+end

data/lib/stubby/loader.rb

@@ -0,0 +1,23 @@
+module Stubby
+  module Loader
+    class << self
+      def scenario(name, &block)
+        Stubby.scenarios[name] = block
+      end
+      
+      def define(original_class, &block)
+        definition = Definition.new :original_class => original_class
+        definition.create! &block
+      end
+    
+      def load
+        unless @loaded
+          Dir["#{Stubby.directory}/*"].each do |filename|
+            instance_eval IO.read(filename), filename
+          end
+        end
+        @loaded = true
+      end 
+    end
+  end
+end

data/spec/no_rails.rb

@@ -0,0 +1,102 @@
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
+class String
+  def singularize
+    sub /s$/, ''
+  end
+  
+  def underscore
+    gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def camelize
+    to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+  alias :classify :camelize
+  
+  def constantize
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+      raise NameError, "#{inspect} is not a valid constant name!"
+    end
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end 
+
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+end
+
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end
+
+class Hash
+  # Returns a new hash with only the given keys.
+  def slice(*keys)
+    allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+    reject { |key,| !allowed.include?(key) }
+  end
+
+  # Replaces the hash with only the given keys.
+  def slice!(*keys)
+    replace(slice(*keys))
+  end
+end
+    
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+        
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'active_support'
+# require File.dirname(__FILE__) + "/no_rails"
+# require 'spec'
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "stubby"
+
+Stubby.directory = File.dirname(__FILE__) + "/stubs"
+
+Spec::Runner.configure do |config|
+  # == Fixtures
+  #
+  # You can declare fixtures for each example_group like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so right here. Just uncomment the next line and replace the fixture
+  # names with your fixtures.
+  #
+  # config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
+  #
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end

data/spec/stubby_spec.rb

@@ -0,0 +1,205 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+module ActiveRecord
+  class Base 
+    attr_accessor :id
+    def has_attribute?(name)
+      false
+    end
+    def inspect
+      "<#{self.class.name}:#{object_id}>"
+    end
+  end 
+end
+
+class Site < ActiveRecord::Base; end
+class Section < ActiveRecord::Base; end
+class User < ActiveRecord::Base; end
+class ApiKey < ActiveRecord::Base; end
+
+Stubby::Loader.load
+
+describe "Stubby" do
+  include Stubby
+
+  before :each do
+    scenario :site
+  end
+  
+  describe "base class creation" do
+    it "creates a class Stubby::Classes::Site" do
+      lambda{ Stubby::Classes::Site }.should_not raise_error
+    end
+    
+    it "creates a class Stubby::Classes::Section" do
+      lambda{ Stubby::Classes::Section }.should_not raise_error
+    end
+    
+    describe "an instance of the site base class" do
+      it "responds to :save" do
+        Stubby::Classes::Site.new.should respond_to(:save)
+      end
+      
+      it "responds to :destroy" do
+        Stubby::Classes::Site.new.should respond_to(:destroy)
+      end
+      
+      it "responds to :active?" do
+        Stubby::Classes::Site.new.should respond_to(:active?)
+      end
+      
+      it "responds to :sections" do
+        Stubby::Classes::Site.new.should respond_to(:sections)
+      end
+      
+      it "responds to :user" do
+        Stubby::Classes::Site.new.should respond_to(:user)
+      end
+      
+      it "responds to :api_key" do
+        Stubby::Classes::Site.new.should respond_to(:api_key)
+      end
+    end
+  end
+  
+  describe "instance class creation" do
+    it "creates a class Stubby::Classes::Site::Site" do
+      lambda{ Stubby::Classes::Site::Site }.should_not raise_error
+    end
+  
+    it "creates a class Stubby::Classes::Section::Root" do
+      lambda{ Stubby::Classes::Section::Root }.should_not raise_error
+    end
+    
+    describe "an instance of the site instance class" do
+      it "responds to :save (as inherited from its base class)" do
+        Stubby::Classes::Site::Site.new.should respond_to(:save)
+      end
+  
+      it "responds to :name" do
+        Stubby::Classes::Site::Site.new.should respond_to(:name)
+      end
+    end
+  end
+  
+  describe "stub lookup" do
+    describe "with a singular lookup method" do
+      it "returns the first defined stub if no key is given" do
+        stub_site.name.should == 'site'
+      end
+    
+      it "returns the stub referenced by a given key" do
+        stub_site(:another).name.should == 'another'
+      end
+    
+      it "returns a collection of all stubs when :all is given as a key" do
+        stub_site(:all).should == [stub_site, stub_site(:another)]
+      end    
+    end
+    
+    describe "with a plural lookup method" do
+      it "returns an array containing all stubs when no key is given" do
+        sites = stub_sites
+        sites.size.should == 2
+        sites.should == [stub_site, stub_site(:another)]
+      end
+          
+      it "returns an array containing all stubs when :all is given as a key" do
+        sites = stub_sites(:all)
+        sites.size.should == 2
+        sites.should == [stub_site, stub_site(:another)]
+      end
+          
+      it "returns an array containing the referenced stub when a key is given" do
+        sites = stub_sites(:another)
+        sites.size.should == 1
+        sites.should == [stub_site(:another)]
+      end
+      
+      it "returns an array containing all stubs even when a single stub has been looked up before" do
+        stub_site
+        sites = stub_sites(:all)
+        sites.size.should == 2
+        sites.should == [stub_site, stub_site(:another)]
+      end
+    end
+    
+  end
+  
+  describe "a has_many_proxy" do                                                
+    it "responds to :find" do
+      @site.sections.respond_to?(:find).should be_true
+    end
+  
+    it "its find method returns an array of stub instance masquerading as a Site instance" do
+      @site.sections.find.should == stub_section
+    end
+  
+    it "its target is an array of stub instances masquerading as a Site instance" do
+      @site.sections.should == stub_sections
+    end
+  
+    it "works with rspec mock expectations" do
+      @site.sections.should_receive(:foo)
+      @site.sections.foo
+    end
+  end
+  
+  describe "a method on a stub" do
+    before :each do
+      @another = stub_site(:another)
+    end
+    
+    it "returns the same stub during one spec" do
+      @site.next.object_id.should == @another.object_id
+      @site.next.object_id.should == @another.object_id
+    end
+    
+    previous_object_id = nil
+    1.upto(2) do # what's a less brittle way to spec something like this?
+      it "returns a new stub for each spec" do
+        previous_object_id.should_not == @site.next.object_id
+        previous_object_id = @site.next.object_id
+      end
+    end
+  end
+  
+  describe "a method on a HasManyProxy" do
+    before :each do
+      @section = stub_section
+    end
+    
+    it "returns the same stub during one spec" do
+      @site.sections.find.object_id.should == @section.object_id
+      @site.sections.find.object_id.should == @section.object_id
+    end
+    
+    previous_object_id = nil
+    1.upto(2) do # what's a less brittle way to spec something like this?
+      it "returns a new stub for each spec" do
+        previous_object_id.should_not == @site.sections.find.object_id
+        previous_object_id = @site.sections.find.object_id
+      end
+    end
+  end
+  
+  describe "a HasManyProxy's content" do
+    before :each do
+      @section = stub_section
+    end
+    
+    it "returns the same stub during one spec" do
+      @site.sections.first.object_id.should == @section.object_id
+      @site.sections.first.object_id.should == @section.object_id
+    end
+    
+    previous_object_id = nil
+    1.upto(2) do # what's a less brittle way to spec something like this?
+      it "returns a new stub for each spec" do
+        previous_object_id.should_not == @site.sections.first.object_id
+        previous_object_id = @site.sections.first.object_id
+      end
+    end
+  end
+
+end

data/spec/stubs/site.rb

@@ -0,0 +1,34 @@
+define Section do
+  instance :root
+end
+
+define User do
+  instance :admin
+end
+
+define ApiKey do
+  instance :default
+end
+
+define Site do
+  has_many :sections, [:find, :build, :root] => stub_section,
+                      [:paginate] => stub_sections
+  belongs_to :user
+  has_one :api_key
+    
+  methods  [:save, :destroy] => true,
+           :next => stub_site(:another),
+           :active? => true
+  
+  instance :site,
+           :id => 1,
+           :name => 'site'
+  
+  instance :another,
+           :id => 2,
+           :name => 'another'
+end
+
+scenario :site do
+  @site = stub_site(:site)
+end

data/stubby.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "stubby"
+  s.version = "0.0.1"
+  s.date = "2008-05-29"
+  s.summary = "Lightweight and fast stubbing framework"
+  s.email = "svenfuchs@artweb-design.de"
+  s.homepage = "http://github.com/svenfuchs/stubby"
+  s.description = "Stubby is a lightweight and fast stubbing framework that was designed to help with the repetitive work of setting up stub scenarios for specifying/testing and optimized for speed and ease of use."
+  s.has_rdoc = false
+  s.authors = ["Sven Fuchs"]
+  s.files = ["lib/stubby/base.rb", "lib/stubby/class_factory.rb", "lib/stubby/definition.rb", "lib/stubby/handle.rb", "lib/stubby/has_many_proxy.rb", "lib/stubby/instances.rb",  "lib/stubby/loader.rb", "lib/stubby.rb", "MIT-LICENSE", "README.markdown", "spec/no_rails.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/stubby_spec.rb", "spec/stubs", "spec/stubs/site.rb", "stubby.gemspec"]
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: svenfuchs-stubby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-29 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Stubby is a lightweight and fast stubbing framework that was designed to help with the repetitive work of setting up stub scenarios for specifying/testing and optimized for speed and ease of use.
+email: svenfuchs@artweb-design.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/stubby/base.rb
+- lib/stubby/class_factory.rb
+- lib/stubby/definition.rb
+- lib/stubby/handle.rb
+- lib/stubby/has_many_proxy.rb
+- lib/stubby/instances.rb
+- lib/stubby/loader.rb
+- lib/stubby.rb
+- MIT-LICENSE
+- README.markdown
+- spec/no_rails.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/stubby_spec.rb
+- spec/stubs
+- spec/stubs/site.rb
+- stubby.gemspec
+has_rdoc: false
+homepage: http://github.com/svenfuchs/stubby
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Lightweight and fast stubbing framework
+test_files: []
+