active-fedora 13.1.2 → 13.1.3

data/spec/integration/json_serialization_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe "Objects should be serialized to JSON" do
-  it "has json results" do
-    expect(ActiveFedora::Base.new.to_json).to eq "{\"id\":null}"
-  end
-
-  context "with properties" do
-    before do
-      class Foo < ActiveFedora::Base
-        property :title, predicate: ::RDF::Vocab::DC.title
-        property :description, predicate: ::RDF::Vocab::DC.description, multiple: false
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :Foo)
-    end
-
-    let(:obj) { Foo.new(title: ['My Title'], description: 'Wonderful stuff') }
-
-    before { allow(obj).to receive(:id).and_return('test-123') }
-
-    let(:json) { JSON.parse(obj.to_json) }
-
-    it "has to_json" do
-      expect(json['id']).to eq "test-123"
-      expect(json['title']).to eq ["My Title"]
-      expect(json['description']).to eq "Wonderful stuff"
-    end
-  end
-end

data/spec/integration/marshal_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe "Marshalling and loading" do
-  before do
-    class Post < ActiveFedora::Base
-      has_many :comments
-      property :text, predicate: ::RDF::URI('http://example.com/text')
-    end
-
-    class Comment < ActiveFedora::Base
-      belongs_to :post, predicate: ::RDF::URI('http://example.com/post')
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Post)
-    Object.send(:remove_const, :Comment)
-  end
-
-  context "persisted records" do
-    let(:post) { Post.create(text: ['serialize me']) }
-    it "marshals them" do
-      marshalled = Marshal.dump(post)
-      loaded     = Marshal.load(marshalled)
-
-      expect(loaded.attributes).to eq post.attributes
-    end
-  end
-
-  context "with associations" do
-    let(:post) { Post.create(comments: [Comment.new]) }
-    it "marshals associations" do
-      marshalled = Marshal.dump(post)
-      loaded     = Marshal.load(marshalled)
-
-      expect(loaded.comments.size).to eq 1
-    end
-  end
-end

