ibm_db 3.0.0-x86-mingw32 → 3.0.1-x86-mingw32

data/test/models/auto_id.rb

@@ -0,0 +1,4 @@
+class AutoId < ActiveRecord::Base
+  self.table_name = "auto_id_tests"
+  self.primary_key = "auto_id"
+end

data/test/models/autoloadable/extra_firm.rb

@@ -0,0 +1,2 @@
+class ExtraFirm < Company
+end

data/test/models/binary.rb

@@ -0,0 +1,2 @@
+class Binary < ActiveRecord::Base
+end

data/test/models/bird.rb

@@ -0,0 +1,12 @@
+class Bird < ActiveRecord::Base
+  belongs_to :pirate
+  validates_presence_of :name
+
+  accepts_nested_attributes_for :pirate
+
+  attr_accessor :cancel_save_from_callback
+  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  def cancel_save_callback_method
+    false
+  end
+end

data/test/models/book.rb

@@ -0,0 +1,18 @@
+class Book < ActiveRecord::Base
+  has_many :authors
+
+  has_many :citations, :foreign_key => 'book1_id'
+  has_many :references, -> { distinct }, through: :citations, source: :reference_of
+
+  has_many :subscriptions
+  has_many :subscribers, through: :subscriptions
+
+  enum status: [:proposed, :written, :published]
+  enum read_status: {unread: 0, reading: 2, read: 3}
+  enum nullable_status: [:single, :married]
+
+  def published!
+    super
+    "do publish work..."
+  end
+end

data/test/models/boolean.rb

@@ -0,0 +1,2 @@
+class Boolean < ActiveRecord::Base
+end

data/test/models/bulb.rb

@@ -0,0 +1,51 @@
+class Bulb < ActiveRecord::Base
+  default_scope { where(:name => 'defaulty') }
+  belongs_to :car, :touch => true
+
+  attr_reader :scope_after_initialize, :attributes_after_initialize
+
+  after_initialize :record_scope_after_initialize
+  def record_scope_after_initialize
+    @scope_after_initialize = self.class.all
+  end
+
+  after_initialize :record_attributes_after_initialize
+  def record_attributes_after_initialize
+    @attributes_after_initialize = attributes.dup
+  end
+
+  def color=(color)
+    self[:color] = color.upcase + "!"
+  end
+
+  def self.new(attributes = {}, &block)
+    bulb_type = (attributes || {}).delete(:bulb_type)
+
+    if bulb_type.present?
+      bulb_class = "#{bulb_type.to_s.camelize}Bulb".constantize
+      bulb_class.new(attributes, &block)
+    else
+      super
+    end
+  end
+end
+
+class CustomBulb < Bulb
+  after_initialize :set_awesomeness
+
+  def set_awesomeness
+    self.frickinawesome = true if name == 'Dude'
+  end
+end
+
+class FunkyBulb < Bulb
+  before_destroy do
+    raise "before_destroy was called"
+  end
+end
+
+class FailedBulb < Bulb
+  before_destroy do
+    false
+  end
+end

data/test/models/cake_designer.rb

@@ -0,0 +1,3 @@
+class CakeDesigner < ActiveRecord::Base
+  has_one :chef, as: :employable
+end

data/test/models/car.rb

@@ -0,0 +1,26 @@
+class Car < ActiveRecord::Base
+  has_many :bulbs
+  has_many :all_bulbs, -> { unscope where: :name }, class_name: "Bulb"
+  has_many :funky_bulbs, class_name: 'FunkyBulb', dependent: :destroy
+  has_many :failed_bulbs, class_name: 'FailedBulb', dependent: :destroy
+  has_many :foo_bulbs, -> { where(:name => 'foo') }, :class_name => "Bulb"
+
+  has_one :bulb
+
+  has_many :tyres
+  has_many :engines, :dependent => :destroy, inverse_of: :my_car
+  has_many :wheels, :as => :wheelable, :dependent => :destroy
+
+  scope :incl_tyres, -> { includes(:tyres) }
+  scope :incl_engines, -> { includes(:engines) }
+
+  scope :order_using_new_style,  -> { order('name asc') }
+end
+
+class CoolCar < Car
+  default_scope { order('name desc') }
+end
+
+class FastCar < Car
+  default_scope { order('name desc') }
+end

data/test/models/carrier.rb

