mongoid-giza 0.5.1 → 0.6.0

data/spec/mongoid/giza/index/attribute_spec.rb

@@ -5,7 +5,8 @@ require "spec_helper"
 describe Mongoid::Giza::Index::Attribute do
   describe "name" do
     it "should be mandatory" do
-      expect { Mongoid::Giza::Index::Attribute.new }.to raise_error(ArgumentError)
+      expect { Mongoid::Giza::Index::Attribute.new }
+        .to raise_error(ArgumentError)
     end
 
     it "should be set on creation" do
@@ -43,7 +44,8 @@ describe Mongoid::Giza::Index::Attribute do
 
   describe "type" do
     it "should be mandatory" do
-      expect { Mongoid::Giza::Index::Attribute.new("attribute") }.to raise_error(ArgumentError)
+      expect { Mongoid::Giza::Index::Attribute.new("attribute") }
+        .to raise_error(ArgumentError)
     end
 
     it "should be set on creation" do
@@ -53,12 +55,47 @@ describe Mongoid::Giza::Index::Attribute do
     end
 
     it "should be a valid type" do
-      expect { Mongoid::Giza::Index::Attribute.new("attribute", :type) }.to raise_error(TypeError)
+      expect { Mongoid::Giza::Index::Attribute.new("attribute", :type) }
+        .to raise_error(TypeError)
     end
   end
 
   it "should accept a block" do
-    attribute = Mongoid::Giza::Index::Attribute.new("attribute", :uint) { }
+    attribute = Mongoid::Giza::Index::Attribute.new("attribute", :uint) {}
     expect(attribute.block).to be_a(Proc)
   end
+
+  describe "options" do
+    describe "default" do
+      it "should accept default option" do
+        attribute = Mongoid::Giza::Index::Attribute.new("attribute",
+                                                        :uint, default: 1)
+        expect(attribute.default).to be 1
+      end
+
+      it "should be nil if not set" do
+        attribute = Mongoid::Giza::Index::Attribute.new("attribute", :uint)
+        expect(attribute.default).to be nil
+      end
+    end
+
+    describe "bits" do
+      it "should accept bits option" do
+        attribute = Mongoid::Giza::Index::Attribute.new("attribute",
+                                                        :uint, bits: 16)
+        expect(attribute.bits).to be 16
+      end
+
+      it "should ignore if it's not an int attribute" do
+        attribute = Mongoid::Giza::Index::Attribute.new("attribute",
+                                                        :bool, bits: 16)
+        expect(attribute.bits).to be nil
+      end
+
+      it "should be nil if not set" do
+        attribute = Mongoid::Giza::Index::Attribute.new("attribute", :uint)
+        expect(attribute.bits).to be nil
+      end
+    end
+  end
 end

data/spec/mongoid/giza/index/field_spec.rb

@@ -47,7 +47,7 @@ describe Mongoid::Giza::Index::Field do
   end
 
   it "should accept a block" do
-    field = Mongoid::Giza::Index::Field.new("field") { }
+    field = Mongoid::Giza::Index::Field.new("field") {}
     expect(field.block).to be_a(Proc)
   end
 end

data/spec/mongoid/giza/index_spec.rb

@@ -44,7 +44,7 @@ describe Mongoid::Giza::Index do
     end
 
     it "should create a new Field" do
-      expect(Mongoid::Giza::Index::Field).to receive(:new).with(name, false)
+      expect(Mongoid::Giza::Index::Field).to receive(:new).with(name, nil)
       index.field(name)
     end
 
@@ -63,14 +63,17 @@ describe Mongoid::Giza::Index do
   describe "attribute" do
     let(:name) { "attribute" }
 
-    let(:type) { :uint }
+    let(:type) { :int }
+
+    let(:options) { {default: 1} }
 
     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)
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new)
+        .with(name, type, {})
       index.attribute(name, type)
     end
 
@@ -85,21 +88,23 @@ describe Mongoid::Giza::Index do
         end
         fields
       end
-      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, Mongoid::Giza::Index::TYPES_MAP[type])
+      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
+    it "should default to string 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)
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new)
+        .with(name, :string, {})
       index.attribute(name)
     end
 
-    it "should default to the first type when the type is not mapped" do
+    it "should default to string when the type is not mapped" do
       allow(klass).to receive(:fields) do
         fields = double("fields")
         allow(fields).to receive(:[]).with(name) do
@@ -109,9 +114,16 @@ describe Mongoid::Giza::Index do
         end
         fields
       end
-      expect(Mongoid::Giza::Index::Attribute).to receive(:new).with(name, Mongoid::Giza::Index::TYPES_MAP.values.first)
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new)
+        .with(name, :string, {})
       index.attribute(name)
     end
