ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/component_spec.rb

@@ -1,119 +1,17 @@
+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"
   it_behaves_like "a non-collection model"
-  it_behaves_like "a potentially publishable object"
-  it_behaves_like "an object that can be captioned"
-  it_behaves_like "an object that can have an intermediate file"
-  it_behaves_like "an object that can be streamable"
 
   describe "indexing" do
     subject { FactoryGirl.build(:component) }
     before do
-      allow(subject).to receive(:collection) { Collection.new(pid: "test:1") }
+      allow(subject).to receive(:collection) { Collection.new(id: "test-1") }
     end
-    its(:index_fields) { is_expected.to include(Ddr::Index::Fields::COLLECTION_URI => "info:fedora/test:1") }
+    its(:index_fields) { is_expected.to include(Ddr::Index::Fields::COLLECTION_URI => "test-1") }
   end
 
-  describe "default structure" do
-    describe "no content" do
-      let(:expected) do
-        xml = <<-EOS
-            <mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
-              <metsHdr>
-                <agent ROLE="#{Ddr::Models::Structures::Agent::ROLE_CREATOR}">
-                  <name>#{Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT}</name>
-                </agent>
-              </metsHdr>
-              <structMap TYPE="#{Ddr::Models::Structure::TYPE_DEFAULT}" />
-            </mets>
-        EOS
-        xml
-      end
-      it "should be the appropriate structure" do
-        expect(described_class.new.default_structure.to_xml).to be_equivalent_to(expected)
-      end
-    end
-    describe "has content" do
-      before { allow(subject).to receive(:has_content?) { true } }
-      before { allow(subject).to receive(:has_thumbnail?) { true } }
-      let(:struct) { subject.default_structure }
-      it "has the correct original file" do
-        expect(struct.uses[Ddr::Models::Structure::USE_ORIGINAL_FILE].first.href).to eq(Ddr::Datastreams::CONTENT)
-      end
-      it "has the correct preservation master file" do
-        expect(struct.uses[Ddr::Models::Structure::USE_PRESERVATION_MASTER_FILE].first.href)
-                                                                                  .to eq(Ddr::Datastreams::CONTENT)
-      end
-      describe "intermediate file" do
-        describe "with intermediate file" do
-          before do
-            allow(subject).to receive(:has_intermediate_file?) { true }
-          end
-          it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_INTERMEDIATE_FILE].first.href)
-                .to eq(Ddr::Datastreams::INTERMEDIATE_FILE)
-          end
-        end
-        describe "without intermediate image" do
-          it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_INTERMEDIATE_FILE]).to be nil
-          end
-        end
-      end
-      describe "service file" do
-        let(:service_files) { struct.uses[Ddr::Models::Structure::USE_SERVICE_FILE].map(&:href) }
-        describe "with multires image but not streamable media" do
-          before { allow(subject).to receive(:has_multires_image?) { true } }
-          it "has the correct structure file" do
-            expect(service_files).to contain_exactly(Ddr::Datastreams::MULTIRES_IMAGE)
-          end
-        end
-        describe "with streamable media but not multires image" do
-          before { allow(subject).to receive(:streamable?) { true } }
-          it "has the correct structure file" do
-            expect(service_files).to contain_exactly(Ddr::Datastreams::STREAMABLE_MEDIA)
-          end
-        end
-        describe "with both multires image and streamable media" do
-          before do
-            allow(subject).to receive(:has_multires_image?) { true }
-            allow(subject).to receive(:streamable?) { true }
-          end
-          it "has the correct structure file" do
-            expect(service_files).to contain_exactly(Ddr::Datastreams::MULTIRES_IMAGE,
-                                                     Ddr::Datastreams::STREAMABLE_MEDIA)
-          end
-        end
-        describe "with neither multires image nor streamable media" do
-          it "has the correct structure file" do
-            expect(service_files).to contain_exactly(Ddr::Datastreams::CONTENT)
-          end
-        end
-      end
-      describe "transcript" do
-        describe "with caption file" do
-          before do
-            allow(subject).to receive(:captioned?) { true }
-          end
-          it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_TRANSCRIPT].first.href)
-                .to eq(Ddr::Datastreams::CAPTION)
-          end
-        end
-        describe "without caption file" do
-          it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_TRANSCRIPT]).to be nil
-          end
-        end
-      end
-      it "has the correct thumbnail image" do
-        expect(struct.uses[Ddr::Models::Structure::USE_THUMBNAIL_IMAGE].first.href).to eq(Ddr::Datastreams::THUMBNAIL)
-      end
-    end
-
-  end
 end

