test_dummy 0.2.10 → 0.3.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem 'rails'
+
+group :development do
+  gem 'jeweler'
+  gem 'sqlite3'
+end

data/README.md

@@ -0,0 +1,51 @@
+# test_dummy
+
+Test Dummy is an easy fake data generator library with the ability to create
+fake models or entirely faked data structures on-demand.
+
+After installing the gem, methods to declare how to fake data are made
+available within ActiveRecord-derived models. There are several ways to
+declare how to dummy something:
+
+```
+class MyModel < ActiveRecord::Base
+  # Pass a block that defines how to dummy this attribute
+  dummy :name do
+    "user%d" % rand(10e6)
+  end
+  
+  # Pass a block that defines how to dummy several attributes
+  dummy :password, :password_confirmation do
+    'tester'
+  end
+  
+  # Use one of the pre-defined helper methods to dummy this attribute
+  dummy :nickname, :use => :random_phonetic_string
+end
+```
+
+Dummy configuration can also be stored in test/dummy to avoid cluttering
+your models up with generators. An equivalent external declaration would look
+like this:
+
+```ruby
+TestDummy.declare(MyModel) do
+  dummy :name do
+    "user%d" % rand(10e6)
+  end
+
+  dummy :password, :password_confirmation do
+    'tester'
+  end
+
+  dummy :nickname, :use => :random_phonetic_string
+end
+```
+
+The name of the test/dummy file should be the same as the main model
+defined in app/models. For instance, app/models/my_model.rb would have a
+corresponding test/dummy/my_model.rb that would be loaded as required.
+
+== Copyright
+
+Copyright (c) 2010-2012 Scott Tadman, The Working Group

data/Rakefile

@@ -23,38 +23,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-task :test => [ :check_dependencies, "test:db:prepare" ]
-
 task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "test_dummy #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-namespace :test do
-  namespace :db do
-    desc "Prepares the test Sqlite3 database"
-    task :prepare do
-      # ...
-    end
-  end
-end

data/VERSION

@@ -1 +1 @@
-0.2.10
+0.3.0

data/lib/test_dummy/helper.rb

@@ -1,13 +1,27 @@
 module TestDummy::Helper
-  ALPHANUMERIC_SET = [ 'a'..'z', 'A'..'Z', '0'..'9' ].collect(&:to_a).flatten.freeze
+  ALPHANUMERIC_SET = [
+    'a'..'z', 'A'..'Z', '0'..'9'
+  ].collect(&:to_a).flatten.freeze
 
   # There are certain substrings that shouldn't be emitted as part of the
   # random strings in order to keep them safe and inoffensive. While this is
   # not exhaustive, it should scrub the random strings enough that it would
   # be a stretch to see something wrong with them, at least in English.
   AVOID_SUBSTRINGS = Regexp.new(%w[
-    ass a55 as5 a5s bal bit btc b1t bul bll bls but btu chi ch1 cun cnt dic dik d1c d1k fag f4g fuc fuk fck fcu fkn fkc kik kyk k1k jer jrk j3r jew j3w mot m0t m07 mth m7h mtr m7r neg n3g ngr nig n1g pak p4k pof p0f poo po0 p00 que qu3 qee q3e qe3 shi sh1 shy stf sht sfu spi spk sp1 tar t4r trd wtf wth xxx
-  ].join('|'))
+    ass a55 as5 a5s bal bit btc b1t bul bll bls but btu chi
+    ch1 cun cnt dic dik d1c d1k fag f4g fuc fuk fck fcu fkn
+    fkc kik kyk k1k jer jrk j3r jew j3w mot m0t m07 mth m7h
+    mtr m7r neg n3g ngr nig n1g pak p4k pof p0f poo po0 p00
+    que qu3 qee q3e qe3 shi sh1 shy stf sht sfu spi spk sp1
+    tar t4r trd wtf wth xxx f1f fif msl mus mlm grl kil kll
+  ].join('|')).freeze
+
+  CONSONANTS = %w[
+    b c d f g h j k l m n p qu r s t v w x z ch cr fr
+    nd ng nk nt ph pr rd sh sl sp st th tr 
+  ].freeze
+
+  VOWELS = %w[ a e i o u y ].freeze
   
   def random_string(length = 12)
     string = nil
