activerecord 1.0.0 → 2.0.0

data/lib/active_record/wrappers/yaml_wrapper.rb

@@ -1,15 +0,0 @@
-require 'yaml'
-
-module ActiveRecord
-  module Wrappings #:nodoc:
-    class YamlWrapper < AbstractWrapper #:nodoc:
-      def wrap(attribute)   attribute.to_yaml end
-      def unwrap(attribute) YAML::load(attribute) end
-    end
-
-    module ClassMethods #:nodoc:
-      # Wraps the attribute in Yaml encoding
-      def wrap_in_yaml(*attributes) wrap_with(YamlWrapper, attributes) end
-    end
-  end
-end

data/lib/active_record/wrappings.rb

@@ -1,59 +0,0 @@
-module ActiveRecord
-  # A plugin framework for wrapping attribute values before they go in and unwrapping them after they go out of the database.
-  # This was intended primarily for YAML wrapping of arrays and hashes, but this behavior is now native in the Base class.
-  # So for now this framework is laying dorment until a need pops up.
-  module Wrappings #:nodoc:
-    module ClassMethods #:nodoc:
-      def wrap_with(wrapper, *attributes)
-        [ attributes ].flat.each { |attribute| wrapper.wrap(attribute) }
-      end
-    end
-
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)
-    end
-
-    class AbstractWrapper #:nodoc:
-      def self.wrap(attribute, record_binding) #:nodoc:
-        %w( before_save after_save after_initialize ).each do |callback|
-          eval "#{callback} #{name}.new('#{attribute}')", record_binding
-        end
-      end
-
-      def initialize(attribute) #:nodoc:
-        @attribute = attribute
-      end
-
-      def save_wrapped_attribute(record) #:nodoc:
-        if record.attribute_present?(@attribute)
-          record.send(
-            "write_attribute", 
-            @attribute, 
-            wrap(record.send("read_attribute", @attribute))
-          )
-        end
-      end
-
-      def load_wrapped_attribute(record) #:nodoc:
-        if record.attribute_present?(@attribute)
-          record.send(
-            "write_attribute", 
-            @attribute, 
-            unwrap(record.send("read_attribute", @attribute))
-          )
-        end
-      end
-  
-      alias_method :before_save, :save_wrapped_attribute #:nodoc:
-      alias_method :after_save, :load_wrapped_attribute #:nodoc:
-      alias_method :after_initialize, :after_save #:nodoc:
-
-      # Overwrite to implement the logic that'll take the regular attribute and wrap it.
-      def wrap(attribute) end
-  
-      # Overwrite to implement the logic that'll take the wrapped attribute and unwrap it.
-      def unwrap(attribute) end
-    end
-  end
-end

data/rakefile

