ddr-models 3.0.0.beta.3 → 3.0.0.beta.4

data/spec/index/filter_spec.rb

@@ -1,45 +1,170 @@
 module Ddr::Index
   RSpec.describe Filter do
 
-    describe "#where(conditions)" do
-      it "should add raw query filters for the field, value hash of conditions" do
-        subject.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"])
-        expect(subject.clauses).to eq(["{!term f=foo}bar", "{!term f=spam}eggs", "stuff:(dog OR cat OR bird)"])
-      end
-    end
+    its(:clauses) { are_expected.to eq [] }
 
-    describe "#raw(*clauses)" do
-      it "should add the clauses w/o escaping" do
-        subject.raw("foo:bar", "spam:eggs")
-        expect(subject.clauses).to eq(["foo:bar", "spam:eggs"])
+    describe "equality" do
+      describe "when the other is a Filter instance" do
+        describe "and the clauses are equal" do
+          subject { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
+          let(:other) { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
+          specify { expect(subject).to eq other }
+        end
+        describe "and the clauses are not equal" do
+          subject { described_class.new(clauses: ["foo:bar", "bam:baz"]) }
+          let(:other) { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
+          specify { expect(subject).not_to eq other }
+        end
       end
-    end
-
-    describe "#present(field)" do
-      it "should add a \"field present\" clause" do
-        subject.present("foo")
-        expect(subject.clauses).to eq(["foo:[* TO *]"])
+      describe "when the other is not a Filter instance" do
+        subject { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
+        let(:other) { double(clauses: ["foo:bar", "spam:eggs"]) }
+        specify { expect(subject).not_to eq other }
       end
     end
 
-    describe "#absent(field)" do
-      it "should add a \"field not present\" clause" do
-        subject.absent("foo")
-        expect(subject.clauses).to eq(["-foo:[* TO *]"])
+    describe "class methods" do
+      describe ".is_governed_by" do
+        describe "with an object" do
+          subject { described_class.is_governed_by(Item.new(id: "test-1")) }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_governed_by, "test-1")])
+          }
+        end
+        describe "with an ID" do
+          subject { described_class.is_governed_by("test-1") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_governed_by, "test-1")])
+          }
+        end
       end
-    end
-
-    describe "#before_days(field, days)" do
-      it "should add a date range query clause" do
-        subject.before_days("foo", 60)
-        expect(subject.clauses).to eq(["foo:[* TO NOW-60DAYS]"])
+      describe ".is_member_of_collection" do
+        describe "with an object" do
+          subject { described_class.is_member_of_collection(Item.new(id: "test-1")) }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_member_of_collection, "test-1")])
+          }
+        end
+        describe "with an ID" do
+          subject { described_class.is_member_of_collection("test-1") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_member_of_collection, "test-1")])
+          }
+        end
+      end
+      describe ".has_content" do
+        subject { described_class.has_content }
+        its(:clauses) {
+          are_expected.to eq([QueryClause.where(:active_fedora_model, ["Component", "Attachment", "Target"])])
+        }
+      end
+      describe ".model" do
+        describe "with a single model" do
+          subject { described_class.model("Component") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.where(:active_fedora_model, "Component")])
+          }
+        end
+        describe "with a list of models" do
+          subject { described_class.model("Component", "Attachment", "Target") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.where(:active_fedora_model, ["Component", "Attachment", "Target"])])
+          }
+        end
+      end
+      describe ".where" do
+        subject { described_class.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"]) }
+        its(:clauses) {
+          are_expected.to eq([QueryClause.where("foo", "bar"),
+                              QueryClause.where("spam", "eggs"),
+                              QueryClause.where("stuff", ["dog", "cat", "bird"])
+                             ])
+        }
+      end
+      describe ".raw" do
+        subject { described_class.raw("foo:bar", "spam:eggs") }
+        its(:clauses) { are_expected.to eq(["foo:bar", "spam:eggs"]) }
+      end
+      describe ".negative" do
+        subject { described_class.negative("foo", "bar") }
+        its(:clauses) { are_expected.to eq([QueryClause.negative("foo", "bar")]) }
+      end
+      describe ".present" do
+        subject { described_class.present("foo") }
+        its(:clauses) { are_expected.to eq([QueryClause.present("foo")]) }
+      end
+      describe ".absent" do
+        subject { described_class.absent("foo") }
+        its(:clauses) { are_expected.to eq([QueryClause.absent("foo")]) }
+      end
+      describe ".before_days" do
+        subject { described_class.before_days("foo", 60) }
+        its(:clauses) { are_expected.to eq([QueryClause.before_days("foo", 60)]) }
+      end
+      describe ".before" do
+        subject { described_class.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400")) }
+        its(:clauses) {
+          are_expected.to eq([QueryClause.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))])
+        }
       end
     end
 