@@ -27,9 +41,6 @@ module TestDummy::Helper
     string
   end
 
-  CONSONANTS = %w[ b c d f g h j k l m n p qu r s t v w x z ch cr fr nd ng nk nt ph pr rd sh sl sp st th tr ]
-  VOWELS = %w[ a e i o u y ]
-
   def random_phonetic_string(length = 12)
     string = nil
     

data/lib/test_dummy/railtie.rb

@@ -6,6 +6,9 @@ when 2
   if (defined?(ActiveSupport) and defined?(ActiveSupport::TestCase))
     ActiveSupport::TestCase.send(:include, TestDummy::TestHelper)
   end
+  if (defined?(Test) and defined?(Test::Unit))
+    Test::Unit::TestCase.send(:include, TestDummy::TestHelper)
+  end
 else
   class TestDummy::Railtie < Rails::Railtie
     def self.apply!
@@ -14,6 +17,7 @@ else
       end
 
       ActiveSupport::TestCase.send(:include, TestDummy::TestHelper)
+      Test::Unit::TestCase.send(:include, TestDummy::TestHelper)
     end
     
     config.before_configuration do

data/lib/test_dummy.rb

@@ -4,15 +4,27 @@ module TestDummy
     require 'test_dummy/railtie'
   end
 
+  class Exception < ::Exception
+  end
+
   autoload(:Helper, File.expand_path('test_dummy/helper', File.dirname(__FILE__)))
   autoload(:TestHelper, File.expand_path('test_dummy/test_helper', File.dirname(__FILE__)))
   
-  def self.dummy_directory
-    @dummy_directory or (defined?(Rails) and Rails.root)
+  # Returns the current path used to load dummy extensions into models, or
+  # nil if no path is currently defined. Defaults to "test/dummy" off of the
+  # Rails root if Rails is available.
+  def self.dummy_extensions_path
+    @dummy_extensions_path ||= begin
+      if (defined?(Rails))
+        File.expand_path('test/dummy', Rails.root)
+      else
+        nil
+      end
+    end
   end
   
-  def self.dummy_directory=(value)
-    @dummy_directory = value
+  def self.dummy_extensions_path=(value)
+    @dummy_extensions_path = value
   end
 
   def self.included(base)
@@ -45,12 +57,36 @@ module TestDummy
 
       combined_attributes
     end
+
+    # This method is used to provide a unified interface to the otherwise
+    # irregular methods to discover information on assocations. Rails 3
+    # introduces a new method. Returns the reflected class and foreign key
+    # properties for a named attribute, or nil if no association could be found.
+    def self.reflection_properties(model_class, attribute)
+      if (model_class.respond_to?(:reflect_on_association) and reflection = model_class.reflect_on_association(attribute))
+        [
+          reflection.klass,
+          (reflection.respond_to?(:foreign_key) ? reflection.foreign_key : reflection.primary_key_name).to_sym
+        ]
+      elsif (model_class.respond_to?(:association_reflection) and reflection = model_class.association_reflection(attribute))
+        [
+          reflection[:associated_class],
+          reflection[:key] || :"#{attribute.to_s.underscore}_id"
+        ]
+      end
+    end
   end
 
   # Adds a mixin to the core Helper module
   def self.add_module(new_module)
     Helper.send(:extend, new_module)
   end
+
+  # Used to configure defaults or aliases that can be used by all definitions.
+  # Takes a block that should call definition methods like `dummy`.
+  def self.define(&block)
+    instance_eval(&block)
+  end
   
   # Used in an initializer to define things that can be dummied by all
   # models if these properties are available.
@@ -61,18 +97,22 @@ module TestDummy
     end
     
     if (options and options[:with])
-      block = options[:with]
-    end
+      with = options[:with]
 