@@ -0,0 +1,2 @@
+class Carrier < ActiveRecord::Base
+end

data/test/models/categorization.rb

@@ -0,0 +1,19 @@
+class Categorization < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :category, counter_cache: true
+  belongs_to :named_category, :class_name => 'Category', :foreign_key => :named_category_name, :primary_key => :name
+  belongs_to :author
+
+  has_many :post_taggings, :through => :author, :source => :taggings
+
+  belongs_to :author_using_custom_pk,  :class_name => 'Author', :foreign_key => :author_id, :primary_key => :author_address_extra_id
+  has_many   :authors_using_custom_pk, :class_name => 'Author', :foreign_key => :id,        :primary_key => :category_id
+end
+
+class SpecialCategorization < ActiveRecord::Base
+  self.table_name = 'categorizations'
+  default_scope { where(:special => true) }
+
+  belongs_to :author
+  belongs_to :category
+end

data/test/models/category.rb

@@ -0,0 +1,35 @@
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+  has_and_belongs_to_many :special_posts, :class_name => "Post"
+  has_and_belongs_to_many :other_posts, :class_name => "Post"
+  has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, :class_name => "Post"
+
+  has_and_belongs_to_many :select_testing_posts,
+                          -> { select 'posts.*, 1 as correctness_marker' },
+                          :class_name => 'Post',
+                          :foreign_key => 'category_id',
+                          :association_foreign_key => 'post_id'
+
+  has_and_belongs_to_many :post_with_conditions,
+                          -> { where :title => 'Yet Another Testing Title' },
+                          :class_name => 'Post'
+
+  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, :class_name => "Post"
+  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, :class_name => "Post"
+
+  def self.what_are_you
+    'a category...'
+  end
+
+  has_many :categorizations
+  has_many :special_categorizations
+  has_many :post_comments, :through => :posts, :source => :comments
+
+  has_many :authors, :through => :categorizations
+  has_many :authors_with_select, -> { select 'authors.*, categorizations.post_id' }, :through => :categorizations, :source => :author
+
+  scope :general, -> { where(:name => 'General') }
+end
+
+class SpecialCategory < Category
+end

data/test/models/chef.rb

@@ -0,0 +1,3 @@
+class Chef < ActiveRecord::Base
+  belongs_to :employable, polymorphic: true
+end

data/test/models/citation.rb

@@ -0,0 +1,3 @@
+class Citation < ActiveRecord::Base
+  belongs_to :reference_of, :class_name => "Book", :foreign_key => :book2_id
+end

data/test/models/club.rb

@@ -0,0 +1,23 @@
+class Club < ActiveRecord::Base
+  has_one :membership
+  has_many :memberships, :inverse_of => false
+  has_many :members, :through => :memberships
+  has_one :sponsor
+  has_one :sponsored_member, :through => :sponsor, :source => :sponsorable, :source_type => "Member"
+  belongs_to :category
+
+  has_many :favourites, -> { where(memberships: { favourite: true }) }, through: :memberships, source: :member
+
+  private
+
+  def private_method
+    "I'm sorry sir, this is a *private* club, not a *pirate* club"
+  end
+end
+
+class SuperClub < ActiveRecord::Base
+  self.table_name = "clubs"
+
+  has_many :memberships, class_name: 'SuperMembership', foreign_key: 'club_id'
+  has_many :members, through: :memberships
+end

data/test/models/college.rb

@@ -0,0 +1,10 @@
+require_dependency 'models/arunit2_model'
+require 'active_support/core_ext/object/with_options'
+
+class College < ARUnit2Model
+  has_many :courses
+
+  with_options dependent: :destroy do |assoc|
+    assoc.has_many :students, -> { where(active: true) }
+  end
+end

data/test/models/column.rb

@@ -0,0 +1,3 @@
+class Column < ActiveRecord::Base
+  belongs_to :record
+end

data/test/models/column_name.rb

@@ -0,0 +1,3 @@
+class ColumnName < ActiveRecord::Base
+  self.table_name = "colnametests"
+end

data/test/models/comment.rb