@@ -1,122 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-
-PKG_VERSION = "1.0.0"
-
-PKG_FILES = FileList[
-    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "install.rb", "rakefile"
-].exclude(/\bCVS\b|~$/)
-
-
-desc "Default Task"
-task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_postgresql ]
-
-# Run the unit tests
-
-Rake::TestTask.new("test_ruby_mysql") { |t|
-  t.libs << "test" << "test/connections/native_mysql"
-  t.test_files = "lib/active_record/vendor/mysql.rb"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-}
-
-Rake::TestTask.new("test_mysql_ruby") { |t|
-  t.libs << "test" << "test/connections/native_mysql"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-}
-
-Rake::TestTask.new("test_postgresql") { |t|
-  t.libs << "test" << "test/connections/native_postgresql"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-}
-
-Rake::TestTask.new("test_sqlite") { |t|
-  t.libs << "test" << "test/connections/native_sqlite"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-}
-
-# Genereate the RDoc documentation
-
-Rake::RDocTask.new { |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.title    = "Active Record -- Object-relation mapping put on rails"
-  rdoc.options << '--line-numbers --inline-source --accessor cattr_accessor=object'
-  rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.rdoc_files.exclude('lib/active_record/vendor/*')
-  rdoc.rdoc_files.include('dev-utils/*.rb')
-}
-
-
-# Publish documentation
-desc "Publish the API documentation"
-task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@one.textdrive.com", "domains/rubyonrails.org/ar", "doc").upload
-end
-
-desc "Publish to RubyForge"
-task :rubyforge do
-    Rake::RubyForgePublisher.new('activerecord', 'webster132').upload
-end
-
-
-# Create compressed packages
-
-dist_dirs = [ "lib", "test", "examples", "dev-utils" ]
-
-spec = Gem::Specification.new do |s|
-  s.name = 'activerecord'
-  s.version = PKG_VERSION
-  s.summary = "Implements the ActiveRecord pattern for ORM."
-  s.description = %q{Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database tables and classes together for business objects, like Customer or Subscription, that can find, save, and destroy themselves without resorting to manual SQL.}
-
-  s.files = [ "rakefile", "install.rb", "README", "RUNNING_UNIT_TESTS", "CHANGELOG" ]
-  dist_dirs.each do |dir|
-    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "CVS" ) }
-  end
-  s.files.delete "test/fixtures/fixture_database.sqlite"
-  s.require_path = 'lib'
-  s.autorequire = 'active_record'
-
-  s.has_rdoc = true
-  s.extra_rdoc_files = %w( README )
-  s.rdoc_options.concat ['--main',  'README']
-  
-  s.author = "David Heinemeier Hansson"
-  s.email = "david@loudthinking.com"
-  s.homepage = "http://activerecord.rubyonrails.org"
-  s.rubyforge_project = "activerecord"
-end
-  
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
-end
-
-
-task :lines do
-  lines = 0
-  codelines = 0
-  Dir.foreach("lib/active_record") { |file_name| 
-    next unless file_name =~ /.*rb/
-    
-    f = File.open("lib/active_record/" + file_name)
-
-    while line = f.gets
-      lines += 1
-      next if line =~ /^\s*$/
-      next if line =~ /^\s*#/
-      codelines += 1
-    end
-  }
-  puts "Lines #{lines}, LOC #{codelines}"
-end

data/test/deprecated_associations_test.rb