-    # Create a temporary Module and use this to roll up the methods defined
-    # into the Helper module
-    Helper.send(
-      :extend,
-      names.inject(Module.new) do |m, name|
-        m.send(:define_method, name, &block)
-        m
+      names.each do |name|
+        if (Helper.respond_to?(with))
+          Helper.send(:alias_method, name, with)
+        else
+          Helper.send(:define_method, name) do
+            send(with)
+          end
+        end
+      end
+    else
+      names.each do |name|
+        Helper.send(:define_method, name, &block)
       end
-    )
+    end
   end
   
   # Used in an initializer to define configuration parameters.
@@ -99,15 +139,103 @@ module TestDummy
         options = names.pop
       end
       
-      if (options and options[:with])
-        block = options[:with]
-      end
-      
       @test_dummy ||= { }
       @test_dummy_order ||= [ ]
       
       names.flatten.each do |name|
         name = name.to_sym
+        from = nil
+        create_options_proc = nil
+
+        if (options)
+          if (options[:with])
+            if (block)
+              raise TestDummy::Exception, "Cannot use block and :with option at the same time."
+            end
+
+            block =
+              case (with = options[:with])
+              when Proc
+                with
+              when String, Symbol
+                lambda { send(with) }
+              else
+                lambda { with }
+              end
+          end
+
+          # The :inherit directive is used to pass arguments through to the
+          # create_dummy call on the association's class.
+          if (inherit = options[:inherit])
+            inherit_options = Hash[
+              inherit.collect do |attribute, spec|
+                [
+                  attribute.to_sym,
+                  case (spec)
+                  when Array
+                    spec.collect(&:to_sym)
+                  when String
+                    spec.split('.').collect(&:to_sym)
+                  when Proc
+                    spec
+                  end
+                ]
+              end
+            ]
+
+            create_options_proc = lambda do |target, model, with_attributes|
+              inherit_options.each do |attribute, spec|
+                target[attribute] ||=
+                  case (spec)
+                  when Array
+                    spec.inject(model) do |_model, _method|
+                      _model ? _model.send(_method) : nil
+                    end
+                  when Proc
+                    proc.call(model, with_attributes)
+                  end
+              end
+            end
+          end
+
+          if (from = options[:from])
+            if (block)
+              raise TestDummy::Exception, "Cannot use block, :with, or :from option at the same time."
+            end
+
+            case (from)
+            when Array
+              # Already in correct form
+            when Hash
+              from = from.to_a
+            when String
+              from = from.split('.')
+            else
+              raise TestDummy::Exception, "Argument to :from must be a String, Array or Hash."
+            end
+          end
+
+          block = lambda do |model, with_attributes|
+            reflection_class, foreign_key = TestDummy::Support.reflection_properties(self, name)
+
+            if (reflection_class and foreign_key)
+              unless ((with_attributes and (with_attributes.key?(name) or with_attributes.key?(foreign_key))) or model.send(name).present?)
+                object = from && from.inject(model) do |_model, _method|
+                  _model ? _model.send(_method) : nil
+                end
+
+                object ||=
+                  reflection_class.create_dummy(with_attributes) do |target|
+                    if (create_options_proc)
+                      create_options_proc.call(target, model, with_attributes)
+                    end
+                  end
+
+                model.send(:"#{name}=", object)
+              end
+            end
+          end
+        end
 
         # For associations, delay creation of block until first call
         # to allow for additional relationships to be defined after
@@ -136,7 +264,7 @@ module TestDummy
       load_dummy_declaration!
       
       build_scope = (method(:scoped).arity == 1) ? scoped(nil).scope(:create) : scoped.scope_for_create
-      
+
       model = new(TestDummy::Support.combine_attributes(build_scope, with_attributes))
 
       yield(model) if (block_given?)
@@ -210,8 +338,16 @@ module TestDummy
       return model unless (@test_dummy_order)
       
       @test_dummy_order.each do |name|
