slacker 1.0.7 → 1.0.8

data/lib/slacker/rspec_ext.rb

@@ -1,49 +1,49 @@
-require 'slacker'
-require 'slacker/query_result_matcher'
-require 'csv'
-
-module Slacker
-  module RSpecExt
-    def query(query_string, options = {}, log_name = nil)
-      log_name ||= Slacker.construct_log_name('query', query_string, options)
-      sql = Slacker.sql_from_query_string(query_string, options)
-      @results = Slacker.query_script(example, sql, log_name)
-      if block_given?
-        yield @results
-      end
-      @results
-    end
-
-    def sql
-      Slacker.sql(self)
-    end
-
-    # Get a matcher which will compare the query results to a golden master
-    def match(golden_master)
-      QueryResultMatcher.new(Slacker.filter_golden_master(golden_master))
-    end
-
-    def csv(csv_file)
-      Slacker.get_csv(csv_file)
-    end
-
-    def touch_csv(csv_file_or_object, fields, field_generators = {})
-      Slacker.touch_csv(csv_file_or_object, fields, field_generators)
-    end
-
-    def load_csv(csv_file_or_object, table_name, log_name = nil)
-      log_name ||= "load_csv '#{csv_file_or_object.kind_of?(CSV::Table) ? 'CSV Object' : csv_file_or_object }', 'table_name'"
-      csv_object = case csv_file_or_object
-      when String then Slacker.get_csv(csv_file_or_object)
-      when CSV::Table then csv_file_or_object
-      when Array then Slacker.hash_array_to_csv(csv_file_or_object)
-      end
-
-      Slacker.load_csv(example, csv_object, table_name, log_name)
-    end
-
-    def yes?(val)
-      val != nil && val.downcase == 'yes'
-    end
-  end
-end
+require 'slacker'
+require 'slacker/query_result_matcher'
+require 'csv'
+
+module Slacker
+  module RSpecExt
+    def query(query_string, options = {}, log_name = nil)
+      log_name ||= Slacker.construct_log_name('query', query_string, options)
+      sql = Slacker.sql_from_query_string(query_string, options)
+      @results = Slacker.query_script(example, sql, log_name)
+      if block_given?
+        yield @results
+      end
+      @results
+    end
+
+    def sql
+      Slacker.sql(self)
+    end
+
+    # Get a matcher which will compare the query results to a golden master
+    def match(golden_master)
+      QueryResultMatcher.new(Slacker.filter_golden_master(golden_master))
+    end
+
+    def csv(csv_file)
+      Slacker.get_csv(csv_file)
+    end
+
+    def touch_csv(csv_file_or_object, fields, field_generators = {})
+      Slacker.touch_csv(csv_file_or_object, fields, field_generators)
+    end
+
+    def load_csv(csv_file_or_object, table_name, log_name = nil)
+      log_name ||= "load_csv '#{csv_file_or_object.kind_of?(CSV::Table) ? 'CSV Object' : csv_file_or_object }', 'table_name'"
+      csv_object = case csv_file_or_object
+      when String then Slacker.get_csv(csv_file_or_object)
+      when CSV::Table then csv_file_or_object
+      when Array then Slacker.hash_array_to_csv(csv_file_or_object)
+      end
+
+      Slacker.load_csv(example, csv_object, table_name, log_name)
+    end
+
+    def yes?(val)
+      val != nil && val.downcase == 'yes'
+    end
+  end
+end

data/lib/slacker/rspec_monkey.rb

@@ -1,7 +1,7 @@
-# Monkeypatch a method to reset RSpec to reset it
-module RSpec
-  def self.slacker_reset
-    @world = nil
-    @configuration = nil
-  end
+# Monkeypatch a method to reset RSpec to reset it
+module RSpec
+  def self.slacker_reset
+    @world = nil
+    @configuration = nil
+  end
 end

data/lib/slacker/sql.rb

