ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/index/query_builder_spec.rb

@@ -1,140 +0,0 @@
-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
-      describe "join" do
-        subject {
-          described_class.new do
-            join from: :id, to: :collection_uri, where: {admin_set: "dvs"}
-          end
-        }
-        specify {
-          expect(subject.query.filters).to eq [Filter.join(from: :id, to: :collection_uri, where: {admin_set: "dvs"})]
-        }
-      end
-      describe "regexp" do
-        subject { described_class.new { regexp "foo", "foo/bar.*" } }
-        specify {
-          expect(subject.query.filters).to eq [Filter.regexp("foo", "foo/bar.*")]
-        }
-      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
-
-    describe "passing local vars" do
-      let(:local_var) { double(bar: "bar") }
-      subject {
-        described_class.new(local_var) { |foo| asc foo.bar }
-      }
-      specify {
-        expect(subject.query.sort).to eq [SortOrder.asc("bar")]
-      }
-    end
-  end
-end

data/spec/index/query_clause_spec.rb

@@ -1,68 +0,0 @@
-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
-      describe ".join" do
-        subject {
-          described_class.join(from: :id, to: :collection_uri, where: { admin_set: "dvs"})
-        }
-        its(:to_s) { is_expected.to eq "{!join from=id to=collection_uri_ssim}admin_set_ssi:dvs" }
-      end
-      describe ".regexp" do
-        subject { described_class.regexp("foo", "foo/bar.*") }
-        its(:to_s) { is_expected.to eq "foo:/foo\\/bar.*/" }
-      end
-    end
-
-  end
-end

data/spec/models/cache_spec.rb

@@ -1,32 +0,0 @@
-module Ddr::Models
-  RSpec.describe Cache do
-
-    describe "#get" do
-      it "retrieves a value by key" do
-        expect(subject.get(:foo)).to be_nil
-        subject[:foo] = "bar"
-        expect(subject.get(:foo)).to eq "bar"
-      end
-    end
-
-    describe "#put" do
-      it "inserts a key/value" do
-        expect { subject.put(:foo, "bar") }.to change { subject[:foo] }.from(nil).to("bar")
-      end
-    end
-
-    describe "#with" do
-      it "returns the value of the block" do
-        result = subject.with(foo: "bar") { 1 }
-        expect(result).to eq 1
-      end
-      it "temporarily caches the arguments" do
-        subject.with(foo: "bar") do
-          expect(subject.get(:foo)).to eq "bar"
-        end
-        expect(subject.get(:foo)).to be_nil
-      end
-    end
-
-  end
-end

data/spec/models/contact_spec.rb

@@ -1,56 +0,0 @@
-module Ddr::Models
-  RSpec.describe Contact, ddr_aux: true do
-
-    describe ".call" do
-      describe "when the slug is found" do
-        before {
-          allow(described_class).to receive(:get).with(:find, slug: "abc") {
-            {"id"=>1, "slug"=>"abc", "name"=>"A, B, and C Services", "short_name"=>"ABCS",
-             "url"=>"http://library.inst.edu/abc", "phone"=>"555-1234", "email"=>"abc@library.inst.edu",
-             "ask"=>"http://library.inst.edu/abc-ask", "created_at"=>"2015-09-15T16:15:58.514Z",
-             "updated_at"=>"2015-09-15T16:15:58.514Z"}
-          }
-        }
-        it "returns a Contact instance" do
-          expect(described_class.call("abc")).to be_a(described_class)
-        end
-      end
-      describe "when the slug is not found" do
-        before {
-          allow(described_class).to receive(:get).with(:find, slug: "abc")
-                                     .and_raise(ActiveResource::ResourceNotFound, "404")
-        }
-        it "raises an exception" do
-          expect { described_class.call("abc") }.to raise_error(Ddr::Models::NotFoundError)
-        end
-      end
-    end
-
-    describe ".keys" do
-      let(:entries) { [ described_class.new(id: 1, slug: 'abc', name: 'contact ABC'),
-                        described_class.new(id: 2, slug: 'def', name: 'contact DEF') ] }
-      let(:response_collection) { ActiveResource::Collection.new }
-      before do
-        response_collection.elements = entries
-        allow(described_class).to receive(:all) { response_collection }
-      end
-      it "returns the defined slugs" do
-        expect(described_class.keys).to match_array([ entries[0].slug, entries[1].slug ])
-      end
-    end
-
-
-    describe "instance methods" do
-      subject {
-        described_class.new(
-          "id"=>1, "slug"=>"abc", "name"=>"A, B, and C Services", "short_name"=>"ABCS",
-          "url"=>"http://library.inst.edu/abc", "phone"=>"555-1234", "email"=>"abc@library.inst.edu",
-          "ask"=>"http://library.inst.edu/abc-ask", "created_at"=>"2015-09-15T16:15:58.514Z",
-          "updated_at"=>"2015-09-15T16:15:58.514Z"
-        )
-      }
-      its(:to_s) { is_expected.to eq("A, B, and C Services") }
-    end
-
-  end
-end

