active-fedora 13.1.2 → 13.2.4

data/spec/integration/date_time_properties_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before do
-    class Foo < ActiveFedora::Base
-      # Date attributes are recognized by having index.type :Date or class_name: 'DateTime'
-      property :date, predicate: ::RDF::Vocab::DC.date do |index|
-        index.type :date
-      end
-      property :integer, predicate: ::RDF::URI.new('http://www.example.com/integer'), multiple: false do |index|
-        index.type :integer
-      end
-      property :single_date, multiple: false, class_name: 'DateTime', predicate: ::RDF::URI.new('http://www.example.com/single_date')
-      property :missing_date, multiple: false, class_name: 'DateTime', predicate: ::RDF::URI.new('http://www.example.com/missing_date')
-      property :empty_date, multiple: false, class_name: 'DateTime', predicate: ::RDF::URI.new('http://www.example.com/empty_date')
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Foo)
-  end
-
-  let(:date) { DateTime.parse("2015-10-22T10:20:03.653+01:00") }
-  let(:date2) { DateTime.parse("2015-10-22T15:34:20.323-11:00") }
-
-  describe "saving and loading in Fedora" do
-    let(:object) { Foo.create!(date: [date], single_date: date2, empty_date: '', integer: 1).reload }
-    it "loads the correct time" do
-      expect(object.date.first).to eql date
-      expect(object.single_date).to eql date2
-    end
-  end
-
-  describe 'serializing' do
-    let(:object) { Foo.new(date: [date]) }
-    let(:triple) { object.resource.query(predicate: ::RDF::Vocab::DC.date).to_a.first }
-    it 'time zone must have semicolin to be a cannonical XMLSchema#dateTime' do
-      expect(triple.to_s).to match(/\+01:00/)
-    end
-  end
-end

