slacker 0.0.1

data/lib/slacker/configuration.rb

@@ -0,0 +1,59 @@
+module Slacker
+  class Configuration
+    attr_accessor :base_dir, :error_stream, :output_stream, :formatter, :db_server, :db_name, :db_user, :db_password, :console_enabled
+
+    def initialize
+      @console_enabled = true
+      @base_dir = Dir.pwd
+      @error_stream = nil
+      @output_stream = nil
+      @rspec_args = nil
+      @formatter = nil
+      @db_server = nil
+      @db_name = nil
+      @db_user = nil
+      @db_password = nil
+    end
+
+    def expand_path(path)
+      File.expand_path("#{@base_dir}/#{path}")
+    end
+
+    def console_enabled
+      @console_enabled
+    end
+
+    def console_enabled=(value)
+      @console_enabled = value
+      if @console_enabled
+        @error_stream = $stderr
+        @output_stream = $stdout
+        @rspec_args = ARGV
+      else
+        @error_stream = nil
+        @output_stream = nil
+        @rspec_args = []
+      end
+    end
+
+    def rspec_args
+      if @rspec_args.nil? || @rspec_args.empty?
+        Dir.glob(expand_path("spec/**/*.rb"))
+      else
+        @rspec_args
+      end
+    end
+
+    def rspec_args=(value)
+      @rspec_args = value
+    end
+
+    def dsn_string
+      "Driver={SQL Server};Server=#{@db_server};Database=#{@db_name};Uid=#{@db_user};Pwd=#{@db_password}"
+    end
+
+    def db_config
+      {:adapter => 'sqlserver', :mode => 'odbc', :dsn => dsn_string}
+    end
+  end
+end

data/lib/slacker/formatter.rb

@@ -0,0 +1,19 @@
+require 'slacker'
+
+module Slacker
+  module Formatter
+    def example_failure_text(example)
+      text = ''
+      exception = example.execution_result[:exception]
+      text << "Failure/Error: #{read_failed_line(exception, example).strip}\n"
+      text << "#{long_padding}#{exception.class.name << ":"}\n" unless exception.class.name =~ /RSpec/
+      exception.message.split("\n").each { |line| text <<  "#{line}\n" }
+
+      format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+        text << "# #{backtrace_info}\n"
+      end
+
+      text
+    end
+  end
+end

data/lib/slacker/query_result_matcher.rb

@@ -0,0 +1,169 @@
+require 'csv'
+
+module Slacker
+  class QueryResultMatcher
+    def initialize(golden_master)
+      @golden_master = golden_master
+      @failure_message = ''
+    end
+
+    def matches?(subject)
+      does_match = false
+
+      subject = normalize_query_result_subject(subject)
+
+      catch :no_match do
+        test_type_match(subject)
+        test_value_match(subject)
+        does_match = true
+      end
+      
+      does_match
+    end
+
+    def failure_message_for_should
+      @failure_message
+    end
+
+    private
+
+    #test if the subject type is consistent with the golden master
+    def test_type_match(subject)
+      if !is_well_formed_query_result?(subject)
+        throw_no_match "Can perform query matches only against a well formed query result subject"
+      end
+      
+      if (@golden_master.kind_of? Array) && !is_well_formed_query_result?(@golden_master)
+        throw_no_match "Cannot match against a non-well formed golden master array"
+      end
+    end
+
+    def test_value_match(subject)
+      case @golden_master
+      when CSV::Table
+        test_csv_table_match(subject)
+      when Array
+        test_array_match(subject)
+      else
+        test_single_value_match(subject)
+      end
+    end
+
+    # Compare the golden master CSV table with the subject query result
+    def test_csv_table_match(subject)
+      # Compare the fields
+      if !subject.empty?
+        subject_fields = subject[0].keys
+        master_fields = @golden_master.headers
+
+        if subject_fields.count != master_fields.count
+          throw_no_match "Expected #{master_fields.count} field(s), got #{subject_fields.count}"
+        end
+
+        master_fields.each_with_index do |column, index|
+          if column != subject_fields[index]
+            throw_no_match "Expected field \"#{column}\", got field \"#{subject_fields[index]}\""
+          end
+        end
+      end
+
+      # Compare the number of records
+      subject_record_count = subject.count
+      master_record_count = @golden_master.inject(0){|count| count += 1}
+      if subject_record_count != master_record_count
+        throw_no_match "Expected #{master_record_count} record(s), got #{subject_record_count}"
+      end
+
+      # Compare the values of the golden master with the subject
+      current_row = 0
+      @golden_master.each do |row|
+        row.each do |field, master_string|
+          subject_value = subject[current_row][field]
+          if !match_values?(master_string, subject_value)
+            throw_no_match "Field \"#{field}\", Record #{current_row + 1}: Expected value #{master_string.nil? ? '<NULL>' : "\"#{master_string}\""}, got #{subject_value.nil? ? '<NULL>' : "\"#{subject_value}\""}"
+          end
+        end
+        current_row += 1
+      end
+    end
+
+    def match_types?(master_val, subject_val)
+      subject_val.kind_of? master_val.class
+    end
+
+    def match_values?(master_val, subject_val)
+      if master_val.nil?
+        master_val == subject_val
+      elsif subject_val.kind_of?(Time) && master_val.kind_of?(String)
+        Time.parse(master_val) == subject_val
+      else
+        subject_val.to_s == master_val.to_s
+      end
+    end
+
+    def test_array_match(subject)
+      # Compare the fields
+      if !(subject.empty? || @golden_master.empty?)
+        subject_fields = subject[0].keys
+        master_fields = @golden_master[0].keys
+
+        if subject_fields.count != master_fields.count
+          throw_no_match "Expected #{master_fields.count} field(s), got #{subject_fields.count}"
+        end
+
+        master_fields.each_with_index do |column, index|
+          if column != subject_fields[index]
+            throw_no_match "Expected field \"#{column}\", got field \"#{subject_fields[index]}\""
+          end
+        end
+      end
+
+      # Compare the number of records
+      subject_record_count = subject.count
+      master_record_count = @golden_master.count
+      if subject_record_count != master_record_count
+        throw_no_match "Expected #{master_record_count} record(s), got #{subject_record_count}"
+      end
+
+      # Compare the values of the golden master with the subject
+      current_row = 0
+      @golden_master.each do |row|
+        row.each do |field, master_value|
+          subject_value = subject[current_row][field]
+          if !match_values?(master_value, subject_value)
+            throw_no_match "Field \"#{field}\", Record #{current_row + 1}: Expected value #{master_value.nil? ? '<NULL>' : "\"#{master_value}\""}, got #{subject_value.nil? ? '<NULL>' : "\"#{subject_value}\""}"
+          end
+        end
+        current_row += 1
+      end
+    end
+
+    def is_well_formed_query_result?(arr)
+      return false unless arr.kind_of? Array
+      header =[]
+      arr.find{|row| !row.kind_of?(Hash) || (header = header.empty? ? row.keys : header) != row.keys || row.keys.empty?}.nil?
+    end
+
+    def test_single_value_match(subject)
+      subject_value = subject[0].values[0]
+      subject_field = subject[0].keys[0]
+      if !match_types?(@golden_master, subject_value)
+        throw_no_match "Field \"#{subject_field}\", Record 1: Expected type \"#{@golden_master.class}\", got \"#{subject_value.class}\""
+      end
+
+      if !match_values?(@golden_master, subject_value)
+        throw_no_match "Field \"#{subject_field}\", Record 1: Expected value #{@golden_master.nil? ? '<NULL>' : "\"#{@golden_master}\""}, got #{subject_value.nil? ? '<NULL>' : "\"#{subject_value}\""}"
+      end
+    end
+
+    # In case of a multi-resultset subject, extract the first result set
+    def normalize_query_result_subject(subject)
+      subject.kind_of?(Array) && !subject.empty? && is_well_formed_query_result?(subject[0]) ? subject[0] : subject
+    end
+
+    def throw_no_match(message)
+      @failure_message = message
+      throw :no_match
+    end
+  end
+end

