ddr-models 1.2.0

data/spec/models/file_management_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+RSpec.shared_examples "a repository external file" do
+  it "should be owned by the effective user" do
+    expect(File.owned?(file_path)).to be true
+  end
+  it "should be readable by the effective user" do
+    expect(File.readable?(file_path)).to be true
+  end
+  it "should be writable by the effective user" do
+    expect(File.writable?(file_path)).to be true
+  end
+  it "should not have the sticky bit set" do
+    expect(File.sticky?(file_path)).to be false
+  end
+  it "should have 644 mode" do
+    expect("%o" % File.world_readable?(file_path)).to eq "644"
+  end
+end
+
+module Ddr
+  module Models
+    RSpec.describe FileManagement, :type => :model do
+
+      let(:object) { FileManageable.new }
+      let(:file) { fixture_file_upload("library-devil.tiff", "image/tiff") }
+
+      before(:all) do
+        class FileManageable < ActiveFedora::Base
+          include Ddr::Models::FileManagement
+          has_file_datastream name: "e_content", control_group: "E"
+          has_file_datastream name: "m_content", control_group: "M"
+        end
+      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, "m_content"
+        end
+        it "should call add_file_datastream by default" do
+          expect(object).to receive(:add_file_datastream)
+          object.add_file file, "random_ds_1"
+        end
+        it "should call add_file_datastream when dsid spec is managed" do
+          expect(object).to receive(:add_file_datastream)
+          object.add_file file, "m_content"
+        end
+        it "should call add_external_file when dsid spec is external" do
+          expect(object).to receive(:add_external_file).with(file, "e_content", {mime_type: file.content_type})
+          object.add_file file, "e_content"
+        end
+        it "should call add_external_file when :external => true option passed" do
+          expect(object).to receive(:add_external_file).with(file, "random_ds_2", {mime_type: file.content_type})
+          object.add_file file, "random_ds_2", external: true
+        end
+      end
+
+      describe "#add_external_file" do
+        it "should call 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(file, "random_ds_3")
+        end
+        it "should raise an error if datastream is not external" do
+          expect { object.add_external_file(file, "m_content") }.to raise_error 
+        end
+        it "should raise an error if dsLocation has changed" do
+          allow(object.e_content).to receive(:dsLocation_changed?) { true }
+          expect { object.add_external_file(file, "e_content") }.to raise_error
+        end
+        it "should set the mimeType" do
+          expect(object.e_content).to receive(:mimeType=).with("image/tiff")
+          object.add_external_file(file, "e_content")
+        end
+        context "storage path generation" do
+          it "should generate a UUID for the for the file name" do
+            expect(SecureRandom).to receive(:uuid).and_call_original
+            object.add_external_file(file, "e_content")
+          end
+          it "should set the file name to the UUID" do
+            uuid = "dfa9fd19-3ec6-4d59-ac34-f7a796902397"
+            allow(object).to receive(:generate_external_file_name) { uuid }          
+            object.add_external_file(file, "e_content")
+            expect(object.e_content.file_name).to eq uuid
+          end
+          it "should prepend the configured external file store base directory" do
+            object.add_external_file(file, "e_content")
+            expect(object.e_content.file_path.start_with?(Ddr::Models.external_file_store)).to be true
+          end
+          it "should add a subpath using the configured pattern" do
+            uuid = "dfa9fd19-3ec6-4d59-ac34-f7a796902397"
+            allow(object).to receive(:generate_external_file_name) { uuid }
+            object.add_external_file(file, "e_content")
+            path = object.e_content.file_path
+            subpath = File.dirname(path.sub(Ddr::Models.external_file_store, "").sub("/", ""))
+            expect(Ddr::Models.external_file_subpath_regexp.match(uuid)[0]).to eq subpath
+          end
+        end
+        it "should set dsLocation to URI for generated file path by default" do
+          object.add_external_file(file, "e_content")
+          expect(object.e_content.dsLocation).not_to eq URI.escape("file:#{file.path}")
+          expect(object.e_content.dsLocation).not_to be_nil
+          expect(File.exists?(object.e_content.file_path)).to be true
+        end
+        it "should set dsLocation to URI for original file path if :use_original => true option" do
+          expect(object.e_content).to receive(:dsLocation=).with(URI.escape("file:#{file.path}"))
+          object.add_external_file(file, "e_content", use_original: true)
+        end
+        it "should raise an error if using original file not owned by effective user" do
+          allow(File).to receive(:owned?).with(file.path) { false }
+          expect { object.add_external_file(file, "e_content", use_original: true) }.to raise_error
+        end
+        context "external file permissions" do
+          context "for a generated file" do
+            before { object.add_external_file(file, "e_content") }
+            it_should_behave_like "a repository external file" do
+              let(:file_path) {  object.e_content.file_path }
+            end
+          end
+          context "for an original file" do
+            before { object.add_external_file(file, "e_content", use_original: true) }
+            it_should_behave_like "a repository external file" do
+              let(:file_path) {  object.e_content.file_path }
+            end
+          end
+        end
+      end
+
+      describe "#add_external_datastream" do
+        it "should return 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("image1.tiff", "image/tiff") }
+        let(:file2) { fixture_file_upload("image2.tiff", "image/tiff") }
+        let(:file3) { fixture_file_upload("image3.tiff", "image/tiff") }
+        before do
+          object.add_file(file1, "e_content")
+          object.save
+          object.add_file(file2, "e_content")
+          object.save
+          object.add_file(file3, "e_content_2", external: true)
+          object.save
+        end      
+        it "should return 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 3
+          paths.each do |path|
+            expect(File.exists?(path)).to be true
+          end
+        end
+      end
+
+      describe "cleanup on destroy" do
+        let(:file1) { fixture_file_upload("image1.tiff", "image/tiff") }
+        let(:file2) { fixture_file_upload("image2.tiff", "image/tiff") }
+        let(:file3) { fixture_file_upload("image3.tiff", "image/tiff") }
+        before do
+          object.add_file(file1, "e_content")
+          object.save
+          object.add_file(file2, "e_content")
+          object.save
+          object.add_file(file3, "e_content_2", external: true)
+          object.save
+        end      
+        it "should delete all files for all versions of all external datastreams" do
+          expect(File).to receive(:unlink).with(*object.external_datastream_file_paths)
+          object.destroy
+        end
+      end
+
+    end
+  end
+end