-    describe "#before(field, date_time)" do
-      it "should add a date range query clause" do
-        subject.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))
-        expect(subject.clauses).to eq(["foo:[* TO 2015-08-27T21:42:34Z]"])
+    describe "API methods" do
+      describe "#where" do
+        it "adds query clauses for the hash of conditions" do
+          subject.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"])
+          expect(subject.clauses).to eq([QueryClause.where("foo", "bar"),
+                                         QueryClause.where("spam", "eggs"),
+                                         QueryClause.where("stuff", ["dog", "cat", "bird"])
+                                        ])
+        end
+      end
+      describe "#where_not" do
+        it "adds negative query clauses for the hash of conditions" do
+          subject.where_not("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"])
+          expect(subject.clauses).to eq([QueryClause.negative("foo", "bar"),
+                                         QueryClause.negative("spam", "eggs"),
+                                         QueryClause.negative("stuff", "dog"),
+                                         QueryClause.negative("stuff", "cat"),
+                                         QueryClause.negative("stuff", "bird")
+                                        ])
+        end
+      end
+      describe "#raw" do
+        it "adds the query clauses w/o escaping" do
+          subject.raw("foo:bar", "spam:eggs")
+          expect(subject.clauses).to eq(["foo:bar", "spam:eggs"])
+        end
+      end
+      describe "#negative" do
+        it "adds a negation query clause" do
+          subject.negative("foo", "bar")
+          expect(subject.clauses).to eq([QueryClause.negative("foo", "bar")])
+        end
+      end
+      describe "#present" do
+        it "adds a \"field present\" query clause" do
+          subject.present("foo")
+          expect(subject.clauses).to eq([QueryClause.present("foo")])
+        end
+      end
+      describe "#absent" do
+        it "adds a \"field not present\" query clause" do
+          subject.absent("foo")
+          expect(subject.clauses).to eq([QueryClause.absent("foo")])
+        end
+      end
+      describe "#before_days" do
+        it "adds a date range query clause" do
+          subject.before_days("foo", 60)
+          expect(subject.clauses).to eq([QueryClause.before_days("foo", 60)])
+        end
+      end
+      describe "#before" do
+        it "adds a date range query clause" do
+          subject.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))
+          expect(subject.clauses).to eq([QueryClause.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))])
+        end
       end
     end
 

data/spec/index/query_builder_spec.rb

@@ -0,0 +1,116 @@
+module Ddr::Index
+  RSpec.describe QueryBuilder do
+
+    describe "DSL" do
+      describe "id" do
+        subject { described_class.new { id "test:1" } }
+        specify {
+          expect(subject.query.rows).to eq 1
+          expect(subject.query.q).to eq QueryClause.id("test:1")
+        }
+      end
+      describe "q" do
+        subject { described_class.new { q "foo:bar" } }
+        specify { expect(subject.query.q).to eq "foo:bar" }
+      end
+      describe "asc" do
+        subject { described_class.new { asc "foo", "bar" } }
+        specify {
+          expect(subject.query.sort).to eq [SortOrder.asc("foo"), SortOrder.asc("bar")]
+        }
+      end
+      describe "desc" do
+        subject { described_class.new { desc "foo", "bar" } }
+        specify {
+          expect(subject.query.sort).to eq [SortOrder.desc("foo"), SortOrder.desc("bar")]
+        }
+      end
+      describe "filter" do
+        subject { described_class.new { filter Filter.where("foo"=>"bar") } }
+        specify { expect(subject.query.filters).to eq [Filter.where("foo"=>"bar")] }
+      end
+      describe "filters" do
+        subject {
+          described_class.new { filters Filter.where("foo"=>"bar"), Filter.where("bing"=>"bang") }
+        }
+        specify {
+          expect(subject.query.filters).to eq([Filter.where("foo"=>"bar"),
+                                               Filter.where("bing"=>"bang")
+                                              ])
+        }
+      end
+      describe "field" do
+        subject { described_class.new { field "foo", "bar" } }
+        specify { expect(subject.query.fields).to include("foo", "bar") }
+      end
+      describe "fields" do
+        subject { described_class.new { fields "foo", "bar" } }
+        specify { expect(subject.query.fields).to include("foo", "bar") }
+      end
+      describe "sort" do
+        subject { described_class.new { sort "foo"=>"asc", "bar"=>"desc" } }
+        specify {
+          expect(subject.query.sort).to eq([SortOrder.new(field: "foo", order: "asc"),
+                                            SortOrder.new(field: "bar", order: "desc")
+                                           ])
+        }
+      end
+      describe "order_by" do
+        subject { described_class.new { order_by "foo"=>"asc", "bar"=>"desc" } }
+        specify { expect(subject.query.sort).to eq [SortOrder.new(field: "foo", order: "asc"), SortOrder.new(field: "bar", order: "desc")] }
+      end
+      describe "limit" do
+        subject { described_class.new { limit 5 } }
+        specify { expect(subject.query.rows).to eq 5 }
+      end
+      describe "rows" do
+        subject { described_class.new { rows 5 } }
+        specify { expect(subject.query.rows).to eq 5 }
+      end
+      describe "raw" do
+        subject { described_class.new { raw "foo:bar" } }
+        specify { expect(subject.query.filters).to eq [Filter.raw("foo:bar")] }
+      end
+      describe "where" do
+        subject { described_class.new { where "foo"=>"bar" } }
+        specify { expect(subject.query.filters).to eq [Filter.where("foo"=>"bar")] }
+      end
+      describe "absent" do
+        subject { described_class.new { absent "foo" } }
+        specify { expect(subject.query.filters).to eq [Filter.absent("foo")] }
+      end
+      describe "present" do
+        subject { described_class.new { present "foo" } }
+        specify { expect(subject.query.filters).to eq [Filter.present("foo")] }
+      end
+      describe "before" do
+        subject {
+          described_class.new { before "foo", DateTime.parse("2015-12-14T20:40:06Z") }
+        }
+        specify {
+          expect(subject.query.filters).to eq [Filter.before("foo", DateTime.parse("2015-12-14T20:40:06Z"))]
+        }
+      end
+      describe "before_days" do
+        subject { described_class.new { before_days "foo", 7 } }
+        specify { expect(subject.query.filters).to eq [Filter.before_days("foo", 7)] }
+      end
+    end
+
+    describe "using static filters" do
+      describe "has_content" do
+        before { subject.has_content }
+        specify { expect(subject.query.filters).to eq [Filter.has_content] }
+      end
+      describe "is_governed_by" do
+        before { subject.is_governed_by "test:1" }
+        specify { expect(subject.query.filters).to eq [Filter.is_governed_by("test:1")] }
+      end
+      describe "is_governed_by" do
+        before { subject.is_member_of_collection "test:1" }
+        specify { expect(subject.query.filters).to eq [Filter.is_member_of_collection("test:1")] }
+      end
+    end
+
+  end
+end