data/lib/slacker/rspec_ext.rb

@@ -0,0 +1,69 @@
+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
+      end
+      @results
+    end
+
+    def result(index = 1, options = {})
+      # Flatten the result in case we're getting a multi-result-set response
+      res = case !@results.empty? && @results[0].kind_of?(Array)
+      when true
+        raise "The query result contains only #{@results.count} result set(s)" unless @results.count >= index
+        @results[index - 1]
+      else
+        raise "The query result contains a single result set" unless index == 1
+        @results
+      end
+
+      #Optionally extract the record and or the field
+      if options[:record] != nil
+        raise "The result set contains only #{res.count} record(s)" unless res.count >= options[:record]
+        res = res[options[:record] - 1]
+        if options[:field] != nil
+          raise "The result set does not contain field \"#{options[:field]}\"" unless res[options[:field]] != nil
+          res = res[options[:field]]
+        end
+      end
+
+      res
+    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 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 csv(csv_file)
+      Slacker.get_csv(csv_file)
+    end
+
+    def sql
+      Slacker.sql(self)
+    end
+
+    def yes?(val)
+      val != nil && val.downcase == 'yes'
+    end
+  end
+end

data/lib/slacker/rspec_monkey.rb

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +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

data/lib/slacker/string_helper.rb

@@ -0,0 +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
+end

data/lib/slacker/version.rb

@@ -0,0 +1,3 @@
+module Slacker
+  VERSION = "0.0.1"
+end

data/slacker.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "slacker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "slacker"
+  s.version     = Slacker::VERSION
+  s.authors     = ["Vassil Kovatchev"]
+  s.email       = ["vassil.kovatchev@gmail.com"]
+  s.homepage    = "https://github.com/vassilvk/slacker"
+  s.summary     = %q{Behavior Driven Development for SQL Server}
+  s.description = %q{RSpec-based framework for developing automated tests for SQL Server programmable objects such as stored procedures and scalar/table functions}
+
+  s.rubyforge_project = "slacker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'ruby-odbc', '=0.99994'
+  s.add_dependency 'rspec', '=2.5.0'
+end

data/spec/application_spec.rb

@@ -0,0 +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
+end

data/spec/query_result_matcher_spec.rb

@@ -0,0 +1,267 @@
+require 'slacker'
+require 'spec_helper'
+require 'time'
+
+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' => Time.parse('1/1/2011'), '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