active-fedora 9.1.2 → 9.2.0.rc1

data/spec/integration/file_spec.rb

@@ -5,12 +5,23 @@ require "rexml/document"
 
 describe ActiveFedora::File do
   describe "#save" do
-    context "with a string" do
-      it "should save" do
-        subject.content = "some stuff"
-        subject.save
-        expect(subject).not_to be_new_record
+
+    context "with new files" do
+
+      context "with a string" do
+        before { subject.content = "hello" }
+        it "saves" do
+          expect(subject.save).to be true
+        end
       end
+
+      context "with no content" do
+        before { subject.content = nil }
+        it "does not save" do
+          expect(subject.save).to be false
+        end
+      end
+
     end
 
     context "with UploadedFile" do

data/spec/integration/has_many_associations_spec.rb

@@ -280,85 +280,120 @@ describe "Deleting a dependent relationship" do
 end
 
 describe "Autosave" do
-  context "a has_many - belongs_to relationship" do
-    before do
-      class Item < ActiveFedora::Base
-        has_many :components
-        has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
-          m.field "title", :string
-        end
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :title, datastream: 'foo'
-        end
-      end
-      class Component < ActiveFedora::Base
-        belongs_to :item, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-        has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
-          m.field "description", :string
+  context "with new objects" do
+    context "a has_many - belongs_to relationship" do
+      before do
+        class Item < ActiveFedora::Base
+          has_many :components
+          has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+            m.field "title", :string
+          end
+          Deprecation.silence(ActiveFedora::Attributes) do
+            has_attributes :title, datastream: 'foo'
+          end
         end
-        Deprecation.silence(ActiveFedora::Attributes) do
-          has_attributes :description, datastream: 'foo'
+        class Component < ActiveFedora::Base
+          belongs_to :item, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
+          has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
+            m.field "description", :string
+          end
+          Deprecation.silence(ActiveFedora::Attributes) do
+            has_attributes :description, datastream: 'foo'
+          end
         end
       end
-    end
 
-    after do
-      Object.send(:remove_const, :Item)
-      Object.send(:remove_const, :Component)
-    end
+      after do
+        Object.send(:remove_const, :Item)
+        Object.send(:remove_const, :Component)
+      end
 
-    context "From the belongs_to side" do
-      let(:component) { Component.create(item: Item.new(title: 'my title')) }
+      context "From the belongs_to side" do
+        let(:component) { Component.create(item: Item.new(title: 'my title')) }
 
-      it "should save dependent records" do
-        component.reload
-        expect(component.item.title).to eq 'my title'
+        it "should save dependent records" do
+          component.reload
+          expect(component.item.title).to eq 'my title'
+        end
       end
-    end
 
-    context "From the has_many side" do
-      let(:item) { Item.create(components: [Component.new(description: 'my description')]) }
+      context "From the has_many side" do
+        let(:item) { Item.create(components: [Component.new(description: 'my description')]) }
 
-      it "should save dependent records" do
-        item.reload
-        expect(item.components.first.description).to eq 'my description'
+        it "should save dependent records" do
+          item.reload
+          expect(item.components.first.description).to eq 'my description'
+        end
       end
     end
-  end
 
-  context "a has_many - has_and_belongs_to_many relationship" do
-    context "with ActiveFedora::Base as classes" do
-      before do
-        class Novel < ActiveFedora::Base
-          has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
-          has_and_belongs_to_many :contents, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+    context "a has_many - has_and_belongs_to_many relationship" do
+      context "with ActiveFedora::Base as classes" do
+        before do
+          class Novel < ActiveFedora::Base
+            has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+            has_and_belongs_to_many :contents, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+          end
+          class Text < ActiveFedora::Base
+            has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+          end
         end