data/spec/index/query_clause_spec.rb

@@ -0,0 +1,58 @@
+module Ddr::Index
+  RSpec.describe QueryClause do
+
+    describe "class methods" do
+      describe ".unique_key" do
+        subject { described_class.unique_key("test:1") }
+        its(:to_s) { is_expected.to eq "{!term f=id}test:1" }
+      end
+      describe ".id" do
+        subject { described_class.id("test:1") }
+        its(:to_s) { is_expected.to eq "{!term f=id}test:1" }
+      end
+      describe ".negative" do
+        subject { described_class.negative("foo", "Jungle Fever") }
+        its(:to_s) { is_expected.to eq "-foo:\"Jungle Fever\"" }
+      end
+      describe ".present" do
+        subject { described_class.present("foo") }
+        its(:to_s) { is_expected.to eq "foo:[* TO *]" }
+      end
+      describe ".absent" do
+        subject { described_class.absent("foo") }
+        its(:to_s) { is_expected.to eq "-foo:[* TO *]" }
+      end
+      describe ".disjunction" do
+        subject { described_class.disjunction("foo", ["Jungle Fever", "bar"]) }
+        its(:to_s) { is_expected.to eq "{!lucene q.op=OR df=foo}\"Jungle Fever\" bar" }
+      end
+      describe ".before" do
+        subject { described_class.before("foo", DateTime.parse("2015-12-14T20:40:06Z")) }
+        its(:to_s) { is_expected.to eq "foo:[* TO 2015-12-14T20:40:06Z]" }
+      end
+      describe ".before_days" do
+        subject { described_class.before_days("foo", 5) }
+        its(:to_s) { is_expected.to eq "foo:[* TO NOW-5DAYS]" }
+      end
+      describe ".term" do
+        subject { described_class.term("foo", "bar") }
+        its(:to_s) { is_expected.to eq "{!term f=foo}bar" }
+      end
+      describe ".where" do
+        describe "when the value is a string" do
+          subject { described_class.where("foo", "Jungle Fever") }
+          its(:to_s) { is_expected.to eq "foo:\"Jungle Fever\"" }
+        end
+        describe "when the value is an Array with one entry" do
+          subject { described_class.where("foo", ["Jungle Fever"]) }
+          its(:to_s) { is_expected.to eq "foo:\"Jungle Fever\"" }
+        end
+        describe "when the value is an array with multiple entries" do
+          subject { described_class.where("foo", ["Jungle Fever", "bar"]) }
+          its(:to_s) { is_expected.to eq "{!lucene q.op=OR df=foo}\"Jungle Fever\" bar" }
+        end
+      end
+    end
+
+  end
+end