data/spec/integration/nested_attribute_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-describe "NestedAttribute behavior" do
-  before do
-    class Bar < ActiveFedora::Base
-      belongs_to :car, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasMember
-      property :uno, predicate: ::RDF::URI('http://example.com/uno'), multiple: false
-      property :dos, predicate: ::RDF::URI('http://example.com/dos'), multiple: false
-    end
-
-    # base Car class, used in test for association updates and :allow_destroy flag
-    class Car < ActiveFedora::Base
-      has_many :bars, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasMember
-      accepts_nested_attributes_for :bars, allow_destroy: true
-    end
-  end
-  after do
-    Object.send(:remove_const, :Bar)
-    Object.send(:remove_const, :Car)
-  end
-
-  let(:car_class) { Car }
-  let(:car) { car_class.create }
-  let(:bar1) { Bar.create(car: car) }
-  let(:bar2) { Bar.create(car: car) }
-
-  it "has _destroy" do
-    expect(Bar.new._destroy).to be_nil
-  end
-
-  it "updates the child objects" do
-    car.update bars_attributes: [{ id: bar1.id, uno: "bar1 uno" }, { uno: "newbar uno" }, { id: bar2.id, _destroy: '1', uno: 'bar2 uno' }]
-    expect(Bar.all.map(&:uno)).to match_array ['bar1 uno', 'newbar uno']
-
-    bars = car.bars(true)
-    expect(bars).to include(bar1)
-    expect(bars).to_not include(bar2)
-  end
-
-  context "when reject_if: :all_blank" do
-    before do
-      class CarAllBlank < Car
-        accepts_nested_attributes_for :bars, reject_if: :all_blank
-      end
-    end
-
-    let(:car_class) { CarAllBlank }
-    after { Object.send(:remove_const, :CarAllBlank) }
-    let(:car) { car_class.create }
-    let!(:bar1) { Bar.create(car: car) }
-    let!(:bar2) { Bar.create(car: car) }
-
-    it "rejects attributes when all blank" do
-      expect(car.bars.count).to eq 2
-      car.update bars_attributes: [{}, { id: bar1.id, uno: "bar1 uno" }]
-      expect(car.bars(true).count).to eq 2
-
-      bar1.reload
-      expect(bar1.uno).to eq "bar1 uno"
-    end
-  end
-
-  context "when reject_if attribute is supplied with a proc" do
-    before do
-      class CarProc < Car
-        accepts_nested_attributes_for :bars, reject_if: ->(attributes) { attributes['uno'].blank? }
-      end
-    end
-
-    after { Object.send(:remove_const, :CarProc) }
-    let(:car_class) { CarProc }
-
-    context "and the reject_if proc evaluates to false" do
-      before do
-        car.update bars_attributes: [{}, { id: bar1.id, uno: "bar1 uno" }]
-      end
-      it "updates attributes" do
-        expect(bar1.reload.uno).to eq "bar1 uno"
-      end
-    end
-
-    context "and the reject_if proc evaluates to true" do
-      before do
-        car.update bars_attributes: [{}, { id: bar1.id, dos: "bar1 uno" }]
-      end
-      it "rejects attributes" do
-        expect(bar1.reload.dos).to be_nil
-      end
-    end
-
-    context "and `allow_destroy: false`" do
-      context "and the reject_if proc evaluates to true" do
-        before do
-          car.update bars_attributes: [{}, { id: bar1.id, dos: "bar1 uno", _destroy: "1" }]
-        end
-        it "rejects attributes (_destroy doesn't affect the outcome)" do
-          expect(bar1.reload.dos).to be_nil
-        end
-      end
-
-      context "a record with the destroy flag and without an id" do
-        it "creates a new record" do
-          expect {
-            car.update bars_attributes: [{ uno: "bar1 uno", _destroy: "1" }]
-          }.to change { car.bars(true).count }.by(1)
-        end
-
-        it "does not create a new record if reject_if conditions are triggered" do
-          expect {
-            car.update bars_attributes: [{ uno: "", _destroy: "1" }]
-          }.not_to change { car.bars(true).count }
-        end
-      end
-    end
-  end
-
-  describe "reject_if: with a symbol" do
-    before do
-      # class used in test for reject_if: with method name as symbol
-      class CarSymbol < Car
-        accepts_nested_attributes_for :bars, reject_if: :uno_blank
-
-        def uno_blank(attributes)
-          attributes['uno'].blank?
-        end
-      end
-    end
-
-    after { Object.send(:remove_const, :CarSymbol) }
-    let(:car_class) { CarSymbol }
-
-    it "rejects attributes based on method name" do
-      car.update bars_attributes: [{}, { id: bar1.id, uno: "bar1 uno" }, { id: bar2.id, dos: "bar2 dos" }]
-      bar1.reload
-      bar2.reload
-      expect(bar1.uno).to eq "bar1 uno"
-      expect(bar2.dos).to be_nil
-    end
-  end
-
-  describe "allow_destroy: true" do
-    before do
-      class CarDestroy < Car
-        accepts_nested_attributes_for :bars, allow_destroy: true
-      end
-    end
-
-    let(:car_class) { CarDestroy }
-    after { Object.send(:remove_const, :CarDestroy) }
-
-    it "doesn't create a new record if _destroy is set" do
-      expect {
-        car.update bars_attributes: [{ uno: "new uno", _destroy: "1" }]
-      }.not_to change { car.bars(true).count }
-    end
-  end
-
-  describe "limit" do
-    before do
-      class CarWithLimit < Car
-        accepts_nested_attributes_for :bars, limit: 1
-      end
-    end
-    after { Object.send(:remove_const, :CarWithLimit) }
-
-    let(:car_class) { CarWithLimit }
-    it "throws TooManyRecords" do
-      expect {
-        car.attributes = { bars_attributes: [{}] }
-      }.to_not raise_exception
-
-      expect {
-        car.attributes = { bars_attributes: [{}, {}] }
-      }.to raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
-    end
-  end
-end

data/spec/integration/nested_hash_resources_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe "nested hash resources" do
-  before do
-    class NestedResource < ActiveTriples::Resource
-      property :title, predicate: ::RDF::Vocab::DC.title
-      ## Necessary to get AT to create hash URIs.
-      def initialize(uri, parent)
-        if uri.try(:node?)
-          uri = RDF::URI("#nested_#{uri.to_s.gsub('_:', '')}")
-        elsif uri.start_with?("#")
-          uri = RDF::URI(uri)
-        end
-        super
-      end
-
-      def final_parent
-        parent
-      end
-    end
-    class ExampleOwner < ActiveFedora::Base
-      property :relation, predicate: ::RDF::Vocab::DC.relation, class_name: NestedResource
-      accepts_nested_attributes_for :relation
-    end
-  end
-  after do
-    Object.send(:remove_const, :NestedResource)
-    Object.send(:remove_const, :ExampleOwner)
-  end
-  it "is able to nest resources" do
-    obj = ExampleOwner.new
-    obj.attributes = {
-      relation_attributes: [
-        {
-          title: "Test"
-        }
-      ]
-    }
-    obj.save!
-
-    expect(obj.reload.relation.first.title).to eq ["Test"]
-  end
-end