-        class Text < ActiveFedora::Base
-          has_many :books, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ActiveFedora::Base'
+        let(:text) { Text.create}
+        let(:novel) { Novel.create}
+
+        after do
+          Object.send(:remove_const, :Novel)
+          Object.send(:remove_const, :Text)
+        end
+
+        it "should work when added via the has_many" do
+          text.books << novel
+          novel.save
+          expect(novel.reload.contents).to eq [text]
+          expect(text.reload.books).to eq [novel]
+        end
+
+        it "should work when added via the has_and_belongs_to_many" do
+          novel.contents << text
+          novel.save!
+          text.reload
+          expect(text.books).to eq [novel]
         end
-      end
-      let(:text) { Text.create}
-      let(:novel) { Novel.create}
 
-      after do
-        Object.send(:remove_const, :Novel)
-        Object.send(:remove_const, :Text)
       end
+    end
+  end
 
-      it "should work when added via the has_many" do
-        text.books << novel
-        novel.save
-        expect(novel.reload.contents).to eq [text]
-        expect(text.reload.books).to eq [novel]
+  context "with updated objects" do
+    
+    before :all do
+      class Library < ActiveFedora::Base
+        has_many :books, autosave: true
       end
 
-      it "should work when added via the has_and_belongs_to_many" do
-        novel.contents << text
-        novel.save!
-        text.reload
-        expect(text.books).to eq [novel]
+      class Book < ActiveFedora::Base
+        belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent
+        property :title, predicate: ::RDF::DC.title
       end
+    end
+    after :all do
+      Object.send(:remove_const, :Book)
+      Object.send(:remove_const, :Library)
+    end
+  
+    let(:library) { Library.create }
+    
+    before do
+      library.books.create(title: ["Great Book"])
+      library.books.first.title = ["Better book"]
+      library.save
+    end
 
+    subject { library.books(true) }
+
+    it "saves the new title" do
+      expect(subject.first.title).to eql ["Better book"]
     end
+
   end
 end