data/spec/models/descriptive_metadata_datastream_spec.rb

@@ -1,139 +0,0 @@
-require 'rdf/isomorphic'
-include RDF::Isomorphic
-
-def sample_metadata_triples(subject_string="_:test")
-  triples = <<-EOS
-#{subject_string} <http://purl.org/dc/terms/title> "Sample title" .
-#{subject_string} <http://purl.org/dc/terms/creator> "Sample, Example" .
-#{subject_string} <http://purl.org/dc/terms/type> "Image" .
-#{subject_string} <http://purl.org/dc/terms/type> "Still Image" .
-#{subject_string} <http://purl.org/dc/terms/spatial> "Durham County (NC)" .
-#{subject_string} <http://purl.org/dc/terms/spatial> "Durham (NC)" .
-#{subject_string} <http://purl.org/dc/terms/date> "1981-01" .
-#{subject_string} <http://purl.org/dc/terms/rights> "The copyright for these materials is unknown." .
-#{subject_string} <http://library.duke.edu/metadata/terms/print_number> "12-345-6" .
-#{subject_string} <http://library.duke.edu/metadata/terms/series> "Photographic Materials Series" .
-#{subject_string} <http://library.duke.edu/metadata/terms/subseries> "Local Court House" .
-EOS
-end
-
-module Ddr::Datastreams
-  RSpec.describe DescriptiveMetadataDatastream do
-    describe "terminology" do
-      it "should have a term for each term name in the RDF::DC vocab except :license" do
-        expect(described_class.term_names).to include(*Ddr::Vocab::Vocabulary.term_names(RDF::DC)-[:license])
-      end
-      it "should have a term for each term name in the DukeTerms vocab" do
-        expect(described_class.term_names).to include(*Ddr::Vocab::Vocabulary.term_names(Ddr::Vocab::DukeTerms))
-      end
-    end
-    describe "properties" do
-      subject { described_class.properties.map { |prop| prop[1].predicate } }
-      it "should include all the RDF::DC predicates except http://purl.org/dc/terms/license" do
-        expected_predicates = Ddr::Vocab::Vocabulary.property_terms(RDF::DC).select { |p| p.to_s != 'http://purl.org/dc/terms/license' }
-        expect(subject).to include(*expected_predicates)
-      end
-      it "should include all the DukeTerms predicates" do
-        expect(subject).to include(*Ddr::Vocab::Vocabulary.property_terms(Ddr::Vocab::DukeTerms))
-      end
-    end
-    describe "raw content" do
-      let(:obj) { Item.new }
-      subject { obj.descMetadata }
-      before do
-        content = sample_metadata_triples(subject.rdf_subject.to_s)
-        subject.content = content
-        subject.resource.set_subject!(subject.rdf_subject)
-      end
-      it "should retrieve the content using the terminology" do
-        expect(subject.title).to eq(["Sample title"])
-        expect(subject.creator).to eq(["Sample, Example"])
-        expect(subject.type).to eq(["Image", "Still Image"])
-        expect(subject.spatial).to eq(["Durham County (NC)", "Durham (NC)"])
-        expect(subject.date).to eq(["1981-01"])
-        expect(subject.rights).to eq(["The copyright for these materials is unknown."])
-        expect(subject.print_number).to eq(["12-345-6"])
-        expect(subject.series).to eq(["Photographic Materials Series"])
-        expect(subject.subseries).to eq(["Local Court House"])
-      end
-    end
-    describe "using the terminology setters" do
-      let(:obj) { Item.new }
-      subject { obj.descMetadata }
-      let(:content) { sample_metadata_triples(subject.rdf_subject.to_s) }
-      before do
-        subject.title = "Sample title"
-        subject.creator = "Sample, Example"
-        subject.type = ["Image", "Still Image"]
-        subject.spatial = ["Durham County (NC)", "Durham (NC)"]
-        subject.date = "1981-01"
-        subject.rights = "The copyright for these materials is unknown."
-        subject.print_number = "12-345-6"
-        subject.series = "Photographic Materials Series"
-        subject.subseries = "Local Court House"
-      end
-      its(:resource) { is_expected.to be_isomorphic_with(RDF::Reader.for(:ntriples).new(content)) }
-    end
-    describe "using the set_values and add_value methods" do
-      let(:obj) { Item.new }
-      subject { obj.descMetadata }
-      before { subject.type = "Photograph" }
-      describe "#set_values" do
-        it "sets the values of the term to those supplied" do
-          subject.set_values :type, [ "Image", "Still Image" ]
-          expect(subject.type).to eq([ "Image", "Still Image" ])
-        end
-        it "does not add blank values" do
-          subject.set_values :type, [ "Image", "", nil, "\t" ]
-          expect(subject.type).to eq([ "Image" ])
-        end
-        it "strips whitespace from values" do
-          subject.set_values :type, [ "Image", "Still Image " ]
-          expect(subject.type).to eq([ "Image", "Still Image" ])
-        end
-        it "strips control characters from values" do
-          subject.set_values :type, [ "Image", "Still\f Image" ]
-          expect(subject.type).to eq([ "Image", "Still Image" ])
-        end
-        it "does not strip CR and LF characters from values" do
-          subject.set_values :type, [ "Image", "Still\nImage" ]
-          expect(subject.type).to eq([ "Image", "Still\nImage" ])
-        end
-      end
-      describe "#add_value" do
-        it "should add the supplied value to those of the term" do
-          subject.add_value :type, "Image"
-          expect(subject.type).to eq([ "Photograph", "Image" ])
-        end
-        it "strips whitespace from the value" do
-          subject.add_value :type, "Image "
-          expect(subject.type).to eq([ "Photograph", "Image" ])
-        end
-        it "does not add blank values" do
-          subject.add_value :type, nil
-          subject.add_value :type, ""
-          subject.add_value :type, "\t"
-          expect(subject.type).to eq(["Photograph"])
-        end
-      end
-    end
-    describe "solrization" do
-      let(:obj) { Item.new }
-      subject { obj.descMetadata }
-      before do
-        content = sample_metadata_triples(subject.rdf_subject.to_s)
-        subject.content = content
-        subject.resource.set_subject!(subject.rdf_subject)
-      end
-      its(:to_solr) { is_expected.to include("title_tesim" => ["Sample title"]) }
-      its(:to_solr) { is_expected.to include("creator_tesim" => ["Sample, Example"]) }
-      its(:to_solr) { is_expected.to include("type_tesim" => ["Image", "Still Image"]) }
-      its(:to_solr) { is_expected.to include("spatial_tesim" => ["Durham County (NC)", "Durham (NC)"]) }
-      its(:to_solr) { is_expected.to include("date_tesim" => ["1981-01"]) }
-      its(:to_solr) { is_expected.to include("rights_tesim" => ["The copyright for these materials is unknown."]) }
-      its(:to_solr) { is_expected.to include("print_number_tesim" => ["12-345-6"]) }
-      its(:to_solr) { is_expected.to include("series_tesim" => ["Photographic Materials Series"]) }
-      its(:to_solr) { is_expected.to include("subseries_tesim" => ["Local Court House"]) }
-    end
-  end
-end

data/spec/models/file_characterization_spec.rb

@@ -1,39 +0,0 @@
-module Ddr::Models
-  RSpec.describe FileCharacterization do
-
-    subject { described_class.new(obj) }
-
-    before {
-      obj.content.checksumType = "SHA-1"
-      obj.save!
-    }
-
-    let(:obj) { FactoryGirl.create(:component) }
-    let(:fits_output) { "<fits/>" }
-
-    describe "when there is an error running FITS" do
-      before {
-        allow(subject).to receive(:run_fits).and_raise(FileCharacterization::FITSError)
-      }
-      specify {
-        begin
-          subject.call
-        rescue FileCharacterization::FITSError
-        ensure
-          expect(subject.fits).not_to have_content
-        end
-      }
-    end
-
-    describe "when FITS runs successfully" do
-      before {
-        allow(subject).to receive(:run_fits) { fits_output }
-      }
-      specify {
-        subject.call
-        expect(subject.fits.content).to eq(fits_output)
-      }
-    end
-
-  end
-end