radiant 0.6.9 → 0.7.0

data/vendor/rails/activerecord/test/fixtures/db_definitions/sybase2.drop.sql

@@ -1,4 +0,0 @@
-DROP TABLE courses
-go
-
-

data/vendor/rails/activerecord/test/fixtures/db_definitions/sybase2.sql

@@ -1,5 +0,0 @@
-CREATE TABLE courses (
- id int NOT NULL PRIMARY KEY,
- name varchar(255) NOT NULL
-)
-go

data/vendor/rails/activerecord/test/fixtures/developer.rb

@@ -1,72 +0,0 @@
-module DeveloperProjectsAssociationExtension
-  def find_most_recent
-    find(:first, :order => "id DESC")
-  end
-end
-
-module DeveloperProjectsAssociationExtension2
-  def find_least_recent
-    find(:first, :order => "id ASC")
-  end
-end
-
-class Developer < ActiveRecord::Base
-  has_and_belongs_to_many :projects do
-    def find_most_recent
-      find(:first, :order => "id DESC")
-    end
-  end
-  
-  has_and_belongs_to_many :projects_extended_by_name, 
-      :class_name => "Project", 
-      :join_table => "developers_projects", 
-      :association_foreign_key => "project_id",
-      :extend => DeveloperProjectsAssociationExtension
-
-  has_and_belongs_to_many :projects_extended_by_name_twice, 
-      :class_name => "Project", 
-      :join_table => "developers_projects", 
-      :association_foreign_key => "project_id",
-      :extend => [DeveloperProjectsAssociationExtension, DeveloperProjectsAssociationExtension2]
-
-  has_and_belongs_to_many :projects_extended_by_name_and_block, 
-      :class_name => "Project", 
-      :join_table => "developers_projects", 
-      :association_foreign_key => "project_id",
-      :extend => DeveloperProjectsAssociationExtension do
-        def find_least_recent
-          find(:first, :order => "id ASC")
-        end
-      end
-
-  has_and_belongs_to_many :special_projects, :join_table => 'developers_projects', :association_foreign_key => 'project_id'
-
-  has_many :audit_logs
-
-  validates_inclusion_of :salary, :in => 50000..200000
-  validates_length_of    :name, :within => 3..20
-
-  before_create do |developer|
-    developer.audit_logs.build :message => "Computer created"
-  end
-end
-
-class AuditLog < ActiveRecord::Base
-  belongs_to :developer
-end
-
-DeveloperSalary = Struct.new(:amount)
-class DeveloperWithAggregate < ActiveRecord::Base
-  self.table_name = 'developers'
-  composed_of :salary, :class_name => 'DeveloperSalary', :mapping => [%w(salary amount)]
-end
-
-class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, :join_table => 'developers_projects', :foreign_key => 'developer_id'
-  before_destroy :raise_if_projects_empty!
-
-  def raise_if_projects_empty!
-    raise if projects.empty?
-  end
-end

data/vendor/rails/activerecord/test/fixtures/developers_projects/david_action_controller

@@ -1,3 +0,0 @@
-developer_id => 1
-project_id => 2
-joined_on => 2004-10-10

data/vendor/rails/activerecord/test/fixtures/developers_projects/david_active_record

@@ -1,3 +0,0 @@
-developer_id => 1
-project_id => 1
-joined_on => 2004-10-10

data/vendor/rails/activerecord/test/fixtures/developers_projects/jamis_active_record

@@ -1,2 +0,0 @@
-developer_id => 2
-project_id => 1

data/vendor/rails/activerecord/test/fixtures/migrations/1_people_have_last_names.rb

@@ -1,9 +0,0 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
-  def self.up
-    add_column "people", "last_name", :string
-  end
-  
-  def self.down
-    remove_column "people", "last_name"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations/2_we_need_reminders.rb

@@ -1,12 +0,0 @@
-class WeNeedReminders < ActiveRecord::Migration
-  def self.up
-    create_table("reminders") do |t|
-      t.column :content, :text
-      t.column :remind_at, :datetime
-    end
-  end
-  
-  def self.down
-    drop_table "reminders"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations_with_duplicate/1_people_have_last_names.rb