data/spec/integration/persistence_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe "persisting objects" do
-  describe "#create!" do
-    before do
-      class MockAFBaseRelationship < ActiveFedora::Base
-        property :name, predicate: ::RDF::Vocab::DC.title, multiple: false
-        validates :name, presence: true
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :MockAFBaseRelationship)
-    end
-
-    it "validates" do
-      expect { MockAFBaseRelationship.create! }.to raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
-    end
-  end
-
-  describe "#save" do
-    context "With undefined contains associations" do
-      let(:f1) { ActiveFedora::Base.create }
-      let!(:f2) { ActiveFedora::Base.create(id: "#{f1.id}/part2") }
-
-      before do
-        f1.reload # so it learns about f2
-      end
-
-      it "doesn't load the children" do
-        allow(f1).to receive(:update_index) # solrizing can load the attached files.
-        expect(ActiveFedora::File).not_to receive(:new)
-        f1.save
-      end
-    end
-  end
-end

data/spec/integration/query_result_builder_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::QueryResultBuilder do
-  describe "#reify_solr_results" do
-    before do
-      class FooObject < ActiveFedora::Base
-        def self.id_namespace
-          "foo"
-        end
-      end
-    end
-
-    let(:test_object) { ActiveFedora::Base.create }
-    let(:foo_object) { FooObject.create }
-
-    after do
-      Object.send(:remove_const, :FooObject)
-    end
-
-    it "returns an array of objects that are of the class stored in active_fedora_model_s" do
-      query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([test_object.id, foo_object.id])
-      solr_result = ActiveFedora::SolrService.query(query, rows: 10)
-      result = described_class.reify_solr_results(solr_result)
-      expect(result.length).to eq 2
-      result.each do |r|
-        expect((r.class == ActiveFedora::Base || r.class == FooObject)).to be true
-      end
-    end
-
-    it '#reifies a lightweight object as a new instance' do
-      query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([foo_object.id])
-      solr_result = ActiveFedora::SolrService.query(query, rows: 10)
-      result = described_class.reify_solr_results(solr_result, load_from_solr: true)
-      expect(result.first).to be_instance_of FooObject
-    end
-  end
-end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe "Nesting attribute behavior of RDF resources" do
-  before do
-    class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
-      property :Topic
-      property :Name
-      property :Source
-    end
-
-    class CustomName < ActiveFedora::Base
-      property :pref_label, predicate: ::RDF::Vocab::SKOS.prefLabel, multiple: false
-    end
-
-    class CustomSource < ActiveFedora::Base
-    end
-
-    class ComplexResource < ActiveFedora::Base
-      property :topic, predicate: DummyMADS.Topic, class_name: "ComplexResource::Topic"
-      property :name, predicate: DummyMADS.Name, class_name: "CustomName" do |index|
-        index.as :stored_searchable, using: :pref_label
-      end
-      property :source, predicate: DummyMADS.Source, class_name: "CustomSource" do |index|
-        index.as :stored_searchable
-      end
-
-      class Topic < ActiveTriples::Resource
-        property :subject, predicate: ::RDF::Vocab::DC.subject
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :ComplexResource)
-    Object.send(:remove_const, :DummyMADS)
-    Object.send(:remove_const, :CustomName)
-    Object.send(:remove_const, :CustomSource)
-  end
-
-  context "with an AT resource as a property" do
-    subject(:complex_resource) { ComplexResource.new }
-
-    let(:params) { [{ subject: 'Foo' }, { subject: 'Bar' }] }
-
-    before do
-      ComplexResource.accepts_nested_attributes_for(*args)
-      complex_resource.topic_attributes = params
-    end
-
-    context "when no options are set" do
-      let(:args) { [:topic] }
-
-      it "sets the attributes" do
-        expect(complex_resource.topic.size).to eq 2
-        expect(complex_resource.topic.map(&:subject)).to contain_exactly ['Foo'], ['Bar']
-      end
-
-      it "marks the attributes as changed" do
-        expect(complex_resource.changed_attributes.keys).to eq ["topic"]
-      end
-    end
-
-    context "when reject_if is set" do
-      let(:args) { [:topic, reject_if: reject_proc] }
-      let(:reject_proc) { lambda { |attributes| attributes[:subject] == 'Bar' } }
-      let(:params) { [{ subject: 'Foo' }, { subject: 'Bar' }] }
-
-      it "does not add terms for which the proc is true" do
-        expect(complex_resource.topic.map(&:subject)).to eq [['Foo']]
-      end
-    end
-  end
-
-  context "with an AF::Base object as a property" do
-    describe "#to_solr" do
-      let(:name) { CustomName.create(pref_label: "Joe Schmo") }
-      let(:source) { CustomSource.create }
-      let(:solr_doc) { ComplexResource.new(name: [name], source: [source]).to_solr }
-      it "indexes the value of the properties accordingly" do
-        expect(solr_doc).to include("name_tesim" => ["Joe Schmo"])
-        expect(solr_doc).to include("source_tesim" => [source.uri])
-      end
-    end
-  end
-end