data/spec/integration/indirect_container_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+describe "Indirect containers" do
+  before do
+    class RelatedObject < ActiveFedora::Base
+      property :title, predicate: ::RDF::DC.title, multiple: false
+    end
+    class Proxy < ActiveFedora::Base
+      belongs_to :proxy_for, predicate: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), class_name: 'ActiveFedora::Base'
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :RelatedObject)
+    Object.send(:remove_const, :Proxy)
+  end
+
+  describe "#include?" do
+    before do
+      class FooHistory < ActiveFedora::Base
+        indirectly_contains :related_objects,
+          has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'),
+          inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'),
+          through: 'Proxy', foreign_key: :proxy_for
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FooHistory)
+    end
+
+    let(:foo) { FooHistory.new }
+
+    let(:file1) { RelatedObject.create }
+
+    before do
+      foo.related_objects << file1
+      foo.save
+    end
+
+    context "when it is not loaded" do
+      context "and it contains the file" do
+        subject { foo.reload.related_objects.include? file1 }
+        it { is_expected.to be true }
+      end
+
+      context "and it doesn't contain the file" do
+        let!(:file2) { RelatedObject.create }
+        subject { foo.reload.related_objects.include? file2 }
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when it is loaded" do
+      before { foo.related_objects.to_a } # initial load of the association
+
+      context "and it contains the file" do
+        subject { foo.related_objects.include? file1 }
+        it { is_expected.to be true }
+      end
+
+      context "and it doesn't contain the file" do
+        let!(:file2) { RelatedObject.create }
+        subject { foo.related_objects.include? file2 }
+        it { is_expected.to be false }
+      end
+    end
+  end
+
+  describe "delete" do
+    before do
+      class FooHistory < ActiveFedora::Base
+        indirectly_contains :related_objects,
+          has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'),
+          through: 'Proxy',
+          foreign_key: :proxy_for
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FooHistory)
+    end
+
+    it "should delete only one object" do
+      foo = FooHistory.new
+      foo.related_objects.build
+      file2 = foo.related_objects.build
+      foo.save
+      expect(foo.related_objects.each.count).to eq(2)
+      foo.related_objects.delete(file2)
+      expect(foo.related_objects.each.count).to eq 1
+      foo = FooHistory.find(foo.id)
+      expect(foo.related_objects.each.count).to eq(1)
+    end
+  end
+
+  describe "#indirectly_contains" do
+    context "when the class is implied" do
+      before do
+        class FooHistory < ActiveFedora::Base
+          # TODO inserted_content_relation can look up the predicate at options[:through].constantize.reflect_on_association(options[:foreign_key]).predicate
+          indirectly_contains :related_objects, has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), through: 'Proxy', foreign_key: :proxy_for
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+
+      let(:file) { o.related_objects.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      context "with no related_objects" do
+        let(:o) { FooHistory.new }
+        subject { o.related_objects }
+
+        it { is_expected.to be_empty }
+        it { is_expected.to eq [] }
+      end
+
+      context "when the object exists" do
+        let(:o) { FooHistory.create }
+
+        before do
+          file.title = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.related_objects.first }
+          it "has the content" do
+            expect(subject.title).to eq 'HMMM'
+          end
+        end
+
+        describe "#==" do
+          subject { reloaded.related_objects }
+
+          it "delegates to to_a" do
+            expect(subject).to eq [file]
+          end
+        end
+
+        describe "#append" do
+          let(:file2) { o.related_objects.build }
+          it "has two related_objects" do
+            expect(o.related_objects).to eq [file, file2]
+          end
+
+          context "and then saved/reloaded" do
+            before do
+              file2.title = "Derp"
+              o.save!
+            end
+            it "has two related_objects" do
+              expect(reloaded.related_objects).to eq [file, file2]
+            end
+            it "has inbound triples" do
+              statement = file.reload.resource.query(predicate: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor')).to_a.first
+
+              expect(statement.object).to eq file.resource.rdf_subject
+            end
+          end
+        end
+        describe "remove" do
+          it "should be able to remove" do
+            o.related_objects = []
+            o.save!
+
+            expect(reloaded.related_objects).to eq []
+          end
+        end
+      end
+    end
+
+    context "when the class is provided" do
+      before do
+        class Different < ActiveFedora::Base
+          property :title, predicate: ::RDF::DC.title, multiple: false
+        end
+        class FooHistory < ActiveFedora::Base
+          indirectly_contains :related_objects, has_member_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/aggregates'), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), class_name: 'Different', through: 'Proxy', foreign_key: :proxy_for
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+        Object.send(:remove_const, :Different)
+      end
+
+      let(:o) { FooHistory.create }
+      let(:file) { o.related_objects.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      describe "#build" do
+        subject { file }
+        it { is_expected.to be_kind_of Different }
+      end
+
+      context "when the object exists" do
+        before do
+          file.title = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.related_objects.first }
+          it "has the content" do
+            expect(subject.title).to eq 'HMMM'
+          end
+        end
+      end
+    end
+
+    context "when using is_member_of_relation" do #, skip: "As far as I can tell, FC4 doesn't support IndirectContainer with isMemberOfRelation" do
+      before do
+        class FooHistory < ActiveFedora::Base
+          indirectly_contains :related_objects, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin"), inserted_content_relation: ::RDF::URI.new('http://www.openarchives.org/ore/terms/proxyFor'), through: 'Proxy', foreign_key: :proxy_for
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+
+      let(:file) { o.related_objects.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      context "with no related_objects" do
+        let(:o) { FooHistory.new }
+        subject { o.related_objects }
+
+        it { is_expected.to be_empty }
+        it { is_expected.to eq [] }
+      end
+
+      context "when the object exists" do
+        let(:o) { FooHistory.create }
+
+        before do
+          file.title = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.related_objects.first }
+          it "has the content" do
+            expect(subject.title).to eq 'HMMM'
+          end
+        end
+      end
+    end
+  end
+end