outoftime-sunspot 0.0.2 → 0.7.0

data/spec/api/standard_search_builder_spec.rb

@@ -1,76 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe 'standard search builder' do
-  before :each do
-    stub_results
-  end
-
-  it 'should give access to order through hash and object' do
-    search = session.search(Post, :order => 'sort_title asc')
-    search.builder.params[:order].should == 'sort_title asc'
-    search.builder.order.should == 'sort_title asc'
-  end
-
-  it 'should give nil order if no order set' do
-    search = session.search(Post)
-    search.builder.params.should have_key(:order)
-    search.builder.params[:order].should be_nil
-    search.builder.order.should be_nil
-  end
-
-  it 'should give access to page and per-page through hash and object' do
-    search = session.search(Post, :page => 2, :per_page => 15)
-    search.builder.params[:page].should == 2
-    search.builder.params[:per_page].should == 15
-    search.builder.page.should == 2
-    search.builder.per_page.should == 15
-  end
-
-  it 'should give access to keywords' do
-    search = session.search(Post, :keywords => 'some keywords')
-    search.builder.params[:keywords].should == 'some keywords'
-    search.builder.keywords.should == 'some keywords'
-  end
-
-  it 'should have nil keywords if no keywords given' do
-    search = session.search(Post)
-    search.builder.params.should have_key(:keywords)
-    search.builder.params[:keywords].should be_nil
-    search.builder.keywords.should be_nil
-  end
-
-  it 'should give access to conditions' do
-    search = session.search(Post, :conditions => { :blog_id => 1 })
-    search.builder.params[:conditions][:blog_id].should == 1
-    search.builder.conditions.blog_id.should == 1
-  end
-
-  it 'should have nil values for fields with unspecified conditions' do
-    search = session.search(Post)
-    %w(title blog_id category_ids average_rating published_at sort_title).each do |field_name|
-      search.builder.params[:conditions].should have_key(field_name.to_sym)
-      search.builder.params[:conditions][field_name.to_sym].should == nil
-      search.builder.conditions.should respond_to(field_name)
-      search.builder.conditions.send(field_name).should == nil
-    end
-  end
-
-  private
-
-  def stub_results(*results)
-    response = mock('response', :hits => [], :total_hits => 0)
-    connection.stub!(:query).and_return(response)
-  end
-
-  def config
-    @config ||= Sunspot::Configuration.build
-  end
-
-  def connection
-    @connection ||= mock('connection')
-  end
-
-  def session
-    @session ||= Sunspot::Session.new(config, connection)
-  end
-end

data/spec/custom_expectation.rb

@@ -1,53 +0,0 @@
-module Matchy
-  module Expectations
-    class HaveKeyExpectation < Base
-      def matches?(receiver)
-        @receiver = receiver
-        receiver.has_key?(@expected)
-      end
-
-      def failure_message
-        "Expected #{@receiver.inspect} to have key #{@expected.inspect}"
-      end
-
-      def negative_failure_message
-        "Expected #{@receiver.inspect} not to have key #{@expected.inspect}"
-      end
-    end
-
-    class BooleanExpectation < Base
-      def initialize(method, args, test_case)
-        @method = method
-        @args = args
-        @test_case = test_case
-      end
-
-      def matches?(receiver)
-        @receiver = receiver
-        receiver.send("#{@method}?", *@args)
-      end
-      
-      def failure_message
-        "Expected #{@receiver} to #{'be ' if @args.empty?}#{@method}#{@args.map { |arg| arg.inspect } * ', '}"
-      end
-
-      def negative_failure_message
-        "Expected #{@receiver} to not #{'be ' if @args.empty?}#{@method}#{@args.map { |arg| arg.inspect } * ', '}"
-      end
-    end
-
-    module TestCaseExtensions
-      def have_key(key)
-        Matchy::Expectations::HaveKeyExpectation.new(key, self)
-      end
-
-      def method_missing(method, *args, &block)
-        if match = /be_(.*)/.match(method.to_s)
-          Matchy::Expectations::BooleanExpectation.new(match[1], [], self)
-        else
-          Matchy::Expectations::BooleanExpectation.new(method.to_s, args, self)
-        end
-      end
-    end
-  end
-end

data/spec/integration/field_types_spec.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe 'field types' do
-  def self.test_field_type(name, field, *values)
-    raise(ArgumentError, 'Please supply five values') unless values.length == 5
-
-    context "with field of type #{name}" do
-      before :all do
-        Sunspot.remove_all
-        @posts = values.map do |value|
-          post = Post.new(field => value)
-          Sunspot.index(post)
-          post
-        end
-      end
-
-      it 'should filter by exact match' do
-        Sunspot.search(Post) { with.send(field, values[2]) }.results.should == [@posts[2]]
-      end
-
-      it 'should filter by less than' do
-        results = Sunspot.search(Post) { with.send(field).less_than values[2] }.results
-        (0..2).each { |i| results.should include(@posts[i]) }
-        (3..4).each { |i| results.should_not include(@posts[i]) }
-      end
-
-      it 'should filter by greater than' do
-        results = Sunspot.search(Post) { with.send(field).greater_than values[2] }.results
-        (2..4).each { |i| results.should include(@posts[i]) }
-        (0..1).each { |i| results.should_not include(@posts[i]) }
-      end
-
-      it 'should filter by between' do
-        results = Sunspot.search(Post) { with.send(field).between(values[1]..values[3]) }.results
-        (1..3).each { |i| results.should include(@posts[i]) }
-        [0, 4].each { |i| results.should_not include(@posts[i]) }
-      end
-
-      it 'should filter by any of' do
-        results = Sunspot.search(Post) { with.send(field).any_of(values.values_at(1, 3)) }.results
-        [1, 3].each { |i| results.should include(@posts[i]) }
-        [0, 2, 4].each { |i| results.should_not include(@posts[i]) }
-      end
-
-      it 'should order by field ascending' do
-        results = Sunspot.search(Post) { order_by field, :asc }.results
-        results.should == @posts
-      end
-
-      it 'should order by field descending' do
-        results = Sunspot.search(Post) { order_by field, :desc }.results
-        results.should == @posts.reverse
-      end
-    end
-  end
-
-  test_field_type 'String', :title, 'apple', 'banana', 'cherry', 'date', 'eggplant'
-  test_field_type 'Integer', :blog_id, -2, 0, 3, 12, 20
-  test_field_type 'Float', :average_rating, -2.5, 0.0, 3.2, 3.5, 16.0
-  test_field_type 'Time', :published_at, *(['1970-01-01 00:00:00 UTC', '1983-07-08 04:00:00 UTC', '1983-07-08 02:00:00 -0500',
-                                            '2005-11-05 10:00:00 UTC', Time.now.to_s].map { |t| Time.parse(t) })
-end