data/spec/integration/delete_all_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before(:all) do
-    module SpecModel
-      class Basic < ActiveFedora::Base
-        class_attribute :callback_counter
-
-        before_destroy :inc_counter
-
-        def inc_counter
-          self.class.callback_counter += 1
-        end
-      end
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :SpecModel)
-  end
-
-  let!(:model1) { SpecModel::Basic.create! }
-  let!(:model2) { SpecModel::Basic.create! }
-
-  before do
-    SpecModel::Basic.callback_counter = 0
-  end
-
-  describe ".destroy_all" do
-    it "removes both and run callbacks" do
-      SpecModel::Basic.destroy_all
-      expect(SpecModel::Basic.count).to eq 0
-      expect(SpecModel::Basic.callback_counter).to eq 2
-    end
-
-    describe "when a model is missing" do
-      let(:model3) { SpecModel::Basic.create! }
-      let!(:id) { model3.id }
-
-      before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, model3.uri).delete }
-
-      after do
-        ActiveFedora::SolrService.instance.conn.tap do |conn|
-          conn.delete_by_query "id:\"#{id}\""
-          conn.commit
-        end
-      end
-
-      it "is able to skip a missing model" do
-        expect(described_class.logger).to receive(:error).with("Although #{id} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
-        SpecModel::Basic.destroy_all
-        expect(SpecModel::Basic.count).to eq 1
-      end
-    end
-  end
-
-  describe ".delete_all" do
-    it "removes both and not run callbacks" do
-      SpecModel::Basic.delete_all
-      expect(SpecModel::Basic.count).to eq 0
-      expect(SpecModel::Basic.callback_counter).to eq 0
-    end
-  end
-end

data/spec/integration/direct_container_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper'
-
-describe "Direct containers" do
-  describe "#directly_contains" do
-    context "when the class is ActiveFedora::File" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles")
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-
-      let(:file) { o.files.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      context "with no files" do
-        subject { o.files }
-        let(:o) { FooHistory.new }
-
-        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.content = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first_file) { reloaded.files.first }
-          it "has the content" do
-            expect(first_file.content).to eq 'HMMM'
-          end
-        end
-
-        describe "#to_a" do
-          subject(:files) { reloaded.files }
-          it "has the content" do
-            expect(files.to_a).to eq [file]
-          end
-        end
-
-        describe "#append" do
-          let(:file2) { o.files.build }
-          it "has two files" do
-            expect(o.files).to contain_exactly file, file2
-          end
-
-          context "and then saved/reloaded" do
-            before do
-              file2.content = "Derp"
-              o.save!
-            end
-            it "has two files" do
-              expect(reloaded.files).to contain_exactly file, file2
-            end
-          end
-        end
-      end
-
-      context "when the object is new" do
-        let(:o) { FooHistory.new }
-        let(:file) { o.files.build }
-
-        it "fails" do
-          # This is the expected behavior right now. In the future make the uri get assigned by autosave.
-          expect { o.files.build }.to raise_error "Can't get uri. Owner isn't saved"
-        end
-      end
-    end
-
-    context "when the class is a subclass of ActiveFedora::File" do
-      before do
-        class SubFile < ActiveFedora::File; end
-        class FooHistory < ActiveFedora::Base
-          directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles"), class_name: 'SubFile'
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-        Object.send(:remove_const, :SubFile)
-      end
-
-      let(:o) { FooHistory.create }
-      let(:file) { o.files.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      describe "#build" do
-        subject { file }
-        it { is_expected.to be_kind_of SubFile }
-      end
-
-      context "when the object exists" do
-        before do
-          file.content = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first_file) { reloaded.files.first }
-          it "has the content" do
-            expect(first_file.content).to eq 'HMMM'
-          end
-        end
-      end
-    end
-
-    context "when using is_member_of_relation" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          directly_contains :files, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin")
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-
-      let(:file) { o.files.build }
-      let(:reloaded) { FooHistory.find(o.id) }
-
-      context "with no files" do
-        subject { o.files }
-        let(:o) { FooHistory.new }
-
-        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.content = "HMMM"
-          o.save
-        end
-
-        describe "#first" do
-          subject(:first_file) { reloaded.files.first }
-          it "has the content" do
-            expect(first_file.content).to eq 'HMMM'
-          end
-        end
-      end
-    end
-
-    context "deleting members" do
-      before do
-        class FooHistory < ActiveFedora::Base
-          directly_contains :files, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin")
-        end
-      end
-      after do
-        Object.send(:remove_const, :FooHistory)
-      end
-
-      describe "#delete the contained object directly" do
-        let(:history) { FooHistory.create }
-        let(:file1) { history.files.build }
-        let(:file2) { history.files.build }
-
-        before do
-          file1.content = "hello"
-          file2.content = "hola"
-          history.save
-          history.reload
-        end
-
-        it "deletes the contained resource directly" do
-          expect(history.files).to contain_exactly file1, file2
-          file1.delete
-          history.reload
-          expect(history.files).to eq [file2]
-        end
-      end
-
-      describe "#delete via the collection proxy" do
-        let(:history) { FooHistory.create }
-        let(:file1) { history.files.build }
-        let(:file2) { history.files.build }
-
-        before do
-          file1.content = "hello"
-          file2.content = "hola"
-          history.save
-          history.reload
-        end
-
-        it "deletes the contained resource via the collection proxy" do
-          expect(history.reload.files).to contain_exactly file1, file2
-          history.files.delete(file1)
-          expect(history.reload.files).to eq [file2]
-        end
-      end
-    end
-  end
-
-  describe "#include?" do
-    before do
-      class FooHistory < ActiveFedora::Base
-        directly_contains :files, has_member_relation: ::RDF::URI.new('http://example.com/hasFiles')
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :FooHistory)
-    end
-
-    let(:foo) { FooHistory.create }
-
-    let!(:file1) { foo.files.build }
-
-    before do
-      file1.content = 'hmm'
-      foo.save
-    end
-
-    context "when it is not loaded" do
-      context "and it contains the file" do
-        subject { foo.reload.files.include? file1 }
-        it { is_expected.to be true }
-      end
-
-      context "and it doesn't contain the file" do
-        let!(:file2) { ActiveFedora::File.new { |f| f.content = 'hmm'; f.save } }
-        subject { foo.reload.files.include? file2 }
-        it { is_expected.to be false }
-      end
-    end
-
-    context "when it is loaded" do
-      before { foo.files.to_a } # initial load of the association
-
-      context "and it contains the file" do
-        subject { foo.files.include? file1 }
-        it { is_expected.to be true }
-      end
-
-      context "and it doesn't contain the file" do
-        let!(:file2) { ActiveFedora::File.new { |f| f.content = 'hmm'; f.save } }
-        subject { foo.files.include? file2 }
-        it { is_expected.to be false }
-      end
-    end
-  end
-end

