sunspot_matchers 1.1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in sunspot_matchers.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    sunspot_matchers (1.1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    diff-lcs (1.1.2)
+    escape (0.0.4)
+    rsolr (0.12.1)
+      builder (>= 2.1.2)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+    sunspot (1.1.0)
+      escape (= 0.0.4)
+      rsolr (= 0.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  rspec (~> 2.1.0)
+  sunspot (~> 1.1.0)
+  sunspot_matchers!

data/README.markdown

@@ -0,0 +1,229 @@
+# Sunspot Matchers
+
+[Sunspot](http://outoftime.github.com/sunspot/) is a great Ruby library for constructing searches against Solr.  However,
+because of the way the Sunspot DSL is constructed, it can be difficult to do simple assertions about your searches
+without doing full integration tests.
+
+The goal of these matchers are to make it easier to unit test search logic without having to construct the individual
+fixture scenarios inside of Solr and then actually perform a search against Solr.
+
+# Installation
+
+You will need to replace the Sunspot Session object with the spy provided.  You can do this globally by putting the
+following in your spec_helper.
+
+    config.before do
+      Sunspot.session = SunspotMatchers::SunspotSessionSpy.new(Sunspot.session)
+    end
+
+Keep in mind, this will prevent any test from actually hitting Solr, so if you have integration tests, you'll either
+need to be more careful which tests you replace the session for, or you'll need to restore the original session before
+those tests
+
+    Sunspot.session = Sunspot.session.original_session
+
+You will also need to include the matchers in your specs.  Again, this can be done globally in your spec_helper.
+
+    config.include SunspotMatchers
+
+Alternately, you could include them into individual tests if needed.
+
+# Matchers
+
+## be_a_search_for
+
+If you perform a search against your Post model, you could write this expectation:
+
+`Sunspot.session.should be_a_search_for(Post)`
+
+Individual searches are stored in an array, so if you perform multiple, you'll have to match against them manually.  Without
+an explicit search specified, it will use the last one.
+
+`Sunspot.session.searches.first.should be_a_search_for(Post)`
+
+## have_search_params
+
+This is where the bulk of the functionality lies.  There are seven types of search matches you can perform: `keywords`,
+`with`, `without`, `paginate`, `order_by`, `facet`, and `boost`.
+
+In all of the examples below, the expectation fully matches the search terms.  This is not expected or required.  You can
+have a dozen `with` restrictions on a search and still write an expectation on a single one of them.
+
+Negative expectations also work correctly.  `should_not` will fail if the search actually includes the expectation.
+
+With all matchers, you can specify a `Proc` as the second argument, and perform multi statement expectations inside the
+Proc.  Keep in mind, that only the expectation type specified in the first argument will actually be checked.  So if
+you specify `keywords` and `with` restrictions in the same Proc, but you said `have_search_params(:keywords, ...`
+the `with` restrictions are simply ignored.
+
+### wildcard matching
+
+keywords, with, and without support wildcard expectations using the `any_param` parameter:
+
+    Sunspot.search(Post) do
+      with :blog_id, 4
+    end
+
+    Sunspot.session.should have_search_params(:with, :blog_id, any_param)
+
+### :keywords
+
+You can match against a keyword search:
+
+    Sunspot.search(Post) do
+      keywords 'great pizza'
+    end
+
+    Sunspot.session.should have_search_params(:keywords, 'great pizza')
+
+### :with
+
+You can match against a with restriction:
+
+    Sunspot.search(Post) do
+      with :author_name, 'Mark Twain'
+    end
+
+    Sunspot.session.should have_search_params(:with, :author_name, 'Mark Twain')
+
+Complex conditions can be matched by using a Proc instead of a value.  Be aware that order does matter, not for
+the actual results that would come out of Solr, but the matcher will fail of the order of `with` restrictions is
+different.
+
+    Sunspot.search(Post) do
+      any_of do
+        with :category_ids, 1
+        with :category_ids, 2
+      end
+    end
+
+    Sunspot.session.should have_search_params(:with, Proc.new {
+      any_of do
+        with :category_ids, 1
+        with :category_ids, 2
+      end
+    })
+
+### :without
+
+Without is nearly identical to with:
+
+    Sunspot.search(Post) do
+      without :author_name, 'Mark Twain'
+    end
+
+    Sunspot.session.should have_search_params(:without, :author_name, 'Mark Twain')
+
+### :paginate
+
+You can also specify only page or per_page, both are not required.
+
+    Sunspot.search(Post) do
+      paginate :page => 3, :per_page => 15
+    end
+
+    Sunspot.session.should have_search_params(:paginate, :page => 3, :per_page => 15)
+
+### :order_by
+
+Expectations on multiple orderings are supported using using the Proc format mentioned above.
+
+    Sunspot.search(Post) do
+      order_by :published_at, :desc
+    end
+
+    Sunspot.session.should have_search_params(:order_by, :published_at, :desc)
+
+### :facet
+
+Standard faceting expectation:
+
+    Sunspot.search(Post) do
+      facet :category_ids
+    end
+
+    Sunspot.session.should have_search_params(:facet, :category_ids)
+
+Faceting where a query is excluded:
+
+    Sunspot.search(Post) do
+      category_filter = with(:category_ids, 2)
+      facet(:category_ids, :exclude => category_filter)
+    end
+
+    Sunspot.session.should have_search_params(:facet, Proc.new {
+      category_filter = with(:category_ids, 2)
+      facet(:category_ids, :exclude => category_filter)
+    })
+
+Query faceting:
+
+    Sunspot.search(Post) do
+      facet(:average_rating) do
+        row(1.0..2.0) do
+          with(:average_rating, 1.0..2.0)
+        end
+        row(2.0..3.0) do
+          with(:average_rating, 2.0..3.0)
+        end
+      end
+    end
+    
+    Sunspot.session.should have_search_params(:facet, Proc.new {
+      facet(:average_rating) do
+        row(1.0..2.0) do
+          with(:average_rating, 1.0..2.0)
+        end
+        row(2.0..3.0) do
+          with(:average_rating, 2.0..3.0)
+        end
+      end
+    })
+
+### :boost
+
+Field boost matching:
+
+    Sunspot.search(Post) do
+      keywords 'great pizza' do
+        boost_fields :body => 2.0
+      end
+    end
+
+    Sunspot.session.should have_search_params(:boost, Proc.new {
+      keywords 'great pizza' do
+        boost_fields :body => 2.0
+      end
+    })
+
+Boost query matching:
+
+    Sunspot.search(Post) do
+      keywords 'great pizza' do
+        boost(2.0) do
+          with :blog_id, 4
+        end
+      end
+    end
+
+    Sunspot.session.should have_search_params(:boost, Proc.new {
+      keywords 'great pizza' do
+        boost(2.0) do
+          with :blog_id, 4
+        end
+      end
+    })
+
+Boost function matching:
+
+    Sunspot.search(Post) do
+      keywords 'great pizza' do
+        boost(function { sum(:average_rating, product(:popularity, 10)) })
+      end
+    end
+
+    Sunspot.session.should have_search_params(:boost, Proc.new {
+      keywords 'great pizza' do
+        boost(function { sum(:average_rating, product(:popularity, 10)) })
+      end
+    })

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/sunspot_matchers/matchers.rb

@@ -0,0 +1,237 @@
+module SunspotMatchers
+  class BaseMatcher
+    def initialize(actual_search, comparison_search, args)
+      @args = args
+      @actual_search, @comparison_search = actual_search, comparison_search
+    end
+
+    def search_tuple
+      search_tuple = @actual.is_a?(Array) ? @actual : @actual.searches.last
+      raise 'no search found' unless search_tuple
+      search_tuple
+    end
+
+    def actual_search
+      search_tuple.last
+    end
+
+    def search_types
+      search_tuple.first
+    end
+
+    def wildcard?
+      @args && @args.last == any_param
+    end
+
+    def field
+      @args && @args.first
+    end
+
+    def query_params_for_search(search)
+      search.instance_variable_get(:@query).to_params
+    end
+
+    def actual_params
+      @actual_params ||= query_params_for_search(@actual_search)
+    end
+
+    def comparison_params
+      @comparison_params ||= query_params_for_search(@comparison_search)
+    end
+
+    def match?
+      differences.empty?
+    end
+
+    def missing_param_error_message
+      missing_params = differences
+      actual_values = missing_params.keys.collect {|key| "#{key} => #{actual_params[key]}"}
+      missing_values = missing_params.collect{ |key, value| "#{key} => #{value}"}
+      "expected search params: #{actual_values.join(' and ')} to match expected: #{missing_values.join(' and ')}"
+    end
+
+    def unexpected_match_error_message
+      actual_values = keys_to_compare.collect {|key| "#{key} => #{actual_params[key]}"}
+      comparison_values = keys_to_compare.collect {|key| "#{key} => #{comparison_params[key]}"}
+      "expected search params: #{actual_values.join(' and ')} NOT to match expected: #{comparison_values.join(' and ')}"
+    end
+
+    def differences
+      keys_to_compare.inject({}) do |hsh, key|
+        result = compare_key(key)
+        hsh[key] = result unless result.empty?
+        hsh
+      end
+    end
+
+    def compare_key(key)
+      if(actual_params[key].is_a?(Array) || comparison_params[key].is_a?(Array))
+        compare_multi_value(actual_params[key], comparison_params[key])
+      else
+        compare_single_value(actual_params[key], comparison_matcher_for_key(key))
+      end
+    end
+
+    def comparison_matcher_for_key(key)
+      if wildcard? && wildcard_matcher_for_keys.has_key?(key)
+        wildcard_matcher_for_keys[key]
+      else
+        comparison_params[key]
+      end
+    end
+
+    def compare_single_value(actual, comparison)
+      if comparison.is_a?(Regexp)
+        return [] if comparison =~ actual
+        return [comparison]
+      end
+      return [comparison] unless actual == comparison
+      []
+    end
+
+    def compare_multi_value(actual, comparison)
+      filter_values(comparison).reject do |value|
+        next false unless actual
+        value_matcher = Regexp.new(Regexp.escape(value))
+        actual.any?{ |actual_value| actual_value =~ value_matcher }
+      end
+    end
+
+    def normalize_value(value)
+
+    end
+
+    def filter_values(values)
+      return values unless wildcard?
+      field_matcher = Regexp.new(field.to_s)
+      values.select{ |value| field_matcher =~ value }.collect{|value| value.gsub(/:.*/, '')}
+    end
+
+    def wildcard_matcher_for_keys
+      {}
+    end
+  end
+
+  class HaveSearchParams < BaseMatcher
+    def initialize(method, *args)
+      @method = method
+      @args = args
+    end
+
+    def matches?(actual)
+      @actual = actual
+      @matcher = build_matcher
+      @matcher.match?
+    end
+
+    def failure_message_for_should
+      @matcher.missing_param_error_message
+    end
+
+    def failure_message_for_should_not
+      @matcher.unexpected_match_error_message
+    end
+
+    def build_matcher
+      comparison_search = if(@args.last.is_a?(Proc))
+        SunspotMatchers::SunspotSessionSpy.new(nil).build_search(search_types, &@args.last)
+      else
+        method = @method
+        args = @args
+        SunspotMatchers::SunspotSessionSpy.new(nil).build_search(search_types) do
+          send(method, *args)
+        end
+      end
+
+      get_matcher.new(actual_search, comparison_search, @args)
+    end
+
+    def get_matcher
+      case @method
+        when :with, :without
+          WithMatcher
+        when :keywords
+          KeywordsMatcher
+        when :boost
+          BoostMatcher
+        when :facet
+          FacetMatcher
+        when :order_by
+          SortMatcher
+        when :paginate
+          PaginationMatcher
+      end
+    end
+  end
+
+  def have_search_params(method, *args)
+    HaveSearchParams.new(method, *args)
+  end
+
+  class WithMatcher < BaseMatcher
+    def keys_to_compare
+      [:fq]
+    end
+  end
+
+  class KeywordsMatcher < BaseMatcher
+    def keys_to_compare
+      [:q, :qf]
+    end
+
+    def wildcard_matcher_for_keys
+      {:q => /./, :qf => /./}
+    end
+  end
+
+  class BoostMatcher < BaseMatcher
+    def keys_to_compare
+      [:qf, :bq, :bf]
+    end
+  end
+
+  class FacetMatcher < BaseMatcher
+    def keys_to_compare
+      comparison_params.keys.select {|key| /facet/ =~ key.to_s}
+    end
+  end
+
+  class SortMatcher < BaseMatcher
+    def keys_to_compare
+      [:sort]
+    end
+  end
+
+  class PaginationMatcher < BaseMatcher
+    def keys_to_compare
+      [:rows, :start]
+    end
+  end
+
+  class BeASearchFor < BaseMatcher
+    def initialize(expected_class)
+      @expected_class = expected_class
+    end
+
+    def matches?(actual)
+      @actual = actual
+      search_types.include?(@expected_class)
+    end
+
+    def failure_message_for_should
+      "expected search class: #{search_types.join(' and ')} to match expected class: #{@expected_class}"
+    end
+
+    def failure_message_for_should_not
+      "expected search class: #{search_types.join(' and ')} NOT to match expected class: #{@expected_class}"
+    end
+  end
+
+  def be_a_search_for(expected_class)
+    BeASearchFor.new(expected_class)
+  end
+end
+
+def any_param
+  "ANY_PARAM"
+end

data/lib/sunspot_matchers/sunspot_session_spy.rb

@@ -0,0 +1,111 @@
+module SunspotMatchers
+  class SunspotSearchSpy < Sunspot::Search::StandardSearch
+    def execute
+      self
+    end
+    def solr_response
+      {}
+    end
+    def facet_response
+      {'facet_queries' => {}}
+    end
+  end
+
+  class SunspotSessionSpy < Sunspot::Session
+    attr_reader :original_session
+    attr_reader :current_search_class
+
+    attr_accessor :searches
+
+    def initialize(original_session)
+      @searches = []
+      @original_session = original_session
+      @config = Sunspot::Configuration.build
+    end
+
+    def inspect
+      'Solr Search'
+    end
+
+    def index(*objects)
+    end
+
+    def index!(*objects)
+    end
+
+    def remove(*objects)
+    end
+
+    def remove!(*objects)
+    end
+
+    def remove_by_id(clazz, id)
+    end
+
+    def remove_by_id!(clazz, id)
+    end
+
+    def remove_all(clazz = nil)
+    end
+
+    def remove_all!(clazz = nil)
+    end
+
+    def dirty?
+      false
+    end
+
+    def delete_dirty?
+      false
+    end
+
+    def commit_if_dirty
+    end
+
+    def commit_if_delete_dirty
+    end
+
+    def commit
+    end
+
+    def search(*types, &block)
+      new_search(*types, &block)
+    end
+
+    def new_search(*types, &block)
+      search = build_search(*types, &block)
+      @searches << [types, search]
+      search
+    end
+
+    def build_search(*types, &block)
+      types.flatten!
+      search = SunspotSearchSpy.new(
+        nil,
+        setup_for_types(types),
+        Sunspot::Query::StandardQuery.new(types),
+        @config
+      )
+      search.build(&block) if block
+      search
+    end
+
+    def setup_for_types(types)
+      if types.empty?
+        raise(ArgumentError, "You must specify at least one type to search")
+      end
+      if types.length == 1
+        Sunspot::Setup.for(types.first)
+      else
+        CompositeSetup.for(types)
+      end
+    end
+  end
+end
+
+# Support Sunspot random field in test -- Sunspot originally generate a random number for the field
+class Sunspot::Query::Sort::RandomSort < Sunspot::Query::Sort::Abstract
+  def to_param
+    "random #{direction_for_solr}"
+  end
+end

data/lib/sunspot_matchers/version.rb

@@ -0,0 +1,3 @@
+module SunspotMatchers
+  VERSION = "1.1.0.0"
+end

data/lib/sunspot_matchers.rb

@@ -0,0 +1,2 @@
+require 'sunspot_matchers/matchers'
+require 'sunspot_matchers/sunspot_session_spy'