data/spec/models/has_role_assignments_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Ddr
+  module Models
+    RSpec.describe HasRoleAssignments, type: :model do
+    
+      before(:all) do
+        class RoleAssignable < ActiveFedora::Base
+          include HasRoleAssignments
+        end
+      end
+
+      subject { RoleAssignable.new }
+
+      describe "#principal_has_role?" do
+        it "should respond when given a list of principals and a valid role" do
+          expect { subject.principal_has_role?(["bob", "admins"], :administrator) }.not_to raise_error
+        end
+        it "should respond when given a principal name and a valid role" do
+          expect { subject.principal_has_role?("bob", :administrator) }.not_to raise_error
+        end
+        it "should raise an error when given an invalid role" do
+          expect { subject.principal_has_role?("bob", :foo) }.to raise_error
+        end
+      end
+
+    end
+  end
+end

data/spec/models/has_workflow_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Ddr
+  module Models
+    RSpec.describe HasWorkflow, type: :model do
+
+      before(:all) do
+        class Workflowable < ActiveFedora::Base
+          include HasWorkflow
+        end
+      end
+
+      subject { Workflowable.new(pid: 'test:1') }
+
+      describe "#published?" do
+        context "object is published" do
+          before { Ddr::Workflow::WorkflowState.create(pid: subject.pid, workflow_state: Ddr::Workflow::WorkflowState::PUBLISHED) }
+          it "should return true" do
+            expect(subject.published?).to eql(true)
+          end
+        end
+        context "object is not published" do
+          context "has never been published" do
+            it "should return false" do
+              expect(subject.published?).to eql(false)
+            end
+          end
+          context "has been published and unpublished" do
+            before { Ddr::Workflow::WorkflowState.create(pid: subject.pid, workflow_state: nil) }
+            it "should return false" do
+              expect(subject.published?).to eql(false)
+            end
+          end
+        end
+      end
+
+      describe "#publish!" do
+        it "should publish the object" do
+          subject.publish!
+          expect(subject.published?).to eql(true)
+        end
+      end
+
+      describe "#unpublish!" do
+        before { subject.publish! }
+        it "should unpublish the object" do
+          subject.unpublish!
+          expect(subject.published?).to eql(false)
+        end
+      end
+
+    end
+  end
+end

data/spec/models/item_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe Item, :type => :model do
+  it_behaves_like "a DDR model"
+  it_behaves_like "an object that has content metadata"
+  it_behaves_like "it has an association", :belongs_to, :parent, :is_member_of_collection, "Collection"
+  it_behaves_like "it has an association", :has_many, :children, :is_part_of, "Component"
+end