-        if (reflection = reflect_on_association(name))
-          unless ((with_attributes and with_attributes.key?(name.to_sym)) or model.send(name).present?)
+        if (respond_to?(:reflect_on_association) and reflection = reflect_on_association(name))
+          foreign_key = (reflection.respond_to?(:foreign_key) ? reflection.foreign_key : reflection.primary_key_name).to_sym
+          
+          unless ((with_attributes and (with_attributes.key?(name.to_sym) or with_attributes.key?(foreign_key.to_sym))) or model.send(name).present?)
+            model.send(:"#{name}=", dummy_method_call(model, with_attributes, dummy_method(name)))
+          end
+        elsif (respond_to?(:association_reflection) and reflection = association_reflection(name))
+          key = reflection[:key] || :"#{name.to_s.underscore}_id"
+
+          unless ((with_attributes and (with_attributes.key?(name.to_sym) or with_attributes.key?(key.to_sym))) or model.send(name).present?)
             model.send(:"#{name}=", dummy_method_call(model, with_attributes, dummy_method(name)))
           end
         else
@@ -230,15 +366,13 @@ module TestDummy
 
       @_dummy_module =
         begin
-          dummy_path = File.expand_path(
-            "test/dummy/#{name.underscore}.rb",
-            TestDummy.dummy_directory
-          )
+          dummy_path = File.expand_path("#{name.underscore}.rb", TestDummy.dummy_extensions_path)
       
           if (File.exist?(dummy_path))
-            load dummy_path
+            load(dummy_path)
           end
         rescue LoadError
+          # Persist that this load attempt failed and don't retry later.
           false
         end
     end
@@ -265,14 +399,25 @@ module TestDummy
       when Symbol
         Helper.method(name)
       when true
-        # Configure association dummyr the first time it is called
-        if (reflection = reflect_on_association(name))
+        # Configure association dummy the first time it is called
+        if (respond_to?(:reflect_on_association) and reflection = reflect_on_association(name))
           foreign_key = (reflection.respond_to?(:foreign_key) ? reflection.foreign_key : reflection.primary_key_name).to_sym
 
           @test_dummy[name] =
             lambda do |model, with_attributes|
-              (with_attributes and with_attributes.key?(foreign_key)) ? nil : reflection.klass.send(:create_dummy)
+              (with_attributes and (with_attributes.key?(foreign_key) or with_attributes.key?(name))) ? nil : reflection.klass.send(:create_dummy)
+            end
+        elsif (respond_to?(:association_reflection) and reflection = association_reflection(name))
+          key = reflection[:key] || :"#{name.to_s.underscore}_id"
+
+          @test_dummy[name] =
+            lambda do |model, with_attributes|
+              (with_attributes and (with_attributes.key?(key) or with_attributes.key?(name))) ? nil : reflection[:associated_class].send(:create_dummy)
             end
+        elsif (TestDummy::Helper.respond_to?(name))
+          @test_dummy[name] = lambda do |model, with_attributes|
+            TestDummy::Helper.send(name)
+          end
         else
           raise "Cannot dummy unknown relationship #{name}"
         end

data/test/db/migrate/0001_create_examples.rb

@@ -0,0 +1,8 @@
+class CreateExamples < ActiveRecord::Migration
+  def change
+    create_table :examples do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/test/db/migrate/0002_create_accounts.rb

@@ -0,0 +1,8 @@
+class CreateAccounts < ActiveRecord::Migration
+  def change
+    create_table :accounts do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/test/db/migrate/0003_create_bills.rb

@@ -0,0 +1,9 @@
+class CreateBills < ActiveRecord::Migration
+  def change
+    create_table :bills do |t|
+      t.integer :account_id
+      t.date :order_date
+      t.timestamps
+    end
+  end
+end

data/test/db/migrate/0004_create_items.rb

@@ -0,0 +1,10 @@
+class CreateItems < ActiveRecord::Migration
+  def change
+    create_table :items do |t|
+      t.integer :account_id
+      t.integer :bill_id
+      t.string :description
+      t.timestamps
+    end
+  end
+end

data/test/{models/simple.rb → dummy/account.rb}

@@ -1,4 +1,4 @@
-class Simple < ActiveRecord::Base
+class Account
   dummy :name do
     TestDummy::Helper.random_string(8)
   end

data/test/dummy/bill.rb

