ddr-models 1.2.0

data/spec/support/shared_examples_for_event_loggables.rb

@@ -0,0 +1,3 @@
+shared_examples "an event loggable object" do
+
+end

data/spec/support/shared_examples_for_events.rb

@@ -0,0 +1,179 @@
+def mock_object(opts={})
+  double("object", {create_date: "2014-01-01T01:01:01.000Z", modified_date: "2014-06-01T01:01:01.000Z"}.merge(opts))
+end
+
+RSpec.shared_examples "a preservation-related event" do
+  subject { described_class.new }
+  it "should have an event_type" do
+    expect(subject.preservation_event_type).not_to be_nil
+  end
+  it "should have a PREMIS representation" do
+    expect(subject).to respond_to :as_premis
+    expect(subject).to respond_to :to_xml
+  end
+end
+
+RSpec.shared_examples "an event that reindexes its object after save" do
+  it "should implement the reindexing concern" do
+    expect(subject).to be_a Ddr::Events::ReindexObjectAfterSave
+  end
+  context "when object is present" do
+    let(:object) { mock_object }
+    before do
+      allow(subject).to receive(:object) { object }
+    end
+    it "should reindex its object after save" do
+      expect(object).to receive(:update_index)
+      subject.save(validate: false)
+    end
+  end
+end
+
+RSpec.shared_examples "an event" do
+  describe "validation" do
+    context "of pid" do
+      it "should require presence" do
+        expect(subject).not_to be_valid
+        expect(subject.errors[:pid]).to include "can't be blank"
+      end
+      context "when the object exists" do
+        before { subject.pid = ActiveFedora::Base.create.pid }
+        it "should be valid" do
+          expect(subject).to be_valid
+        end
+      end
+      context "when the object doesn't exist" do
+        before { subject.pid = "test:123" }
+        it "should not be valid" do
+          expect(subject).not_to be_valid
+          expect(subject.errors).to have_key :pid
+        end
+      end
+    end
+    it "should require an event_date_time" do
+      subject.event_date_time = nil # reset b/c set to default after init
+      expect(subject).not_to be_valid
+      expect(subject.errors[:event_date_time]).to include "can't be blank"
+    end
+    it "should require a valid outcome" do
+      subject.outcome = Ddr::Events::Event::SUCCESS
+      subject.valid?
+      expect(subject.errors).not_to have_key :outcome
+      subject.outcome = Ddr::Events::Event::FAILURE
+      subject.valid?
+      expect(subject.errors).not_to have_key :outcome
+      subject.outcome = "Some other value"
+      expect(subject).not_to be_valid
+      expect(subject.errors[:outcome]).to include "\"Some other value\" is not a valid event outcome"
+    end
+  end
+
+  describe "outcome setters and getters" do
+    it "should encapsulate access" do
+      subject.success!
+      expect(subject.outcome).to eq Ddr::Events::Event::SUCCESS
+      expect(subject).to be_success
+      subject.failure!
+      expect(subject.outcome).to eq Ddr::Events::Event::FAILURE
+      expect(subject).to be_failure
+    end
+  end
+
+  describe "setting defaults" do
+    context "after initialization" do
+      it "should set outcome to 'success'" do
+        expect(subject.outcome).to eq Ddr::Events::Event::SUCCESS
+      end
+      it "should set event_date_time" do
+        expect(subject.event_date_time).to be_present
+      end
+      it "should set software" do
+        expect(subject.software).to be_present
+        expect(subject.software).to eq subject.send(:default_software)
+      end
+      it "should set summary" do
+        expect(subject.summary).to eq subject.send(:default_summary)
+      end
+    end
+    context "when attributes are set" do
+      let(:obj) { ActiveFedora::Base.create }
+      let(:event) { described_class.new(pid: obj.pid, outcome: Ddr::Events::Event::FAILURE, event_date_time: Time.utc(2013), software: "Test", summary: "A terrible disaster") }
+      it "should not overwrite attributes" do
+        expect { event.send(:set_defaults) }.not_to change { event.outcome }
+        expect { event.send(:set_defaults) }.not_to change { event.event_date_time }
+        expect { event.send(:set_defaults) }.not_to change { event.software }
+        expect { event.send(:set_defaults) }.not_to change { event.summary }
+      end
+    end
+  end
+
+  describe "object getter" do
+    subject { described_class.new(pid: "test:123") }
+    let(:object) { mock_object }
+    before { allow(ActiveFedora::Base).to receive(:find).with("test:123") { object } }
+    it "should retrieve the object" do
+      expect(subject.object).to eq object
+    end
+    it "should cache the object" do
+      expect(ActiveFedora::Base).to receive(:find).with("test:123").once
+      subject.object
+      subject.object
+    end
+  end
+
+  describe "object setter" do
+    let(:object) { mock_object(pid: "test:123") }
+    it "should set the event pid and object" do
+      allow(object).to receive(:new_record?) { false }
+      subject.object = object
+      expect(subject.pid).to eq "test:123"
+      expect(subject.object).to eq object
+    end
+    it "should raise an ArgumentError if object is a new record" do
+      allow(object).to receive(:new_record?) { true }
+      expect { subject.object = object }.to raise_error ArgumentError
+    end
+  end
+
+  describe "object existence" do
+    it "should be false if pid is nil" do
+      expect(subject.object_exists?).to be_falsey
+    end
+    it "should be false if pid not found in repository" do
+      subject.pid = "test:123"
+      expect(subject.object_exists?).to be_falsey
+    end
+    it "should be true if object exists in repository" do
+      allow(ActiveFedora::Base).to receive(:find).with("test:123") { mock_object }
+      subject.pid = "test:123"
+      expect(subject.object_exists?).to be_truthy
+    end
+    it "should be true if object instance variable is set" do
+      obj = mock_object(pid: "test:123")
+      allow(obj).to receive(:new_record?) { false }
+      subject.object = obj
+      expect(subject.object_exists?).to be_truthy
+    end
+  end
+
+  describe "event_date_time string representation" do
+    subject { described_class.new(event_date_time: Time.utc(2014, 6, 4, 11, 7, 35)) }
+    it "should conform to the specified format" do
+      expect(subject.event_date_time_s).to eq "2014-06-04T11:07:35.000Z"
+    end
+  end
+
+  describe "rendering who/what performed the action" do
+    context "when performed by a user" do
+      before { subject.user = User.new(username: "bob") }
+      it "should render the user" do
+        expect(subject.performed_by).to eq "bob"
+      end
+    end
+    context "when not performed by a user" do
+      it "should render 'SYSTEM'" do
+        expect(subject.performed_by).to eq "SYSTEM"
+      end
+    end
+  end
+end

