mongoid-giza 0.1.0

data/spec/mongoid/giza/index_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+describe Mongoid::Giza::Index do
+  let(:klass) do
+    klass = double("klass")
+    allow(klass).to receive(:name) { "Klass" }
+    allow(klass).to receive(:all)
+    klass
+  end
+
+  let(:index) { Mongoid::Giza::Index.new(klass) }
+
+  it "should have a list of fields" do
+    expect(index.fields).to be_a_kind_of(Array)
+  end
+
+  it "should have a list of attributes" do
+    expect(index.attributes).to be_a_kind_of(Array)
+  end
+
+  it "should accept a settings hash" do
+    settings = {setting1: 1, setting2: 2}
+    index = Mongoid::Giza::Index.new(klass, settings)
+    expect(index.settings).to be(settings)
+  end
+
+  describe "klass" do
+    it "should be mandatory" do
+      expect { Mongoid::Giza::Index.new }.to raise_error(ArgumentError)
+    end
+
+    it "should be set on creation" do
+      expect(index.klass).to be(klass)
+    end
+  end
+
+  describe "field" do
+    let(:field) { double("field") }
+
+    let(:name) { "field" }
+
+    it "should require a name" do
+      expect { index.field }.to raise_error(ArgumentError)
+    end
+
+    it "should create a new Field" do
+      expect(Mongoid::Giza::Index::Field).to receive(:new).with(name, false)
+      index.field(name)
+    end
+
+    it "should accept :attribute as an option" do
+      expect(Mongoid::Giza::Index::Field).to receive(:new).with(name, true)
+      index.field(name, attribute: true)
+    end
+
+    it "should add the new field to the list of fields" do
+      allow(Mongoid::Giza::Index::Field).to receive(:new) { field }
+      index.field(name)
+      expect(index.fields.first).to be(field)
+    end
+  end
+
+  describe "attribute" do
+    let(:name) { "attribute" }
+
+    let(:type) { :uint }
+
+    it "should require a name" do
+      expect { index.attribute }.to raise_error(ArgumentError)
+    end
+
+    it "should accept a type" do
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, type)
+      index.attribute(name, type)
+    end
+
+    it "should automatically define the type when it is not supplied" do
+      type = String
+      allow(klass).to receive(:fields) do
+        fields = double("fields")
+        allow(fields).to receive(:[]).with(name) do
+          field = double("field")
+          allow(field).to receive(:type) { type }
+          field
+        end
+        fields
+      end
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, Mongoid::Giza::Index::TYPES_MAP[type])
+      index.attribute(name)
+    end
+
+    it "should default to the first type when the field is not found" do
+      allow(klass).to receive(:fields) do
+        fields = double("fields")
+        allow(fields).to receive(:[]).with(name) { nil }
+        fields
+      end
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, Mongoid::Giza::Index::TYPES_MAP.values.first)
+      index.attribute(name)
+    end
+
+    it "should default to the first type when the type is not mapped" do
+      allow(klass).to receive(:fields) do
+        fields = double("fields")
+        allow(fields).to receive(:[]).with(name) do
+          field = double("field")
+          allow(field).to receive(:type) { Object }
+          field
+        end
+        fields
+      end
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, Mongoid::Giza::Index::TYPES_MAP.values.first)
+      index.attribute(name)
+    end
+  end
+
+  describe "name" do
+    it "should be the class name by default" do
+      allow(klass).to receive(:name) { "Klass" }
+      expect(index.name).to eql(:Klass)
+    end
+
+    it "should define a new name when supplied" do
+      index.name(:Index)
+      expect(index.name).to eql(:Index)
+    end
+  end
+
+  describe "generate_xmlpipe2" do
+    let(:xmlpipe2) { double("XMLPipe2") }
+
+    let(:buffer) { double("buffer") }
+
+    it "should create a new XMLPipe2 object" do
+      expect(Mongoid::Giza::XMLPipe2).to receive(:new).with(index, buffer) { xmlpipe2.as_null_object }
+      index.generate_xmlpipe2(buffer)
+    end
+
+    it "should generate the xml" do
+      allow(Mongoid::Giza::XMLPipe2).to receive(:new) { xmlpipe2 }
+      expect(xmlpipe2).to receive(:generate!)
+      index.generate_xmlpipe2(buffer)
+    end
+  end
+
+  describe "criteria" do
+    let(:all) { double("all") }
+
+    let(:criteria) { double("criteria") }
+
+    it "should default to all" do
+      allow(klass).to receive(:all) { all }
+      expect(index.criteria).to be(all)
+    end
+
+    it "should accept a new criteria as a parameter" do
+      allow(klass).to receive(:where) { criteria }
+      index.criteria(klass.where(name: "one"))
+      expect(index.criteria).to be(criteria)
+    end
+  end
+end

