ddr-models 1.2.0

data/spec/models/active_fedora_base_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe ActiveFedora::Base do
+  describe "attachments", attachments: true do
+    before do
+      class AttachToable < ActiveFedora::Base
+        include Ddr::Models::HasAttachments
+      end
+    end
+    after do
+      Object.send(:remove_const, :AttachToable)
+    end
+    describe "#can_have_attachments?" do
+      it "#should return true if the object can have attachments, otherwise false" do
+        expect(AttachToable.new.can_have_attachments?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_attachments?).to be_falsey
+      end
+    end
+    describe "#has_attachments?" do
+      let(:attach_toable) { AttachToable.new }
+      before { attach_toable.attachments << Attachment.new }
+      it "should return true if the object has Attachments, otherwise false" do
+        expect(AttachToable.new).not_to have_attachments
+        expect(ActiveFedora::Base.new).not_to have_attachments
+        expect(attach_toable).to have_attachments
+      end
+    end
+  end
+
+  describe "children", children: true do
+    before do
+      class Childrenable < ActiveFedora::Base
+        has_many :children, property: :is_member_of, class_name: 'ActiveFedora::Base'
+      end
+    end
+    after do
+      Object.send(:remove_const, :Childrenable)
+    end
+    describe "#can_have_children?" do
+      it "should return true if object can have children, otherwise false" do
+        expect(Childrenable.new.can_have_children?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_children?).to be_falsey
+      end
+    end
+    describe "#has_children?" do
+      let(:childrenable) { Childrenable.new }
+      before { childrenable.children << ActiveFedora::Base.new }
+      it "should return true if object has children, otherwise false" do
+        expect(Childrenable.new).not_to have_children
+        expect(ActiveFedora::Base.new).not_to have_children
+        expect(childrenable).to have_children
+      end
+    end
+  end
+
+  describe "thumbnail" do
+    before do
+      class Thumbnailable < ActiveFedora::Base
+        include Ddr::Models::HasThumbnail
+      end
+    end
+    after do
+      Object.send(:remove_const, :Thumbnailable)
+    end
+    describe "#can_have_thumbnail?" do
+      it "should return true if object can have a thumbnail, else false" do
+        expect(Thumbnailable.new.can_have_thumbnail?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_thumbnail?).to be_falsey
+      end
+    end
+    describe "#has_thumbnail?" do
+      let(:thumbnailable) { Thumbnailable.new }
+      before { allow(thumbnailable.datastreams[Ddr::Datastreams::THUMBNAIL]).to receive(:has_content?).and_return(true) }
+      it "should return true if object has a thumbnail, else false" do
+        expect(thumbnailable).to have_thumbnail
+        expect(Thumbnailable.new).not_to have_thumbnail
+        expect(ActiveFedora::Base.new).not_to have_thumbnail
+      end
+    end
+  end
+
+  describe "content" do
+    before do
+      class Contentable < ActiveFedora::Base
+        include Ddr::Models::HasContent
+      end
+    end
+    after do
+      Object.send(:remove_const, :Contentable)
+    end
+    describe "#can_have_content?" do
+      it "should return true if object can have content, else false" do
+        expect(Contentable.new.can_have_content?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_content?).to be_falsey
+      end
+    end
+    describe "#has_content?" do
+      let(:contentable) { Contentable.new }
+      before { allow(contentable.datastreams[Ddr::Datastreams::CONTENT]).to receive(:has_content?).and_return(true) }
+      it "should return true if object has content, else false" do
+        expect(contentable).to have_content
+        expect(Contentable.new).not_to have_content
+        expect(ActiveFedora::Base.new).not_to have_content
+      end
+    end
+  end
+end

