ar_attr_lazy 0.1.0

data/test/helper.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+
+require 'pp'
+
+if ENV["AR_VERSION"]
+  gem 'activerecord', "= #{ENV["AR_VERSION"]}"
+end
+require 'activerecord'
+require 'active_record/version'
+ActiveRecord::Base.establish_connection(
+  "adapter" => "sqlite3",
+  "database" => ":memory:"
+)
+
+gem 'mcmire-protest'
+require 'protest'
+gem 'mcmire-matchy'
+require 'matchy'
+gem 'mcmire-mocha'
+require 'mocha'
+require 'mocha-protest-integration'
+
+Protest.report_with :documentation
+#Protest::Utils::BacktraceFilter::ESCAPE_PATHS << %r|test/unit| << %r|matchy| << %r|mocha-protest-integration|
+Protest::Utils::BacktraceFilter::ESCAPE_PATHS.clear
+
+#------------------------
+
+module Protest
+  class TestCase
+    def full_name
+      self.class.description + " " + self.name
+    end
+    
+    class TestWrapper #:nodoc:
+      attr_reader :name
+
+      def initialize(type, test_case)
+        @type = type
+        @test = test_case
+        @name = "Global #{@type} for #{test_case.description}"
+      end
+
+      def run(report)
+        @test.send("do_global_#{@type}")
+      end
+      
+      def full_name
+        @name
+      end
+    end
+  end
+  
+  module TestWithErrors
+    def file
+      file_and_line[0]
+    end
+    
+    def line
+      file_and_line[1]
+    end
+    
+    def file_and_line
+      backtrace.find {|x| x =~ %r{^.*/test/(.*_test|test_.*)\.rb} }.split(":")[0..1]
+    end
+  end
+  
+  module Utils
+    module Summaries
+      def summarize_errors
+        return if failures_and_errors.empty?
+
+        puts "Failures:"
+        puts
+
+        pad_indexes = failures_and_errors.size.to_s.size
+        failures_and_errors.each_with_index do |error, index|
+          colorize_as = ErroredTest === error ? :errored : :failed
+          # PATCH: test.full_name
+          puts "  #{pad(index+1, pad_indexes)}) #{test_type(error)} in `#{error.test.full_name}' (on line #{error.line} of `#{error.file}')", colorize_as
+          # If error message has line breaks, indent the message
+          prefix = "with"
+          unless error.error.is_a?(Protest::AssertionFailed) ||
+          ((RUBY_VERSION =~ /^1\.9/) ? error.error.is_a?(MiniTest::Assertion) : error.error.is_a?(::Test::Unit::AssertionFailedError))
+            prefix << " #{error.error.class}" 
+          end
+          if error.error_message =~ /\n/
+            puts indent("#{prefix}: <<", 6 + pad_indexes), colorize_as
+            puts indent(error.error_message, 6 + pad_indexes + 2), colorize_as
+            puts indent(">>", 6 + pad_indexes), colorize_as
+          else
+            puts indent("#{prefix} `#{error.error_message}'", 6 + pad_indexes), colorize_as
+          end
+          indent(error.backtrace, 6 + pad_indexes).each {|backtrace| puts backtrace, colorize_as }
+          puts
+        end
+      end
+    end
+  end
+end
+
+#------------------------
+
+require 'matchers'
+require 'factories'
+
+require 'mcmire/ar_attr_lazy'

data/test/matchers.rb

