fixture_replacement 3.0.1

data/lib/fixture_replacement/class_methods.rb

@@ -0,0 +1,45 @@
+module FixtureReplacement
+  module ClassMethods
+    def attributes_for(fixture_name, options={}, &block)
+      builder = AttributeBuilder.new(fixture_name, options, &block)
+      MethodGenerator.new(builder, self).generate_methods
+    end
+
+    def validate!
+      AttributeBuilder.validate_instances!
+    end
+
+    def random_string(length=10)
+      chars = ("a".."z").to_a
+      string = ""
+      1.upto(length) { |i| string << chars[rand(chars.size-1)]}
+      string
+    end
+
+    def load_example_data
+      load "#{rails_root}/db/example_data.rb"
+    rescue LoadError
+      # no-op.  If the file is not found, don't panic
+    end
+
+    def rails_root
+      defined?(RAILS_ROOT) ? RAILS_ROOT : "."
+    end
+
+    def reload!
+      AttributeBuilder.clear_out_instances!
+      load File.expand_path(File.dirname(__FILE__) + "/../fixture_replacement.rb")
+    end
+
+  private
+
+    # Any user defined instance methods need the module's class scope to be
+    # accessible inside the block given to attributes_for
+    #
+    # Addresses bug #16858 (see CHANGELOG)
+    def method_added(method)
+      module_function method if method != :method_added
+      public method
+    end
+  end
+end

data/lib/fixture_replacement/method_generator.rb

@@ -0,0 +1,38 @@
+module FixtureReplacement
+  class MethodGenerator
+    def initialize(builder, evaluation_module)
+      @builder           = builder
+      @evaluation_module = evaluation_module
+    end
+
+    def generate_methods
+      builder       = @builder
+      builder_name  = builder.fixture_name
+
+      @evaluation_module.module_eval do
+        define_method("valid_#{builder_name}_attributes") do |*args|
+          obj = __send__ "new_#{builder_name}"
+          obj.attributes
+        end
+
+        define_method("create_#{builder_name}") do |*args|
+          obj = __send__("new_#{builder_name}", *args)
+          obj.save!
+          obj
+        end
+
+        define_method("new_#{builder_name}") do |*args|
+          new_object = builder.instantiate(*args)
+        end
+
+        define_method("default_#{builder_name}") do |*args|
+          warning = "default_#{builder_name} has been deprecated. "
+          warning << "Please replace instances of default_#{builder_name} with the new_#{builder_name} method"
+          Kernel.warn(warning)
+
+          __send__ "new_#{builder_name}"
+        end
+      end
+    end
+  end
+end

data/lib/fixture_replacement/version.rb

@@ -0,0 +1,13 @@
+module FixtureReplacement
+  module Version
+    unless defined?(FixtureReplacement::VERSION)
+      MAJOR             = 3
+      MINOR             = 0
+      TINY              = 1
+
+      version_string = "#{MAJOR}.#{MINOR}.#{TINY}"
+      version_string << " RC#{RELEASE_CANDIDATE}" if defined?(RELEASE_CANDIDATE)
+      VERSION = version_string
+    end
+  end
+end

data/lib/fr.rb

@@ -0,0 +1 @@
+FR = FixtureReplacement unless defined?(FR)

data/philosophy_and_bugs.rdoc