@@ -0,0 +1,64 @@
+class Comment < ActiveRecord::Base
+  scope :limit_by, lambda {|l| limit(l) }
+  scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
+  scope :not_again, -> { where("comments.body NOT LIKE '%again%'") }
+  scope :for_first_post, -> { where(:post_id => 1) }
+  scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
+  scope :created, -> { all }
+
+  belongs_to :post, :counter_cache => true
+  belongs_to :author,   polymorphic: true
+  belongs_to :resource, polymorphic: true
+  belongs_to :developer
+
+  has_many :ratings
+
+  belongs_to :first_post, :foreign_key => :post_id
+
+  has_many :children, :class_name => 'Comment', :foreign_key => :parent_id
+  belongs_to :parent, :class_name => 'Comment', :counter_cache => :children_count
+
+  def self.what_are_you
+    'a comment...'
+  end
+
+  def self.search_by_type(q)
+    where("#{QUOTED_TYPE} = ?", q)
+  end
+
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, -> { all }
+
+  def to_s
+    body
+  end
+end
+
+class SpecialComment < Comment
+end
+
+class SubSpecialComment < SpecialComment
+end
+
+class VerySpecialComment < Comment
+end
+
+class CommentThatAutomaticallyAltersPostBody < Comment
+  belongs_to :post, class_name: "PostThatLoadsCommentsInAnAfterSaveHook", foreign_key: :post_id
+
+  after_save do |comment|
+    comment.post.update_attributes(body: "Automatically altered")
+  end
+end
+
+class CommentWithDefaultScopeReferencesAssociation < Comment
+  default_scope ->{ includes(:developer).order('developers.name').references(:developer) }
+  belongs_to :developer
+end
+
+class CommentWithConflictingDefaultScope < Comment
+  default_scope ->{ where(author_id: 42) }
+  belongs_to :post_with_conflicting_default_scope, foreign_key: :post_id
+end

data/test/models/company.rb