@@ -1,39 +1,39 @@
-require 'slacker'
-require 'slacker/rspec_ext'
-
-module Slacker
-  class Sql < BasicObject
-    attr_accessor :base_folder, :rspec_ext
-
-    def initialize(base_folder, rspec_ext)
-      @base_folder = base_folder
-      @rspec_ext = rspec_ext
-    end
-
-    def method_missing(method_name, *params, &block)
-      ::Kernel.raise "Slacker::Sql.rspec_ext not initialized" if rspec_ext.nil?
-      ::Kernel.raise "Missing folder #{base_folder}" if !::File.directory?(base_folder)
-
-      method_name = method_name.to_s
-      
-      if ::File.directory?(::File.join(base_folder, method_name))
-        ::Slacker::Sql.new(::File.join(base_folder, method_name), rspec_ext)
-      else
-        sql_file = ::Slacker.sql_file_from_method_name(base_folder, method_name)
-        case sql_file
-        when nil
-          ::Kernel.raise "No SQL file found corresponding to method '#{method_name}' in folder #{base_folder}"
-        else
-          rspec_ext.query sql_file, *params, &block
-        end
-      end
-    end
-
-    def respond_to?(method_name)
-      method_name = method_name.to_s
-      ::Kernel.raise "Slacker::Sql.rspec_ext not initialized" if rspec_ext.nil?
-      ::File.directory?(::File.join(base_folder, method_name)) ||
-        !(::Slacker.sql_file_from_method_name(base_folder, method_name).nil?)
-    end
-  end
-end
+require 'slacker'
+require 'slacker/rspec_ext'
+
+module Slacker
+  class Sql < BasicObject
+    attr_accessor :base_folder, :rspec_ext
+
+    def initialize(base_folder, rspec_ext)
+      @base_folder = base_folder
+      @rspec_ext = rspec_ext
+    end
+
+    def method_missing(method_name, *params, &block)
+      ::Kernel.raise "Slacker::Sql.rspec_ext not initialized" if rspec_ext.nil?
+      ::Kernel.raise "Missing folder #{base_folder}" if !::File.directory?(base_folder)
+
+      method_name = method_name.to_s
+      
+      if ::File.directory?(::File.join(base_folder, method_name))
+        ::Slacker::Sql.new(::File.join(base_folder, method_name), rspec_ext)
+      else
+        sql_file = ::Slacker.sql_file_from_method_name(base_folder, method_name)
+        case sql_file
+        when nil
+          ::Kernel.raise "No SQL file found corresponding to method '#{method_name}' in folder #{base_folder}"
+        else
+          rspec_ext.query sql_file, *params, &block
+        end
+      end
+    end
+
+    def respond_to?(method_name)
+      method_name = method_name.to_s
+      ::Kernel.raise "Slacker::Sql.rspec_ext not initialized" if rspec_ext.nil?
+      ::File.directory?(::File.join(base_folder, method_name)) ||
+        !(::Slacker.sql_file_from_method_name(base_folder, method_name).nil?)
+    end
+  end
+end

data/lib/slacker/string_helper.rb

@@ -1,17 +1,17 @@
-module Slacker
-  module StringHelper
-    class << self
-      def camelize(lower_case_and_underscored_word)
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      end
-
-      def constantize(camel_cased_word)
-        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-        end
-
-        Object.module_eval("::#{$1}", __FILE__, __LINE__)
-      end
-    end
-  end
+module Slacker
+  module StringHelper
+    class << self
+      def camelize(lower_case_and_underscored_word)
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+
+      def constantize(camel_cased_word)
+        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+        end
+
+        Object.module_eval("::#{$1}", __FILE__, __LINE__)
+      end
+    end
+  end
 end

data/lib/slacker/version.rb

@@ -1,3 +1,3 @@
 module Slacker
-  VERSION = "1.0.7"
+  VERSION = "1.0.8"
 end

data/lib/slacker_new/project/sql/sample_1/my_table_on_power.sql.erb

@@ -1,2 +1,2 @@
-select x, y, convert(int, Power(x, y)) as [power]
+select x, y, convert(int, Power(x, y)) as [power]
   from MyTable;

data/lib/slacker_new/project/sql/sample_1/play_with_numbers.sql.erb

@@ -1,16 +1,16 @@
-declare @x int;
-declare @y int;
-
-set @x = <%= options[:x]%>;
-set @y = <%= options[:y]%>;
-
--- Return just the product of @x and @y
-select @x * @y [product] union all
-select 12;
-
--- Return the numbers and their sum
-select @x x, @y y, @x + @y [sum];
-
--- Get the two numbers in one column and their sum with 32 in another
-select @x p, @x + 32 s union all
-select @y p, @y + 32 s;
+declare @x int;
+declare @y int;
+
+set @x = <%= options[:x]%>;
+set @y = <%= options[:y]%>;
+
+-- Return just the product of @x and @y
+select @x * @y [product] union all
+select 12;
+
+-- Return the numbers and their sum
+select @x x, @y y, @x + @y [sum];
+
+-- Get the two numbers in one column and their sum with 32 in another
+select @x p, @x + 32 s union all
+select @y p, @y + 32 s;