data/spec/support/shared_examples_for_governables.rb

@@ -0,0 +1,17 @@
+RSpec.shared_examples "a governable object" do
+  let(:object) do
+    described_class.new.tap do |obj|
+      obj.title = [ 'Describable' ]
+      obj.identifier = [ 'id001' ]
+      obj.save(validate: false)
+    end
+  end
+  describe "can have an admin policy" do
+    let(:coll) { FactoryGirl.create(:collection) }
+    it "should set its admin policy with #admin_policy= and get with #admin_policy" do
+      object.admin_policy = coll
+      object.save(validate: false)
+      expect(ActiveFedora::Base.find(object.pid, cast: true).admin_policy).to eq(coll)
+    end
+  end
+end

data/spec/support/shared_examples_for_has_content.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'openssl'
+
+RSpec.shared_examples "an object that can have content" do
+
+  let(:object) { described_class.new(title: [ "I Have Content!" ]) }
+
+  it "should delegate :validate_checksum! to :content" do
+    checksum = "dea56f15b309e47b74fa24797f85245dda0ca3d274644a96804438bbd659555a"
+    expect(object.content).to receive(:validate_checksum!).with(checksum, "SHA-256")
+    object.validate_checksum!(checksum, "SHA-256")
+  end
+
+  describe "indexing" do
+    let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+    before { object.upload file }
+    it "should index the content ds control group" do
+      expect(object.to_solr).to include(Ddr::IndexFields::CONTENT_CONTROL_GROUP)
+    end
+  end
+
+  describe "adding a file" do
+    let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+    context "defaults" do
+      before { object.add_file file, "content" }
+      it "should have an original_filename" do
+        expect(object.original_filename).to eq("library-devil.tiff")
+      end
+      it "should have a content_type" do
+        expect(object.content_type).to eq("image/tiff")
+      end
+      it "should create a 'virus check' event for the object" do
+        expect { object.save }.to change { object.virus_checks.count }.by(1)
+      end
+    end
+    context "with option `:original_name=>false`" do
+      before { object.add_file file, "content", original_name: false }
+      it "should not have an original_filename" do
+        expect(object.original_filename).to be_nil
+      end
+    end
+    context "with `:original_name` option set to a string" do
+      before { object.add_file file, "content", original_name: "another-name.tiff" }
+      it "should have an original_filename" do
+        expect(object.original_filename).to eq("another-name.tiff")
+      end
+    end
+  end
+
+  describe "save" do
+
+    describe "when content is not present" do
+      it "should not save" do
+        expect(object.save).to be false
+        expect(object.errors[:content]).to include "can't be blank"
+      end
+    end
+
+    describe "when new content is present" do
+
+      context "and it's a new object" do
+        before { object.add_file file, "content" }
+
+        context "and the content is an image" do
+          let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+          it "should generate a thumbnail" do
+            expect(object.thumbnail).not_to be_present
+            object.save
+            expect(object.thumbnail).to be_present
+          end
+        end
+        context "and the content is a pdf" do
+          let(:file) { fixture_file_upload("sample.pdf", "application/pdf") }
+          it "should generate a thumbnail" do
+            expect(object.thumbnail).not_to be_present
+            object.save
+            expect(object.thumbnail).to be_present
+          end
+        end
+        context "and the content is neither an image nor a pdf" do
+          let(:file) { fixture_file_upload("sample.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document") }
+          it "should not generate a thumbnail" do
+            expect(object.thumbnail).not_to be_present
+            object.save
+            expect(object.thumbnail).not_to be_present
+          end
+        end
+      end
+
+      context "and it's an existing object with content" do
+        before { object.upload! fixture_file_upload('library-devil.tiff', 'image/tiff') }
+
+        context "and the content is an image" do
+          let(:file) { fixture_file_upload("image1.tiff", "image/tiff") }
+          it "should generate a new thumbnail" do
+            expect(object.thumbnail).to be_present
+            expect { object.upload! file }.to change { object.thumbnail.content }
+          end
+        end
+        context "and the content is a pdf" do
+          let(:file) { fixture_file_upload("sample.pdf", "application/pdf") }
+          it "should generate a new thumbnail" do
+            expect(object.thumbnail).to be_present
+            expect { object.upload! file }.to change { object.thumbnail.content }
+          end
+        end
+        context "and the content is neither an image nor a pdf" do
+          let(:file) { fixture_file_upload("sample.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document") }
+          it "should delete the thumbnail" do
+            expect(object.thumbnail).to be_present
+            object.upload! file
+            expect(object.thumbnail).to_not be_present
+          end
+        end
+      end
+    end
+  end
+
+  describe "#upload" do
+    let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+    it "should add the file to the content datastream" do
+      expect(object).to receive(:add_file).with(file, "content", {})
+      object.upload(file)
+    end
+  end
+
+  describe "#upload!" do 
+    let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+    it "should add the file to the content datastream and save the object" do
+      expect(object).to receive(:add_file).with(file, "content", {}).and_call_original
+      expect(object).to receive(:save)
+      object.upload!(file)
+    end
+  end
+
+end