data/spec/index/query_spec.rb

@@ -1,19 +1,48 @@
 module Ddr::Index
   RSpec.describe Query do
 
-    subject do
-      QueryBuilder.build do |query|
-        query
-          .q("foo:bar")
-          .where("spam"=>"eggs")
-          .fields("id", "foo", "spam")
-          .limit(50)
-      end
+    describe "initialized with attributes" do
+      let(:id) { UniqueKeyField.instance }
+      let(:foo) { Field.new("foo") }
+      let(:spam) { Field.new("spam") }
+      let(:filter) { Filter.where(spam=>"eggs") }
+      let(:sort_order) { SortOrder.new(field: foo, order: "asc") }
+      let(:fields) { [id, foo, spam] }
+
+      subject {
+        described_class.new(q: "foo:bar",
+                            filters: [filter],
+                            fields: fields,
+                            sort: sort_order,
+                            rows: 50)
+      }
+
+      its(:to_s) {
+        is_expected.to eq "q=foo%3Abar&fq=spam%3Aeggs&fl=id%2Cfoo%2Cspam&sort=foo+asc&rows=50"
+      }
+      its(:params) {
+        is_expected.to eq({q: "foo:bar", fl: "id,foo,spam", fq: ["spam:eggs"], sort: "foo asc", rows: 50})
+      }
     end
 
-    its(:to_s) { is_expected.to eq("q=foo%3Abar&fq=%7B%21term+f%3Dspam%7Deggs&fl=id%2Cfoo%2Cspam&rows=50") }
+    describe "initialized with a block" do
+      subject {
+        described_class.new do
+          q "foo:bar"
+          where "spam"=>"eggs"
+          fields :id, "foo", "spam"
+          asc "foo"
+          limit 50
+        end
+      }
 
-    its(:params) { is_expected.to eq({q: "foo:bar", fl: "id,foo,spam", fq: ["{!term f=spam}eggs"], rows: 50}) }
+      its(:to_s) {
+        is_expected.to eq "q=foo%3Abar&fq=spam%3Aeggs&fl=id%2Cfoo%2Cspam&sort=foo+asc&rows=50"
+      }
+      its(:params) {
+        is_expected.to eq({q: "foo:bar", fl: "id,foo,spam", fq: ["spam:eggs"], sort: "foo asc", rows: 50})
+      }
+    end
 
   end
 end

data/spec/jobs/fits_file_characterization_spec.rb

@@ -3,50 +3,14 @@ require 'spec_helper'
 module Ddr::Jobs
   RSpec.describe FitsFileCharacterization, jobs: true, file_characterization: true do
 
-    shared_examples "has a fits update event" do
-      let(:event) { object.update_events.last }
-      it "should have the correct event attributes" do
-        expect(event.outcome).to eq(expected_outcome)
-        expect(event.detail).to eq(expected_detail)
-        expect(event.software).to eq("fits #{fits_version}")
-      end
-    end
+    let(:obj) { double }
 
-    context "content-bearing object" do
-      let(:object) { TestContent.create }
-      let(:stdout_msg) { '<fits />' }
-      let(:stderr_msg) { 'stderr msg' }
-      let(:fits_version) { '0.9.9 '}
-      before { allow(Ddr::Jobs::FitsFileCharacterization).to receive(:fits_version) { fits_version } }
-      context "fits command is successful" do
-        let(:expected_outcome) { Ddr::Events::Event::SUCCESS }
-        let(:expected_detail) { nil }
-        before do
-          allow(Open3).to receive(:capture3) { [ stdout_msg, stderr_msg,  $? ] }
-          allow_any_instance_of(Process::Status).to receive(:success?) { true }
-          Ddr::Jobs::FitsFileCharacterization.perform(object.id)
-          object.reload
-        end
-        it "should populate the fits datastream" do
-          expect(object.fits.content).to be_present
-        end
-        it_behaves_like "has a fits update event"
-      end
-      context "fits command is not successful" do
-        let(:expected_outcome) { Ddr::Events::Event::FAILURE }
-        let(:expected_detail) { stderr_msg }
-        before do
-          allow(Open3).to receive(:capture3) { [ stdout_msg, stderr_msg,  $? ] }
-          allow_any_instance_of(Process::Status).to receive(:success?) { false }
-          Ddr::Jobs::FitsFileCharacterization.perform(object.id)
-          object.reload
-        end
-        it "should not populate the fits datastream" do
-          expect(object.fits.content).to_not be_present
-        end
-        it_behaves_like "has a fits update event"
-      end
-    end
+    before { allow(ActiveFedora::Base).to receive(:find).with("test:1") { obj } }
+
+    specify {
+      expect(Ddr::Models::FileCharacterization).to receive(:call).with(obj) { nil }
+      described_class.perform("test:1")
+    }
 
   end
 end