data/spec/mongoid/giza/indexer_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Mongoid::Giza::Indexer do
+  before do
+    @controller = double("controller")
+    allow(Riddle::Controller).to receive(:new) { @controller }
+    @indexer = Mongoid::Giza::Indexer.send(:new)
+  end
+
+  let(:config) { Mongoid::Giza::Configuration.instance }
+
+  describe "index!" do
+    it "should create the sphinx configuration file" do
+      allow(@controller).to receive(:index)
+      expect(config).to receive(:render)
+      @indexer.index!
+    end
+
+    it "should execute the sphinx indexer" do
+      allow(config).to receive(:render)
+      expect(@controller).to receive(:index).with(verbose: true)
+      @indexer.index!
+    end
+
+    it "should accept an index list" do
+      allow(config).to receive(:render)
+      expect(@controller).to receive(:index).with(:Person, :Person_2, verbose: true)
+      @indexer.index!(:Person, :Person_2)
+    end
+  end
+
+  describe "full_index" do
+    let(:klass) { double("class") }
+
+    before do
+      allow(@indexer).to receive(:index!)
+    end
+
+    it "should clear the generated indexes from the configuration" do
+      expect(config).to receive(:clear_generated_indexes)
+      allow(@indexer).to receive(:giza_classes) { [klass] }
+      allow(klass).to receive(:regenerate_dynamic_sphinx_indexes)
+      @indexer.full_index
+    end
+
+    it "should regenerate all dynamic indexes of the giza classes" do
+      allow(config).to receive(:clear_generated_indexes)
+      allow(@indexer).to receive(:giza_classes) { [klass] }
+      expect(klass).to receive(:regenerate_dynamic_sphinx_indexes)
+      @indexer.full_index
+    end
+
+    it "should execute the indexer" do
+      allow(config).to receive(:clear_generated_indexes)
+      allow(@indexer).to receive(:giza_classes) { [klass] }
+      allow(klass).to receive(:regenerate_dynamic_sphinx_indexes)
+      expect(@indexer).to receive(:index!).with(no_args)
+      @indexer.full_index
+    end
+  end
+
+  describe "giza_classes" do
+    before(:all) do
+      class One
+        include Mongoid::Document
+        include Mongoid::Giza
+      end
+
+      class Two
+        include Mongoid::Document
+      end
+
+      class Three
+        include Mongoid::Document
+        include Mongoid::Giza
+      end
+    end
+
+    it "should return all classes that include the Giza module" do
+      expect(@indexer.giza_classes).to include(One, Three)
+    end
+
+    it "should not return classes that do not include the Giza module" do
+      expect(@indexer.giza_classes).not_to include(Two)
+    end
+  end
+end

data/spec/mongoid/giza/models/giza_id_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Mongoid::Giza::GizaID do
+  describe "instance" do
+    let(:giza_id) { Mongoid::Giza::GizaID.new(id: :Person) }
+
+    it "should be valid" do
+      expect(giza_id).to be_valid
+    end
+
+    it "should have the specified id" do
+      expect(giza_id.id).to eql(:Person)
+    end
+
+    it "should have a sequence default to zero" do
+      expect(giza_id.seq).to eql(0)
+    end
+  end
+
+  describe "next_id" do
+    before do
+      Mongoid::Giza::GizaID.create(id: :Person)
+    end
+
+    it "should return the next id for the given class" do
+      expect(Mongoid::Giza::GizaID.next_id(:Person)).to eql(1)
+      expect(Mongoid::Giza::GizaID.next_id(:Person)).to eql(2)
+    end
+  end
+end