data/spec/models/descriptive_metadata_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'rdf/isomorphic'
+
+include RDF::Isomorphic
+
+module Ddr::Models
+  RSpec.describe DescriptiveMetadata do
+
+    let(:obj) { FactoryGirl.build(:item) }
+
+    describe "terminology" do
+      subject { described_class.unqualified_names }
+      it { is_expected.to_not include(:license) }
+      it "should have a term for each term name in the RDF::DC vocab, except :license" do
+        expect(subject).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(subject).to include(*Ddr::Vocab::Vocabulary.term_names(Ddr::Vocab::DukeTerms))
+      end
+    end
+    describe "using the set_values and add_value methods" do
+      let(:ds) { described_class.new(obj) }
+      before { ds.type = ["Photograph"] }
+      describe "#set_values" do
+        it "should set the values of the term to those supplied" do
+          ds.set_values :type, [ "Image", "Still Image" ]
+          expect(ds.type).to eq([ "Image", "Still Image" ])
+        end
+      end
+      describe "#add_value" do
+        it "should add the supplied value to those of the term" do
+          ds.add_value :type, "Image"
+          expect(ds.type).to eq([ "Photograph", "Image" ])
+        end
+      end
+    end
+  end
+end

data/spec/models/effective_license_spec.rb

@@ -0,0 +1,64 @@
+module Ddr::Models
+  RSpec.describe EffectiveLicense do
+
+    subject { described_class.call(obj) }
+
+    let(:url) { "https://creativecommons.org/licenses/by-nc-nd/4.0/" }
+
+    let(:license) { License.new(url: url) }
+    before { allow(License).to receive(:find).with(url: url) { license } }
+
+    let(:obj) { double(pid: "test:1", id: "test:1", license: nil, parent: nil, admin_policy: nil, admin_policy_id: nil) }
+
+    describe "when the object has a license" do
+      before { allow(obj).to receive(:license) { url } }
+      it { is_expected.to eq(license) }
+    end
+
+    describe "when the object does not have a license" do
+      describe "and the object has a parent" do
+        let(:parent) { double(pid: "test:2", license: nil) }
+        before do
+          allow(obj).to receive(:parent) { parent }
+        end
+        describe "and the parent has a license" do
+          before do
+            allow(parent).to receive(:license) { url }
+          end
+          it { is_expected.to eq(license) }
+        end
+        describe "and the parent does not have a license" do
+          it { is_expected.to be_nil }
+        end
+      end
+      describe "and the object does not have a parent" do
+        describe "and the object has an admin policy" do
+          let(:admin_policy) { double(pid: "test:3", id: "test:3", license: nil) }
+          before { allow(obj).to receive(:admin_policy) { admin_policy } }
+          describe "and the admin policy has a different id from the object" do
+            before do
+              allow(obj).to receive(:admin_policy_id) { "test:3" }
+            end
+            describe "and the admin policy has a license" do
+              before do
+                allow(admin_policy).to receive(:license) { url }
+              end
+              it { is_expected.to eq(license) }
+            end
+            describe "and the admin policy does not have a license" do
+              it { is_expected.to be_nil }
+            end
+          end
+          describe "and the admin policy has the same id as the object" do
+            before { allow(obj).to receive(:admin_policy_id) { obj.id } }
+            it { is_expected.to be_nil }
+          end
+        end
+        describe "and the object does not have an admin policy" do
+          it { is_expected.to be_nil }
+        end
+      end
+    end
+
+  end
+end