data/spec/models/permanent_identification_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Ddr
+  module Models
+
+    RSpec.shared_examples "a permanently identified object" do
+      it "should have a permanent id" do
+        expect(object.permanent_id).to_not be_nil
+      end
+      it "should have an appropriate update event" do
+        expect(object.update_events.map(&:summary)).to include("Assigned permanent ID")
+      end
+      it "should be a referent for the permanent id" do
+        expect(Ddr::Models::MintedId.find_by(minted_id: object.permanent_id).referent).to eql(object.pid)
+      end
+      it "should have a permlink" do
+        expect(object.permalink).to eql(Ddr::Models::PermanentIdentification::PERMALINK_BASE_URL + object.permanent_id)
+      end
+    end
+
+    RSpec.describe PermanentIdentification, type: :model do
+
+      before(:all) do
+        class PermanentlyIdentifiable < ActiveFedora::Base
+          include Ddr::Models::Describable
+          include Ddr::Models::HasProperties
+          include Ddr::Models::PermanentIdentification
+          include Ddr::Models::EventLoggable
+        end
+      end
+
+      context "creating new object" do
+        let(:object) { PermanentlyIdentifiable.create }
+        it_behaves_like "a permanently identified object"
+      end
+    
+      context "saving new object" do
+        let(:object) { PermanentlyIdentifiable.new }
+        before { object.save }
+        it_behaves_like "a permanently identified object"
+      end
+    
+      context "saving an existing object" do
+        let(:object) { PermanentlyIdentifiable.create }
+        it "should keep its existing permanent id" do
+          perm_id = object.permanent_id
+          object.title = [ "New Title" ]
+          object.save
+          expect(object.permanent_id).to eq(perm_id)
+        end
+      end
+    
+      context "exception during permanent id minting" do
+        let(:object) { PermanentlyIdentifiable.create }
+        before { allow(Ddr::Services::IdService).to receive(:mint).and_raise(Exception) }
+        it "should have a failure update event" do
+          expect(object.update_events.last.summary).to eq("Assigned permanent ID")
+          expect(object.update_events.last.outcome).to eq(Ddr::Events::Event::FAILURE)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/models/role_assignments_datastream_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Ddr
+  module Datastreams
+    RSpec.describe RoleAssignmentsDatastream do
+
+      subject { described_class.new(nil) }
+
+      describe "#principal_has_role?" do
+        before do
+          subject.administrator = ["bob", "sally"]
+        end
+        it "should accept a single principal" do
+          expect(subject.principal_has_role?("sally", :administrator)).to be true
+          expect(subject.principal_has_role?("fred", :administrator)).to be false
+        end
+        it "should accept a list of principals and return if at least one of the principals has the role" do
+          expect(subject.principal_has_role?(["sally", "fred"], :administrator)).to be true
+          expect(subject.principal_has_role?(["wendy", "fred"], :administrator)).to be false
+        end
+      end
+
+    end
+  end
+end

data/spec/models/superuser_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'cancan/matchers'
+
+module Ddr
+  module Auth
+    RSpec.describe Superuser, type: :model, abilities: true do
+      subject { described_class.new }
+      it "should be able to manage all" do
+        expect(subject).to be_able_to(:manage, :all)
+      end
+    end
+  end
+end

data/spec/models/superuser_spec.rb~

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'cancan/matchers'
+
+module Ddr
+  module Auth
+    describe Superuser, type: :model, abilities: true do
+      subject { described_class.new }
+      it "should be able to manage all" do
+        expect(subject).to be_able_to(:manage, :all)
+      end
+    end
+  end
+end

data/spec/models/target_spec.rb

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

data/spec/models/user_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Ddr
+  module Auth
+    RSpec.describe User, :type => :model do
+
+      subject { FactoryGirl.build(:user) }
+
+      describe "#member_of?" do
+        it "should return true if the user is a member of the group" do
+          allow(subject).to receive(:groups).and_return(["foo", "bar"])
+          expect(subject).to be_member_of("foo")
+        end
+        it "should return false if the user is not a member of the group" do
+          allow(subject).to receive(:groups).and_return(["foo", "bar"])
+          expect(subject).not_to be_member_of("baz")
+        end
+      end
+
+      describe "#authorized_to_act_as_superuser?" do
+        it "should return false if the superuser group is not defined (nil)" do
+          Ddr::Auth.superuser_group = nil
+          expect(subject).not_to be_authorized_to_act_as_superuser
+        end
+        it "should return false if the user is not a member of the superuser group" do
+          Ddr::Auth.superuser_group = "superusers"
+          allow(subject).to receive(:groups).and_return(["normal"])
+          expect(subject).not_to be_authorized_to_act_as_superuser
+        end
+        it "should return true if the user is a member of the superuser group" do
+          Ddr::Auth.superuser_group = "superusers"
+          allow(subject).to receive(:groups).and_return(["superusers"])
+          expect(subject).to be_authorized_to_act_as_superuser
+        end
+      end
+
+      describe "#principal_name" do
+        it "should return the principal name for the user" do
+          expect(subject.principal_name).to eq subject.user_key
+        end
+      end
+
+      describe "#principals" do
+        it "should be a list of the user's groups + the user's principal_name" do
+          allow(subject).to receive(:groups) { ["foo", "bar"] }
+          expect(subject.principals).to match_array ["foo", "bar", subject.principal_name]
+        end
+      end
+
+      describe "#has_role?" do
+        let(:obj) { double }
+        it "should send :principal_has_role? to the object with the user's principals" do
+          expect(obj).to receive(:principal_has_role?).with(subject.principals, :administrator)
+          subject.has_role?(obj, :administrator)
+        end
+      end
+
+    end
+  end
+end