@@ -0,0 +1,7 @@
+class Bill
+  dummy :account
+
+  dummy :order_date do
+    Date.today.advance(:days => rand(-2000))
+  end
+end

data/test/dummy/item.rb

@@ -0,0 +1,11 @@
+class Item
+  dummy :account,
+    :from => 'bill.account'
+
+  dummy :bill,
+    :inherit => {
+      :account_id => [ :account, :id ]
+    }
+
+  dummy :description
+end

data/test/helper.rb

@@ -3,10 +3,14 @@ require 'test/unit'
 
 ENV['RAILS_ENV'] = 'test'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+base_path = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift(base_path)
+$LOAD_PATH.unshift(File.join(base_path, '..', 'lib'))
+$LOAD_PATH.unshift(File.join(base_path, '..', 'test', 'models'))
 
 gem 'rails'
+
 require 'rails'
 require 'active_record'
 
@@ -15,13 +19,32 @@ require 'test_dummy'
 TestDummy::Railtie.apply!
 
 class Test::Unit::TestCase
+  include TestDummy::TestHelper
 end
 
-module TestDummy
-  class Application < Rails::Application
-    config.active_support.deprecation = :warn
-  end
+class TestDummy::Application < Rails::Application
+  config.active_support.deprecation = :warn
 end
 
-TestDummy::Application.initialize!
-ActiveRecord::Base.establish_connection(Rails.env)
+TestDummy.dummy_extensions_path = File.expand_path('dummy', File.dirname(__FILE__))
+
+ActiveRecord::Base.establish_connection(
+  'adapter' => "sqlite3",
+  'database'  => File.expand_path('db/test.sqlite3', base_path)
+)
+
+ActiveRecord::Migrator.migrate(File.expand_path('db/migrate', base_path))
+
+ActiveSupport::Dependencies.autoload_paths << File.expand_path('models', base_path)
+
+# Trigger loading the Rails root path here
+Rails.root
+
+TestDummy.define do
+  dummy :description,
+    :with => :phonetic_string
+
+  dummy :phonetic_string do
+    TestDummy::Helper.random_phonetic_string(32)
+  end
+end

data/test/models/account.rb

@@ -0,0 +1,10 @@
+class Account < ActiveRecord::Base
+  attr_accessible :name
+
+  validates :name,
+    :presence => true
+
+  has_many :bills
+  has_many :items,
+    :through => :bills
+end

data/test/models/bill.rb

@@ -0,0 +1,4 @@
+class Bill < ActiveRecord::Base
+  belongs_to :account
+  has_many :items
+end

data/test/models/example.rb

@@ -0,0 +1,5 @@
+class Example < ActiveRecord::Base
+  dummy :name do
+    TestDummy::Helper.random_string(8)
+  end
+end

data/test/models/item.rb

@@ -0,0 +1,4 @@
+class Item < ActiveRecord::Base
+  belongs_to :account
+  belongs_to :bill
+end

data/test/unit/test_account.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../helper', File.dirname(__FILE__))
+
+class TestAccount < ActiveSupport::TestCase
+  def test_extension_loaded
+    assert Account.respond_to?(:create_dummy)
+  end
+
+  def test_create_dummy
+    account = Account.create_dummy
+
+    assert account
+
+    assert account.name?
+
+    assert_equal true, account.valid?
+    assert_equal false, account.new_record?
+
+    assert_equal [ ], account.bills.collect(&:ids)
+    assert_equal [ ], account.items.collect(&:ids)
+  end
+end

data/test/unit/test_bill.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../helper', File.dirname(__FILE__))
+
+class TestBill < ActiveSupport::TestCase
+  def test_extension_loaded
+    assert Bill.respond_to?(:create_dummy)
+  end
+
+  def test_create_dummy
+    bill = Bill.create_dummy
+
+    assert bill
+
+    assert bill.order_date
+
+    assert_equal true, bill.valid?
+    assert_equal false, bill.new_record?
+
+    assert bill.account
+    assert_equal false, bill.account.new_record?
+
+    assert_equal [ ], bill.items.collect(&:ids)
+  end
+
+  def test_create_dummy_via_association
+    account = an Account
+
+    bill = one_of account.bills
+
+    assert bill
+    assert_equal true, bill.valid?
+    assert_equal false, bill.new_record?
+
+    assert_equal account.id, bill.account_id
+
+    assert_equal [ bill.id ], account.bills.collect(&:id)
+  end
+end