data/spec/mongoid/giza/search_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+describe Mongoid::Giza::Search do
+  let(:client) do
+    client = double("client")
+    allow(Riddle::Client).to receive(:new).with("localhost", 9132) { client }
+    client
+  end
+
+  let(:search) { Mongoid::Giza::Search.new("localhost", 9132) }
+
+  let(:filters) do
+    filters = double("filters")
+    allow(client).to receive(:filters) { filters }
+    filters
+  end
+
+  let(:filter) { double("filter") }
+
+  describe "initialize" do
+    it "should create a new client with the given host and port" do
+      expect(Riddle::Client).to receive(:new).with("localhost", 9132)
+      search
+    end
+
+    it "should accept a index list" do
+      indexes = Mongoid::Giza::Search.new("localhost", 9132, :index1, :index2).indexes
+      expect(indexes).to eql([:index1, :index2])
+    end
+  end
+
+  describe "fulltext" do
+    it "should append a query on the specified indexes" do
+      expect(client).to receive(:append_query).with("query", "index1 index2")
+      allow(search).to receive(:indexes) { [:index1, :index2] }
+      search.fulltext("query")
+    end
+
+    it "should search all indexes by default" do
+      expect(client).to receive(:append_query).with("query", "*")
+      allow(search).to receive(:indexes) { [] }
+      search.fulltext("query")
+    end
+  end
+
+  describe "with" do
+    it "should add a filter to the search" do
+      expect(Riddle::Client::Filter).to receive(:new).with("attr", 1, false) { filter }
+      expect(filters).to receive(:<<).with(filter)
+      client
+      search.with(:attr, 1)
+    end
+  end
+
+  describe "without" do
+    it "should add a filter to the search" do
+      expect(Riddle::Client::Filter).to receive(:new).with("attr", 1, true) { filter }
+      expect(filters).to receive(:<<).with(filter)
+      client
+      search.without(:attr, 1)
+    end
+  end
+
+  describe "order_by" do
+    it "should set the search order" do
+      expect(client).to receive(:sort_by=).with("attr ASC")
+      search.order_by(:attr, :asc)
+    end
+  end
+
+  describe "run" do
+    it "should run the query" do
+      expect(client).to receive(:run) { [1, 2] }
+      search.run
+    end
+
+    it "should return the result array" do
+      expect(client).to receive(:run) { [1, 2] }
+      expect(search.run).to eql([1, 2])
+    end
+  end
+
+  describe "riddle methods mapping" do
+    it "should respond to method from riddle" do
+      allow(client).to receive(:respond_to?).with("offset=") { true }
+      expect(search.respond_to?(:offset)).to eql(true)
+    end
+
+    it "should call the equivalent method from riddle" do
+      allow(client).to receive(:respond_to?).with("offset=") { true }
+      expect(client).to receive(:offset=).with(1)
+      search.offset(1)
+    end
+
+    it "should raise an error when the equivalent riddle's method does not exists" do
+      allow(client).to receive(:respond_to?).with("idontexist=") { false }
+      expect { search.idontexist }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/mongoid/giza/xml_pipe2_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Mongoid::Giza::XMLPipe2 do
+  let(:xmlpipe2) { Mongoid::Giza::XMLPipe2.new(@index, @buffer) }
+
+  before do
+    @buffer = ""
+    @index = double("index")
+  end
+
+  describe "generate_schema" do
+    before do
+      @field = double("field")
+      @attribute = double("attribute")
+      allow(@index).to receive(:fields) { [@field] }
+      allow(@index).to receive(:attributes) { [@attribute] }
+      allow(@field).to receive(:name) { :name }
+      allow(@attribute).to receive(:name) { :age }
+      allow(@attribute).to receive(:type) { :uint }
+    end
+
+    it "should generate the schema of the docset" do
+      allow(@field).to receive(:attribute) { false }
+      xmlpipe2.generate_schema
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name"/><sphinx:attr name="age" type="uint"/></sphinx:schema>')
+    end
+
+    it "should generate a field attribute" do
+      allow(@field).to receive(:attribute) { true }
+      xmlpipe2.generate_schema
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name" attr="string"/><sphinx:attr name="age" type="uint"/></sphinx:schema>')
+    end
+  end
+
+  describe "generate_docset" do
+    before do
+      field = double("field")
+      attribute = double("attribute")
+      person = double("person")
+      allow(@index).to receive(:fields) { [field] }
+      allow(@index).to receive(:attributes) { [attribute] }
+      allow(@index).to receive(:criteria) { [person] }
+      allow(person).to receive(:giza_id) { 1 }
+      allow(xmlpipe2).to receive(:generate_doc_tags).with([field], person) do
+        @buffer << "<name>Person One</name>"
+      end
+      allow(xmlpipe2).to receive(:generate_doc_tags).with([attribute], person) do
+        @buffer << "<age>25</age>"
+      end
+    end
+
+    context "static fields and attributes" do
+      it "should generate the document entries" do
+        xmlpipe2.generate_docset
+        expect(@buffer).to eql('<sphinx:document id="1"><name>Person One</name><age>25</age></sphinx:document>')
+      end
+    end
+  end
+
+  describe "generate_doc_tags" do
+    before do
+      name = double("name")
+      bio = double("bio")
+      @fields = [name, bio]
+      @person = {name: "Person One", bio: "About me"}
+      allow(name).to receive(:name) { :name }
+      allow(name).to receive(:block) do
+        Proc.new { |document| document[:name].upcase }
+      end
+      allow(bio).to receive(:name) { :bio }
+      allow(bio).to receive(:block) { nil }
+    end
+
+    it "should generate all tags for the given fields or attributes" do
+      xmlpipe2.generate_doc_tags(@fields, @person)
+      expect(@buffer).to eql('<name>PERSON ONE</name><bio>About me</bio>')
+    end
+  end
+
+  describe "generate!" do
+    it "should generate a xml file of the index" do
+      result = '<?xml version="1.0" encoding="utf-8"?>'
+      result << '<sphinx:docset><sphinx:schema>'
+      result << '<sphinx:field name="name"/><sphinx:attr name="age" type="uint"/>'
+      result << '</sphinx:schema>'
+      result << '<sphinx:document id="1"><name>Person One</name><age>25</age></sphinx:document>'
+      result << '</sphinx:docset>'
+      expect(xmlpipe2).to receive(:generate_schema) do
+        @buffer << '<sphinx:schema><sphinx:field name="name"/><sphinx:attr name="age" type="uint"/></sphinx:schema>'
+      end
+      expect(xmlpipe2).to receive(:generate_docset) do
+        @buffer << '<sphinx:document id="1"><name>Person One</name><age>25</age></sphinx:document>'
+      end
+      xmlpipe2.generate!
+      expect(@buffer).to eql(result)
+    end
+  end
+end