ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/language_spec.rb

@@ -1,59 +0,0 @@
-module Ddr::Models
-  RSpec.describe Language, ddr_aux: true do
-
-    describe ".call" do
-      let(:obj) { Item.new }
-
-      describe "when the object has a language" do
-        before { obj.language = ["cym"] }
-        let(:language) {
-          described_class.new("id"=>1, "code"=>"cym", "title"=>"Welsh", "created_at"=>"2015-09-15T16:15:58.514Z", "updated_at"=>"2015-09-15T16:15:58.514Z")
-        }
-        describe "and the language code is found" do
-          before {
-            allow(described_class).to receive(:find_by_code).with("cym") { language }
-          }
-          it "returns a Language instance" do
-            expect(described_class.call(obj)).to eq([language])
-          end
-        end
-        describe "and the language is not found" do
-          before {
-            allow(described_class).to receive(:find_by_code).with("cym")
-                                       .and_raise(ActiveResource::ResourceNotFound, "404")
-          }
-          it "raises an exception" do
-            expect { described_class.call(obj) }.to raise_error(Ddr::Models::NotFoundError)
-          end
-        end
-      end
-
-      describe "when the object does not have language" do
-        it "returns empty array" do
-          expect(described_class).not_to receive(:find_by_code)
-          expect(described_class.call(obj)).to eq([])
-        end
-      end
-    end
-
-
-    describe ".codes" do
-      let(:entries) { [ described_class.new(id: 1, code: 'cym', label: 'Welsh'),
-                        described_class.new(id: 2, code: 'fre', label: 'French') ] }
-      let(:response_collection) { ActiveResource::Collection.new }
-      before do
-        response_collection.elements = entries
-        allow(described_class).to receive(:all) { response_collection }
-      end
-      it "returns the defined codes" do
-        expect(described_class.codes).to match_array([ entries[0].code, entries[1].code ])
-      end
-    end
-
-    describe "instance methods" do
-      subject { described_class.new("id"=>1, "code"=>"cym", "label"=>"Welsh") }
-      its(:to_s) { is_expected.to eq("Welsh") }
-    end
-
-  end
-end

data/spec/models/media_type_spec.rb

@@ -1,46 +0,0 @@
-module Ddr::Models
-  RSpec.describe MediaType do
-
-    subject { described_class.call(file) }
-
-    describe "when a preferred media type is available" do
-      describe "with a file path" do
-        let(:file) { 'foo.mp4' }
-        it { is_expected.to eq 'video/mp4' }
-      end
-      describe "with an object that responds to :path" do
-        let(:file) { double(path: 'foo.mp4') }
-        it { is_expected.to eq 'video/mp4' }
-      end
-    end
-    describe "when a preferred media type is not available" do
-      describe "and the file responds to :content_type" do
-        let(:file) { double(path: 'foo.jpg', content_type: 'foo/bar') }
-        it { is_expected.to eq 'foo/bar' }
-      end
-      describe "and the file does not respond to :content_type" do
-        describe "and MIME types are present" do
-          describe "with an object that responds to :path" do
-            let(:file) { double(path: 'foo.jpg') }
-            it { is_expected.to eq 'image/jpeg' }
-          end
-          describe "with a file path" do
-            let(:file) { 'foo.jpg' }
-            it { is_expected.to eq 'image/jpeg' }
-          end
-        end
-        describe "and MIME types are not present" do
-          describe "with an object that responds to :path" do
-            let(:file) { double(path: 'foo.bar') }
-            it { is_expected.to eq 'application/octet-stream' }
-          end
-          describe "with a file path" do
-            let(:file) { 'foo.bar' }
-            it { is_expected.to eq 'application/octet-stream' }
-          end
-        end
-      end
-    end
-
-  end
-end

data/spec/models/permanent_id_spec.rb