data/spec/support/shared_examples_for_has_content_metadata.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.shared_examples "an object that has content metadata" do
+  let!(:object) { described_class.create! }
+  let(:file_path) { File.join(File.dirname(__FILE__), '..', 'fixtures', 'contentMetadata.xml') }
+  before do
+    object.contentMetadata.content = File.new(file_path, "r")
+    object.save!
+  end
+  context "contentMetadata datastream" do
+    let(:expected_result) do
+      [
+        {
+          "div" => [
+            {
+              "type" => "image",
+              "label" => "Images",
+              "div" => [
+                {
+                  "pids" => [
+                    {
+                      "pid" => "test:1",
+                      "use" => "Master Image"
+                    }
+                  ]
+                },
+                {
+                  "pids" => [
+                    {
+                      "pid" => "test:2",
+                      "use" => "Master Image"
+                    }
+                  ]
+                },
+                {
+                  "pids" => [
+                    {
+                      "pid" => "test:3",
+                      "use" => "Master Image"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type" => "pdf",
+              "label" => "PDF",
+              "pids" => [
+                {
+                  "pid" => "test:4",
+                  "use" => "Composite PDF"
+                }
+              ]
+            }
+            
+          ]
+        }
+      ]
+    end
+    context "#parse" do
+      it "should produce the appropriate result" do
+        result = object.contentMetadata.parse
+        expect(result).to eq(expected_result)
+      end
+    end
+    context "#to_solr" do
+      let(:solr_result) { ActiveFedora::SolrService.query("id:#{object.pid.gsub(':', '\\:')}").first }
+      it "should add the parsed contentMetadata to the index" do
+        expect(JSON.parse(solr_result[ActiveFedora::SolrService.solr_name(:content_metadata_parsed, :symbol)].first)).to eq(expected_result)
+      end
+    end
+  end
+end

data/spec/support/shared_examples_for_has_properties.rb

@@ -0,0 +1,5 @@
+RSpec.shared_examples "an object that has properties" do
+  it "should have a properties datastream" do
+    expect(subject.datastreams.keys).to include(Ddr::Datastreams::PROPERTIES)
+  end
+end

data/spec/support/shared_examples_for_indexing.rb

@@ -0,0 +1,36 @@
+RSpec.shared_examples "an object that has a display title" do
+  describe "#title_display" do
+    let(:object) { described_class.new }
+    subject { object.title_display }
+    context "has title" do
+      before { object.title = [ 'Title' ] }
+      it "should return the first title" do
+        expect(subject).to eq('Title')
+      end
+    end
+    context "has no title, has identifier" do
+      before { object.identifier = [ 'id001' ] }
+      it "should return the first identifier" do
+        expect(subject).to eq('id001')
+      end
+    end
+    # Only objects with content implement :original_filename
+    # This test worked before b/c allowing rspec to stub methods
+    # that aren't defined on object. This rspec-mocks config setting prevents that:
+    #
+    #   verify_partial_doubles = true
+    #
+    # context "has no title, no identifier, has original_filename" do
+    #   before { allow(object).to receive(:original_filename) { "file.txt" } }
+    #   it "should return original_filename" do
+    #     expect(subject).to eq "file.txt"
+    #   end
+    # end
+    context "has no title, no identifier, no original_filename" do
+      let(:object) { described_class.new(:pid => 'duke:test') }
+      it "should return the PID in square brackets" do
+        expect(subject).to eq "[duke:test]"
+      end
+    end
+  end
+end