xapit 0.1.0

data/spec/xapit/collection_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::Collection do
+  describe "with database" do
+    before(:each) do
+      XapitMember.xapit do |index|
+        index.text :name
+        index.field :name
+        index.facet :name
+        index.sortable :name
+      end
+    end
+    
+    describe "indexed" do
+      before(:each) do
+        @hello = XapitMember.new(:name => "hello world")
+        @foo = XapitMember.new(:name => "foo bar")
+        Xapit.index_all
+      end
+      
+      it "should find all xapit members in database given nil" do
+        Xapit::Collection.new(XapitMember, nil).should == [@hello, @foo]
+      end
+      
+      it "should matching xapit member given a word" do
+        Xapit::Collection.new(XapitMember, "foo").should == [@foo]
+      end
+      
+      it "should not be case sensitive on query matching" do
+        Xapit::Collection.new(XapitMember, "BAR Foo").should == [@foo]
+      end
+      
+      it "should have 2 records for empty string" do
+        Xapit::Collection.new(XapitMember, "").size.should == 2
+      end
+      
+      it "should not be empty for blank query" do
+        Xapit::Collection.new(XapitMember, "").empty?.should be_false
+      end
+      
+      it "should filter by conditions, case insensitive" do
+        Xapit::Collection.new(XapitMember, "", :conditions => { :name => "HELLO world"}).should == [@hello]
+      end
+      
+      it "should know first entry" do
+        Xapit::Collection.new(XapitMember, "").first.should == @hello
+      end
+      
+      it "should know last entry" do
+        Xapit::Collection.new(XapitMember, "").last.should == @foo
+      end
+      
+      it "should support nested search" do
+        Xapit::Collection.new(XapitMember, "world").search("foo") == [@foo]
+      end
+      
+      it "should support page and per_page options" do
+        Xapit::Collection.new(XapitMember, :page => 1, :per_page => 1).should == [@hello]
+        Xapit::Collection.new(XapitMember, :page => 2, :per_page => 1).should == [@foo]
+      end
+      
+      it "should have offset" do
+        Xapit::Collection.new(XapitMember, :page => 2, :per_page => 1).offset.should == 1
+      end
+      
+      it "should have total_entries, total_pages, current_page, per_page, previous_page, next_page" do
+        collection = Xapit::Collection.new(XapitMember, "", :per_page => 1, :page => 2)
+        collection.total_entries.should == 2
+        collection.total_pages.should == 2
+        collection.previous_page.should == 1
+        collection.next_page.should be_nil
+      end
+      
+      it "should set xapit_relevance in results" do
+        results = Xapit::Collection.new(XapitMember, "")
+        results.each do |record|
+          record.xapit_relevance.class.should == Fixnum
+        end
+      end
+      
+      it "should find nothing when searching unknown facet" do
+        Xapit::Collection.new(XapitMember, :facets => ["unknownfacet"]).should be_empty
+      end
+      
+      it "should find matching facet" do
+        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
+        Xapit::Collection.new(XapitMember, :facets => ids*2).should == [@hello]
+      end
+      
+      it "should split facets string on dash" do
+        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
+        Xapit::Collection.new(XapitMember, :facets => (ids*2).join("-")).should == [@hello]
+      end
+      
+      it "should have one facet with two options with blank keywords" do
+        facets = Xapit::Collection.new(XapitMember, "").facets
+        facets.size.should == 1
+        facets.first.options.size.should == 2
+      end
+      
+      it "should have no applied facets when there are no given facets" do
+        Xapit::Collection.new(XapitMember, "").applied_facet_options.should be_empty
+      end
+      
+      it "should list applied facets" do
+        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
+        results = Xapit::Collection.new(XapitMember, "", :facets => (ids*2).join("-"))
+        results.applied_facet_options.map(&:name).should == ["hello world", "hello world"]
+      end
+      
+      it "should pass existing facet identifiers to applied options" do
+        ids = Xapit::FacetBlueprint.new(XapitMember, 0, :name).identifiers_for(@hello)
+        results = Xapit::Collection.new(XapitMember, "", :facets => (ids*2).join("-"))
+        results.applied_facet_options.first.existing_facet_identifiers.should == (ids*2)
+      end
+      
+      it "should sort records in specified order" do
+        Xapit::Collection.new(XapitMember, :order => :name).should == [@foo, @hello]
+      end
+      
+      it "should have no spelling suggestions for empty query" do
+        Xapit::Collection.new(XapitMember).spelling_suggestion.should == nil
+      end
+      
+      it "should have no spelling suggestion for very different query" do
+        Xapit::Collection.new(XapitMember, "match nothing").spelling_suggestion.should == nil
+      end
+      
+      it "should have spelling suggestion for single-word query" do
+        Xapit::Collection.new(XapitMember, "wrld").spelling_suggestion.should == "world"
+      end
+      
+      it "should have spelling suggestion for multi-word query" do
+        Xapit::Collection.new(XapitMember, "helo bat wrld").spelling_suggestion.should == "hello bar world"
+      end
+      
+      it "should raise error when fetching spelling suggestion if spelling is disabled" do
+        Xapit::Config.options[:spelling] = false
+        lambda { Xapit::Collection.new(XapitMember, "foo").spelling_suggestion }.should raise_error
+      end
+      
+      it "should find similar records" do
+        member = XapitMember.new(:name => "foo bar world")
+        Xapit::Collection.search_similar(member).should == [@foo, @hello]
+      end
+      
+      it "should be able to specify classes" do
+        Xapit::Collection.new(nil, "foo", :classes => [String, Array]).should == []
+        Xapit::Collection.new(nil, "foo", :classes => [String, Array, XapitMember]).should == [@foo]
+      end
+    end
+  end
+end

