marklogic 0.0.1

data/spec/marklogic/connection_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe MarkLogic::Connection do
+
+  class Response
+
+    def initialize(b)
+      @body = b
+    end
+
+    def body
+      @body
+    end
+
+    def body=(val)
+      @body = val
+    end
+
+    def read_body
+      true
+    end
+
+    def [](x)
+      "multipart/mixed; boundary=4ae338aa9d1fc38e"
+    end
+  end
+
+  before do
+    @b = MarkLogic::Connection.app_services_connection
+  end
+
+  describe "split_multipart" do
+    it "should split properly when multiple values are returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: integer\r\n\r\n5\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: integer\r\n\r\n6\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq([5, 6])
+    end
+
+    it "should split properly when a single value is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: integer\r\n\r\n5\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq(5)
+    end
+
+    it "should split properly when an array value is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: application/json\r\nX-Primitive: array\r\n\r\n["5", 6]\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq(["5", 6])
+    end
+
+    it "should split properly when an object value is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: application/json\r\nX-Primitive: map\r\n\r\n{"hi":"stuff"}\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq({"hi" => "stuff"})
+    end
+
+    it "should split properly when a true boolean is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: boolean\r\n\r\ntrue\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to be true
+    end
+
+    it "should split properly when a false boolean is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: boolean\r\n\r\nfalse\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to be false
+    end
+
+    it "should split properly when a decimal is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: text/plain\r\nX-Primitive: decimal\r\n\r\n3.1\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq(3.1)
+    end
+
+    it "should split properly when a crazy object is returned" do
+      response = Response.new(%Q{\r\n--4ae338aa9d1fc38e\r\nContent-Type: application/json\r\nX-Primitive: map\r\n\r\n{"stuff":[1, 2, 3], "junk":false}\r\n--4ae338aa9d1fc38e--\r\n})
+      expect(@b.send(:split_multipart, response)).to eq({"stuff" => [1, 2, 3], "junk" => false})
+    end
+
+  end
+
+  describe "run_query" do
+    it "should split properly when multiple values are returned" do
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+    end
+
+    it "should split properly when a single value is returned" do
+      expect(@b.run_query('5').body).to eq(5)
+    end
+
+    it "should split properly when an array value is returned" do
+      expect(@b.run_query(%Q{x = ["5", 6]; x}).body).to eq(["5", 6])
+    end
+
+    it "should split properly when an object value is returned" do
+      expect(@b.run_query('x = {hi: "stuff"}; x').body).to eq({"hi" => "stuff"})
+    end
+
+    it "should split properly when a true boolean is returned" do
+      expect(@b.run_query('true').body).to be true
+    end
+
+    it "should split properly when a false boolean is returned" do
+      expect(@b.run_query('false').body).to be false
+    end
+
+    it "should split properly when a decimal is returned" do
+      expect(@b.run_query('3.1').body).to eq(3.1)
+    end
+
+    it "should split properly when a crazy object is returned" do
+      expect(@b.run_query(%Q{x = { stuff: [1, 2, 3], junk: false}; x}).body).to eq({"stuff" => [1, 2, 3], "junk" => false})
+    end
+  end
+
+  describe "#digest" do
+    it "#digest should cache login creds" do
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+    end
+  end
+
+  describe "run_query" do
+    it "should work" do
+      expect(@b.run_query('(5, 6)', 'xquery').body).to eq([5, 6])
+      expect(@b.run_query('<a/>,<a/>', 'xquery').body).to eq(['<a/>', '<a/>'])
+
+      res = @b.run_query('<a/>, try { fn:error((), "stuff") } catch($ex) { $ex }', 'xquery').body
+      expect(res[0]).to eq('<a/>')
+      expect(res[1]).to match(/<error:error.*/)
+    end
+  end
+end