data/test/unit/test_item.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../helper', File.dirname(__FILE__))
+
+class TestItem < ActiveSupport::TestCase
+  def test_extension_loaded
+    assert Item.respond_to?(:create_dummy)
+  end
+
+  def test_reflection_properties
+    reflection_class, foreign_key = TestDummy::Support.reflection_properties(Item, :account)
+
+    assert_equal Account, reflection_class
+    assert_equal :account_id, foreign_key
+  end
+
+  def test_create_dummy
+    item = Item.create_dummy
+
+    assert item
+
+    assert item.description?
+
+    assert_equal true, item.valid?
+    assert_equal false, item.new_record?
+
+    assert item.account
+    assert_equal false, item.account.new_record?
+    assert_equal item.account.id, item.account_id
+
+    assert item.bill
+    assert_equal false, item.bill.new_record?
+    assert_equal item.bill.id, item.bill_id
+    assert_equal item.account.id, item.bill.account_id
+
+    assert_equal [ item.id ], item.account.items.collect(&:id)
+    assert_equal [ item.id ], item.bill.items.collect(&:id)
+  end
+
+  def test_create_dummy_via_association
+    bill = a Bill
+
+    assert_equal false, bill.new_record?
+
+    item = one_of bill.items
+
+    assert item
+    assert_equal true, item.valid?
+    assert_equal false, item.new_record?
+
+    assert_equal bill.id, item.bill_id
+
+    assert_equal bill.account_id, item.account_id
+
+    account = bill.account
+
+    assert_equal [ bill.id ], account.bills.collect(&:id)
+    assert_equal [ item.id ], account.items.collect(&:id)
+  end
+end

data/test/unit/test_test_dummy.rb

@@ -0,0 +1,22 @@
+require  File.expand_path('../helper', File.dirname(__FILE__))
+
+require 'example'
+
+class TestTestDummy < Test::Unit::TestCase
+  def test_example_model
+    example = Example.create_dummy
+    
+    assert_equal Example, example.class
+    
+    assert_equal [ ], example.errors.full_messages
+    assert !example.new_record?
+    
+    assert_equal 8, example.name.length
+  end
+
+  def test_extensions
+    assert_equal true, respond_to?(:a)
+    assert_equal true, respond_to?(:an)
+    assert_equal true, respond_to?(:one_of)
+  end
+end

data/test_dummy.gemspec

@@ -5,46 +5,68 @@
 
 Gem::Specification.new do |s|
   s.name = "test_dummy"
-  s.version = "0.2.10"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]
-  s.date = "2012-03-06"
+  s.date = "2012-11-30"
   s.description = "Test Dummy allows you to define how to fake models automatically so that you can use dummy data for testing instead of fixtures. Dummy models are always generated using the current schema and don't need to me migrated like fixtures."
   s.email = "github@tadman.ca"
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
+    "Gemfile",
     "LICENSE",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "lib/test_dummy.rb",
     "lib/test_dummy/helper.rb",
     "lib/test_dummy/railtie.rb",
     "lib/test_dummy/test_helper.rb",
-    "test/config/database.yml",
     "test/db/.gitignore",
+    "test/db/migrate/0001_create_examples.rb",
+    "test/db/migrate/0002_create_accounts.rb",
+    "test/db/migrate/0003_create_bills.rb",
+    "test/db/migrate/0004_create_items.rb",
+    "test/dummy/account.rb",
+    "test/dummy/bill.rb",
+    "test/dummy/item.rb",
     "test/helper.rb",
-    "test/models/simple.rb",
-    "test/test_test_dummy.rb",
+    "test/models/account.rb",
+    "test/models/bill.rb",
+    "test/models/example.rb",
+    "test/models/item.rb",
+    "test/unit/test_account.rb",
+    "test/unit/test_bill.rb",
+    "test/unit/test_item.rb",
+    "test/unit/test_test_dummy.rb",
     "test_dummy.gemspec"
   ]
   s.homepage = "http://github.com/tadman/test_dummy"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