@@ -1,336 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/developer'
-require 'fixtures/project'
-require 'fixtures/company'
-require 'fixtures/topic'
-# require File.dirname(__FILE__) + '/../dev-utils/eval_debugger'
-require 'fixtures/reply'
-
-# Can't declare new classes in test case methods, so tests before that
-bad_collection_keys = false
-begin
-  class Car < ActiveRecord::Base; has_many :wheels, :name => "wheels"; end
-rescue ActiveRecord::ActiveRecordError
-  bad_collection_keys = true
-end
-raise "ActiveRecord should have barked on bad collection keys" unless bad_collection_keys
-
-
-class DeprecatedAssociationsTest < Test::Unit::TestCase
-  def setup
-    create_fixtures "accounts", "companies", "accounts", "developers", "projects", "developers_projects", "topics"
-    @signals37 = Firm.find(1)
-  end
-
-  def test_has_many_find
-    assert_equal 2, Firm.find_first.clients.length
-  end
-  
-  def test_has_many_orders
-    assert_equal "Summit", Firm.find_first.clients.first.name
-  end
-
-  def test_has_many_class_name
-    assert_equal "Microsoft", Firm.find_first.clients_sorted_desc.first.name
-  end
-
-  def test_has_many_foreign_key
-    assert_equal "Microsoft", Firm.find_first.clients_of_firm.first.name
-  end
-  
-  def test_has_many_conditions
-    assert_equal "Microsoft", Firm.find_first.clients_like_ms.first.name
-  end
-
-  def test_has_many_sql
-    firm = Firm.find_first
-    assert_equal "Microsoft", firm.clients_using_sql.first.name
-    assert_equal 1, firm.clients_using_sql_count
-    assert_equal 1, Firm.find_first.clients_using_sql_count
-  end
-  
-  def test_has_many_queries
-    assert Firm.find_first.has_clients?
-    firm = Firm.find_first
-    assert_equal 2, firm.clients_count # tests using class count
-    firm.clients
-    assert firm.has_clients?
-    assert_equal 2, firm.clients_count # tests using collection length
-  end
-
-  def test_has_many_dependence
-    assert_equal 2, Client.find_all.length
-    Firm.find_first.destroy
-    assert_equal 0, Client.find_all.length
-  end
-
-  def test_has_many_dependence_with_transaction_support_on_failure
-    assert_equal 2, Client.find_all.length
-
-    firm = Firm.find_first
-    clients = firm.clients
-    clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end }
-
-    firm.destroy rescue "do nothing"
-
-    assert_equal 2, Client.find_all.length
-  end
-  
-  def test_has_one_dependence
-    firm = Firm.find(1)
-    assert firm.has_account?
-    firm.destroy
-    assert_equal 1, Account.find_all.length
-  end
-
-  def test_has_one_dependence_with_missing_association
-    Account.destroy_all
-    firm = Firm.find(1)
-    assert !firm.has_account?
-    firm.destroy
-  end
-
-  def test_belongs_to
-    assert_equal @signals37.name, Client.find(3).firm.name
-    assert Client.find(3).has_firm?, "Microsoft should have a firm"
-    # assert !Company.find(1).has_firm?, "37signals shouldn't have a firm"
-  end
-  
-  def test_belongs_to_with_different_class_name
-    assert_equal Company.find(1).name, Company.find(3).firm_with_other_name.name
-    assert Company.find(3).has_firm_with_other_name?, "Microsoft should have a firm"
-    assert !Company.find(1).has_firm_with_other_name?, "37signals shouldn't have a firm"
-  end
-
-  def test_belongs_to_with_condition
-    assert_equal Company.find(1).name, Company.find(3).firm_with_condition.name
-    assert Company.find(3).has_firm_with_condition?, "Microsoft should have a firm"
-    assert !Company.find(1).has_firm_with_condition?, "37signals shouldn't have a firm"
-  end
-
-  
-  def test_belongs_to_equality
-    assert Company.find(3).firm?(Company.find(1)), "Microsoft should have 37signals as firm"
-    assert_raises(RuntimeError) { !Company.find(3).firm?(Company.find(3)) } # "Summit shouldn't have itself as firm"
-  end
-  
-  def test_has_one
-    assert @signals37.account?(Account.find(1))
-    assert_equal Account.find(1).credit_limit, @signals37.account.credit_limit
-    assert @signals37.has_account?, "37signals should have an account"
-    assert Account.find(1).firm?(@signals37), "37signals account should be able to backtrack"
-    assert Account.find(1).has_firm?, "37signals account should be able to backtrack"
-
-    assert !Account.find(2).has_firm?, "Unknown isn't linked"
-    assert !Account.find(2).firm?(@signals37), "Unknown isn't linked"
-  end
-
-  def test_has_many_dependence_on_account
-    assert_equal 2, Account.find_all.length
-    @signals37.destroy
-    assert_equal 1, Account.find_all.length
-  end
-  
-  def test_find_in
-    assert_equal Client.find(2).name, @signals37.find_in_clients(2).name
-    assert_raises(ActiveRecord::RecordNotFound) { @signals37.find_in_clients(6) }
-  end
-  
-  def test_force_reload
-    firm = Firm.new
-    firm.save
-    firm.clients.each {|c|} # forcing to load all clients
-    assert firm.clients.empty?, "New firm shouldn't have client objects"
-    assert !firm.has_clients?, "New firm shouldn't have clients"
-    assert_equal 0, firm.clients_count, "New firm should have 0 clients"
-    
-    client = Client.new("firm_id" => firm.id)
-    client.save
-
-    assert firm.clients.empty?, "New firm should have cached no client objects"
-    assert !firm.has_clients?, "New firm should have cached a no-clients response"
-    assert_equal 0, firm.clients_count, "New firm should have cached 0 clients count"
-
-    assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
-    assert firm.has_clients?(true), "New firm should have reloaded with a have-clients response"
-    assert_equal 1, firm.clients_count(true), "New firm should have reloaded clients count"
-  end
-    
-  def test_included_in_collection
-    assert @signals37.clients.include?(Client.find(2))
-  end
-
-  def test_build_to_collection
-    assert_equal 1, @signals37.clients_of_firm_count
-    new_client = @signals37.build_to_clients_of_firm("name" => "Another Client")
-    assert_equal "Another Client", new_client.name
-    assert new_client.save
-
-    assert new_client.firm?(@signals37)
-    assert_equal 2, @signals37.clients_of_firm_count(true)
-  end
-  
-  def test_create_in_collection
-    assert_equal @signals37.create_in_clients_of_firm("name" => "Another Client"), @signals37.clients_of_firm(true).last
-  end
-  
-  def test_succesful_build_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    
-    account = firm.build_account("credit_limit" => 1000)
-    assert account.save
-    assert_equal account, firm.account
-  end
-  
-  def test_failing_build_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    
-    account = firm.build_account
-    assert !account.save
-    assert_equal "can't be empty", account.errors.on("credit_limit")
-  end
-  
-  def test_create_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    assert_equal firm.create_account("credit_limit" => 1000), firm.account
-  end
-  
-  def test_has_and_belongs_to_many
-    david = Developer.find(1)
-    assert david.has_projects?
-    assert_equal 2, david.projects_count
-
-    active_record = Project.find(1)
-    assert active_record.has_developers?
-    assert_equal 2, active_record.developers_count
-    assert_equal david.name, active_record.developers.first.name
-  end
-
-  def test_has_and_belongs_to_many_removing
-    david = Developer.find(1)
-    active_record = Project.find(1)
-
-    david.remove_projects(active_record)
-    
-    assert_equal 1, david.projects_count
-    assert_equal 1, active_record.developers_count    
-  end
-
-  def test_has_and_belongs_to_many_zero
-    david = Developer.find(1)
-    david.remove_projects(Project.find_all)
-    
-    assert_equal 0, david.projects_count
-    assert !david.has_projects?
-  end
-
-  def test_has_and_belongs_to_many_adding
-    jamis = Developer.find(2)
-    action_controller = Project.find(2)
-
-    jamis.add_projects(action_controller)
-    
-    assert_equal 2, jamis.projects_count
-    assert_equal 2, action_controller.developers_count    
-  end
-
-  def test_has_and_belongs_to_many_adding_from_the_project
-    jamis = Developer.find(2)
-    action_controller = Project.find(2)
-
-    action_controller.add_developers(jamis)
-    
-    assert_equal 2, jamis.projects_count
-    assert_equal 2, action_controller.developers_count
-  end
-  
-  def test_has_and_belongs_to_many_adding_a_collection
-    aridridel = Developer.new("name" => "Aridridel")
-    aridridel.save
-    
-    aridridel.add_projects([ Project.find(1), Project.find(2) ])
-    assert_equal 2, aridridel.projects_count
-  end
-  
-  def test_belongs_to_counter
-    topic = Topic.create("title" => "Apple", "content" => "hello world")
-    assert_equal 0, topic.send(:read_attribute, "replies_count"), "No replies yet"
-
-    reply = topic.create_in_replies("title" => "I'm saying no!", "content" => "over here")
-    assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count"), "First reply created"
-
-    reply.destroy
-    assert_equal 0, Topic.find(topic.id).send(:read_attribute, "replies_count"), "First reply deleted"
-  end
-  
-  def test_natural_assignment_of_has_one
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-  end
-  
-  def test_natural_assignment_of_belongs_to
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    citibank.firm = apple
-    assert_equal apple.id, citibank.firm_id
-  end
-
-  def test_natural_assignment_of_has_many
-    apple = Firm.create("name" => "Apple")
-    natural = Client.new("name" => "Natural Company")
-    apple.clients << natural
-    assert_equal apple.id, natural.firm_id
-    assert_equal Client.find(natural.id), Firm.find(apple.id).clients.find { |c| c.id == natural.id }
-    apple.clients.delete natural
-    assert_nil Firm.find(apple.id).clients.find { |c| c.id == natural.id }
-  end
-
-   
-  def test_natural_adding_of_has_and_belongs_to_many
-    rails = Project.create("name" => "Rails")
-    ap = Project.create("name" => "Action Pack")
-    john = Developer.create("name" => "John")
-    mike = Developer.create("name" => "Mike")
- 		rails.developers << john
- 		rails.developers << mike
- 		
-    assert_equal Developer.find(john.id), Project.find(rails.id).developers.find { |d| d.id == john.id }
-    assert_equal Developer.find(mike.id), Project.find(rails.id).developers.find { |d| d.id == mike.id }
-    assert_equal Project.find(rails.id), Developer.find(mike.id).projects.find { |p| p.id == rails.id }
-    assert_equal Project.find(rails.id), Developer.find(john.id).projects.find { |p| p.id == rails.id }
-    ap.developers << john
-    assert_equal Developer.find(john.id), Project.find(ap.id).developers.find { |d| d.id == john.id }
-    assert_equal Project.find(ap.id), Developer.find(john.id).projects.find { |p| p.id == ap.id }
-    
-    ap.developers.delete john
-    assert_nil Project.find(ap.id).developers.find { |d| d.id == john.id }
-		assert_nil Developer.find(john.id).projects.find { |p| p.id == ap.id }
-  end
-
-  def test_storing_in_pstore
-    require "pstore"
-    apple = Firm.create("name" => "Apple")
-    natural = Client.new("name" => "Natural Company")
-    apple.clients << natural
-
-    db = PStore.new("/tmp/ar-pstore-association-test")
-    db.transaction do
-      db["apple"] = apple
-    end
-
-    db = PStore.new("/tmp/ar-pstore-association-test")
-    db.transaction do
-      assert_equal "Natural Company", db["apple"].clients.first.name
-    end
-  end
-
-  def test_has_many_find_all
-    assert_equal 2, Firm.find_first.find_all_in_clients("type = 'Client'").length
-    assert_equal 1, Firm.find_first.find_all_in_clients("name = 'Summit'").length
-  end
-end