+
+    it "should accept options" do
+      expect(Mongoid::Giza::Index::Attribute).to receive(:new)
+        .with(name, type, options)
+      index.attribute(name, type, options)
+    end
   end
 
   describe "name" do
@@ -137,7 +149,9 @@ describe Mongoid::Giza::Index do
     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 }
+      expect(Mongoid::Giza::XMLPipe2).to receive(:new).with(index, buffer) do
+        xmlpipe2.as_null_object
+      end
       index.xmlpipe2(buffer)
     end
 

data/spec/mongoid/giza/indexer_spec.rb

@@ -11,7 +11,7 @@ describe Mongoid::Giza::Indexer do
 
   describe "index!" do
     it "should execute the sphinx indexer" do
-      expect(@controller).to receive(:index).with(no_args())
+      expect(@controller).to receive(:index).with(no_args)
       @indexer.index!
     end
 
@@ -67,15 +67,18 @@ describe Mongoid::Giza::Indexer do
 
   describe "giza_classes" do
     before(:all) do
+      # :nodoc:
       class One
         include Mongoid::Document
         include Mongoid::Giza
       end
 
+      # :nodoc:
       class Two
         include Mongoid::Document
       end
 
+      # :nodoc:
       class Three
         include Mongoid::Document
         include Mongoid::Giza

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

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe Mongoid::Giza::GizaID do
+describe Mongoid::Giza::ID do
   describe "instance" do
-    let(:giza_id) { Mongoid::Giza::GizaID.new(id: :Person) }
+    let(:giza_id) { Mongoid::Giza::ID.new(id: :Person) }
 
     it "should be valid" do
       expect(giza_id).to be_valid
@@ -17,14 +17,14 @@ describe Mongoid::Giza::GizaID do
     end
   end
 
-  describe "next_id" do
+  describe "next" do
     before do
-      Mongoid::Giza::GizaID.create(id: :Person)
+      Mongoid::Giza::ID.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)
+      expect(Mongoid::Giza::ID.next(:Person)).to eql(1)
+      expect(Mongoid::Giza::ID.next(:Person)).to eql(2)
     end
   end
 end

data/spec/mongoid/giza/search_spec.rb

@@ -1,22 +1,19 @@
 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(:client) { double("client") }
 
   let(:search) { Mongoid::Giza::Search.new("localhost", 9132) }
 
-  let(:filters) do
-    filters = double("filters")
-    allow(client).to receive(:filters) { filters }
-    filters
-  end
+  let(:filters) { double("filters") }
 
   let(:filter) { double("filter") }
 
+  before do
+    allow(Riddle::Client).to receive(:new).with("localhost", 9132) { client }
+    allow(client).to receive(:filters) { filters }
+  end
+
   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)
@@ -24,28 +21,24 @@ describe Mongoid::Giza::Search do
     end
 
     it "should accept a index list" do
-      indexes = Mongoid::Giza::Search.new("localhost", 9132, [:index1, :index2]).indexes
+      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) { [] }
+    it "should define the query string" do
       search.fulltext("query")
+      expect(search.query_string).to eql("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(Riddle::Client::Filter).to receive(:new).with("attr", 1, false) do
+        filter
+      end
       expect(filters).to receive(:<<).with(filter)
       client
       search.with(:attr, 1)
@@ -54,7 +47,9 @@ describe Mongoid::Giza::Search do
 
   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(Riddle::Client::Filter).to receive(:new).with("attr", 1, true) do
+        filter
+      end
       expect(filters).to receive(:<<).with(filter)
       client
       search.without(:attr, 1)
@@ -69,30 +64,57 @@ describe Mongoid::Giza::Search do
   end
 
   describe "run" do
-    it "should run the query" do
-      expect(client).to receive(:run) { [1, 2] }
+    let(:result) { double("result") }
+
+    before do
+      search.fulltext("query")
+    end
+
+    it "should execute the query" do
+      allow(search).to receive(:indexes) { [:index1, :index2] }
+      expect(client).to receive(:query).with("query", "index1 index2")
       search.run
     end
 
-    it "should return the result array" do
-      expect(client).to receive(:run) { [1, 2] }
-      expect(search.run).to eql([1, 2])
+    it "should search all indexes by default" do
+      expect(client).to receive(:query).with("query", "*")
+      search.run
+    end
+
+    it "should return the result of the query" do
+      allow(client).to receive(:query).with("query", "*") { result }
+      expect(search.run).to be result
     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)