data/spec/marklogic/cursor_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe MarkLogic::Cursor do
+  before do
+    @collection = @database.collection("stuff")
+    @collection.drop
+
+    @collection.save((1..101).map do |n|
+      {:_id => n, :name => "John#{n}", :age => n, :weight => n % 5, :stuff => "junk"}
+    end)
+  end
+
+  describe "#sort" do
+    it "should sort ascending" do
+      c = MarkLogic::Cursor.new(@collection, {
+        :sort => [['age', 1]]
+      })
+      expect(c.count).to eq 101
+      expect(c.first['age']).to eq(1)
+    end
+
+    it "should sort descending" do
+      c = MarkLogic::Cursor.new(@collection, {
+        :sort => [['age', -1]]
+      })
+      expect(c.count).to eq 101
+      expect(c.first['age']).to eq(101)
+    end
+
+    it "should do multiple sorts asc, desc" do
+      options = {
+        :sort => [['weight', 1], ['age', -1]]
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 101
+      first = c.first
+      expect(first['age']).to eq(100)
+      expect(first['weight']).to eq(0)
+    end
+
+    it "should do multiple sorts asc, asc" do
+      options = {
+        :sort => [['weight', 1], ['age', 1]]
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 101
+      first = c.first
+      expect(first['age']).to eq(5)
+      expect(first['weight']).to eq(0)
+    end
+
+    it "should do multiple sorts desc, asc" do
+      options = {
+        :sort => [['weight', -1], ['age', 1]]
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 101
+      first = c.first
+      expect(first['age']).to eq(4)
+      expect(first['weight']).to eq(4)
+    end
+
+    it "should do multiple sorts desc, asc" do
+      options = {
+        :sort => [['weight', -1], ['age', -1]]
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 101
+      first = c.first
+      expect(first['age']).to eq(99)
+      expect(first['weight']).to eq(4)
+    end
+  end
+
+  describe "#operators" do
+    it "should support EQ" do
+      criteria = { 'age' => { '$eq' =>  3  } }
+      options = {
+        :query => @collection.from_criteria(criteria)
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 1
+      expect(c.first['age']).to eq 3
+
+      criteria = { 'age' => 3 }
+      options = {
+        :query => @collection.from_criteria(criteria)
+      }
+      c = MarkLogic::Cursor.new(@collection, options)
+      expect(c.count).to eq 1
+      expect(c.first['age']).to eq 3
+
+      criteria = { 'age' => (1..100).to_a }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 100
+    end
+
+    it "should support LT" do
+      criteria = { 'age' => { '$lt' =>  3  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 2
+      expect([1, 2].include?(c.first['age'])).to be true
+      expect([1, 2].include?(c.next['age'])).to be true
+    end
+
+    it "should support GT" do
+      criteria = { 'age' => { '$gt' =>  99  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 2
+      expect([100, 101].include?(c.first['age'])).to be true
+      expect([100, 101].include?(c.next['age'])).to be true
+    end
+
+    it "should support LE" do
+      criteria = { 'age' => { '$le' =>  2  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 2
+      expect([1, 2].include?(c.first['age'])).to be true
+      expect([1, 2].include?(c.next['age'])).to be true
+    end
+
+    it "should support GE" do
+      criteria = { 'age' => { '$ge' =>  100  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 2
+      expect([100, 101].include?(c.first['age'])).to be true
+      expect([100, 101].include?(c.next['age'])).to be true
+    end
+
+    it "should support NE" do
+      criteria = { 'age' => { '$ne' =>  100  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 100
+    end
+  end
+
+  describe "count" do
+    it "should work when indexes are provided" do
+      criteria = { 'age' => { '$gt' =>  3  } }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+      expect(c.count).to eq 98
+    end
+
+    it "should fail when no indexes are provided and should be" do
+      criteria = { 'stuff' => { '$gt' => 3  } }
+      expect {@collection.from_criteria(criteria) }.to raise_error(MarkLogic::MissingIndexError)
+    end
+
+    it "should return the correct count" do
+      c = MarkLogic::Cursor.new(@collection)
+      expect(c.count).to eq 101
+    end
+  end
+
+  describe "each" do
+    it "should work when indexes are provided" do
+      criteria = { 'age' => { '$gt' => 3  }  }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria)
+      })
+
+      count = 0
+      c.each do |doc|
+        count = count + 1
+        expect(doc.kind_of?(Hash)).to eq true
+      end
+      expect(count).to eq 98
+    end
+
+    it "should transform results when a transformer is provided" do
+      @user_class = Struct.new(:id, :name, :age, :stuff)
+
+      criteria = { 'age' => { '$gt' => 3  }  }
+      c = MarkLogic::Cursor.new(@collection, {
+        :query => @collection.from_criteria(criteria),
+        :transformer => lambda { |doc| @user_class.new(doc['_id'], doc['name'], doc['age'], doc['stuff']) }
+      })
+
+      count = 0
+      c.each do |doc|
+        count = count + 1
+        expect(doc.kind_of?(@user_class)).to be true
+        expect(doc.stuff).to eq("junk")
+      end
+      expect(count).to eq 98
+    end
+
+    # it "should fail when no indexes are provided and should be" do
+    #   criteria = { 'age' => { '$gt' => 3  }  }
+    #   c = MarkLogic::Cursor.new(@collection, {
+    #     :query => @collection.from_criteria(criteria)
+    #   })
+    #   expect { c.each { |doc| doc } }.to raise_error(MarkLogic::MissingIndexError)
+    # end
+
+    it "should return the correct count" do
+      c = MarkLogic::Cursor.new(@collection)
+      count = 0
+      c.each do |doc|
+        count = count + 1
+      end
+      expect(count).to eq 101
+    end
+  end
+end

data/spec/marklogic/database_settings/element_word_lexicon_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::ElementWordLexicon do
+  let(:index) do
+    MarkLogic::DatabaseSettings::ElementWordLexicon.new("element")
+  end
+
+  context "#new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "element-word-lexicon" => {
+            "namespace-uri" => "",
+            "localname" => "element",
+            "collation" => MarkLogic::DEFAULT_COLLATION
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/geospatial_element_child_index_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::GeospatialElementChildIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::GeospatialElementChildIndex.new("parent", "child")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "geospatial-element-child-index" => {
+            "parent-namespace-uri" => "",
+            "parent-localname" => "parent",
+            "namespace-uri" => "",
+            "localname" => "child",
+            "coordinate-system" => "wgs84",
+            "point-format" => "point",
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/geospatial_element_index_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::GeospatialElementIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::GeospatialElementIndex.new("element")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "geospatial-element-index" => {
+            "namespace-uri" => "",
+            "localname" => "element",
+            "coordinate-system" => "wgs84",
+            "point-format" => "point",
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/geospatial_element_pair_index_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::GeospatialElementPairIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::GeospatialElementPairIndex.new("parent", "lat", "lon")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "geospatial-element-pair-index" => {
+            "parent-namespace-uri" => "",
+            "parent-localname" => "parent",
+            "latitude-namespace-uri" => "",
+            "latitude-localname" => "lat",
+            "longitude-namespace-uri" => "",
+            "longitude-localname" => "lon",
+            "coordinate-system" => "wgs84",
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end