@@ -0,0 +1,128 @@
+== Motivation Behind FixtureReplacement
+
+As Dan Manges has outlined in his blog post, "Fixing Fixtures with Factory" (http://www.dcmanges.com/blog/38),
+this approach to generating test data has a number of advantages:
+
+- The factory provides default values and relationships
+- Invalid data will never be loaded into your test database, as it is with the typical YAML fixture.
+  A record which is created with a create_* method (create_user, create_post, etc.) uses ActiveRecord's
+  create! behind the scenes, so any invalid data will raise a clear error.  This means that you will
+  spend your time debugging your tests and code, not your test data.
+- It's in Ruby, so you won't have to fight with YAML's spacing issues, plus the data is by nature
+  more dynamic and more agile.
+- When a test fails (and they will), someone who hasn't written the test will be able to figure out
+  the *intention* behind the test.  They won't have to go digging through YAML files to figure out
+  the relevant data to the test.
+- No more opening of 5 different YAML files to see the associations and column names of different models -
+  this is conveniently located in one file (db/example_data.rb)
+- If you set use_transactional_fixtures = true in your test_helper or spec_helper (and you *really* should
+  be using this), the data that is created in each test will be rolled back, meaning no-side effects,
+  and a consistent database among different developers, and for your self during different test runs.
+
+=== Random Data in db/example_data.rb
+
+The use of random data should also be spoken of.  Many may think this to be dangerous, but in fact random
+data is often helpful.  Consider the following snippets of psudo-code (along with it's test):
+
+  # apps/models/user.rb :
+  # ----------------------
+
+  class User < ActiveRecord::Base
+    validates_uniqueness_of :username
+    validates_presence_of :password
+
+    after_create :check_password
+
+  private
+
+    def check_password
+      # ...
+    end
+
+  public
+
+    def establish_friendship_with(other_user)
+      # ...
+    end
+
+    def friends
+      # ...
+    end
+  end
+
+  # The test:
+  # ---------
+
+  def test_make_sure_user_can_establish_friendship
+    @user_one = User.create({
+      :username              => "foo",
+      :password              => "some password",
+      :password_confirmation => "some password_confirmation"
+    })
+
+    @user_two = User.create({
+      :username              => "bar",
+      :password              => "some password",
+      :password_confirmation => "some password confirmation"
+    })
+
+    @user_one.establish_friendship_with(@user_two)
+    @user_one.friends.should == [@user_two]
+  end
+
+Notice that the above test adds a lot of extra noise in getting valid users into the database; The test, however, doesn't care what the usernames are, that the password is a good one, that the password matches the password confirmation, and so on.  The point of the test is not to check those things, but rather that a friendship can be established.
+
+Here would be a similar test with the FixtureReplacement:
+
+  # The test:
+  # ---------
+
+  before do
+    @user_one = create_user
+    @user_two = create_user
+  end
+
+  def test_make_sure_user_can_establish_friendship
+    @user_one.establish_friendship_with(@user_two)
+    @user_one.friends.should == [@user_two]
+  end
+
+Once again, the test above doesn't care about usernames, so why should you?  But to even store those two users into the database, you will need unique usernames, as well as password which match.  Here is where the random data comes in:
+
+  # db/example_data.rb
+  # -------------------
+
+  module FixtureReplacement
+    attributes_for :user do |u|
+      password = random_string
+
+      u.username              = random_string
+      u.password              = password
+      u.password_confirmation = password
+    end
+  end
+
+Now, in a different test case, if you do care about the usernames not being random, it is easy to set them:
+
+  create_user({
+    :username              => "scott",
+    :password              => "foobar",
+    :password_confirmation => "foobar"
+  })
+
+=== Disadvantages of FixtureReplacement
+
+The one major disadvantage behind this approach is that it's slow - just as slow as fixtures, if not slower.
+One approach that the rspec crowd is using is to use this plugin in integration tests, while using mocks & stubs
+in model unit tests.  It's not a big deal if your integration tests run slow, since you probably don't run
+them very often.
+
+Another approach is to look to external sources to speed up your test suite:
+
+- a sqlite3 in-memory database (can cut your test/spec time in half)
+- unit-record gem (by Dan Manges), which takes advantage of multi-core processors
+- a distributed build system, such as spec_distributed
+- running tests individually, or per file
+- A faster machine
+
+If you have other ideas for speeding up your test suite, I'm all ears.

data/rake_tasks/code_quality.rb

@@ -0,0 +1,37 @@
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems']
+  t.rcov_dir = "doc/rcov"
+end
+
+desc "Feel the pain of my code, and submit a refactoring patch"
+task :flog do
+  puts %x(find lib | grep ".rb$" | xargs flog)
+end
+
+task :flog_to_disk => :create_doc_directory do
+  puts "Flogging..."
+  %x(find lib | grep ".rb$" | xargs flog > doc/flog.txt)
+  puts "Done Flogging...\n"
+end
+
+def sloc
+  `sloccount #{File.dirname(__FILE__)}/lib`
+end
+
+desc "Output sloccount report.  You'll need sloccount installed."
+task :sloc do
+  puts "Counting lines of code"
+  puts sloc
+end
+
+desc "Write sloccount report"
+task :output_sloc => :create_doc_directory do
+  File.open(File.dirname(__FILE__) + "/doc/lines_of_code.txt", "w") do |f|
+    f << sloc
+  end
+end

data/rake_tasks/docs.rb

@@ -0,0 +1,59 @@
+require 'hanna/rdoctask'
+
+def doc_directory
+  "doc"
+end
+
+desc 'Generate documentation for the fixture_replacement plugin.'
+Rake::RDocTask.new(:rdoc_without_analytics) do |rdoc|
+  rdoc.rdoc_dir = doc_directory
+  rdoc.title    = 'FixtureReplacement'
+  rdoc.options << '--line-numbers' << '--inline-source'
+
+  rdoc.options << '--webcvs=http://github.com/smtlaissezfaire/fixturereplacement/tree/master/'
+
+  [
+    "README.rdoc",
+    "CHANGELOG.rdoc",
+    "GPL_LICENSE",
+    "MIT_LICENSE",
+    "contributions.rdoc",
+    "philosophy_and_bugs.rdoc",
+    "lib/**/*.rb"
+  ].each do |file|
+    rdoc.rdoc_files.include(file)
+  end
+end
+
+task :rdoc => [:rdoc_without_analytics] do
+  google_analytics = File.read(File.dirname(__FILE__) + "/etc/google_analytics")
+  rdoc_index = File.dirname(__FILE__) + "/#{doc_directory}/index.html"
+
+  contents = File.read(rdoc_index)
+  contents.gsub!("</head>", "#{google_analytics}\n</head>")
+
+  File.open(rdoc_index, "r+") do |file|
+    file.write(contents)
+  end
+end
+
+task :rerdoc => [:clobber_rdoc, :rdoc]
+task :clobber_rdoc => [:clobber_rdoc_without_analytics]
+
+def create_doc_directory
+  unless File.exists?(doc_directory)
+    `mkdir doc`
+  end
+end
+
+task :create_doc_directory do
+  create_doc_directory
+end
+
+desc "Create the html specdoc"
+Spec::Rake::SpecTask.new(:specdoc => :create_doc_directory) do |t|
+  t.spec_opts = ["--format", "html:doc/specdoc.html"]
+end
+
+desc 'Create the specdoc + rdoc'
+task :build_docs => [:rerdoc, :specdoc, :rcov, :flog_to_disk]

data/rake_tasks/gem.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/fixture_replacement")
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gemspec|
+    File.open(File.expand_path(File.dirname(__FILE__) + "/../VERSION"), "w") do |f|
+      f << FixtureReplacement::Version::VERSION
+    end
+
+    gemspec.name        = "fixture_replacement"
+    gemspec.summary     = "The original fixture replacement solution for rails"
+    gemspec.email       = "scott@railsnewbie.com"
+    gemspec.homepage    = "http://replacefixtures.rubyforge.org"
+    gemspec.authors     = ["Scott Taylor"]
+    gemspec.description = <<-DESC
+FixtureReplacement is a Rails plugin that provides a simple way to
+quickly populate your test database with model objects without having to manage multiple,
+brittle fixture files. You can easily set up complex object graphs (with models which
+reference other models) and add new objects on the fly.
+    DESC
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/rake_tasks/specs.rb

@@ -0,0 +1,7 @@
+require 'spec/rake/spectask'
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new do |t|
+  t.warning = false
+  t.spec_opts = ["--color"]
+end

data/rake_tasks/tests.rb

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*test*.rb']
+  t.verbose = true
+end

data/rake_tasks/website.rb

@@ -0,0 +1,11 @@
+require 'rake/contrib/rubyforgepublisher'
+
+desc 'Publish the website, building the docs first'
+task :publish_website => [:build_docs] do
+  publisher = Rake::SshDirPublisher.new(
+    "smtlaissezfaire@rubyforge.org",
+    "/var/www/gforge-projects/replacefixtures/",
+    "doc"
+  )
+  publisher.upload
+end

data/spec/fixture_replacement/attribute_builder_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module FixtureReplacement
+  describe AttributeBuilder do
+    before do
+      AttributeBuilder.clear_out_instances!
+    end
+
+    it "should add the instance to the global attributes" do
+      a = AttributeBuilder.new(:foo)
+      AttributeBuilder.instances.should == [a]
+    end
+
+    it "should have no instances when none have been created" do
+      AttributeBuilder.instances.should == []
+    end
+
+    it "should have two instances when two have been created" do
+      a1 = AttributeBuilder.new(:foo)
+      a2 = AttributeBuilder.new(:foo)
+      AttributeBuilder.instances.should == [a1, a2]
+    end
+
+    it "should have the fixture name as accessible" do
+      a1 = AttributeBuilder.new(:foo)
+      a1.fixture_name.should == :foo
+    end
+
+    it "should have the from attribute as nil, if none provided" do
+      a1 = AttributeBuilder.new(:foo)
+      a1.from.should be_nil
+    end
+
+    it "should have the from attribute as the symbol of the attribute from which it derives" do
+      a1 = AttributeBuilder.new(:foo, :from => :bar)
+      a1.from.should == :bar
+    end
+
+    it "should be able to find the Attribute by fixture name" do
+      a = AttributeBuilder.new(:baz)
+      AttributeBuilder.find_by_fixture_name(:baz).should == a
+    end
+
+    it "should find no attributes for fixture_name :baz, if it was never created" do
+      a = AttributeBuilder.new(:bar)
+      AttributeBuilder.find_by_fixture_name(:baz).should be_nil
+    end
+
+    it "should find no attributes for fixture_name :baz, if no fixture at all was ever created" do
+      AttributeBuilder.find_by_fixture_name(:baz).should be_nil
+    end
+
+    it "should have the class name if specified" do
+      AttributeBuilder.new(:foo, :class => Object).active_record_class.should == Object
+    end
+
+    it "should use the class name of the fixture_name, camel-cased, if the class is unspecified, and the fixture uninherited" do
+      AttributeBuilder.new(:object).active_record_class.should == Object
+    end
+
+    it "should use the class name of the inherited attribute, if specified" do
+      AttributeBuilder.new(:foo, :class => Object)
+      AttributeBuilder.new(:bar, :from => :foo).active_record_class.should == Bar
+    end
+
+    it "should prefer the constantized name to the derived name" do
+      AttributeBuilder.new(:user)
+      AttributeBuilder.new(:admin, :from => :user).active_record_class.should == Admin
+    end
+
+    it "should use the derived name if the constantized name fails (doesn't exist)" do
+      AttributeBuilder.new(:foo)
+      no_constant = AttributeBuilder.new(:no_constant, :from => :foo)
+      no_constant.active_record_class.should == Foo
+    end
+
+    it "should raise a name error if it has no class, the name can't be constantized, and is derived, but the derived class can't be constantized" do
+      builder_one = AttributeBuilder.new(:does_not_exist)
+      builder_two = AttributeBuilder.new(:also_does_not_exist, :from => :does_not_exist)
+
+      lambda {
+        builder_two.active_record_class
+      }.should raise_error(NameError)
+    end
+
+    it "should not raise an error if the model ends with 's'" do
+      AttributeBuilder.new(:actress).active_record_class.should == Actress
+    end
+
+    it "should allow a string key" do
+      AttributeBuilder.new(:admin, "from" => :user).active_record_class.should == Admin
+    end
+
+    it "should allow a string name for the builder" do
+      AttributeBuilder.new("admin").active_record_class.should == Admin
+    end
+
+    it "should store the from key as a symbol, even when passed a string" do
+      builder = AttributeBuilder.new(:admin, "from" => "user")
+      builder.from.should == :user
+    end
+
+    it "should convert the fixture name to a symbol" do
+      builder = AttributeBuilder.new("admin")
+      builder.fixture_name.should == :admin
+    end
+
+    describe "validating all instances" do
+      it "should return true if there are no instances" do
+        AttributeBuilder.validate_instances!.should be_true
+      end
+
+      it "should raise an error if an instance is not valid" do
+        AttributeBuilder.new(:validate_name)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should raise_error
+      end
+
+      it "should not raise an error if there is only one instance, and it is valid" do
+        AttributeBuilder.new(:event)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should_not raise_error
+      end
+
+      it "should raise an error, giving the fixture name, and the error" do
+        AttributeBuilder.new(:validate_name)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should raise_error(FixtureReplacement::InvalidInstance, "new_validate_name is not valid! - Errors: [name: can't be blank]")
+      end
+
+      it "should use the correct name" do
+        AttributeBuilder.new(:validate_name_two)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should raise_error(FixtureReplacement::InvalidInstance, "new_validate_name_two is not valid! - Errors: [name: can't be blank]")
+      end
+
+      it "should use the correct errors" do
+        AttributeBuilder.new(:address_with_valid_city)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should raise_error(FixtureReplacement::InvalidInstance, "new_address_with_valid_city is not valid! - Errors: [city: can't be blank]")
+      end
+
+      it "should use multiple errors on a single model" do
+        AttributeBuilder.new(:address_with_valid_city_and_state)
+
+        lambda {
+          AttributeBuilder.validate_instances!
+        }.should raise_error(FixtureReplacement::InvalidInstance, "new_address_with_valid_city_and_state is not valid! - Errors: [city: can't be blank], [state: can't be blank]")
+      end
+    end
+  end
+end