ddr-models 1.7.0 → 1.8.0

data/lib/ddr/models/has_role_assignments.rb

@@ -1,17 +0,0 @@
-module Ddr
-  module Models
-    module HasRoleAssignments
-      extend ActiveSupport::Concern
-
-      included do
-        has_metadata name: "roleAssignments", 
-                     type: Ddr::Datastreams::RoleAssignmentsDatastream,
-                     versionable: true, 
-                     control_group: "M"
-
-        delegate :principal_has_role?, to: :roleAssignments
-      end
-
-    end
-  end
-end

data/lib/ddr/models/has_workflow.rb

@@ -1,29 +0,0 @@
-module Ddr
-  module Models
-    module HasWorkflow
-      extend ActiveSupport::Concern
-
-      PUBLISHED = Ddr::Workflow::WorkflowState::PUBLISHED
-      UNPUBLISHED = nil
-
-      def workflow_state
-        Ddr::Workflow::WorkflowState.workflow_state_for_object(self)
-      end
-
-      def published?
-        self.workflow_state == PUBLISHED
-      end
-      
-      def publish!
-        Ddr::Workflow::WorkflowState.set_for_object(self, PUBLISHED)
-        update_index
-      end
-      
-      def unpublish!
-        Ddr::Workflow::WorkflowState.set_for_object(self, UNPUBLISHED)
-        update_index
-      end
-
-    end
-  end
-end

data/lib/ddr/vocab/preservation.rb

@@ -1,14 +0,0 @@
-module Ddr
-  module Vocab
-    class Preservation < RDF::StrictVocabulary("http://repository.lib.duke.edu/vocab/preservation/")
-
-      property "permanentId", 
-      label: "Permanent Identifier",
-      subPropertyOf: RDF::DC.identifier
-      
-      property "permanentUrl",
-      label: "Permanent URL"
-                                  
-    end
-  end
-end

data/lib/ddr/workflow.rb

@@ -1,8 +0,0 @@
-module Ddr
-  module Workflow
-    extend ActiveSupport::Autoload
-    
-    autoload :WorkflowState
-    
-  end
-end

data/lib/ddr/workflow/workflow_state.rb

@@ -1,39 +0,0 @@
-module Ddr
-  module Workflow
-    class WorkflowState < ActiveRecord::Base
-
-      PUBLISHED = "published"
-      
-      def self.workflow_state_for_object(obj)
-        workflow_state_for_pid(obj.pid)
-      end
-
-      def self.workflow_state_for_pid(pid)
-        for_pid(pid).present? ? for_pid(pid).first.workflow_state : nil
-      end
-
-      def self.set_for_object(obj, state)
-        set_for_pid(obj.pid, state)
-      end
-
-      def self.set_for_pid(pid, state)
-        if for_pid(pid).present?
-          for_pid(pid).first.update(workflow_state: state)
-        else
-          create(pid: pid, workflow_state: state)
-        end
-      end
-
-      private
-
-      def self.for_object(obj)
-        for_pid(obj.pid)
-      end
-
-      def self.for_pid(pid)
-        where(pid: pid)
-      end
-      
-    end
-  end
-end

data/spec/models/has_preservation_metadata_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-module Ddr
-  module Models
-    RSpec.describe HasPreservationMetadata, type: :model do
-
-      before(:all) do
-        class PermanentlyIdentifiable < ActiveFedora::Base
-          include Ddr::Models::Describable
-          include Ddr::Models::Indexing
-          include Ddr::Models::HasWorkflow
-          include Ddr::Models::HasPreservationMetadata
-          include Ddr::Models::EventLoggable
-        end
-      end
-
-      subject { PermanentlyIdentifiable.new }
-
-      describe "permanent_id" do
-        describe "when a permanent id has not been assigned" do
-          it "should be nil" do
-            expect(subject.permanent_id).to be_nil
-          end
-        end
-      end
-
-      describe "object lifecycle" do
-        context "when created" do
-          context "and auto-assignment is enabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }
-            it "should assign a permanent id" do
-              expect_any_instance_of(PermanentlyIdentifiable).to receive(:assign_permanent_id!) { nil }
-              PermanentlyIdentifiable.create
-            end
-          end
-          context "and auto-assignment is disabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false } }
-            it "should not assign a permanent id" do
-              expect_any_instance_of(PermanentlyIdentifiable).not_to receive(:assign_permanent_id!)
-              PermanentlyIdentifiable.create
-            end
-          end
-        end        
-        context "when saved" do
-          context "and auto-assignment is enabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }
-            it "should assign a permanent id once" do
-              expect(subject).to receive(:assign_permanent_id!).once { nil }
-              subject.save
-              subject.title = ["New Title"]
-              subject.save
-            end
-          end
-          context "and auto-assignment is disabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false } }
-            it "should not assign a permanent id" do
-              expect(subject).not_to receive(:assign_permanent_id!)
-              subject.save
-            end
-          end
-        end
-      end
-
-      describe "#assign_permanent_id!" do
-        it "should assign the permanent id later" do
-          expect(subject.permanent_id_manager).to receive(:assign_later) { nil }
-          subject.assign_permanent_id!
-        end
-      end
-
-      describe "events" do
-        before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }  
-        context "when the operation succeeds" do
-          let(:stub_identifier) { double(id: "ark:/99999/fk4zzz", metadata: "_target: http://example.com") }
-          before { allow_any_instance_of(Ddr::Managers::PermanentIdManager).to receive(:mint) { stub_identifier } }
-          it "should create a success event" do
-            expect { subject.save }.to change { subject.update_events.count }.by(1)
-          end
-        end
-        context "when there's an exception" do
-          before { allow(Ezid::Identifier).to receive(:create).and_raise(Ezid::Error) }
-          it "should create a failure event" do
-            begin
-              subject.save
-            rescue Ezid::Error
-            end
-            expect(subject.update_events.last).to be_failure
-          end
-        end
-      end
-
-      describe "indexing" do
-        let(:permanent_id) { "ark:/99999/fk4zzz" }
-        let(:permanent_url) { "http://id.library.duke.edu/ark:/99999/fk4zzz" }
-        before do
-          subject.permanent_id = permanent_id
-          subject.permanent_url = permanent_url
-        end
-        it "should index the permanent id value" do
-          expect(subject.to_solr[Ddr::IndexFields::PERMANENT_ID]).to eq(permanent_id)
-        end
-        it "should index the permanent url" do
-          expect(subject.to_solr[Ddr::IndexFields::PERMANENT_URL]).to eq(permanent_url)
-        end
-      end
-    
-    end
-  end
-end

data/spec/models/has_role_assignments_spec.rb

@@ -1,29 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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/role_assignments_datastream_spec.rb

@@ -1,25 +0,0 @@
-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