@@ -1,9 +0,0 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
-  def self.up
-    add_column "people", "last_name", :string
-  end
-  
-  def self.down
-    remove_column "people", "last_name"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations_with_duplicate/2_we_need_reminders.rb

@@ -1,12 +0,0 @@
-class WeNeedReminders < ActiveRecord::Migration
-  def self.up
-    create_table("reminders") do |t|
-      t.column :content, :text
-      t.column :remind_at, :datetime
-    end
-  end
-  
-  def self.down
-    drop_table "reminders"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations_with_missing_versions/1000_people_have_middle_names.rb

@@ -1,9 +0,0 @@
-class PeopleHaveMiddleNames < ActiveRecord::Migration
-  def self.up
-    add_column "people", "middle_name", :string
-  end
-  
-  def self.down
-    remove_column "people", "middle_name"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations_with_missing_versions/1_people_have_last_names.rb

@@ -1,9 +0,0 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
-  def self.up
-    add_column "people", "last_name", :string
-  end
-  
-  def self.down
-    remove_column "people", "last_name"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/migrations_with_missing_versions/3_we_need_reminders.rb

@@ -1,12 +0,0 @@
-class WeNeedReminders < ActiveRecord::Migration
-  def self.up
-    create_table("reminders") do |t|
-      t.column :content, :text
-      t.column :remind_at, :datetime
-    end
-  end
-  
-  def self.down
-    drop_table "reminders"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/order.rb

@@ -1,4 +0,0 @@
-class Order < ActiveRecord::Base
-  belongs_to :billing, :class_name => 'Customer', :foreign_key => 'billing_customer_id' 
-  belongs_to :shipping, :class_name => 'Customer', :foreign_key => 'shipping_customer_id' 
-end

data/vendor/rails/activerecord/test/fixtures/person.rb

@@ -1,4 +0,0 @@
-class Person < ActiveRecord::Base
-  has_many :readers
-  has_many :posts, :through => :readers
-end

data/vendor/rails/activerecord/test/fixtures/pirate.rb

@@ -1,5 +0,0 @@
-class Pirate < ActiveRecord::Base
-  belongs_to :parrot
-  has_and_belongs_to_many :parrots
-  has_many :loots, :as => :looter
-end

data/vendor/rails/activerecord/test/fixtures/post.rb

@@ -1,59 +0,0 @@
-class Post < ActiveRecord::Base
-  belongs_to :author do
-    def greeting
-      "hello"
-    end
-  end
-
-  belongs_to :author_with_posts, :class_name => "Author", :foreign_key => :author_id, :include => :posts
-
-  has_many   :comments, :order => "body" do
-    def find_most_recent
-      find(:first, :order => "id DESC")
-    end
-  end
-
-  has_one  :very_special_comment
-  has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
-  has_many :special_comments
-  has_many :nonexistant_comments, :class_name => 'Comment', :conditions => 'comments.id < 0'
-
-  has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
-
-  has_many :taggings, :as => :taggable
-  has_many :tags, :through => :taggings, :include => :tagging do
-    def add_joins_and_select
-      find :all, :select => 'tags.*, authors.id as author_id', :include => false,
-        :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
-    end
-  end
-  
-  has_many :funky_tags, :through => :taggings, :source => :tag
-  has_many :super_tags, :through => :taggings
-  has_one :tagging, :as => :taggable
-
-  has_many :invalid_taggings, :as => :taggable, :class_name => "Tagging", :conditions => 'taggings.id < 0'
-  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
-
-  has_many :categorizations, :foreign_key => :category_id
-  has_many :authors, :through => :categorizations
-
-  has_many :readers
-  has_many :people, :through => :readers
-
-  def self.what_are_you
-    'a post...'
-  end
-end
-
-class SpecialPost < Post; end
-
-class StiPost < Post
-  self.abstract_class = true
-  has_one :special_comment, :class_name => "SpecialComment"
-end
-
-class SubStiPost < StiPost
-  self.table_name = Post.table_name
-end

