marklogic 0.0.1

data/spec/marklogic/database_settings/geospatial_path_index_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::GeospatialPathIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::GeospatialPathIndex.new("/path/to/stuff")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "geospatial-path-index" => {
+            "path-expression" => "/path/to/stuff",
+            "coordinate-system" => "wgs84",
+            "point-format" => "point",
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/range_element_index_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::RangeElementIndex do
+
+  describe "new" do
+    it "should populate correctly" do
+      index = MarkLogic::DatabaseSettings::RangeElementIndex.new("element")
+      expect(index.to_json).to eq(
+        {
+          "scalar-type" => "string",
+          "namespace-uri" => "",
+          "localname" => "element",
+          "collation" => MarkLogic::DEFAULT_COLLATION,
+          "range-value-positions" => false,
+          "invalid-values" => "reject"
+        }
+      )
+    end
+
+    it "should populate correctly with namespace-uri" do
+      index = MarkLogic::DatabaseSettings::RangeElementIndex.new("element", :namespace => "blah")
+      expect(index.to_json).to eq(
+        {
+          "scalar-type" => "string",
+          "namespace-uri" => "blah",
+          "localname" => "element",
+          "collation" => MarkLogic::DEFAULT_COLLATION,
+          "range-value-positions" => false,
+          "invalid-values" => "reject"
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/range_field_index_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::RangeFieldIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::RangeFieldIndex.new("field")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "range-field-index" => {
+            "scalar-type" => "string",
+            "field-name" => "field",
+            "collation" => MarkLogic::DEFAULT_COLLATION,
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_settings/range_path_index_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MarkLogic::DatabaseSettings::RangePathIndex do
+  let(:index) do
+    MarkLogic::DatabaseSettings::RangePathIndex.new("/path/to/stuff")
+  end
+
+  describe "new" do
+    it "should populate correctly" do
+      expect(index.to_json).to eq(
+        {
+          "range-path-index" => {
+            "scalar-type" => "string",
+            "collation" => MarkLogic::DEFAULT_COLLATION,
+            "path-expression" => "/path/to/stuff",
+            "range-value-positions" => false,
+            "invalid-values" => "reject"
+          }
+        }
+      )
+    end
+  end
+end

data/spec/marklogic/database_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe MarkLogic::Database do
+
+  describe "instance" do
+    let(:d) do
+      MarkLogic::Database.new("marklogic-gem-test")
+    end
+
+    it "should create accessors" do
+      expect(d.database_name).to eq("marklogic-gem-test")
+    end
+
+    it "should create adders" do
+      d.add_range_element_index("stuff")
+      expect(d['range-element-index'].length).to eq(1)
+      expect(d['range-element-index'][0].to_json).to eq(
+        {
+          "scalar-type" => "string",
+          "namespace-uri" => "",
+          "localname" => "stuff",
+          "collation" => MarkLogic::DEFAULT_COLLATION,
+          "range-value-positions" => false,
+          "invalid-values" => "reject"
+        }
+      )
+    end
+  end
+
+  describe "stale?" do
+    let(:d) do
+      MarkLogic::Database.new("marklogic-gem-test")
+    end
+
+    before do
+      d.drop if d.exists?
+      d.create
+    end
+
+    after do
+      d.reset_indexes
+      d.drop
+    end
+
+    it "should determine stale state properly" do
+
+      expect(d).to be_exists
+      expect(d).to_not be_stale
+
+      d.add_range_element_index("junk")
+
+      expect(d).to be_stale
+
+      d.update
+
+      expect(d).to_not be_stale
+
+      d.add_range_element_index("whut")
+      d.add_range_element_index("stuff")
+
+      expect(d).to be_stale
+
+      d.update
+
+      d.reset_indexes
+
+      d.add_range_element_index("whut")
+      d.add_range_element_index("stuff")
+      d.add_range_element_index("junk")
+
+      expect(d).to_not be_stale
+    end
+  end
+
+  describe "#collections" do
+    let(:d) do
+      MarkLogic::Database.new("marklogic-gem-test", CONNECTION)
+    end
+
+    before do
+      # d.drop if d.exists?
+      d.create
+    end
+
+    after do
+      d.drop
+    end
+
+    it "should return empty array when no collections are present" do
+      d.collections.each do |collection|
+        d.collection(collection).drop
+      end
+      expect(d.collections.count).to eq(0)
+    end
+
+    it "should return collections" do
+      collection = d.collection("my-test")
+      collection.save({ name: "testing" })
+      collection = d.collection("my-test2")
+      collection.save({ name: "testing2" })
+
+      expect(d.collections.count).to eq(2)
+    end
+  end
+
+  describe "#clear" do
+  end
+end

data/spec/marklogic/forest_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe MarkLogic::Forest do
+
+  describe "#init" do
+    let(:forest) do
+      MarkLogic::Forest.new("marklogic-gem-test")
+    end
+
+    it "should create accessors" do
+      expect(forest.forest_name).to eq("marklogic-gem-test")
+    end
+  end
+
+  describe "#create" do
+    before do
+      @forest = MarkLogic::Forest.new("marklogic-gem-test")
+    end
+
+    it "should create a forest" do
+      expect(@forest).to_not be_exists
+      @forest.create
+      expect(@forest).to be_exists
+
+      @forest.drop
+      expect(@forest).to_not be_exists
+    end
+
+  end
+end

data/spec/marklogic/queries/and_not_query_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::AndNotQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::AndNotQuery.new(
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::CollectionQuery.new("bar"))
+      expect(q.to_xqy).to eq(%Q{cts:and-not-query(cts:directory-query(("/foo/")),cts:collection-query(("bar")))})
+    end
+  end
+end

data/spec/marklogic/queries/and_query_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::AndQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::AndQuery.new
+      expect(q.to_xqy).to eq(%Q{cts:and-query(())})
+    end
+
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::AndQuery.new([])
+      expect(q.to_xqy).to eq(%Q{cts:and-query(())})
+    end
+
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::AndQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/")
+      ])
+      expect(q.to_xqy).to eq(%Q{cts:and-query((cts:directory-query(("/foo/"))))})
+    end
+
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::AndQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ])
+      expect(q.to_xqy).to eq(%Q{cts:and-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))))})
+    end
+  end
+end