data/spec/integration/directly_contains_one_association_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Base do
-  before do
-    class PageImage < ActiveFedora::Base
-      directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles"), class_name: "FileWithMetadata"
-      directly_contains_one :primary_file, through: :files, type: ::RDF::URI.new("http://example.com/primaryFile"), class_name: "FileWithMetadata"
-      directly_contains_one :alternative_file, through: :files, type: ::RDF::URI.new("http://example.com/featuredFile"), class_name: 'AlternativeFileWithMetadata'
-    end
-
-    class FileWithMetadata < ActiveFedora::File
-      include ActiveFedora::WithMetadata
-    end
-    class AlternativeFileWithMetadata < ActiveFedora::File
-      include ActiveFedora::WithMetadata
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :PageImage)
-    Object.send(:remove_const, :FileWithMetadata)
-    Object.send(:remove_const, :AlternativeFileWithMetadata)
-  end
-
-  let(:page_image)              { PageImage.create }
-  let(:reloaded_page_image)     { PageImage.find(page_image.id) }
-
-  let(:a_file)                  { page_image.files.build }
-  let(:primary_file)            { page_image.build_primary_file }
-  let(:alternative_file)        { page_image.build_alternative_file }
-  let(:primary_sub_image)       { page_image.build_primary_sub_image }
-
-  context "#build" do
-    context "when container element is a type of ActiveFedora::File" do
-      before do
-        primary_file.content = "I'm in a container all alone!"
-        page_image.save!
-      end
-      subject(:reloaded_file) { reloaded_page_image.primary_file }
-      it "initializes an object within the container" do
-        expect(reloaded_file.content).to eq("I'm in a container all alone!")
-        expect(reloaded_file.metadata_node.type).to include(::RDF::URI.new("http://example.com/primaryFile"))
-      end
-      it "relies on info from the :through association, including class_name" do
-        expect(page_image.files).to include(primary_file)
-        expect(primary_file.uri.to_s).to include("/files/")
-        expect(reloaded_file.class).to eq FileWithMetadata
-      end
-    end
-  end
-
-  context "finder" do
-    subject { reloaded_page_image.primary_file }
-    context "when no matching child is set" do
-      before { page_image.files.build }
-      it { is_expected.to be_nil }
-    end
-    context "when a matching object is directly contained" do
-      before do
-        a_file.content = "I'm a file"
-        primary_file.content = "I am too"
-        page_image.save!
-      end
-      it { is_expected.to eq primary_file }
-    end
-    context "if class_name is set" do
-      before do
-        a_file.content = "I'm a file"
-        alternative_file.content = "I am too"
-        page_image.save!
-      end
-      subject(:reloaded_file) { reloaded_page_image.alternative_file }
-      it "uses the specified class to load objects" do
-        expect(reloaded_file).to eq alternative_file
-        expect(reloaded_file).to be_instance_of AlternativeFileWithMetadata
-      end
-    end
-  end
-
-  describe "setter" do
-    before do
-      a_file.content = "I'm a file"
-      primary_file.content = "I am too"
-      page_image.save!
-    end
-    subject(:reloaded_file) { reloaded_page_image.files }
-    it "replaces existing record without disturbing the other contents of the container" do
-      replacement_file = page_image.primary_file = FileWithMetadata.new
-      replacement_file.content = "I'm a replacement"
-      page_image.save
-      expect(reloaded_file).to_not include(primary_file)
-      expect(reloaded_file).to contain_exactly(a_file, replacement_file)
-      expect(reloaded_page_image.primary_file).to eq(replacement_file)
-    end
-  end
-end