data/spec/models/active_fedora_datastream_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module ActiveFedora
+  RSpec.describe Datastream do
+
+    describe "#validate_checksum!" do
+      subject { described_class.new(nil, nil, controlGroup: "M") }
+      let!(:checksum) { "dea56f15b309e47b74fa24797f85245dda0ca3d274644a96804438bbd659555a" }
+      let!(:checksum_type) { "SHA-256" }
+      context "with unpersisted content" do
+        context "the datstream is new" do
+          before { allow(subject).to receive(:new?) { true } }
+          it "should raise an exception" do
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+          end
+        end
+        context "the datastream content has changed" do
+          before { allow(subject).to receive(:content_changed?) { true } }
+          it "should raise an exception" do
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+          end
+        end
+      end
+      context "with persisted content" do
+        before do
+          allow(subject).to receive(:new?) { false }
+          allow(subject).to receive(:pid) { "foobar:1" }
+          allow(subject).to receive(:dsCreateDate) { DateTime.now }
+          allow(subject).to receive(:checksum) { checksum }
+          allow(subject).to receive(:checksumType) { checksum_type }
+        end
+        context "and the repository internal checksum in invalid" do
+          before { allow(subject).to receive(:dsChecksumValid) { false } }
+          it "should raise an error" do
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+          end
+        end
+        context "and the repository internal checksum is valid" do
+          before { allow(subject).to receive(:dsChecksumValid) { true } }
+          context "and the checksum type is invalid" do
+            it "should raise an exception" do
+              expect { subject.validate_checksum!("0123456789abcdef", "FOO-BAR") }.to raise_error
+            end
+          end
+          context "and the checksum type is nil" do
+            it "should compare the provided checksum with the datastream checksum" do
+              expect { subject.validate_checksum!(checksum) }.not_to raise_error
+            end
+          end
+          context "and the checksum type is the same as the datastream checksum type" do
+            it "should compare the provided checksum with the datastream checksum" do
+              expect { subject.validate_checksum!(checksum, checksum_type) }.not_to raise_error
+            end
+          end
+          context "and the checksum type differs from the datastream checksum type" do 
+            let!(:md5digest) { "273ae0f4aa60d94e89bc0e0652ae2c8f" }
+            it "should generate a checksum for comparison" do
+              expect(subject).not_to receive(:checksum)
+              allow(subject).to receive(:content_digest).with("MD5") { md5digest }
+              expect { subject.validate_checksum!(md5digest, "MD5") }.not_to raise_error
+            end
+          end
+          context "and the checksum doesn't match" do
+            it "should raise an exception" do
+              expect { subject.validate_checksum!("0123456789abcdef", checksum_type) }.to raise_error
+            end
+          end
+        end
+      end
+    end
+
+    describe "extensions for external datastreams" do
+      subject { described_class.new(nil, nil, controlGroup: "E") }
+
+      describe "#file_path" do
+        it "should return nil when dsLocation is not set" do
+          expect(subject.file_path).to be_nil
+        end
+        it "should return nil when dsLocation is not a file URI" do
+          subject.dsLocation = "http://library.duke.edu/"
+          expect(subject.file_path).to be_nil
+        end
+        it "should return the file path when dsLocation is a file URI" do
+          subject.dsLocation = "file:/tmp/foo/bar.txt"
+          expect(subject.file_path).to eq "/tmp/foo/bar.txt"
+        end
+      end
+
+      describe "#file_name" do
+        it "should return nil when dsLocation is not set" do
+          expect(subject.file_name).to be_nil
+        end
+        it "should return nil when dsLocation is not a file URI" do
+          subject.dsLocation = "http://library.duke.edu/"
+          expect(subject.file_name).to be_nil
+        end
+        it "should return the file name when dsLocation is a file URI" do
+          subject.dsLocation = "file:/tmp/foo/bar.txt"
+          expect(subject.file_name).to eq "bar.txt"
+        end
+      end
+
+      describe "#file_size" do
+        it "should return nil when dsLocation is not set" do
+          expect(subject.file_size).to be_nil
+        end
+        it "should return nil when dsLocation is not a file URI" do
+          subject.dsLocation = "http://library.duke.edu/"
+          expect(subject.file_size).to be_nil
+        end
+        it "should return the file name when dsLocation is a file URI" do
+          allow(File).to receive(:size).with("/tmp/foo/bar.txt") { 42 }
+          subject.dsLocation = "file:/tmp/foo/bar.txt"
+          expect(subject.file_size).to eq 42
+        end        
+      end
+
+    end # external datastreams
+
+  end
+end

data/spec/models/attachment_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe Attachment, type: :model, attachments: true do
+  it_behaves_like "a DDR model"
+  it_behaves_like "an object that can have content"
+  it_behaves_like "it has an association", :belongs_to, :attached_to, :is_attached_to, "ActiveFedora::Base"
+  context "validations" do
+    before { subject.valid? }
+    it "should have content" do
+      expect(subject.errors.messages).to have_key(:content)
+    end
+  end
+end

data/spec/models/collection_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe Collection, :type => :model do
+
+  it_behaves_like "a DDR model"
+  
+  it_behaves_like "it has an association", :has_many, :children, :is_member_of_collection, "Item"
+
+  it_behaves_like "it has an association", :has_many, :targets, :is_external_target_for, "Target"
+
+  describe "terms delegated to defaultRights" do
+    let(:collection) { Collection.new }
+    before do
+      collection.default_license_title = "License Title"
+      collection.default_license_description = "License Description"
+      collection.default_license_url = "http://library.duke.edu"
+    end
+    it "should set the terms correctly" do
+      expect(collection.defaultRights.license.title.first).to eq("License Title")
+      expect(collection.defaultRights.license.description.first).to eq("License Description")
+      expect(collection.defaultRights.license.url.first).to eq("http://library.duke.edu")
+    end
+  end
+
+  context "validation" do
+    let(:collection) { Collection.new }
+    it "should require a title" do
+      expect(collection).to_not be_valid
+      expect(collection.errors.messages).to have_key(:title)
+    end
+  end
+
+end

data/spec/models/component_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe Component, type: :model, components: true do
+  it_behaves_like "a DDR model"
+  it_behaves_like "an object that can have content"
+  it_behaves_like "it has an association", :belongs_to, :parent, :is_part_of, "Item"
+  it_behaves_like "it has an association", :belongs_to, :target, :has_external_target, "Target"
+end