data/spec/xapit/config_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::Config do
+  it "should be able to set database path and fetch writable or readable" do
+    Xapit::Config.writable_database.should be_kind_of(Xapian::WritableDatabase)
+    Xapit::Config.database.should be_kind_of(Xapian::Database)
+  end
+  
+  it "should default query parser to SimpleQueryParser" do
+    Xapit::Config.setup
+    Xapit::Config.query_parser.should == Xapit::ClassicQueryParser
+  end
+  
+  it "should be able to set query parser on setup" do
+    Xapit::Config.setup(:query_parser => Xapit::SimpleQueryParser)
+    Xapit::Config.query_parser.should == Xapit::SimpleQueryParser
+  end
+  
+  it "should default indexer to SimpleIndexer" do
+    Xapit::Config.setup
+    Xapit::Config.indexer.should == Xapit::SimpleIndexer
+  end
+  
+  it "should be able to set indexer on setup" do
+    Xapit::Config.setup(:indexer => Xapit::ClassicIndexer)
+    Xapit::Config.indexer.should == Xapit::ClassicIndexer
+  end
+  
+  it "should have spelling enabled by default" do
+    Xapit::Config.setup
+    Xapit::Config.spelling?.should be_true
+  end
+  
+  it "should be able to specify spelling setting at setup" do
+    Xapit::Config.setup(:spelling => false)
+    Xapit::Config.spelling?.should be_false
+  end
+  
+  it "should default stemming to english" do
+    Xapit::Config.setup
+    Xapit::Config.stemming == "english"
+  end
+  
+  it "should be able to specify stemming setting at setup" do
+    Xapit::Config.setup(:stemming => "german")
+    Xapit::Config.stemming == "german"
+  end
+end