data/spec/marklogic/queries/boost_query_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::BoostQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::BoostQuery.new(
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::CollectionQuery.new("bar"))
+      expect(q.to_xqy).to eq(%Q{cts:boost-query(cts:directory-query(("/foo/")),cts:collection-query(("bar")))})
+    end
+  end
+end

data/spec/marklogic/queries/collection_query_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::CollectionQuery do
+
+  describe "#to_xqy" do
+    it "should handle a single collection" do
+      q = MarkLogic::Queries::CollectionQuery.new("foo")
+      expect(q.to_xqy).to eq(%Q{cts:collection-query(("foo"))})
+    end
+
+    it "should handle multiple collections" do
+      q = MarkLogic::Queries::CollectionQuery.new(["foo", "bar", "baz"])
+      expect(q.to_xqy).to eq(%Q{cts:collection-query(("foo","bar","baz"))})
+    end
+  end
+end

data/spec/marklogic/queries/container_query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::ContainerQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::ContainerQuery.new("foo", MarkLogic::Queries::ValueQuery.new("bar", "baz"))
+      expect(q.to_xqy).to eq(%Q{cts:json-property-scope-query("foo",cts:json-property-value-query("bar",("baz"),("exact"),1.0))})
+    end
+  end
+end

data/spec/marklogic/queries/directory_query_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::DirectoryQuery do
+
+  describe "#to_xqy" do
+    it "should have a default depth" do
+      q = MarkLogic::Queries::DirectoryQuery.new("/foo/")
+      expect(q.to_xqy).to eq(%Q{cts:directory-query(("/foo/"))})
+    end
+
+    it "should accept a supplied depth" do
+      q = MarkLogic::Queries::DirectoryQuery.new("/foo/", "infinity")
+      expect(q.to_xqy).to eq(%Q{cts:directory-query(("/foo/"),"infinity")})
+    end
+
+    it "should accept multiple uri" do
+      q = MarkLogic::Queries::DirectoryQuery.new(["/foo/", "/bar/", "/baz/"], "infinity")
+      expect(q.to_xqy).to eq(%Q{cts:directory-query(("/foo/","/bar/","/baz/"),"infinity")})
+    end
+  end
+end

data/spec/marklogic/queries/document_fragment_query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::DocumentFragmentQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::DocumentFragmentQuery.new(MarkLogic::Queries::ValueQuery.new("bar", "baz"))
+      expect(q.to_xqy).to eq(%Q{cts:document-fragment-query(cts:json-property-value-query("bar",("baz"),("exact"),1.0))})
+    end
+  end
+end

data/spec/marklogic/queries/document_query_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::DocumentQuery do
+
+  describe "#to_xqy" do
+    it "should have a default depth" do
+      q = MarkLogic::Queries::DocumentQuery.new("/foo/blah.json")
+      expect(q.to_xqy).to eq(%Q{cts:document-query(("/foo/blah.json"))})
+    end
+
+    it "should accept multiple uris" do
+      q = MarkLogic::Queries::DocumentQuery.new(["/foo/blah.json", "/bar/stuff.json"])
+      expect(q.to_xqy).to eq(%Q{cts:document-query(("/foo/blah.json","/bar/stuff.json"))})
+    end
+  end
+end

data/spec/marklogic/queries/locks_fragement_query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::LocksFragmentQuery do
+
+  describe "#to_xqy" do
+    it "should create xquery correctly" do
+      q = MarkLogic::Queries::LocksFragmentQuery.new(MarkLogic::Queries::ValueQuery.new("bar", "baz"))
+      expect(q.to_xqy).to eq(%Q{cts:locks-fragment-query(cts:json-property-value-query("bar",("baz"),("exact"),1.0))})
+    end
+  end
+end

data/spec/marklogic/queries/near_query_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe MarkLogic::Queries::NearQuery do
+
+  describe "#to_xqy" do
+    it "should handle a single query" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/")
+      ])
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/"))),10,(),1.0)})
+    end
+
+    it "should handle multiple queries" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ])
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))),10,(),1.0)})
+    end
+
+    it "should handle multiple queries with a distance" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ],
+      5)
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))),5,(),1.0)})
+    end
+
+    it "should handle multiple queries with a distance and weight" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ],
+      5,
+      2.0)
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))),5,(),2.0)})
+    end
+
+    it "should handle multiple queries with a distance and weight and unordered" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ],
+      5,
+      2.0,
+      ordered: false)
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))),5,("unordered"),2.0)})
+    end
+
+    it "should handle multiple queries with a distance and weight and unordered" do
+      q = MarkLogic::Queries::NearQuery.new([
+        MarkLogic::Queries::DirectoryQuery.new("/foo/"),
+        MarkLogic::Queries::DirectoryQuery.new("/bar/")
+      ],
+      5,
+      2.0,
+      ordered: true)
+      expect(q.to_xqy).to eq(%Q{cts:near-query((cts:directory-query(("/foo/")),cts:directory-query(("/bar/"))),5,("ordered"),2.0)})
+    end
+  end
+end