data/slacker.gemspec

@@ -13,14 +13,14 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "slacker"
 
-  s.files = ['README.markdown', 'Rakefile', 'Gemfile', 'slacker.gemspec', 'Gemfile.lock'] + Dir.glob("{bin,lib,spec}/**/*")
+  s.files = ['README.markdown', 'Rakefile', 'Gemfile', 'slacker.gemspec'] + Dir.glob("{bin,lib,spec}/**/*")
   s.test_files = Dir.glob("spec/**/*")
   s.executables = ['slacker', 'slacker_new']
   s.require_paths = ["lib"]
 
   s.required_ruby_version = '>= 1.9.2'
  
-  s.add_dependency 'bundler', '~> 1.0.15'
+  s.add_dependency 'bundler', '>= 1.0.15'
   s.add_dependency 'ruby-odbc', '= 0.99994'
-  s.add_dependency 'rspec', '~> 2.5.0'
+  s.add_dependency 'rspec', '>= 2.5.0'
 end

data/spec/application_spec.rb

@@ -1,14 +1,14 @@
-require 'slacker'
-
-describe Slacker::Application do
-  it 'responds to run' do
-    Slacker.application.should respond_to(:run)
-  end
-
-  it 'responds to target_folder_structure with the correct list of folders' do
-    app = Slacker.application
-    app.should respond_to(:target_folder_structure)
-    folder_struct = app.target_folder_structure
-    folder_struct.should == ['data', 'debug', 'debug/passed_examples', 'debug/failed_examples', 'sql', 'spec', 'lib', 'lib/helpers']
-  end
+require 'slacker'
+
+describe Slacker::Application do
+  it 'responds to run' do
+    Slacker.application.should respond_to(:run)
+  end
+
+  it 'responds to target_folder_structure with the correct list of folders' do
+    app = Slacker.application
+    app.should respond_to(:target_folder_structure)
+    folder_struct = app.target_folder_structure
+    folder_struct.should == ['data', 'debug', 'debug/passed_examples', 'debug/failed_examples', 'sql', 'spec', 'lib', 'lib/helpers']
+  end
 end

data/spec/query_result_matcher_spec.rb