@@ -0,0 +1,225 @@
+class AbstractCompany < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+class Company < AbstractCompany
+  self.sequence_name = :companies_nonstd_seq
+
+  validates_presence_of :name
+
+  has_one :dummy_account, :foreign_key => "firm_id", :class_name => "Account"
+  has_many :contracts
+  has_many :developers, :through => :contracts
+  has_many :accounts
+
+  scope :of_first_firm, lambda {
+    joins(:account => :firm).
+    where('firms.id' => 1)
+  }
+
+  def arbitrary_method
+    "I am Jack's profound disappointment"
+  end
+
+  private
+
+  def private_method
+    "I am Jack's innermost fears and aspirations"
+  end
+end
+
+module Namespaced
+  class Company < ::Company
+  end
+
+  class Firm < ::Company
+    has_many :clients, :class_name => 'Namespaced::Client'
+  end
+
+  class Client < ::Company
+  end
+end
+
+class Firm < Company
+  to_param :name
+
+  has_many :clients, -> { order "id" }, :dependent => :destroy, :before_remove => :log_before_remove, :after_remove  => :log_after_remove
+  has_many :unsorted_clients, :class_name => "Client"
+  has_many :unsorted_clients_with_symbol, :class_name => :Client
+  has_many :clients_sorted_desc, -> { order "id DESC" }, :class_name => "Client"
+  has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :inverse_of => :firm
+  has_many :clients_ordered_by_name, -> { order "name" }, :class_name => "Client"
+  has_many :unvalidated_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :validate => false
+  has_many :dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :destroy
+  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+  has_many :limited_clients, -> { limit 1 }, :class_name => "Client"
+  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, :class_name => "Client"
+  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
+  has_many :clients_like_ms_with_hash_conditions, -> { where(:name => 'Microsoft').order("id") }, :class_name => "Client"
+  has_many :plain_clients, :class_name => 'Client'
+  has_many :clients_using_primary_key, :class_name => 'Client',
+           :primary_key => 'name', :foreign_key => 'firm_name'
+  has_many :clients_using_primary_key_with_delete_all, :class_name => 'Client',
+           :primary_key => 'name', :foreign_key => 'firm_name', :dependent => :delete_all
+  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, :class_name => "Client"
+  has_many :clients_grouped_by_name, -> { group("name").select("name") }, :class_name => "Client"
+
+  has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true
+  has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => 'Account', :validate => false
+  has_one :account_with_select, -> { select("id, firm_id") }, :foreign_key => "firm_id", :class_name=>'Account'
+  has_one :readonly_account, -> { readonly }, :foreign_key => "firm_id", :class_name => "Account"
+  # added order by id as in fixtures there are two accounts for Rails Core
+  # Oracle tests were failing because of that as the second fixture was selected
+  has_one :account_using_primary_key, -> { order('id') }, :primary_key => "firm_id", :class_name => "Account"
+  has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"
+  has_one :account_with_inexistent_foreign_key, class_name: 'Account', foreign_key: "inexistent"
+  has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
+
+  has_one :account_limit_500_with_hash_conditions, -> { where :credit_limit => 500 }, :foreign_key => "firm_id", :class_name => "Account"
+
+  has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+  has_many :accounts
+  has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+
+  has_many :association_with_references, -> { references(:foo) }, :class_name => 'Client'
+
+  def log
+    @log ||= []
+  end
+
+  private
+    def log_before_remove(record)
+      log << "before_remove#{record.id}"
+    end
+
+    def log_after_remove(record)
+      log << "after_remove#{record.id}"
+    end
+end
+
+class DependentFirm < Company
+  has_one :account, :foreign_key => "firm_id", :dependent => :nullify
+  has_many :companies, :foreign_key => 'client_of', :dependent => :nullify
+  has_one :company, :foreign_key => 'client_of', :dependent => :nullify
+end
+
+class RestrictedWithExceptionFirm < Company
+  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_exception
+  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_exception
+end
+
+class RestrictedWithErrorFirm < Company
+  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_error
+  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_error
+end
+
+class Client < Company
+  belongs_to :firm, :foreign_key => "client_of"
+  belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"
+  belongs_to :firm_with_select, -> { select("id") }, :class_name => "Firm", :foreign_key => "firm_id"
+  belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
+  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, :class_name => "Firm", :foreign_key => "client_of"
+  belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
+  belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
+  belongs_to :readonly_firm, -> { readonly }, :class_name => "Firm", :foreign_key => "firm_id"
+  belongs_to :bob_firm, -> { where :name => "Bob" }, :class_name => "Firm", :foreign_key => "client_of"
+  has_many :accounts, :through => :firm, :source => :accounts
+  belongs_to :account
+
+  validate do
+    firm
+  end
+
+  class RaisedOnSave < RuntimeError; end
+  attr_accessor :raise_on_save
+  before_save do
+    raise RaisedOnSave if raise_on_save
+  end
+
+  class RaisedOnDestroy < RuntimeError; end
+  attr_accessor :raise_on_destroy
+  before_destroy do
+    raise RaisedOnDestroy if raise_on_destroy
+  end
+
+  # Record destruction so we can test whether firm.clients.clear has
+  # is calling client.destroy, deleting from the database, or setting
+  # foreign keys to NULL.
+  def self.destroyed_client_ids
+    @destroyed_client_ids ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  before_destroy do |client|
+    if client.firm
+      Client.destroyed_client_ids[client.firm.id] << client.id
+    end
+    true
+  end
+
+  before_destroy :overwrite_to_raise
+
+  # Used to test that read and question methods are not generated for these attributes
+  def rating?
+    query_attribute :rating
+  end
+
+  def overwrite_to_raise
+  end
+
+  class << self
+    private
+
+    def private_method
+      "darkness"
+    end
+  end
+end
+
+class ExclusivelyDependentFirm < Company
+  has_one :account, :foreign_key => "firm_id", :dependent => :delete
+  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", 'BigShot Inc.') }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+end
+
+class SpecialClient < Client
+end
+
+class VerySpecialClient < SpecialClient
+end
+
+class Account < ActiveRecord::Base
+  belongs_to :firm, :class_name => 'Company'
+  belongs_to :unautosaved_firm, :foreign_key => "firm_id", :class_name => "Firm", :autosave => false
+
+  alias_attribute :available_credit, :credit_limit
+
+  def self.destroyed_account_ids
+    @destroyed_account_ids ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  # Test private kernel method through collection proxy using has_many.
+  def self.open
+    where('firm_name = ?', '37signals')
+  end
+
+  before_destroy do |account|
+    if account.firm
+      Account.destroyed_account_ids[account.firm.id] << account.id
+    end
+    true
+  end
+
+  validate :check_empty_credit_limit
+
+  protected
+
+  def check_empty_credit_limit
+    errors.add_on_empty "credit_limit"
+  end
+
+  private
+
+  def private_method
+    "Sir, yes sir!"
+  end
+end