data/spec/models/events_spec.rb

@@ -1,66 +1,73 @@
+require 'spec_helper'
 require 'support/shared_examples_for_events'
 
-module Ddr::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"
-    its(:display_type) { is_expected.to eq "Update" }
-  end
-
-  RSpec.describe CreationEvent, type: :model, events: true do
-    it_behaves_like "an event"
-    it_behaves_like "a preservation-related event"
-    its(:display_type) { is_expected.to eq "Creation" }
-  end
+module Ddr
+  module Events
+    RSpec.describe Event, type: :model, events: true do
+      it_behaves_like "an event"
+    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"
-    its(:display_type) { is_expected.to eq "Fixity Check" }
-    describe "defaults" do
-      it "should set software to the Fedora repository version" do
-        expect(subject.software).to match /^Fedora Repository \d\.\d\.\d$/
+    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
-  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"
-    its(:display_type) { is_expected.to eq "Virus Check" }
-  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 IngestionEvent, type: :model, events: true do
-    it_behaves_like "an event"
-    it_behaves_like "a preservation-related event"
-    its(:display_type) { is_expected.to eq "Ingestion" }
-  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
+          pending "Fedora 4 API for getting repository version"
+          expect(subject.software).to match /^Fedora Repository \d\.\d\.\d$/
+        end
+      end
+    end
 
-  RSpec.describe ValidationEvent, type: :model, events: true do
-    it_behaves_like "an event"
-    it_behaves_like "a preservation-related event"
-    its(:display_type) { is_expected.to eq "Validation" }
-  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 DeletionEvent, type: :model, events: true do
-    it_behaves_like "an event"
-    it_behaves_like "a preservation-related event"
-    its(:display_type) { is_expected.to eq "Deletion" }
-  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 DeaccessionEvent, type: :model, events: true do
-    it_behaves_like "an event"
-    it_behaves_like "a preservation-related event"
-    its(:display_type) { is_expected.to eq "Deaccession" }
+    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
 
-    describe "permanent id" do
-      subject { described_class.new(pid: "test:1", permanent_id: "ark:/99999/fk4zzz") }
-      its(:permanent_id) { is_expected.to eq("ark:/99999/fk4zzz") }
+    RSpec.describe DeletionEvent, 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 "Deletion"
+      end
     end
   end
 end

data/spec/models/file_management_spec.rb

@@ -1,123 +1,23 @@
-RSpec.shared_examples "a repository external file" do
-  it "is owned by the effective user" do
-    expect(File.owned?(file_path)).to be true
-  end
-  it "is readable by the effective user" do
-    expect(File.readable?(file_path)).to be true
-  end
-  it "is writable by the effective user" do
-    expect(File.writable?(file_path)).to be true
-  end
-  it "does not have the sticky bit set" do
-    expect(File.sticky?(file_path)).to be false
-  end
-  it "has 644 mode" do
-    expect("%o" % File.world_readable?(file_path)).to eq "644"
-  end
-end
+require 'spec_helper'
 
-module Ddr::Models
-  RSpec.describe FileManagement, :type => :model do
+module Ddr
+  module Models
+    RSpec.describe FileManagement, :type => :model do
 
-    let(:object) { Component.new }
-    let(:image_file) { fixture_file_upload("imageA.tif", "image/tiff") }
-    let(:xml_file)   { fixture_file_upload("fits/image.xml", "text/xml") }
+      let(:object) { Component.new }
+      let(:file) { fixture_file_upload("imageA.tif", "image/tiff") }
 