@@ -1,432 +0,0 @@
-module Ddr::Models
-  RSpec.describe PermanentId do
-
-    describe "auto assigment" do
-      let(:obj) { FactoryGirl.create(:item) }
-      describe "when enabled" do
-        let!(:id) { described_class.identifier_class.new("foo") }
-        before do
-          allow(id).to receive(:save) { nil }
-          allow(described_class.identifier_class).to receive(:mint) { id }
-          allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-          allow(Ddr::Models).to receive(:auto_assign_permanent_id) { true }
-        end
-        it "assigns a permanent id to the object" do
-          obj.reload
-          expect(obj.permanent_id).to eq("foo")
-          expect(obj.permanent_url).to eq("https://idn.duke.edu/foo")
-        end
-      end
-      describe "when disabled" do
-        before do
-          allow(Ddr::Models).to receive(:auto_assign_permanent_id) { false }
-        end
-        it "does not assign a permanent id to the object" do
-          expect(obj.reload.permanent_id).to be_nil
-        end
-      end
-    end
-
-    describe "assignment" do
-      let(:obj) { FactoryGirl.create(:item) }
-      let!(:id) { described_class.identifier_class.new("foo") }
-      before do
-        allow(id).to receive(:save) { nil }
-        allow(described_class.identifier_class).to receive(:mint) { id }
-        allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-      end
-      it "creates an update event" do
-        expect { described_class.assign!(obj) }.to change(Ddr::Events::UpdateEvent, :count).by(1)
-      end
-    end
-
-    describe "auto updating" do
-      let(:obj) { Item.create(pid: "test:1") }
-      let!(:id) { described_class.identifier_class.new("foo") }
-      before do
-        allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-      end
-      describe "when enabled" do
-        before do
-          allow(Ddr::Models).to receive(:auto_update_permanent_id) { true }
-        end
-        describe "when the object workflow state changes" do
-          describe "and the object has a permanent id" do
-            before do
-              allow(id).to receive(:save) { nil }
-              obj.permanent_id = "foo"
-            end
-            after do
-              obj.permanent_id = nil
-              obj.save!
-            end
-            it "updates the permanent id" do
-              expect { obj.publish! }.to change(id, :status).to("public")
-            end
-          end
-          describe "and the object does not have a permanent id" do
-            it "does not update the permanent id" do
-              expect { obj.publish! }.not_to change(id, :status)
-            end
-          end
-        end
-        describe "when the object workflow state does not change" do
-          it "does not update the permanent id" do
-            expect { obj.save! }.not_to change(id, :status)
-          end
-        end
-      end
-      describe "when disabled" do
-        before do
-          allow(Ddr::Models).to receive(:auto_update_permanent_id) { false }
-        end
-        describe "when the object workflow state changes" do
-          describe "and the object has a permanent id" do
-            before do
-              allow(id).to receive(:save) { nil }
-              obj.permanent_id = "foo"
-            end
-            after do
-              obj.permanent_id = nil
-              obj.save!
-            end
-            it "does not update the permanent id" do
-              expect { obj.publish! }.not_to change(id, :status)
-            end
-          end
-          describe "and the object does not have a permanent id" do
-            it "does not update the permanent id" do
-              expect { obj.publish! }.not_to change(id, :status)
-            end
-          end
-        end
-      end
-    end
-
-    describe "auto deleting / marking unavailable" do
-      describe "when enabled" do
-        before do
-          allow(Ddr::Models).to receive(:auto_update_permanent_id) { true }
-        end
-        describe "when an object has a permanent id" do
-          let(:obj) { Item.create(pid: "test:1", permanent_id: "foo") }
-          let!(:id) { described_class.identifier_class.new("foo") }
-          before do
-            allow(id).to receive(:save) { nil }
-            allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-          end
-          describe "and it's deacessioned" do
-            specify {
-              expect(described_class).to receive(:deaccession!).with("test:1", "foo", nil) { nil }
-              obj.deaccession
-            }
-          end
-          describe "and it's deleted" do
-            specify {
-              expect(described_class).not_to receive(:delete!)
-              expect(described_class).not_to receive(:deaccession!)
-              obj.send(:delete)
-            }
-          end
-          describe "and it's destroyed" do
-            specify {
-              expect(described_class).to receive(:delete!).with("test:1", "foo", nil) { nil }
-              obj.destroy
-            }
-          end
-        end
-        describe "when an object does not have a permanent id" do
-          let(:obj) { FactoryGirl.create(:item) }
-          describe "and it's deacessioned" do
-            specify {
-              expect(described_class).not_to receive(:deaccession!)
-              obj.deaccession
-            }
-          end
-          describe "and it's deleted" do
-            specify {
-              expect(described_class).not_to receive(:deaccession!)
-              expect(described_class).not_to receive(:delete!)
-              obj.send(:delete)
-            }
-          end
-          describe "and it's destroyed" do
-            specify {
-              expect(described_class).not_to receive(:delete!)
-              obj.destroy
-            }
-          end
-        end
-      end
-      describe "when disabled" do
-        before do
-          allow(Ddr::Models).to receive(:auto_update_permanent_id) { false }
-        end
-        describe "when an object has a permanent id" do
-          let(:obj) { Item.create(pid: "test:1", permanent_id: "foo") }
-          let!(:id) { described_class.identifier_class.new("foo") }
-          before do
-            allow(id).to receive(:save) { nil }
-            allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-          end
-          describe "and it's deacessioned" do
-            specify {
-              expect(described_class).not_to receive(:deaccession!)
-              obj.deaccession
-            }
-          end
-          describe "and it's destroyed" do
-            specify {
-              expect(described_class).not_to receive(:delete!)
-              obj.destroy
-            }
-          end
-        end
-      end
-    end
-
-    describe "constructor" do
-      describe "when the object is new" do
-        let(:obj) { FactoryGirl.build(:item) }
-        it "raises an error" do
-          expect { described_class.new(obj) }.to raise_error(PermanentId::RepoObjectNotPersisted)
-        end
-      end
-      describe "when passed a repo object id" do
-        let(:obj) { FactoryGirl.create(:item) }
-        subject { described_class.new(obj.id) }
-        its(:repo_id) { is_expected.to eq(obj.id) }
-      end
-    end
-
-    describe "instance methods" do
-      let(:obj) { FactoryGirl.create(:item) }
-      subject { described_class.new(obj) }
-
-      describe "#assign!" do
-        describe "when the object already has a permanent identifier" do
-          before { obj.permanent_id = "foo" }
-          it "raises an error" do
-            expect { subject.assign! }.to raise_error(PermanentId::AlreadyAssigned)
-            expect { subject.assign!("bar") }.to raise_error(PermanentId::AlreadyAssigned)
-          end
-        end
-        describe "when the object does not have a permanent identifier" do
-          let(:obj) { FactoryGirl.create(:item) }
-          let!(:id) { described_class.identifier_class.new("foo") }
-          before do
-            allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-            allow(id).to receive(:save) { nil }
-            allow(obj).to receive(:save) { true }
-          end
-          describe "when passed an ARK" do
-            before do
-              subject.assign!("foo")
-            end
-            it "assigns the ARK" do
-              expect(obj.permanent_id).to eq("foo")
-            end
-            it "sets the target on the identifier" do
-              expect(id.target).to eq("https://repository.duke.edu/id/foo")
-            end
-            it "sets the status on the identifier" do
-              expect(id.status).to eq("reserved")
-            end
-            it "sets the repository id on the identifier" do
-              expect(id["fcrepo3.pid"]).to eq(obj.id)
-            end
-          end
-          describe "when not passed an ARK" do
-            before do
-              subject.assign!("foo")
-              allow(described_class.identifier_class).to receive(:mint) { id }
-            end
-            it "mints and assigns an ARK" do
-              expect(obj.permanent_id).to eq("foo")
-            end
-            it "sets the target on the identifier" do
-              expect(id.target).to eq("https://repository.duke.edu/id/foo")
-            end
-            it "sets the status on the identifier" do
-              expect(id.status).to eq("reserved")
-            end
-            it "sets the repository id on the identifier" do
-              expect(id["fcrepo3.pid"]).to eq(obj.id)
-            end
-          end
-        end
-      end
-
-      describe "#update!" do
-        describe "when the object has not been assigned a permanent id" do
-          it "raises an error" do
-            expect { subject.update! }.to raise_error(PermanentId::IdentifierNotAssigned)
-          end
-        end
-        describe "when the object has been assigned a permanent id" do
-          let!(:id) { described_class.identifier_class.new("foo") }
-          before do
-            allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-            obj.permanent_id = "foo"
-          end
-          it "sets the status on the permanent id" do
-            expect(subject).to receive(:set_status!) { nil }
-            subject.update!
-          end
-        end
-      end
-
-      describe "#deaccession!" do
-        let!(:id) { described_class.identifier_class.new("foo") }
-        subject { described_class.new("test:1", "foo") }
-        before do
-          allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-          allow(id).to receive(:save) { nil }
-        end
-        specify {
-          expect(id).to receive(:delete)
-          subject.deaccession!
-        }
-        describe " when the identifier is not reserved" do
-          before { id.public! }
-          specify {
-            expect { subject.deaccession! }.to change(id, :status).to("unavailable | deaccessioned")
-          }
-        end
-        describe "when the identifier is associated with another repo id" do
-          before { subject.identifier_repo_id = "test:2" }
-          specify {
-            expect { subject.deaccession! }.to raise_error(PermanentId::Error)
-          }
-        end
-      end
-
-      describe "#delete!" do
-        let!(:id) { described_class.identifier_class.new("foo") }
-        subject { described_class.new("test:1", "foo") }
-        before do
-          allow(described_class.identifier_class).to receive(:find).with("foo") { id }
-        end
-        specify {
-          expect(id).to receive(:delete)
-          subject.delete!
-        }
-        describe " when the identifier is not reserved" do
-          before do
-            allow(id).to receive(:save) { nil }
-            id.public!
-          end
-          specify {
-            expect { subject.delete! }.to change(id, :status).to("unavailable | deleted")
-          }
-        end
-        describe "when the identifier is associated with another repo id" do
-          before { subject.identifier_repo_id = "test:2" }
-          specify {
-            expect { subject.delete! }.to raise_error(PermanentId::Error)
-          }
-        end
-      end
-
-      describe "identifier metadata" do
-        let(:obj) { Item.create(pid: "test:1") }
-        let!(:id) { described_class.identifier_class.new("foo") }
-        subject { described_class.new(obj) }
-        before do
-          allow(subject).to receive(:identifier) { id }
-        end
-        describe "#identifier_repo_id" do
-          before do
-            id["fcrepo3.pid"] = "test:1"
-          end
-          its(:identifier_repo_id) { is_expected.to eq("test:1") }
-        end
-        describe "#identifier_repo_id=" do
-          specify {
-            subject.identifier_repo_id = "test:1"
-            expect(id["fcrepo3.pid"]).to eq("test:1")
-          }
-          describe "when a value was previously assigned" do
-            before { subject.identifier_repo_id = "test:1" }
-            specify {
-              expect { subject.identifier_repo_id = "test:2" }.to raise_error(PermanentId::Error)
-            }
-          end
-        end
-        describe "#set_identifier_repo_id" do
-          specify {
-            subject.set_identifier_repo_id
-            expect(subject.identifier_repo_id).to eq("test:1")
-          }
-        end
-        describe "#set_target" do
-          specify {
-            subject.set_target
-            expect(subject.target).to eq("https://repository.duke.edu/id/foo")
-          }
-        end
-        describe "#set_status" do
-          describe "when object is published" do
-            before { obj.workflow_state = "published" }
-            describe "and identifier is public" do
-              before { subject.public! }
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-            describe "and identifier is reserved" do
-              it "changes to public" do
-                expect { subject.set_status }.to change(subject, :status).to("public")
-              end
-            end
-            describe "and identifier is unavailable" do
-              before { subject.unavailable! }
-              it "changes to public" do
-                expect { subject.set_status }.to change(subject, :status).to("public")
-              end
-            end
-          end
-          describe "when object is unpublished" do
-            before { obj.workflow_state = "unpublished" }
-            describe "and identifier is public" do
-              before { subject.public! }
-              it "changes to unavailable" do
-                expect { subject.set_status }.to change(subject, :status).to("unavailable | not published")
-              end
-            end
-            describe "and identifier is reserved" do
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-            describe "and identifier is unavailable" do
-              before { subject.unavailable! }
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-          end
-          describe "when object has no workflow state" do
-            describe "and identifier is public" do
-              before { subject.public! }
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-            describe "and identifier is reserved" do
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-            describe "and identifier is unavailable" do
-              before { subject.unavailable! }
-              it "does not change" do
-                expect { subject.set_status }.not_to change(subject, :status)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end