data/spec/models/descriptive_metadata_datastream_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+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
+  module Datastreams
+    RSpec.describe DescriptiveMetadataDatastream do
+      context "terminology" do
+        subject { described_class.term_names }
+        it "should have a term for each term name in the RDF::DC vocab" do
+          expect(subject).to include(*Ddr::Metadata::Vocabulary.term_names(RDF::DC))
+        end
+        it "should have a term for each term name in the DukeTerms vocab" do
+          expect(subject).to include(*Ddr::Metadata::Vocabulary.term_names(Ddr::Metadata::DukeTerms))
+        end
+      end
+      context "properties" do
+        subject { described_class.properties.map { |prop| prop[1].predicate } }
+        it "should include all the RDF::DC predicates" do
+          expect(subject).to include(*Ddr::Metadata::Vocabulary.property_terms(RDF::DC))
+        end
+        it "should include all the DukeTerms predicates" do
+          expect(subject).to include(*Ddr::Metadata::Vocabulary.property_terms(Ddr::Metadata::DukeTerms))
+        end
+      end
+      context "raw content" do
+        let(:ds) { described_class.new(nil, 'descMetadata') }
+        before do
+          content = sample_metadata_triples(ds.rdf_subject.to_s)
+          ds.content = content
+          ds.resource.set_subject!(ds.rdf_subject)
+        end
+        it "should retrieve the content using the terminology" do
+          expect(ds.title).to eq(["Sample title"])
+          expect(ds.creator).to eq(["Sample, Example"])
+          expect(ds.type).to eq(["Image", "Still Image"])
+          expect(ds.spatial).to eq(["Durham County (NC)", "Durham (NC)"])
+          expect(ds.date).to eq(["1981-01"])
+          expect(ds.rights).to eq(["The copyright for these materials is unknown."])
+          expect(ds.print_number).to eq(["12-345-6"])
+          expect(ds.series).to eq(["Photographic Materials Series"])
+          expect(ds.subseries).to eq(["Local Court House"])
+        end
+      end
+      context "using the terminology setters" do
+        let(:ds) { described_class.new(nil, 'descMetadata') }
+        let(:content) { sample_metadata_triples(ds.rdf_subject.to_s) }
+        before do
+          ds.title = "Sample title"
+          ds.creator = "Sample, Example"
+          ds.type = ["Image", "Still Image"]
+          ds.spatial = ["Durham County (NC)", "Durham (NC)"]
+          ds.date = "1981-01"
+          ds.rights = "The copyright for these materials is unknown."
+          ds.print_number = "12-345-6"
+          ds.series = "Photographic Materials Series"
+          ds.subseries = "Local Court House"
+        end
+        it "should create equivalent RDF graph to that based on the raw version" do
+          expect(ds.resource).to be_isomorphic_with(RDF::Reader.for(:ntriples).new(content))
+        end
+      end
+      context "solrization" do
+        let(:ds) { described_class.new(nil, 'descMetadata') }
+        subject { ds.to_solr }
+        before do
+          content = sample_metadata_triples(ds.rdf_subject.to_s)
+          ds.content = content
+          ds.resource.set_subject!(ds.rdf_subject)
+        end
+        it "should create fields for all the terms that have non-empty values" do
+          expect(subject).to include("title_tesim" => ["Sample title"])
+          expect(subject).to include("creator_tesim" => ["Sample, Example"])
+          expect(subject).to include("type_tesim" => ["Image", "Still Image"])
+          expect(subject).to include("spatial_tesim" => ["Durham County (NC)", "Durham (NC)"])
+          expect(subject).to include("date_tesim" => ["1981-01"])
+          expect(subject).to include("rights_tesim" => ["The copyright for these materials is unknown."])
+          expect(subject).to include("print_number_tesim" => ["12-345-6"])
+          expect(subject).to include("series_tesim" => ["Photographic Materials Series"])
+          expect(subject).to include("subseries_tesim" => ["Local Court House"])
+        end
+      end
+    end
+  end
+end

data/spec/models/events_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'support/shared_examples_for_events'
+
+module Ddr
+  module Events
+    RSpec.describe Event, type: :model, events: true do  
+      it_behaves_like "an event"
+    end
+
+    RSpec.describe UpdateEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Update"
+      end
+    end
+
+    RSpec.describe CreationEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it_behaves_like "a preservation-related event"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Creation"
+      end
+    end
+
+    RSpec.describe FixityCheckEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it_behaves_like "a preservation-related event"
+      it_behaves_like "an event that reindexes its object after save"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Fixity Check"
+      end
+      describe "defaults" do
+        it "should set software to the Fedora repository version" do
+          expect(subject.software).to match /^Fedora Repository \d\.\d\.\d$/
+        end
+      end
+    end
+
+    RSpec.describe VirusCheckEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it_behaves_like "a preservation-related event"
+      it_behaves_like "an event that reindexes its object after save"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Virus Check"
+      end
+    end
+
+    RSpec.describe IngestionEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it_behaves_like "a preservation-related event"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Ingestion"
+      end
+    end
+
+    RSpec.describe ValidationEvent, type: :model, events: true do
+      it_behaves_like "an event"
+      it_behaves_like "a preservation-related event"
+      it "should have a display type" do
+        expect(subject.display_type).to eq "Validation"
+      end
+    end
+  end
+end