data/spec/xapit/facet_blueprint_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::FacetBlueprint do
+  it "should generate unique identifier based on attribute and value" do
+    facet1 = Xapit::FacetBlueprint.new(XapitMember, 0, :to_s)
+    facet2 = Xapit::FacetBlueprint.new(XapitMember, 0, :length)
+    facet1.identifiers_for("foo").first.length.should == 7
+    facet1.identifiers_for("foo").should_not == facet1.identifiers_for("bar")
+    facet1.identifiers_for("foo").should_not == facet2.identifiers_for("foo")
+  end
+  
+  it "should generate unique identifiers for each value returned" do
+    facet = Xapit::FacetBlueprint.new(XapitMember, 0, :to_a)
+    facet.identifiers_for(["foo", "bar"]).size.should == 2
+  end
+  
+  it "should humanize attribute for name if one isn't given" do
+    Xapit::FacetBlueprint.new(XapitMember, 0, :visible).name.should == "Visible"
+  end
+  
+  it "should use custom name if given" do
+    Xapit::FacetBlueprint.new(XapitMember, 0, :visible, "custom").name.should == "custom"
+  end
+  
+  it "should not have identifiers for blank values" do
+    facet = Xapit::FacetBlueprint.new(XapitMember, 0, :to_a)
+    facet.identifiers_for(["", nil, "bar"]).size.should == 1
+  end
+end

data/spec/xapit/facet_option_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Xapit::FacetOption do
+  it "should combine previous identifiers with current one on to_param" do
+    option = Xapit::FacetOption.new(nil, nil, nil)
+    option.existing_facet_identifiers = ["abc", "123"]
+    stub(option).identifier { "foo" }
+    option.to_param.should == "abc-123-foo"
+  end
+  
+  it "should remove current identifier from previous identifiers if it exists" do
+    Xapit::Config.setup(:breadcrumb_facets => false)
+    option = Xapit::FacetOption.new(nil, nil, nil)
+    option.existing_facet_identifiers = ["abc", "123", "foo"]
+    stub(option).identifier { "foo" }
+    option.to_param.should == "abc-123"
+  end
+  
+  it "should support breadcrumb style facets" do
+    Xapit::Config.setup(:breadcrumb_facets => true)
+    option = Xapit::FacetOption.new(nil, nil, nil)
+    option.existing_facet_identifiers = ["abc", "123", "foo"]
+    stub(option).identifier { "123" }
+    option.to_param.should == "abc-123"
+  end
+  
+  describe "with database" do
+    before(:each) do
+      XapitMember.xapit do |index|
+        index.facet :age, "Person Age"
+        index.facet :category
+      end
+    end
+    
+    it "should have identifier hashing name and value" do
+      option = Xapit::FacetOption.new("XapitMember", "age", "17")
+      option.identifier.should == "0c93ee1"
+    end
+    
+    it "should find facet option from database given id" do
+      doc = Xapian::Document.new
+      doc.data = "XapitMember|||age|||17"
+      doc.add_term("QXapit::FacetOption-abc123")
+      Xapit::Config.writable_database.add_document(doc)
+      option = Xapit::FacetOption.find("abc123")
+      option.name.should == "17"
+      option.facet.name.should == "Person Age"
+    end
+    
+    it "should save facet to database" do
+      Xapit::Config.writable_database # make sure there's a database setup in case we try to read from it
+      option = Xapit::FacetOption.new(nil, nil, nil)
+      option.facet = XapitMember.xapit_facet_blueprint("age")
+      option.name = "23"
+      option.save
+      Xapit::FacetOption.find(option.identifier).should_not be_nil
+    end
+    
+    it "should not save facet if it already exists" do
+      doc = Xapian::Document.new
+      doc.data = "XapitMember|||age|||17"
+      doc.add_term("QXapit::FacetOption-abc123")
+      Xapit::Config.writable_database.add_document(doc)
+      stub(Xapit::Config.writable_database).add_document { raise "should not add doc" }
+      option = Xapit::FacetOption.new(XapitMember, nil, nil)
+      stub(option).identifier { "abc123" }
+      option.save
+    end
+    
+    it "should find facet option which doesn't have a value" do
+      doc = Xapian::Document.new
+      doc.data = "XapitMember|||age|||"
+      doc.add_term("QXapit::FacetOption-abc123")
+      Xapit::Config.writable_database.add_document(doc)
+      option = Xapit::FacetOption.find("abc123")
+      option.name.should == ""
+      option.facet.name.should == "Person Age"
+    end
+  end
+end