-    describe "#add_file" do
-      it "runs a virus scan on the file" do
-        expect(object).to receive(:virus_scan)
-        object.add_file image_file, "content"
-      end
-      it "calls add_file_datastream by default" do
-        expect(object).to receive(:add_file_datastream)
-        object.add_file image_file, "random_ds_1"
-      end
-      it "calls add_file_datastream when dsid spec is managed" do
-        expect(object).to receive(:add_file_datastream)
-        object.add_file xml_file, "fits"
-      end
-      it "calls add_external_file when dsid spec is external" do
-        expect(object).to receive(:add_external_file)
-                           .with(image_file, "content", mime_type: "image/tiff")
-        object.add_file image_file, "content"
-      end
-      it "calls add_external_file when :external => true option passed" do
-        expect(object).to receive(:add_external_file)
-                           .with(image_file, "random_ds_2", mime_type: "image/tiff")
-        object.add_file image_file, "random_ds_2", external: true
-      end
-      context "original_filename" do
-        context "when dsid == 'content'" do
-          it "sets original_filename" do
-            expect { object.add_file image_file, "content" }
-              .to change(object, :original_filename).to("imageA.tif")
-            expect { object.add_file image_file, "content", original_filename: "foo.tif" }
-              .to change(object, :original_filename).to("foo.tif")
-          end
+      describe "#add_file" do
+        it "should run a virus scan on the file" do
+          expect(object).to receive(:virus_scan)
+          object.add_file file, path: "m_content"
         end
-        context "when dsid != 'content'" do
-          it "does not set original_filename" do
-            expect { object.add_file xml_file, "fits" }
-              .not_to change(object, :original_filename)
-            expect { object.add_file xml_file, "fits", original_filename: "foo" }
-              .not_to change(object, :original_filename)
-          end
+        it "should set the mimeType" do
+          object.add_file file, path: "m_content"
+          expect(object.m_content.mime_type).to eq('image/tiff')
         end
       end
-    end
 
-    describe "#add_external_file" do
-      it "calls add_external_datastream if no spec for dsid" do
-        expect(object).to receive(:add_external_datastream).with("random_ds_3").and_call_original
-        object.add_external_file(image_file, "random_ds_3")
-      end
-      it "raises an exception if datastream is not external" do
-        expect { object.add_external_file(xml_file, "fits") }.to raise_error(ArgumentError)
-      end
-      it "sets the mimeType" do
-        expect(object.content).to receive(:mimeType=).with("image/tiff")
-        object.add_external_file(image_file, "content", mime_type: "image/tiff")
-      end
-      it "sets dsLocation to URI for generated file path by default" do
-        object.add_external_file(image_file, "content")
-        expect(object.content.dsLocation).not_to eq URI.escape("file:#{image_file.path}")
-        expect(object.content.dsLocation).not_to be_nil
-        expect(File.exists?(object.content.file_path)).to be true
-      end
-      context "external file permissions" do
-        before { object.add_external_file(image_file, "content") }
-        it_should_behave_like "a repository external file" do
-          let(:file_path) {  object.content.file_path }
-        end
-      end
-    end
-
-    describe "#add_external_datastream" do
-      it "returns a new external datastream" do
-        ds = object.add_external_datastream("random_ds_27")
-        expect(ds.controlGroup).to eq "E"
-        expect(object.datastreams["random_ds_27"]).to eq ds
-        expect(object.random_ds_27).to eq ds
-      end
     end
-
-    describe "#external_datastream_file_paths" do
-      let(:file1) { fixture_file_upload("imageA.tif", "image/tiff") }
-      let(:file2) { fixture_file_upload("imageC.tif", "image/tiff") }
-      before do
-        object.add_file(file1, "content")
-        object.save
-        object.add_file(file2, "e_content_2", external: true)
-        object.save
-      end
-      it "returns a list of file paths for all versions of all external datastreams for the object" do
-        paths = object.external_datastream_file_paths
-        expect(paths.size).to eq 2
-        paths.each do |path|
-          expect(File.exists?(path)).to be true
-        end
-      end
-    end
-
   end
 end