@@ -0,0 +1,172 @@
+module MatchyMatchers
+  # Ported from an RSpec matcher
+  # from https://rspec.lighthouseapp.com/projects/5645/tickets/896-lambda-should-query-matcher
+  # with a few tweaks
+  class ArQuery #:nodoc:
+    cattr_accessor :executed
+
+    @@recording_queries = false
+    def self.recording_queries?
+      @@recording_queries
+    end
+
+    def initialize(test_case, expecteds, &block)
+      @test_case = test_case
+      @expecteds = expecteds
+      @expecteds = [1] if @expecteds.empty?
+      @block = block
+    end
+
+    def matches?(given_proc)
+      @eval_block = false
+      @eval_error = nil
+      ArQuery.executed = []
+      @@recording_queries = true
+
+      given_proc.call
+
+      if @expecteds[0].is_a?(Fixnum)
+        @expecteds = @expecteds[0]
+        @actuals = ArQuery.executed.length
+        @matched = (@actuals == @expecteds)
+      else
+        # assume that a block was not given
+        # PATCH: accept multiple queries
+        @expecteds = Array(@expecteds)
+        @actuals = @expecteds.map {|query| [query, ArQuery.executed.detect {|sql| query === sql }] }
+        @matched = @actuals.all? {|e,a| a }
+      end
+
+      eval_block if @block && @matched && !negative_expectation?
+
+      @matched && @eval_error.nil?
+
+    ensure
+      #ArQuery.executed = nil
+      @@recording_queries = false
+    end
+    
+    # This is necessary for interoperability with Matchy
+    def fail!(which)
+      @test_case.flunk(which ? failure_message_for_should : failure_message_for_should_not)
+    end
+
+    # This is necessary for interoperability with Matchy
+    def pass!(which)
+      @test_case.assert true
+    end
+
+    def eval_block
+      @eval_block = true
+      begin
+        @block.call(ArQuery.executed)
+      rescue Exception => err
+        @eval_error = err
+      end
+    end
+
+    def failure_message_for_should
+      if @eval_error
+        @eval_error.message
+      elsif @expecteds.is_a?(Fixnum)
+        "expected #{@expecteds} to be executed, when in fact #{@actuals} were"
+      else
+        # PATCH: better error message
+        msg = ""
+        @actuals.select {|e,a| !a }.each do |expected, _|
+          msg << "expected a query with pattern #{expected.inspect} to be executed, but it wasn't\n"
+        end
+        msg << "All queries executed:\n"
+        ArQuery.executed.each do |query|
+          msg << " - #{query}\n"
+        end
+        msg
+      end
+    end
+
+    def failure_message_for_should_not
+      if @expecteds.is_a?(Fixnum)
+        "did not expect #{@expecteds} queries to be executed, but they were"
+      else
+        # PATCH: better error message
+        msg = ""
+        @actuals.select {|e,a| a }.each do |_, actual|
+          msg << "expected a query with pattern #{actual.inspect} not to be executed, but it was\n"
+        end
+        msg << "All queries executed:\n"
+        ArQuery.executed.each do |query|
+          msg << " - #{query}\n"
+        end
+        msg
+      end
+    end
+
+    #def description
+    #  if @expecteds.is_a?(Fixnum)
+    #    @expecteds == 1 ? "execute 1 query" : "execute #{@expecteds} queries"
+    #  else
+    #    "execute query with pattern #{@expecteds.inspect}"
+    #  end
+    #end
+
+    # Copied from raise_error
+    def negative_expectation?
+      @negative_expectation ||= !caller.first(3).find { |s| s =~ /should_not/ }.nil?
+    end
+  end
+
+  # :call-seq:
+  # response.should query
+  # response.should query(expected)
+  # response.should query(expected1, expected2)
+  # response.should query(expected) { |sql| ... }
+  # response.should_not query
+  # response.should_not query(expected)
+  # response.should_not query(expected1, expected2)
+  #
+  # Accepts a Fixnum, a String, a Regexp, or an array of Strings or Regexps as arguments.
+  #
+  # With no args, matches if exactly 1 query is executed.
+  # With a Fixnum arg, matches if the number of queries executed equals the given number.
+  # With a Regexp arg, matches if any query is executed with the given pattern.
+  # With multiple args, matches if all given patterns are matched by all queries executed.
+  #
+  # Pass an optional block to perform extra verifications of the queries matched.
+  # The argument of the block will receive an array of query strings that were executed.
+  #
+  # == Examples
+  #
+  # lambda { @object.posts }.should query # same as `should query(1)`
+  # lambda { @object.valid? }.should query(0)
+  # lambda { @object.save }.should query(3)
+  # lambda { @object.line_items }.should query("SELECT DISTINCT")
+  # lambda { @object.line_items }.should query(/SELECT DISTINCT/)
+  # lambda { @object.line_items }.should query(/SELECT DISTINCT/, /SELECT COUNT\(\*\)/)
+  # lambda { @object.line_items }.should query(1) { |sql| sql[0].should =~ /SELECT DISTINCT/ }
+  #
+  # lambda { @object.posts }.should_not query # same as `should_not query(1)`
+  # lambda { @object.valid? }.should_not query(0)
+  # lambda { @object.save }.should_not query(3)
+  # lambda { @object.line_items }.should_not query(/SELECT DISTINCT/)
+  # lambda { @object.line_items }.should_not query(/SELECT DISTINCT/, /SELECT COUNT\(\*\)/)
+  #
+  def query(*expecteds, &block)
+    ArQuery.new(self, expecteds, &block)
+  end
+  
+  unless defined?(IGNORED_SQL)
+    # From active_record/test/cases/helper.rb :
+    ::ActiveRecord::Base.connection.class.class_eval do
+      IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+      def execute_with_query_record(sql, name = nil, &block)
+        if ArQuery.recording_queries?
+          # PATCH: squeeze and strip
+          ArQuery.executed << sql.squeeze(" ").strip unless IGNORED_SQL.any? { |ignore| sql =~ ignore }
+        end
+        execute_without_query_record(sql, name, &block)
+      end
+      alias_method_chain :execute, :query_record
+    end
+  end
+end
+Protest::TestCase.class_eval { include MatchyMatchers }