data/test/fixtures/accounts/signals37

@@ -1,3 +0,0 @@
-id => 1
-firm_id => 1
-credit_limit => 50

data/test/fixtures/accounts/unknown

@@ -1,2 +0,0 @@
-id => 2
-credit_limit => 50

data/test/fixtures/companies/first_client

@@ -1,6 +0,0 @@
-id => 2
-type => Client
-firm_id => 1
-client_of => 2
-name => Summit
-ruby_type => Client

data/test/fixtures/companies/first_firm

@@ -1,4 +0,0 @@
-id => 1
-type => Firm
-name => 37signals
-ruby_type => Firm

data/test/fixtures/companies/second_client

@@ -1,6 +0,0 @@
-id => 3
-type => Client
-firm_id => 1
-client_of => 1
-name => Microsoft
-ruby_type => Client

data/test/fixtures/courses/java

@@ -1,2 +0,0 @@
-id => 2
-name => Java Development

data/test/fixtures/courses/ruby

@@ -1,2 +0,0 @@
-id => 1
-name => Ruby Development

data/test/fixtures/customers/david

@@ -1,6 +0,0 @@
-id => 1
-name => David
-balance => 50
-address_street => Funny Street
-address_city => Scary Town
-address_country => Loony Land

data/test/fixtures/db_definitions/mysql.sql