+    context "with no argument" do
+      it "should respond to method from riddle" do
+        allow(client).to receive(:respond_to?).with(:offset) { true }
+        expect(client).to receive(:"offset").with(no_args)
+        search.offset
+      end
+    end
+
+    context "with one argument" do
+      it "should respond to method from riddle" do
+        allow(client).to receive(:respond_to?).with("offset=") { true }
+        expect(client).to receive(:"offset=").with(1)
+        search.offset(1)
+      end
     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)
+    context "with multiple arguments" do
+      it "should respond to method from riddle" do
+        allow(client).to receive(:respond_to?).with(:offset) { true }
+        expect(client).to receive(:"offset").with(1, 2)
+        search.offset(1, 2)
+      end
     end
 
-    it "should raise an error when the equivalent riddle's method does not exists" do
+    it "should raise an error when the equivalent riddle's method does not " \
+      "exists" do
+      allow(client).to receive(:respond_to?).with(:idontexist) { false }
       allow(client).to receive(:respond_to?).with("idontexist=") { false }
       expect { search.idontexist }.to raise_error(NoMethodError)
     end

data/spec/mongoid/giza/xml_pipe2_spec.rb

@@ -15,20 +15,38 @@ describe Mongoid::Giza::XMLPipe2 do
       allow(@index).to receive(:fields) { [@field] }
       allow(@index).to receive(:attributes) { [@attribute] }
       allow(@field).to receive(:name) { :name }
+      allow(@field).to receive(:attribute)
       allow(@attribute).to receive(:name) { :age }
-      allow(@attribute).to receive(:type) { :uint }
+      allow(@attribute).to receive(:type) { :int }
+      allow(@attribute).to receive(:default)
+      allow(@attribute).to receive(:bits)
     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>')
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name"/>' \
+        '<sphinx:attr name="age" type="int"/></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>')
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name" '\
+        'attr="string"/><sphinx:attr name="age" type="int"/></sphinx:schema>')
+    end
+
+    it "should include default attribute if present" do
+      allow(@attribute).to receive(:default) { 1 }
+      xmlpipe2.generate_schema
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name"/>' \
+        '<sphinx:attr name="age" type="int" default="1"/></sphinx:schema>')
+    end
+
+    it "should include bits attribute if present" do
+      allow(@attribute).to receive(:bits) { 16 }
+      xmlpipe2.generate_schema
+      expect(@buffer).to eql('<sphinx:schema><sphinx:field name="name"/>' \
+        '<sphinx:attr name="age" type="int" bits="16"/></sphinx:schema>')
     end
   end
 
@@ -40,19 +58,19 @@ describe Mongoid::Giza::XMLPipe2 do
       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(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
+      allow(xmlpipe2).to receive(:generate_doc_tags)
+        .with([attribute], person) { @buffer << "<age>25</age>" }
     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>')
+        expect(@buffer).to eql('<sphinx:document id="1"><name>Person One' \
+          "</name><age>25</age></sphinx:document>")
       end
     end
   end
@@ -65,7 +83,7 @@ describe Mongoid::Giza::XMLPipe2 do
       @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 }
+        proc { |document| document[:name].upcase }
       end
       allow(bio).to receive(:name) { :bio }
       allow(bio).to receive(:block) { nil }
@@ -73,26 +91,51 @@ describe Mongoid::Giza::XMLPipe2 do
 
     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>')
+      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>'
+      result << "<sphinx:docset><sphinx:schema>"
+      result <<
+        '<sphinx:field name="name"/><sphinx:attr name="age" type="int"/>'
+      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>'
+        @buffer << '<sphinx:schema><sphinx:field name="name"/><sphinx:attr ' \
+          'name="age" type="int"/></sphinx:schema>'
       end
       expect(xmlpipe2).to receive(:generate_docset) do
-        @buffer << '<sphinx:document id="1"><name>Person One</name><age>25</age></sphinx:document>'
+        @buffer << '<sphinx:document id="1"><name>Person One</name>' \
+          "<age>25</age></sphinx:document>"
       end
       xmlpipe2.generate!
       expect(@buffer).to eql(result)
     end
   end
+
+  describe "process_value" do
+    let(:time_attr) { Mongoid::Giza::Index::Attribute.new(:at, :timestamp) }
+
+    let(:attribute) { Mongoid::Giza::Index::Attribute.new(:age, :uint) }
+
+    let(:object) { {at: @now, age: 50} }
+
+    before do
+      @now = Time.new(1)
+    end
+
+    it "should convert timestamp attributes to unix time" do
+      value = xmlpipe2.process_value(time_attr, object)
+      expect(Time.at(value)).to eq(@now)
+    end
+
+    it "should return other values as is" do
+      expect(xmlpipe2.process_value(attribute, object)).to be 50
+    end
+  end
 end