data/test/not_using_attr_lazy_test.rb

@@ -0,0 +1,324 @@
+require 'helper'
+
+# what about STI? (do the lazy attributes carry over?)
+
+Protest.context "for a model that doesn't have lazy attributes" do
+  global_setup do
+    load File.dirname(__FILE__) + '/setup_migration.rb'
+    load File.dirname(__FILE__) + '/setup_tables_for_not_using.rb'
+    Account.make! do |account|
+      User.make!(:account => account) do |user|
+        Avatar.make!(:user => user)
+        Post.make!(:author => user) do |post|
+          Comment.make!(:post => post)
+          post.tags << Tag.make
+          post.categories << Category.make
+        end
+      end
+    end
+  end
+  
+  global_teardown do
+    ObjectSpace.each_object(Class) do |klass|
+      Object.remove_class(klass) if klass < ActiveRecord::Base
+    end
+  end
+  
+  def regex(str)
+    Regexp.new(Regexp.escape(str))
+  end
+  
+  context "with no associations involved" do
+    test "find selects all attributes by default" do
+      lambda { Account.find(:first) }.should query(regex(%|SELECT * FROM "accounts"|))
+    end
+    test "accessing any one attribute doesn't do a query" do
+      account = Account.first
+      lambda { account.name }.should_not query
+    end
+    test "find still honors an explicit select option" do
+      lambda { Account.find(:first, :select => "name") }.should query(regex(%|SELECT name FROM "accounts"|))
+    end
+    test "find still honors a select option in a parent scope" do
+      lambda {
+        Account.send(:with_scope, :find => {:select => "name"}) do
+          Account.find(:first)
+        end
+      }.should query(regex(%|SELECT name FROM "accounts"|))
+    end
+    if Mcmire::ArAttrLazy.ar_version >= 2.3
+      test "find still honors a select option in a default scope" do
+        lambda { AccountWithDefaultScope.find(:first) }.should query(regex(%|SELECT name FROM "accounts"|))
+      end
+    end
+  end
+  
+  context "accessing a has_many association" do
+    before do
+      @post = Post.first
+    end
+    test "find selects all attributes by default" do
+      lambda { @post.comments.find(:first) }.should query(regex(%|SELECT * FROM "comments"|))
+    end
+    test "find still honors an explicit select option" do
+      lambda { @post.comments.find(:first, :select => "name") }.should query(
+        regex(%|SELECT name FROM "comments"|)
+      )
+    end
+    test "find still honors a select option in a parent scope" do
+      lambda {
+        Comment.send(:with_scope, :find => {:select => "name"}) do
+          @post.comments.find(:first)
+        end
+      }.should query(
+        regex(%|SELECT name FROM "comments"|)
+      )
+    end
+    if Mcmire::ArAttrLazy.ar_version >= 2.3
+      test "find still honors a select option in a default scope" do
+        lambda { @post.comments_with_default_scope.find(:first) }.should query(
+          regex(%|SELECT name FROM "comments"|)
+        )
+      end
+    end
+    test "find still honors a select option in the association definition itself" do
+      lambda { @post.comments_with_select.find(:first) }.should query(
+        regex(%|SELECT name FROM "comments"|)
+      )
+    end
+  end
+  
+  context "accessing a belongs_to association" do
+    test "find selects all attributes by default" do
+      post = Post.first
+      lambda { post.author }.should query(regex(%|SELECT * FROM "users"|))
+    end
+    # can't do a find on a belongs_to, so no testing needed for that
+  end
+  
+  context "accessing a has_one association" do
+    test "find selects all attributes by default" do
+      account = Account.first
+      lambda { account.user }.should query(regex(%|SELECT * FROM "users"|))
+    end
+    # can't do a find on a has_one, so no testing needed for that
+  end
+  
+  context "accessing a has_and_belongs_to_many association" do
+    before do
+      @post = Post.first
+    end
+    test "find selects all attributes by default" do
+      lambda { @post.tags.find(:all) }.should query(regex(%|SELECT * FROM "tags"|))
+    end
+    test "find still honors an explicit select option" do
+      lambda { @post.tags.find(:all, :select => "tags.name") }.should query(
+        regex(%|SELECT tags.name FROM "tags"|)
+      )
+    end
+    test "find still honors a select option in a parent scope" do
+      pending "this fails on Rails 2.3.4"
+      lambda {
+        Tag.send(:with_scope, :find => {:select => "tags.name"}) do
+          @post.tags.find(:all)
+        end
+      }.should query(
+        regex(%|SELECT tags.name FROM "tags"|)
+      )
+    end
+    if Mcmire::ArAttrLazy.ar_version >= 2.3
+      test "find still honors a select option in a default scope" do
+        pending "this fails on Rails 2.3.4"
+        lambda {
+          @post.tags_with_default_scope.find(:all)
+        }.should query(
+          regex(%|SELECT tags.name FROM "tags"|)
+        )
+      end
+    end
+    test "find still honors a select option in the association definition itself" do
+      lambda {
+        @post.tags_with_select.find(:all)
+      }.should query(
+        regex(%|SELECT tags.name FROM "tags"|)
+      )
+    end
+  end
+  
+  context "accessing a has_many :through association" do
+    before do
+      @post = Post.first
+    end
+    test "find selects all attributes by default" do
+      lambda { @post.categories.find(:all) }.should query(
+        regex(%|SELECT "categories".* FROM "categories"|)
+      )
+    end
+    test "find still honors an explicit select option" do
+      lambda { @post.categories.find(:all, :select => "categories.name") }.should query(
+        regex(%|SELECT categories.name FROM "categories"|)
+      )
+    end
+    test "find still honors a select option in a parent scope" do
+      pending "this fails on Rails 2.3.4"
+      lambda {
+        Category.send(:with_scope, :find => {:select => "categories.name"}) do
+          @post.categories.find(:all)
+        end
+      }.should query(
+        regex(%|SELECT categories.name FROM "categories"|)
+      )
+    end
+    if Mcmire::ArAttrLazy.ar_version >= 2.3
+      test "find still honors a select option in a default scope" do
+        pending "this fails on Rails 2.3.4"
+        lambda {
+          @post.categories_with_default_scope.find(:all)
+        }.should query(
+          regex(%|SELECT categories.name FROM "categories"|)
+        )
+      end
+    end
+    test "find still honors a select option in the association definition itself" do
+      lambda {
+        @post.categories_with_select.find(:all)
+      }.should query(
+        regex(%|SELECT categories.name FROM "categories"|)
+      )
+    end
+  end
+  
+  # has_one :through didn't work properly prior to 2.3.4 - see LH #2719
+  if Mcmire::ArAttrLazy.ar_version >= "2.3.4"
+    context "accessing a has_one :through association" do
+      test "find selects all attributes by default" do
+        account = Account.first
+        lambda { account.avatar }.should query(
+          regex(%|SELECT "avatars".* FROM "avatars"|)
+        )
+      end
+      # can't do a find on a has_one, so no testing needed for that
+    end
+  end
+  
+  context "eager loading a has_many association (association preloading)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :comments)
+      }.should query(regex(%|SELECT * FROM "posts"|), regex(%|SELECT "comments".* FROM "comments"|))
+    end
+    # can't test for an explicit select since that will force a table join
+    # can't test for a scope select since association preloading doesn't honor those
+  end
+  context "eager loading a has_many association (table join)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :comments, :order => "comments.id")
+      }.should query(%r{"posts"\."body"}, %r{"comments"\."body"})
+    end
+    # can't test for an explicit select since that clashes with the table join anyway
+    # can't test for a scope for the same reason
+  end
+  
+  context "eager loading a has_one association (association preloading)" do
+    test "find selects all attributes by default" do
+      lambda { Account.find(:first, :include => :user) }.should query(regex(%|SELECT "users".* FROM "users"|))
+    end
+    # can't test for an explicit select since that will force a table join
+    # can't test for a scope select since association preloading doesn't honor those
+  end
+  context "eager loading a has_one association (table join)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Account.find(:first, :include => :user, :order => "users.id")
+      }.should query(%r{"users"\."bio"})
+    end
+    # can't test for an explicit select since that clashes with the table join anyway
+    # can't test for a scope for the same reason
+  end
+  
+  context "eager loading a belongs_to association (association preloading)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :author)
+      }.should query(regex(%|SELECT * FROM "posts"|))
+    end
+    # can't test for an explicit select since that will force a table join
+    # can't test for a scope select since association preloading doesn't honor those
+  end
+  context "eager loading a belongs_to association (table join)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :author, :order => "users.id")
+      }.should query(%r{"posts"\."(body|summary)"}, %r{"users"\."bio"})
+    end
+    # can't test for an explicit select since that clashes with the table join anyway
+    # can't test for a scope for the same reason
+  end
+  
+  context "eager loading a has_and_belongs_to_many association (association preloading)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :tags)
+      }.should query(regex(%|SELECT * FROM "posts"|), regex(%|SELECT "tags".*, t0.post_id as the_parent_record_id FROM "tags"|))
+    end
+    # can't test for an explicit select since that will force a table join
+    # can't test for a scope select since association preloading doesn't honor those
+  end
+  context "eager loading a has_and_belongs_to_many association (table join)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :tags, :order => "tags.id")
+      }.should query(%r{"posts"\."(body|summary)"}, %r{"tags"\."description"})
+    end
+    # can't test for an explicit select since that clashes with the table join anyway
+    # can't test for a scope for the same reason
+  end
+  
+  context "eager loading a has_many :through association (association preloading)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :categories)
+      }.should query(
+        regex(%|SELECT * FROM "categories"|)
+      )
+    end
+    # can't test for an explicit select since that will force a table join
+    # can't test for a scope select since association preloading doesn't honor those
+  end
+  context "eager loading a has_many :through association (table join)" do
+    test "find selects all attributes by default" do
+      lambda {
+        Post.find(:first, :include => :categories, :order => "categories.id")
+      }.should query(
+        regex(%|SELECT "posts"."id" AS t0_r0, "posts"."type" AS t0_r1, "posts"."author_id" AS t0_r2, "posts"."title" AS t0_r3, "posts"."permalink" AS t0_r4, "posts"."body" AS t0_r5, "posts"."summary" AS t0_r6, "categories"."id" AS t1_r0, "categories"."type" AS t1_r1, "categories"."name" AS t1_r2, "categories"."description" AS t1_r3 FROM "posts"|)
+      )
+    end
+    # can't test for an explicit select since that clashes with the table join anyway
+    # can't test for a scope for the same reason
+  end
+  
+  # has_one :through didn't work properly prior to 2.3.4 - see LH #2719
+  if Mcmire::ArAttrLazy.ar_version >= "2.3.4"
+    context "eager loading a has_one :through association (association preloading)" do
+      test "find selects all attributes by default" do
+        lambda { Account.find(:first, :include => :avatar) }.should query(
+          regex(%|SELECT "avatars".* FROM "avatars"|)
+        )
+      end
+      # can't test for an explicit select since that will force a table join
+      # can't test for a scope select since association preloading doesn't honor those
+    end
+    context "eager loading a has_one :through association (table join)" do
+      test "find selects all attributes by default" do
+        pending "this is failing for some reason!"
+        lambda {
+          Account.find(:first, :include => :avatar, :order => "avatars.filename")
+        }.should query(%|SELECT "accounts"."id" AS t0_r0, "accounts"."name" AS t0_r1, "avatars"."id" AS t1_r0, "avatars"."user_id" AS t1_r1, "avatars"."filename" AS t1_r2, "avatars"."data" AS t1_r3 FROM "accounts"|)
+      end
+      # can't test for an explicit select since that clashes with the table join anyway
+      # can't test for a scope for the same reason
+    end
+  end
+  
+end