@@ -1,96 +0,0 @@
-CREATE TABLE `accounts` (
-  `id` int(11) NOT NULL auto_increment,
-  `firm_id` int(11) default NULL,
-  `credit_limit` int(5) default NULL,
-  PRIMARY KEY  (`id`)
-) TYPE=InnoDB;
-
-CREATE TABLE `companies` (
-  `id` int(11) NOT NULL auto_increment,
-  `type` varchar(50) default NULL,
-  `ruby_type` varchar(50) default NULL,
-  `firm_id` int(11) default NULL,
-  `name` varchar(50) default NULL,
-  `client_of` int(11) default NULL,
-  `rating` int(11) default NULL default 1,
-  PRIMARY KEY  (`id`)
-) TYPE=InnoDB;
-
-
-CREATE TABLE `topics` (
-  `id` int(11) NOT NULL auto_increment,
-  `title` varchar(255) default NULL,
-  `author_name` varchar(255) default NULL,
-  `author_email_address` varchar(255) default NULL,
-  `written_on` datetime default NULL,
-  `last_read` date default NULL,
-  `content` text,
-  `approved` tinyint(1) default 1,
-  `replies_count` int(11) default 0,
-  `parent_id` int(11) default NULL,
-  `type` varchar(50) default NULL,
-  PRIMARY KEY  (`id`)
-) TYPE=InnoDB;
-
-CREATE TABLE `developers` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(100) default NULL,
-  PRIMARY KEY  (`id`)
-);
-
-CREATE TABLE `projects` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(100) default NULL,
-  PRIMARY KEY  (`id`)
-);
-
-CREATE TABLE `developers_projects` (
-  `developer_id` int(11) NOT NULL,
-  `project_id` int(11) NOT NULL
-);
-
-CREATE TABLE `customers` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(100) default NULL,
-  `balance` int(6) default 0,
-  `address_street` varchar(100) default NULL,
-  `address_city` varchar(100) default NULL,
-  `address_country` varchar(100) default NULL,
-  PRIMARY KEY  (`id`)
-);
-
-CREATE TABLE `movies` (
-  `movieid` int(11) NOT NULL auto_increment,
-  `name` varchar(100) default NULL,
-   PRIMARY KEY  (`movieid`)
-);
-
-CREATE TABLE `subscribers` (
-  `nick` varchar(100) NOT NULL,
-  `name` varchar(100) default NULL,
-  PRIMARY KEY  (`nick`)
-);
-
-CREATE TABLE `booleantests` (
-  `id` int(11) NOT NULL auto_increment,
-  `value` integer default NULL,
-  PRIMARY KEY (`id`)
-);
-
-CREATE TABLE `auto_id_tests` (
-  `auto_id` int(11) NOT NULL auto_increment,
-  `value` integer default NULL,
-  PRIMARY KEY (`auto_id`)
-);
-
-CREATE TABLE `entrants` (
-  `id` INTEGER NOT NULL PRIMARY KEY,
-  `name` VARCHAR(255) NOT NULL,
-  `course_id` INTEGER NOT NULL
-);
-
-CREATE TABLE `colnametests` (
-  `id` int(11) NOT NULL auto_increment,
-  `references` int(11) NOT NULL,
-  PRIMARY KEY (`id`)
-);

data/test/fixtures/db_definitions/mysql2.sql

@@ -1,4 +0,0 @@
-CREATE TABLE `courses` (
- `id` INTEGER NOT NULL PRIMARY KEY,
- `name` VARCHAR(255) NOT NULL
-);

data/test/fixtures/developers/david

@@ -1,2 +0,0 @@
-id => 1
-name => David

data/test/fixtures/developers/jamis

@@ -1,2 +0,0 @@
-id => 2
-name => Jamis

data/test/fixtures/entrants/first

@@ -1,3 +0,0 @@
-id => 1
-course_id => 1
-name => Ruby Developer