@@ -1,268 +1,268 @@
-require 'slacker'
-require 'spec_helper'
-require 'time'
-require 'odbc'
-
-describe Slacker::QueryResultMatcher do
-  def deep_copy(obj)
-    Marshal.load(Marshal.dump(obj))
-  end
-
-  before(:each) do
-    @subject = [{'Field 1' => 12, 'Field_2' => nil, 'b' => ''},
-      {'Field 1' => 'test string', 'Field_2' => ODBC::TimeStamp.new('2011-01-30'), 'b' => 8.9}]
-  end
-
-  shared_examples_for 'table-based matcher' do
-    it 'correctly rejects a non-matching query result based on wrong columns' do
-      one_column_too_few = deep_copy(@subject).each{|row| row.delete('b')}
-      one_column_too_many = deep_copy(@subject).each{|row| row['new column'] = 'val 1'}
-      wrong_column_name = deep_copy(@subject).each{|row| row.delete('Field_2'); row['Field_x'] = 'val x'}
-
-      @matcher.matches?(one_column_too_few).should be_false
-      @matcher.failure_message_for_should.should == 'Expected 3 field(s), got 2'
-
-      @matcher.matches?(one_column_too_many).should be_false
-      @matcher.failure_message_for_should.should == 'Expected 3 field(s), got 4'
-
-      @matcher.matches?(wrong_column_name).should be_false
-      @matcher.failure_message_for_should.should == 'Expected field "Field_2", got field "b"'
-    end
-
-    it 'correctly rejects a non-matching query result based on number of records' do
-      one_row_too_few = deep_copy(@subject)
-      one_row_too_few.shift
-      one_row_too_many = deep_copy(@subject) << @subject[0]
-      empty_query_result = []
-
-      @matcher.matches?(one_row_too_few).should be_false
-      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 1'
-
-      @matcher.matches?(one_row_too_many).should be_false
-      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 3'
-
-      @matcher.matches?(empty_query_result).should be_false
-      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 0'
-    end
-
-    it 'correctly rejects a non-matching query result based on a value' do
-      wrong_int = deep_copy(@subject)
-      wrong_int[0]['Field 1'] = 14
-
-      wrong_int_type = deep_copy(@subject)
-      wrong_int_type[1]['Field 1'] = 14
-
-      wrong_nil = deep_copy(@subject)
-      wrong_nil[0]['Field 1'] = nil
-
-      wrong_non_nil = deep_copy(@subject)
-      wrong_non_nil[0]['Field_2'] = 'whatever'
-      
-      misplaced_fields = deep_copy(@subject)
-      misplaced_fields[0].delete('Field 1')
-      misplaced_fields[1].delete('Field 1')
-      misplaced_fields[0]['Field 1'] = 12
-      misplaced_fields[1]['Field 1'] = 'test string'
-
-      @matcher.matches?(wrong_int).should be_false
-      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 1: Expected value "12", got "14"'
-
-
-      @matcher.matches?(wrong_int_type).should be_false
-      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 2: Expected value "test string", got "14"'
-
-      @matcher.matches?(wrong_nil).should be_false
-      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 1: Expected value "12", got <NULL>'
-
-      @matcher.matches?(wrong_non_nil).should be_false
-      @matcher.failure_message_for_should.should == 'Field "Field_2", Record 1: Expected value <NULL>, got "whatever"'
-
-      @matcher.matches?(misplaced_fields).should be_false
-      @matcher.failure_message_for_should.should == 'Expected field "Field 1", got field "Field_2"'
-    end
-
-    it 'correctly compares with a query result' do
-      @matcher.matches?(@subject).should be_true(@matcher.failure_message_for_should)
-    end
-
-    it 'only accepts well formed query result subjects' do
-      expected_message = /Can perform query matches only against a well formed query result subject/
-      @matcher.matches?(1).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?('test string').should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?(1.1).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?(Time.now).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?(nil).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x'}]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f3 => 'y'}]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f2 => 'y', :f3 => 'z'}]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, 12]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      @matcher.matches?([12, {:f1 => 'x', :f2 => 'y'}]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-
-      # An array with a single empty row is not a well-formed query result
-      @matcher.matches?([{}]).should be_false
-      @matcher.failure_message_for_should.should =~ expected_message
-    end
-    
-  end
-
-  describe 'CSV-based golden master' do
-    before(:each) do
-      @matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/test_1.csv'))
-    end
-    
-    it_behaves_like 'table-based matcher'
-
-    it 'correctly compares an empty subject with an empty CSV file' do
-      matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/no_rows.csv'))
-      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
-
-      matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/completely_blank.csv'))
-      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
-    end
-  end
-
-  describe 'Array-based golden master' do
-    before(:each) do
-      @matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
-    end
-
-    it_behaves_like 'table-based matcher'
-
-    it 'only accepts well formed query result golden master' do
-      expected_message = /Cannot match against a non-well formed golden master array/
-
-      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x'}])
-      matcher.matches?([]).should be_false
-      matcher.failure_message_for_should.should =~ expected_message
-
-      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f3 => 'y'}])
-      matcher.matches?([]).should be_false
-      matcher.failure_message_for_should.should =~ expected_message
-
-      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f2 => 'y', :f3 => 'z'}])
-      matcher.matches?([]).should be_false
-      matcher.failure_message_for_should.should =~ expected_message
-
-      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, 12])
-      matcher.matches?([]).should be_false
-      matcher.failure_message_for_should.should =~ expected_message
-
-      matcher = Slacker::QueryResultMatcher.new([12, {:f1 => 'x', :f2 => 'y'}])
-      matcher.matches?([]).should be_false
-      matcher.failure_message_for_should.should =~ expected_message
-    end
-
-    it 'correctly compares an empty subject with an empty golden master' do
-      matcher = Slacker::QueryResultMatcher.new([])
-      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
-    end
-  end
-
-  shared_examples_for 'single-value-based matcher' do
-    it 'should correctly match the first value in the result set' do
-      matcher = Slacker::QueryResultMatcher.new(@correct_golden_master)
-      matcher.matches?(@subject).should be_true(matcher.failure_message_for_should)
-    end
-
-    it 'should correctly reject a non-matching first item by value' do
-      if !@wrong_value_golden_master.nil? #Skip nil from value check when the master is nil
-        matcher = Slacker::QueryResultMatcher.new(@wrong_value_golden_master)
-        matcher.matches?(@subject).should be_false
-        matcher.failure_message_for_should.should =~ /Expected value "#{@wrong_value_golden_master}", got "#{@subject[0].values[0]}"/
-      end
-    end
-
-    it 'should correctly reject a non-matching first item by type' do
-      matcher = Slacker::QueryResultMatcher.new(@wrong_type_golden_master)
-      matcher.matches?(@subject).should be_false
-      matcher.failure_message_for_should.should =~ /Expected type "#{@wrong_type_golden_master.class}", got \"#{@subject[0].values[0].class}\"/
-    end
-  end
-
-  describe 'Integer-based golden master' do
-    before(:each) do
-      @subject = [{'Field 1' => 14, 'Field_2' => 'whatever'}]
-      @correct_golden_master = 14
-      @wrong_value_golden_master = 15
-      @wrong_type_golden_master = 'whatever'
-    end
-
-    it_behaves_like 'single-value-based matcher'
-  end
-
-  describe 'String-based golden master' do
-    before(:each) do
-      @subject = [{'Field 1' => 'test string', 'Field_2' => 12}]
-      @correct_golden_master = 'test string'
-      @wrong_value_golden_master = 'whatever'
-      @wrong_type_golden_master = 15
-    end
-
-    it_behaves_like 'single-value-based matcher'
-  end
-
-  describe 'Floating point-based golden master' do
-    before(:each) do
-      @subject = [{'Field 1' => 18.2, 'Field_2' => 12}]
-      @correct_golden_master = 18.2
-      @wrong_value_golden_master = 18.7
-      @wrong_type_golden_master = 15
-    end
-
-    it_behaves_like 'single-value-based matcher'
-  end
-
-  describe 'Date-based golden master' do
-    before(:each) do
-      @subject = [{'Field 1' => Time.parse('1/1/2011'), 'Field_2' => 12}]
-      @correct_golden_master = Time.parse('1/1/2011')
-      @wrong_value_golden_master = Time.parse('2/1/2011')
-      @wrong_type_golden_master = 'whatever'
-    end
-
-    it_behaves_like 'single-value-based matcher'
-  end
-
-  describe 'Nil-based golden master' do
-    before(:each) do
-      @subject = [{'Field 1' => nil, 'Field_2' => 12}]
-      @correct_golden_master = nil
-      @wrong_value_golden_master = nil # There is no wrong value for nil-based master
-      @wrong_type_golden_master = 'whatever'
-    end
-
-    it_behaves_like 'single-value-based matcher'
-  end
-
-  it 'correctly matches a multi-result subject' do
-    subject = [@subject, [{:Field_x => 12}]]
-    matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
-    matcher.matches?(subject).should be_true(matcher.failure_message_for_should)
-  end
-
-  it 'correctly rejects a wrong multi-result subject' do
-    subject = [[{:Field_x => 12}], @subject]
-    matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
-    matcher.matches?(subject).should be_false
-    matcher.failure_message_for_should.should == 'Expected 3 field(s), got 1'
-  end
-end
+require 'slacker'
+require 'spec_helper'
+require 'time'
+require 'odbc'
+
+describe Slacker::QueryResultMatcher do
+  def deep_copy(obj)
+    Marshal.load(Marshal.dump(obj))
+  end
+
+  before(:each) do
+    @subject = [{'Field 1' => 12, 'Field_2' => nil, 'b' => ''},
+      {'Field 1' => 'test string', 'Field_2' => ODBC::TimeStamp.new('2011-01-30'), 'b' => 8.9}]
+  end
+
+  shared_examples_for 'table-based matcher' do
+    it 'correctly rejects a non-matching query result based on wrong columns' do
+      one_column_too_few = deep_copy(@subject).each{|row| row.delete('b')}
+      one_column_too_many = deep_copy(@subject).each{|row| row['new column'] = 'val 1'}
+      wrong_column_name = deep_copy(@subject).each{|row| row.delete('Field_2'); row['Field_x'] = 'val x'}
+
+      @matcher.matches?(one_column_too_few).should be_false
+      @matcher.failure_message_for_should.should == 'Expected 3 field(s), got 2'
+
+      @matcher.matches?(one_column_too_many).should be_false
+      @matcher.failure_message_for_should.should == 'Expected 3 field(s), got 4'
+
+      @matcher.matches?(wrong_column_name).should be_false
+      @matcher.failure_message_for_should.should == 'Expected field "Field_2", got field "b"'
+    end
+
+    it 'correctly rejects a non-matching query result based on number of records' do
+      one_row_too_few = deep_copy(@subject)
+      one_row_too_few.shift
+      one_row_too_many = deep_copy(@subject) << @subject[0]
+      empty_query_result = []
+
+      @matcher.matches?(one_row_too_few).should be_false
+      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 1'
+
+      @matcher.matches?(one_row_too_many).should be_false
+      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 3'
+
+      @matcher.matches?(empty_query_result).should be_false
+      @matcher.failure_message_for_should.should == 'Expected 2 record(s), got 0'
+    end
+
+    it 'correctly rejects a non-matching query result based on a value' do
+      wrong_int = deep_copy(@subject)
+      wrong_int[0]['Field 1'] = 14
+
+      wrong_int_type = deep_copy(@subject)
+      wrong_int_type[1]['Field 1'] = 14
+
+      wrong_nil = deep_copy(@subject)
+      wrong_nil[0]['Field 1'] = nil
+
+      wrong_non_nil = deep_copy(@subject)
+      wrong_non_nil[0]['Field_2'] = 'whatever'
+      
+      misplaced_fields = deep_copy(@subject)
+      misplaced_fields[0].delete('Field 1')
+      misplaced_fields[1].delete('Field 1')
+      misplaced_fields[0]['Field 1'] = 12
+      misplaced_fields[1]['Field 1'] = 'test string'
+
+      @matcher.matches?(wrong_int).should be_false
+      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 1: Expected value "12", got "14"'
+
+
+      @matcher.matches?(wrong_int_type).should be_false
+      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 2: Expected value "test string", got "14"'
+
+      @matcher.matches?(wrong_nil).should be_false
+      @matcher.failure_message_for_should.should == 'Field "Field 1", Record 1: Expected value "12", got <NULL>'
+
+      @matcher.matches?(wrong_non_nil).should be_false
+      @matcher.failure_message_for_should.should == 'Field "Field_2", Record 1: Expected value <NULL>, got "whatever"'
+
+      @matcher.matches?(misplaced_fields).should be_false
+      @matcher.failure_message_for_should.should == 'Expected field "Field 1", got field "Field_2"'
+    end
+
+    it 'correctly compares with a query result' do
+      @matcher.matches?(@subject).should be_true(@matcher.failure_message_for_should)
+    end
+
+    it 'only accepts well formed query result subjects' do
+      expected_message = /Can perform query matches only against a well formed query result subject/
+      @matcher.matches?(1).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?('test string').should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?(1.1).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?(Time.now).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?(nil).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x'}]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f3 => 'y'}]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f2 => 'y', :f3 => 'z'}]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?([{:f1 => 'x', :f2 => 'y'}, 12]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      @matcher.matches?([12, {:f1 => 'x', :f2 => 'y'}]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+
+      # An array with a single empty row is not a well-formed query result
+      @matcher.matches?([{}]).should be_false
+      @matcher.failure_message_for_should.should =~ expected_message
+    end
+    
+  end
+
+  describe 'CSV-based golden master' do
+    before(:each) do
+      @matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/test_1.csv'))
+    end
+    
+    it_behaves_like 'table-based matcher'
+
+    it 'correctly compares an empty subject with an empty CSV file' do
+      matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/no_rows.csv'))
+      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
+
+      matcher = Slacker::QueryResultMatcher.new(SpecHelper.load_csv('matcher/completely_blank.csv'))
+      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
+    end
+  end
+
+  describe 'Array-based golden master' do
+    before(:each) do
+      @matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
+    end
+
+    it_behaves_like 'table-based matcher'
+
+    it 'only accepts well formed query result golden master' do
+      expected_message = /Cannot match against a non-well formed golden master array/
+
+      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x'}])
+      matcher.matches?([]).should be_false
+      matcher.failure_message_for_should.should =~ expected_message
+
+      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f3 => 'y'}])
+      matcher.matches?([]).should be_false
+      matcher.failure_message_for_should.should =~ expected_message
+
+      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, {:f1 => 'x', :f2 => 'y', :f3 => 'z'}])
+      matcher.matches?([]).should be_false
+      matcher.failure_message_for_should.should =~ expected_message
+
+      matcher = Slacker::QueryResultMatcher.new([{:f1 => 'x', :f2 => 'y'}, 12])
+      matcher.matches?([]).should be_false
+      matcher.failure_message_for_should.should =~ expected_message
+
+      matcher = Slacker::QueryResultMatcher.new([12, {:f1 => 'x', :f2 => 'y'}])
+      matcher.matches?([]).should be_false
+      matcher.failure_message_for_should.should =~ expected_message
+    end
+
+    it 'correctly compares an empty subject with an empty golden master' do
+      matcher = Slacker::QueryResultMatcher.new([])
+      matcher.matches?([]).should be_true(matcher.failure_message_for_should)
+    end
+  end
+
+  shared_examples_for 'single-value-based matcher' do
+    it 'should correctly match the first value in the result set' do
+      matcher = Slacker::QueryResultMatcher.new(@correct_golden_master)
+      matcher.matches?(@subject).should be_true(matcher.failure_message_for_should)
+    end
+
+    it 'should correctly reject a non-matching first item by value' do
+      if !@wrong_value_golden_master.nil? #Skip nil from value check when the master is nil
+        matcher = Slacker::QueryResultMatcher.new(@wrong_value_golden_master)
+        matcher.matches?(@subject).should be_false
+        matcher.failure_message_for_should.should =~ /Expected value "#{@wrong_value_golden_master}", got "#{@subject[0].values[0]}"/
+      end
+    end
+
+    it 'should correctly reject a non-matching first item by type' do
+      matcher = Slacker::QueryResultMatcher.new(@wrong_type_golden_master)
+      matcher.matches?(@subject).should be_false
+      matcher.failure_message_for_should.should =~ /Expected type "#{@wrong_type_golden_master.class}", got \"#{@subject[0].values[0].class}\"/
+    end
+  end
+
+  describe 'Integer-based golden master' do
+    before(:each) do
+      @subject = [{'Field 1' => 14, 'Field_2' => 'whatever'}]
+      @correct_golden_master = 14
+      @wrong_value_golden_master = 15
+      @wrong_type_golden_master = 'whatever'
+    end
+
+    it_behaves_like 'single-value-based matcher'
+  end
+
+  describe 'String-based golden master' do
+    before(:each) do
+      @subject = [{'Field 1' => 'test string', 'Field_2' => 12}]
+      @correct_golden_master = 'test string'
+      @wrong_value_golden_master = 'whatever'
+      @wrong_type_golden_master = 15
+    end
+
+    it_behaves_like 'single-value-based matcher'
+  end
+
+  describe 'Floating point-based golden master' do
+    before(:each) do
+      @subject = [{'Field 1' => 18.2, 'Field_2' => 12}]
+      @correct_golden_master = 18.2
+      @wrong_value_golden_master = 18.7
+      @wrong_type_golden_master = 15
+    end
+
+    it_behaves_like 'single-value-based matcher'
+  end
+
+  describe 'Date-based golden master' do
+    before(:each) do
+      @subject = [{'Field 1' => Time.parse('1/1/2011'), 'Field_2' => 12}]
+      @correct_golden_master = Time.parse('1/1/2011')
+      @wrong_value_golden_master = Time.parse('2/1/2011')
+      @wrong_type_golden_master = 'whatever'
+    end
+
+    it_behaves_like 'single-value-based matcher'
+  end
+
+  describe 'Nil-based golden master' do
+    before(:each) do
+      @subject = [{'Field 1' => nil, 'Field_2' => 12}]
+      @correct_golden_master = nil
+      @wrong_value_golden_master = nil # There is no wrong value for nil-based master
+      @wrong_type_golden_master = 'whatever'
+    end
+
+    it_behaves_like 'single-value-based matcher'
+  end
+
+  it 'correctly matches a multi-result subject' do
+    subject = [@subject, [{:Field_x => 12}]]
+    matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
+    matcher.matches?(subject).should be_true(matcher.failure_message_for_should)
+  end
+
+  it 'correctly rejects a wrong multi-result subject' do
+    subject = [[{:Field_x => 12}], @subject]
+    matcher = Slacker::QueryResultMatcher.new(deep_copy(@subject))
+    matcher.matches?(subject).should be_false
+    matcher.failure_message_for_should.should == 'Expected 3 field(s), got 1'
+  end
+end