data/vendor/rails/activerecord/test/fixtures/project.rb

@@ -1,28 +0,0 @@
-class Project < ActiveRecord::Base
-  has_and_belongs_to_many :developers, :uniq => true, :order => 'developers.name desc, developers.id desc'
-  has_and_belongs_to_many :selected_developers, :class_name => "Developer", :select => "developers.*", :uniq => true
-  has_and_belongs_to_many :non_unique_developers, :order => 'developers.name desc, developers.id desc', :class_name => 'Developer'
-  has_and_belongs_to_many :limited_developers, :class_name => "Developer", :limit => 1
-  has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
-  has_and_belongs_to_many :developers_named_david_with_hash_conditions, :class_name => "Developer", :conditions => { :name => 'David' }, :uniq => true
-  has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
-  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id}'
-  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => "DELETE FROM developers_projects WHERE project_id = \#{id} AND developer_id = \#{record.id}"
-  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
-                            :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
-                            :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
-                            :after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
-
-  attr_accessor :developers_log
-
-  def after_initialize
-    @developers_log = []
-  end
-
-end
-
-class SpecialProject < Project
-  def hello_world
-    "hello there!"
-  end
-end

data/vendor/rails/activerecord/test/fixtures/reply.rb

@@ -1,37 +0,0 @@
-require 'fixtures/topic'
-
-class Reply < Topic
-  belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
-  has_many :replies, :class_name => "SillyReply", :dependent => :destroy, :foreign_key => "parent_id"
-
-  validate :errors_on_empty_content
-  validate_on_create :title_is_wrong_create
-  
-  attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read
-
-  def validate
-    errors.add("title", "Empty")   unless attribute_present? "title"
-  end
-  
-  def errors_on_empty_content
-    errors.add("content", "Empty") unless attribute_present? "content"
-  end
-  
-  def validate_on_create
-    if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
-      errors.add("title", "is Content Mismatch") 
-    end
-  end
-
-  def title_is_wrong_create
-    errors.add("title", "is Wrong Create") if attribute_present?("title") && title == "Wrong Create"
-  end
-
-  def validate_on_update
-    errors.add("title", "is Wrong Update") if attribute_present?("title") && title == "Wrong Update"
-  end
-end
-
-class SillyReply < Reply
-  belongs_to :reply, :foreign_key => "parent_id", :counter_cache => :replies_count
-end

data/vendor/rails/activerecord/test/fixtures/subscriber.rb

@@ -1,6 +0,0 @@
-class Subscriber < ActiveRecord::Base
-  set_primary_key 'nick'
-end
-
-class SpecialSubscriber < Subscriber
-end

data/vendor/rails/activerecord/test/fixtures/subscribers/first

@@ -1,2 +0,0 @@
-nick   => alterself
-name   => Luke Holden

data/vendor/rails/activerecord/test/fixtures/subscribers/second

@@ -1,2 +0,0 @@
-nick   => webster132
-name   => David Heinemeier Hansson

data/vendor/rails/activerecord/test/fixtures/topic.rb

@@ -1,37 +0,0 @@
-class Topic < ActiveRecord::Base
-  has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
-  serialize :content
-  
-  before_create  :default_written_on
-  before_destroy :destroy_children
-
-  def parent
-    Topic.find(parent_id)
-  end
-  
-  # trivial method for testing Array#to_xml with :methods
-  def topic_id
-    id
-  end
-  
-
-  protected
-    def approved=(val)
-      @custom_approved = val
-      write_attribute(:approved, val)
-    end
-
-    def default_written_on
-      self.written_on = Time.now unless attribute_present?("written_on")
-    end
-
-    def destroy_children
-      self.class.delete_all "parent_id = #{id}"
-    end
-
-    def after_initialize
-      if self.new_record?
-        self.author_email_address = 'test@test.com'
-      end
-    end
-end

data/vendor/rails/activerecord/test/fixtures/treasure.rb