+  s.rubygems_version = "1.8.24"
   s.summary = "Quick test data generator and fake model maker"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
     else
+      s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test_dummy
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,56 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000 Z
-dependencies: []
+date: 2012-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Test Dummy allows you to define how to fake models automatically so that
   you can use dummy data for testing instead of fixtures. Dummy models are always
   generated using the current schema and don't need to me migrated like fixtures.
@@ -19,22 +67,35 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.rdoc
+- README.md
 files:
 - .document
+- Gemfile
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - lib/test_dummy.rb
 - lib/test_dummy/helper.rb
 - lib/test_dummy/railtie.rb
 - lib/test_dummy/test_helper.rb
-- test/config/database.yml
 - test/db/.gitignore
+- test/db/migrate/0001_create_examples.rb
+- test/db/migrate/0002_create_accounts.rb
+- test/db/migrate/0003_create_bills.rb
+- test/db/migrate/0004_create_items.rb
+- test/dummy/account.rb
+- test/dummy/bill.rb
+- test/dummy/item.rb
 - test/helper.rb
-- test/models/simple.rb
-- test/test_test_dummy.rb
+- test/models/account.rb
+- test/models/bill.rb
+- test/models/example.rb
+- test/models/item.rb
+- test/unit/test_account.rb
+- test/unit/test_bill.rb
+- test/unit/test_item.rb
+- test/unit/test_test_dummy.rb
 - test_dummy.gemspec
 homepage: http://github.com/tadman/test_dummy
 licenses: []
@@ -56,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Quick test data generator and fake model maker

data/README.rdoc

@@ -1,52 +0,0 @@
-= test_dummy
-
-Test Dummy is an easy fake data generator library with the ability to create
-fake models or entirely faked data structures on-demand.
-
-After installing the gem, methods to declare how to fake data are made
-available within ActiveRecord-derived models. There are several ways to
-declare how to dummy something:
-
-    class MyModel < ActiveRecord::Base
-      # Pass a block that defines how to dummy this attribute
-      dummy :name do
-        "user%d" % rand(10e6)
-      end
-      
-      # Pass a block that defines how to dummy several attributes
-      dummy :password, :password_confirmation do
-        'tester'
-      end
-      
-      # Use one of the pre-defined helper methods to dummy this attribute
-      dummy :nickname, :use => :random_phonetic_string
-    end
-
-Dummy configuration can also be stored in test/dummy to avoid cluttering
-your models up with generators. An equivalent external declaration would look
-like this:
-
-    TestDummy.declare(MyModel) do
-      dummy :name do
-        "user%d" % rand(10e6)
-      end
-    
-      dummy :password, :password_confirmation do
-        'tester'
-      end
-    
-      dummy :nickname, :use => :random_phonetic_string
-    end
-
-The name of the test/dummy file should be the same as the main model
-defined in app/models. For instance, app/models/my_model.rb would have a
-corresponding test/dummy/my_model.rb that would be loaded as required.
-
-If you need to override this directory, you can configure the gem using
-the `dummy_directory` option:
-
-    TestDummy.dummy_directory = 'my_alternate/path'
-
-== Copyright
-
-Copyright (c) 2010-2011 Scott Tadman, The Working Group

data/test/config/database.yml

@@ -1,5 +0,0 @@
-test:
-  adapter: sqlite3
-  database: db/test.sqlite3
-  pool: 5
-  timeout: 5000

data/test/test_test_dummy.rb

@@ -1,16 +0,0 @@
-require 'helper'
-
-require 'models/simple'
-
-class TestTestDummy < Test::Unit::TestCase
-  def test_simple_model
-    simple = Simple.dummy
-    
-    assert_equal Simple, simple.class
-    
-    assert_equal [ ], simple.errors.full_messages
-    assert !simple.new_record?
-    
-    assert_equal 8, simple.name.length
-  end
-end