@@ -1,4 +0,0 @@
-class Treasure < ActiveRecord::Base
-  has_and_belongs_to_many :parrots
-  belongs_to :looter, :polymorphic => true
-end

data/vendor/rails/activerecord/test/fixtures_test.rb

@@ -1,602 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/post'
-require 'fixtures/binary'
-require 'fixtures/topic'
-require 'fixtures/computer'
-require 'fixtures/developer'
-require 'fixtures/company'
-require 'fixtures/task'
-require 'fixtures/reply'
-require 'fixtures/joke'
-require 'fixtures/course'
-require 'fixtures/category'
-require 'fixtures/parrot'
-require 'fixtures/pirate'
-require 'fixtures/treasure'
-require 'fixtures/matey'
-require 'fixtures/ship'
-
-class FixturesTest < Test::Unit::TestCase
-  self.use_instantiated_fixtures = true
-  self.use_transactional_fixtures = false
-
-  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries
-
-  FIXTURES = %w( accounts binaries companies customers
-                 developers developers_projects entrants
-                 movies projects subscribers topics tasks )
-  MATCH_ATTRIBUTE_NAME = /[a-zA-Z][-_\w]*/
-
-  BINARY_FIXTURE_PATH = File.dirname(__FILE__) + '/fixtures/flowers.jpg'
-
-  def test_clean_fixtures
-    FIXTURES.each do |name|
-      fixtures = nil
-      assert_nothing_raised { fixtures = create_fixtures(name) }
-      assert_kind_of(Fixtures, fixtures)
-      fixtures.each { |name, fixture|
-        fixture.each { |key, value|
-          assert_match(MATCH_ATTRIBUTE_NAME, key)
-        }
-      }
-    end
-  end
-
-  def test_multiple_clean_fixtures
-    fixtures_array = nil
-    assert_nothing_raised { fixtures_array = create_fixtures(*FIXTURES) }
-    assert_kind_of(Array, fixtures_array)
-    fixtures_array.each { |fixtures| assert_kind_of(Fixtures, fixtures) }
-  end
-
-  def test_attributes
-    topics = create_fixtures("topics")
-    assert_equal("The First Topic", topics["first"]["title"])
-    assert_nil(topics["second"]["author_email_address"])
-  end
-
-  def test_inserts
-    topics = create_fixtures("topics")
-    first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
-    assert_equal("The First Topic", first_row["title"])
-
-    second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
-    assert_nil(second_row["author_email_address"])
-  end
-
-  if ActiveRecord::Base.connection.supports_migrations?
-    def test_inserts_with_pre_and_suffix
-      # Reset cache to make finds on the new table work
-      Fixtures.reset_cache
-
-      ActiveRecord::Base.connection.create_table :prefix_topics_suffix do |t|
-        t.column :title, :string
-        t.column :author_name, :string
-        t.column :author_email_address, :string
-        t.column :written_on, :datetime
-        t.column :bonus_time, :time
-        t.column :last_read, :date
-        t.column :content, :string
-        t.column :approved, :boolean, :default => true
-        t.column :replies_count, :integer, :default => 0
-        t.column :parent_id, :integer
-        t.column :type, :string, :limit => 50
-      end
-
-      # Store existing prefix/suffix
-      old_prefix = ActiveRecord::Base.table_name_prefix
-      old_suffix = ActiveRecord::Base.table_name_suffix
-
-      # Set a prefix/suffix we can test against
-      ActiveRecord::Base.table_name_prefix = 'prefix_'
-      ActiveRecord::Base.table_name_suffix = '_suffix'
-
-      topics = create_fixtures("topics")
-
-      first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
-      assert_equal("The First Topic", first_row["title"])
-
-      second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
-      assert_nil(second_row["author_email_address"])
-    ensure
-      # Restore prefix/suffix to its previous values
-      ActiveRecord::Base.table_name_prefix = old_prefix
-      ActiveRecord::Base.table_name_suffix = old_suffix
-
-      ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil
-    end
-  end
-
-  def test_insert_with_datetime
-    topics = create_fixtures("tasks")
-    first = Task.find(1)
-    assert first
-  end
-
-  def test_bad_format
-    path = File.join(File.dirname(__FILE__), 'fixtures', 'bad_fixtures')
-    Dir.entries(path).each do |file|
-      next unless File.file?(file) and file !~ Fixtures::DEFAULT_FILTER_RE
-      assert_raise(Fixture::FormatError) {
-        Fixture.new(bad_fixtures_path, file)
-      }
-    end
-  end
-
-  def test_deprecated_yaml_extension
-    assert_raise(Fixture::FormatError) {
-      Fixtures.new(nil, 'bad_extension', 'BadExtension', File.join(File.dirname(__FILE__), 'fixtures'))
-    }
-  end
-
-  def test_logger_level_invariant
-    level = ActiveRecord::Base.logger.level
-    create_fixtures('topics')
-    assert_equal level, ActiveRecord::Base.logger.level
-  end
-
-  def test_instantiation
-    topics = create_fixtures("topics")
-    assert_kind_of Topic, topics["first"].find
-  end
-
-  def test_complete_instantiation
-    assert_equal 2, @topics.size
-    assert_equal "The First Topic", @first.title
-  end
-
-  def test_fixtures_from_root_yml_with_instantiation
-    # assert_equal 2, @accounts.size
-    assert_equal 50, @unknown.credit_limit
-  end
-
-  def test_erb_in_fixtures
-    assert_equal 11, @developers.size
-    assert_equal "fixture_5", @dev_5.name
-  end
-
-  def test_empty_yaml_fixture
-    assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/yml/accounts")
-  end
-
-  def test_empty_yaml_fixture_with_a_comment_in_it
-    assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', File.dirname(__FILE__) + "/fixtures/naked/yml/companies")
-  end
-
-  def test_dirty_dirty_yaml_file
-    assert_raises(Fixture::FormatError) do
-      Fixtures.new( Account.connection, "courses", 'Course', File.dirname(__FILE__) + "/fixtures/naked/yml/courses")
-    end
-  end
-
-  def test_empty_csv_fixtures
-    assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/csv/accounts")
-  end
-
-  def test_omap_fixtures
-    assert_nothing_raised do
-      fixtures = Fixtures.new(Account.connection, 'categories', 'Category', File.dirname(__FILE__) + '/fixtures/categories_ordered')
-
-      i = 0
-      fixtures.each do |name, fixture|
-        assert_equal "fixture_no_#{i}", name
-        assert_equal "Category #{i}", fixture['name']
-        i += 1
-      end
-    end
-  end
-
-  def test_yml_file_in_subdirectory
-    assert_equal(categories(:sub_special_1).name, "A special category in a subdir file")
-    assert_equal(categories(:sub_special_1).class, SpecialCategory)
-  end
-
-  def test_subsubdir_file_with_arbitrary_name
-    assert_equal(categories(:sub_special_3).name, "A special category in an arbitrarily named subsubdir file")
-    assert_equal(categories(:sub_special_3).class, SpecialCategory)
-  end
-
-  def test_binary_in_fixtures
-    assert_equal 1, @binaries.size
-    data = File.open(BINARY_FIXTURE_PATH, "rb").read.freeze
-    assert_equal data, @flowers.data
-  end
-end
-
-if Account.connection.respond_to?(:reset_pk_sequence!)
-  class FixturesResetPkSequenceTest < Test::Unit::TestCase
-    fixtures :accounts
-    fixtures :companies
-
-    def setup
-      @instances = [Account.new(:credit_limit => 50), Company.new(:name => 'RoR Consulting')]
-      Fixtures.reset_cache # make sure tables get reinitialized
-    end
-
-    def test_resets_to_min_pk_with_specified_pk_and_sequence
-      @instances.each do |instance|
-        model = instance.class
-        model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
-
-        instance.save!
-        assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
-      end
-    end
-
-    def test_resets_to_min_pk_with_default_pk_and_sequence
-      @instances.each do |instance|
-        model = instance.class
-        model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name)
-
-        instance.save!
-        assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
-      end
-    end
-
-    def test_create_fixtures_resets_sequences_when_not_cached
-      @instances.each do |instance|
-        max_id = create_fixtures(instance.class.table_name).inject(0) do |max_id, (name, fixture)|
-          fixture_id = fixture['id'].to_i
-          fixture_id > max_id ? fixture_id : max_id
-        end
-
-        # Clone the last fixture to check that it gets the next greatest id.
-        instance.save!
-        assert_equal max_id + 1, instance.id, "Sequence reset for #{instance.class.table_name} failed."
-      end
-    end
-  end
-end
-
-class FixturesWithoutInstantiationTest < Test::Unit::TestCase
-  self.use_instantiated_fixtures = false
-  fixtures :topics, :developers, :accounts
-
-  def test_without_complete_instantiation
-    assert_nil @first
-    assert_nil @topics
-    assert_nil @developers
-    assert_nil @accounts
-  end
-
-  def test_fixtures_from_root_yml_without_instantiation
-    assert_nil @unknown
-  end
-
-  def test_accessor_methods
-    assert_equal "The First Topic", topics(:first).title
-    assert_equal "Jamis", developers(:jamis).name
-    assert_equal 50, accounts(:signals37).credit_limit
-  end
-
-  def test_accessor_methods_with_multiple_args
-    assert_equal 2, topics(:first, :second).size
-    assert_raise(StandardError) { topics([:first, :second]) }
-  end
-
-  uses_mocha 'reloading_fixtures_through_accessor_methods' do
-    def test_reloading_fixtures_through_accessor_methods
-      assert_equal "The First Topic", topics(:first).title
-      @loaded_fixtures['topics']['first'].expects(:find).returns(stub(:title => "Fresh Topic!"))
-      assert_equal "Fresh Topic!", topics(:first, true).title
-    end
-  end
-end
-
-class FixturesWithoutInstanceInstantiationTest < Test::Unit::TestCase
-  self.use_instantiated_fixtures = true
-  self.use_instantiated_fixtures = :no_instances
-
-  fixtures :topics, :developers, :accounts
-
-  def test_without_instance_instantiation
-    assert_nil @first
-    assert_not_nil @topics
-    assert_not_nil @developers
-    assert_not_nil @accounts
-  end
-end
-
-class TransactionalFixturesTest < Test::Unit::TestCase
-  self.use_instantiated_fixtures = true
-  self.use_transactional_fixtures = true
-
-  fixtures :topics
-
-  def test_destroy
-    assert_not_nil @first
-    @first.destroy
-  end
-
-  def test_destroy_just_kidding
-    assert_not_nil @first
-  end
-end
-
-class MultipleFixturesTest < Test::Unit::TestCase
-  fixtures :topics
-  fixtures :developers, :accounts
-
-  def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
-  end
-end
-
-# This is to reproduce a bug where if a TestCase is loaded
-# twice by Ruby, it loses its fixture setup hook.
-class_def = <<-CODE
-  class DoubleLoadedTestCase < Test::Unit::TestCase
-    fixtures :topics
-
-    def setup
-    end
-  
-    def test_should_properly_setup_fixtures
-      assert_nothing_raised { topics(:first) }
-    end
-  end
-CODE
-2.times { eval(class_def) }
-
-class OverlappingFixturesTest < Test::Unit::TestCase
-  fixtures :topics, :developers
-  fixtures :developers, :accounts
-
-  def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
-  end
-end
-
-class ForeignKeyFixturesTest < Test::Unit::TestCase
-  fixtures :fk_test_has_pk, :fk_test_has_fk
-
-  # if foreign keys are implemented and fixtures
-  # are not deleted in reverse order then this test
-  # case will raise StatementInvalid
-
-  def test_number1
-    assert true
-  end
-
-  def test_number2
-    assert true
-  end
-end
-
-class SetTableNameFixturesTest < Test::Unit::TestCase
-  set_fixture_class :funny_jokes => 'Joke'
-  fixtures :funny_jokes
-
-  def test_table_method
-    assert_kind_of Joke, funny_jokes(:a_joke)
-  end
-end
-
-class CustomConnectionFixturesTest < Test::Unit::TestCase
-  set_fixture_class :courses => Course
-  fixtures :courses
-
-  def test_connection
-    assert_kind_of Course, courses(:ruby)
-    assert_equal Course.connection, courses(:ruby).connection
-  end
-end
-
-class InvalidTableNameFixturesTest < Test::Unit::TestCase
-  fixtures :funny_jokes
-
-  def test_raises_error
-    assert_raises FixtureClassNotFound do
-      funny_jokes(:a_joke)
-    end
-  end
-end
-
-class CheckEscapedYamlFixturesTest < Test::Unit::TestCase
-  set_fixture_class :funny_jokes => 'Joke'
-  fixtures :funny_jokes
-
-  def test_proper_escaped_fixture
-    assert_equal "The \\n Aristocrats\nAte the candy\n", funny_jokes(:another_joke).name
-  end
-end
-
-class DevelopersProject; end
-class ManyToManyFixturesWithClassDefined < Test::Unit::TestCase
-  fixtures :developers_projects
-
-  def test_this_should_run_cleanly
-    assert true
-  end
-end
-
-class FixturesBrokenRollbackTest < Test::Unit::TestCase
-  def blank_setup; end
-  alias_method :ar_setup_with_fixtures, :setup_with_fixtures
-  alias_method :setup_with_fixtures, :blank_setup
-  alias_method :setup, :blank_setup
-
-  def blank_teardown; end
-  alias_method :ar_teardown_with_fixtures, :teardown_with_fixtures
-  alias_method :teardown_with_fixtures, :blank_teardown
-  alias_method :teardown, :blank_teardown
-
-  def test_no_rollback_in_teardown_unless_transaction_active
-    assert_equal 0, Thread.current['open_transactions']
-    assert_raise(RuntimeError) { ar_setup_with_fixtures }
-    assert_equal 0, Thread.current['open_transactions']
-    assert_nothing_raised { ar_teardown_with_fixtures }
-    assert_equal 0, Thread.current['open_transactions']
-  end
-
-  private
-    def load_fixtures
-      raise 'argh'
-    end
-end
-
-class LoadAllFixturesTest < Test::Unit::TestCase
-  self.fixture_path= File.join(File.dirname(__FILE__), '/fixtures/all')
-  fixtures :all
-
-  def test_all_there
-    assert_equal %w(developers people tasks), fixture_table_names.sort
-  end
-end
-
-class FasterFixturesTest < Test::Unit::TestCase
-  fixtures :categories, :authors
-
-  def load_extra_fixture(name)
-    fixture = create_fixtures(name)
-    assert fixture.is_a?(Fixtures)
-    @loaded_fixtures[fixture.table_name] = fixture
-  end
-
-  def test_cache
-    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'categories')
-    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'authors')
-
-    assert_no_queries do
-      create_fixtures('categories')
-      create_fixtures('authors')
-    end
-
-    load_extra_fixture('posts')
-    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'posts')
-    self.class.setup_fixture_accessors('posts')
-    assert_equal 'Welcome to the weblog', posts(:welcome).title
-  end
-end
-
-class FoxyFixturesTest < Test::Unit::TestCase
-  fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers, :developers
-
-  def test_identifies_strings
-    assert_equal(Fixtures.identify("foo"), Fixtures.identify("foo"))
-    assert_not_equal(Fixtures.identify("foo"), Fixtures.identify("FOO"))
-  end
-
-  def test_identifies_symbols
-    assert_equal(Fixtures.identify(:foo), Fixtures.identify(:foo))
-  end
-
-  TIMESTAMP_COLUMNS = %w(created_at created_on updated_at updated_on)
-
-  def test_populates_timestamp_columns
-    TIMESTAMP_COLUMNS.each do |property|
-      assert_not_nil(parrots(:george).send(property), "should set #{property}")
-    end
-  end
-
-  def test_does_not_populate_timestamp_columns_if_model_has_set_record_timestamps_to_false
-    TIMESTAMP_COLUMNS.each do |property|
-      assert_nil(ships(:black_pearl).send(property), "should not set #{property}")
-    end
-  end
-
-  def test_populates_all_columns_with_the_same_time
-    last = nil
-
-    TIMESTAMP_COLUMNS.each do |property|
-      current = parrots(:george).send(property)
-      last ||= current
-
-      assert_equal(last, current)
-      last = current
-    end
-  end
-
-  def test_only_populates_columns_that_exist
-    assert_not_nil(pirates(:blackbeard).created_on)
-    assert_not_nil(pirates(:blackbeard).updated_on)
-  end
-
-  def test_preserves_existing_fixture_data
-    assert_equal(2.weeks.ago.to_date, pirates(:redbeard).created_on.to_date)
-    assert_equal(2.weeks.ago.to_date, pirates(:redbeard).updated_on.to_date)
-  end
-
-  def test_generates_unique_ids
-    assert_not_nil(parrots(:george).id)
-    assert_not_equal(parrots(:george).id, parrots(:louis).id)
-  end
-
-  def test_automatically_sets_primary_key
-    assert_not_nil(ships(:black_pearl))
-  end
-
-  def test_preserves_existing_primary_key
-    assert_equal(2, ships(:interceptor).id)
-  end
-
-  def test_resolves_belongs_to_symbols
-    assert_equal(parrots(:george), pirates(:blackbeard).parrot)
-  end
-
-  def test_ignores_belongs_to_symbols_if_association_and_foreign_key_are_named_the_same
-    assert_equal(developers(:david), computers(:workstation).developer)
-  end
-
-  def test_supports_join_tables
-    assert(pirates(:blackbeard).parrots.include?(parrots(:george)))
-    assert(pirates(:blackbeard).parrots.include?(parrots(:louis)))
-    assert(parrots(:george).pirates.include?(pirates(:blackbeard)))
-  end
-
-  def test_supports_inline_habtm
-    assert(parrots(:george).treasures.include?(treasures(:diamond)))
-    assert(parrots(:george).treasures.include?(treasures(:sapphire)))
-    assert(!parrots(:george).treasures.include?(treasures(:ruby)))
-  end
-
-  def test_supports_inline_habtm_with_specified_id
-    assert(parrots(:polly).treasures.include?(treasures(:ruby)))
-    assert(parrots(:polly).treasures.include?(treasures(:sapphire)))
-    assert(!parrots(:polly).treasures.include?(treasures(:diamond)))
-  end
-
-  def test_supports_yaml_arrays
-    assert(parrots(:louis).treasures.include?(treasures(:diamond)))
-    assert(parrots(:louis).treasures.include?(treasures(:sapphire)))
-  end
-
-  def test_strips_DEFAULTS_key
-    assert_raise(StandardError) { parrots(:DEFAULTS) }
-
-    # this lets us do YAML defaults and not have an extra fixture entry
-    %w(sapphire ruby).each { |t| assert(parrots(:davey).treasures.include?(treasures(t))) }
-  end
-
-  def test_supports_label_interpolation
-    assert_equal("frederick", parrots(:frederick).name)
-  end
-
-  def test_supports_polymorphic_belongs_to
-    assert_equal(pirates(:redbeard), treasures(:sapphire).looter)
-    assert_equal(parrots(:louis), treasures(:ruby).looter)
-  end
-
-  def test_only_generates_a_pk_if_necessary
-    m = Matey.find(:first)
-    m.pirate = pirates(:blackbeard)
-    m.target = pirates(:redbeard)
-  end
-
-  def test_supports_sti
-    assert_kind_of DeadParrot, parrots(:polly)
-    assert_equal pirates(:blackbeard), parrots(:polly).killer
-  end
-end
-
-class ActiveSupportSubclassWithFixturesTest < ActiveSupport::TestCase
-  fixtures :parrots
-
-  # This seemingly useless assertion catches a bug that caused the fixtures
-  # setup code call nil[]
-  def test_foo
-    assert_equal parrots(:louis), Parrot.find_by_name("King Louis")
-  end
-end