active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/integration/fedora_solr_sync_spec.rb

@@ -18,9 +18,9 @@ describe "fedora_solr_sync_issues" do
   end
 
   let(:parent) { ParentThing.create }
-  subject { ChildThing.create parent: parent }
+  subject(:child) { ChildThing.create parent: parent }
 
-  before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, subject.uri).delete }
+  before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, child.uri).delete }
 
   it "does not go into an infinite loop" do
     parent.reload

data/spec/integration/file_fixity_spec.rb

@@ -15,24 +15,22 @@ describe "Checking fixity" do
     obj = MockAFBase.create
     obj.data.content = "some content"
     obj.save
-    obj.data
+    obj.data.check_fixity
   end
 
   context "with a valid resource" do
-    it "returns true for a successful fixity check" do
-      expect(subject.check_fixity).to be true
-    end
+    it { is_expected.to be true }
   end
   context "when no uri has been set" do
-    subject { ActiveFedora::File.new }
+    subject(:file) { ActiveFedora::File.new }
     it "raises an error" do
-      expect { subject.check_fixity }.to raise_error(ArgumentError, "You must provide a uri")
+      expect { file.check_fixity }.to raise_error(ArgumentError, "You must provide a uri")
     end
   end
   context "with missing resource" do
-    subject { ActiveFedora::File.new(ActiveFedora::Base.id_to_uri('123')) }
+    subject(:file) { ActiveFedora::File.new(ActiveFedora::Base.id_to_uri('123')) }
     it "raises an error" do
-      expect { subject.check_fixity }.to raise_error(Ldp::NotFound)
+      expect { file.check_fixity }.to raise_error(Ldp::NotFound)
     end
   end
 end

data/spec/integration/file_spec.rb

@@ -4,19 +4,20 @@ require 'active_fedora'
 require "rexml/document"
 
 describe ActiveFedora::File do
+  let(:file) { described_class.new }
   describe "#save" do
     context "with new files" do
       context "with a string" do
-        before { subject.content = "hello" }
+        before { file.content = "hello" }
         it "saves" do
-          expect(subject.save).to be true
+          expect(file.save).to be true
         end
       end
 
       context "with no content" do
-        before { subject.content = nil }
+        before { file.content = nil }
         it "does not save" do
-          expect(subject.save).to be false
+          expect(file.save).to be false
         end
       end
     end
@@ -43,9 +44,9 @@ describe ActiveFedora::File do
       end
 
       it "saves" do
-        subject.content = ActionDispatch::Http::UploadedFile.new
-        subject.save
-        expect(subject).not_to be_new_record
+        file.content = ActionDispatch::Http::UploadedFile.new
+        file.save
+        expect(file).not_to be_new_record
       end
     end
   end
@@ -149,9 +150,7 @@ describe ActiveFedora::File do
           end
           context "open ended" do
             let(:range) { 'bytes=0-' }
-            it "gets a response" do
-              expect(subject).to eq 'one1two2threfour'
-            end
+            it { should eq 'one1two2threfour' }
           end
           context "not starting at the beginning" do
             let(:range) { 'bytes=3-15' }

data/spec/integration/has_many_associations_spec.rb

@@ -31,18 +31,16 @@ describe ActiveFedora::Associations::HasManyAssociation do
         let!(:book) { Book.create }
         let(:library) { Library.new }
         subject { library.books.count }
-        it "it excludes the books that aren't associated" do
-          expect(subject).to eq 0
-        end
+        # it excludes the books that aren't associated
+        it { is_expected.to eq 0 }
       end
 
       context "when the owner is saved with associations" do
         let(:book) { Book.create }
         let!(:library) { Library.create(books: [book]) }
         subject { library.reload; library.books.count }
-        it "it excludes the books that are associated" do
-          expect(subject).to eq 1
-        end
+        # it excludes the books that are associated
+        it { is_expected.to eq 1 }
       end
 
       context "when the owner is not saved after checking the count" do
@@ -406,10 +404,10 @@ describe ActiveFedora::Associations::HasManyAssociation do
         library.save
       end
 
-      subject { library.books(true) }
+      subject(:books) { library.books(true) }
 
       it "saves the new title" do
-        expect(subject.first.title).to eq ["Better book"]
+        expect(books.first.title).to eq ["Better book"]
       end
     end
   end

data/spec/integration/indirect_container_spec.rb

@@ -130,18 +130,17 @@ describe "Indirect containers" do
         end
 
         describe "#first" do
-          subject { reloaded.related_objects.first }
+          subject(:first) { reloaded.related_objects.first }
           it "has the content" do
-            expect(subject.title).to eq 'HMMM'
+            expect(first.title).to eq 'HMMM'
           end
         end
 
         describe "#==" do
           subject { reloaded.related_objects }
 
-          it "delegates to to_a" do
-            expect(subject).to eq [file]
-          end
+          # it delegates to to_a
+          it { is_expected.to eq [file] }
         end
 
         describe "#concat" do
@@ -242,9 +241,9 @@ describe "Indirect containers" do
         end
 
         describe "#first" do
-          subject { reloaded.related_objects.first }
+          subject(:first) { reloaded.related_objects.first }
           it "has the content" do
-            expect(subject.title).to eq 'HMMM'
+            expect(first.title).to eq 'HMMM'
           end
         end
       end
@@ -280,9 +279,9 @@ describe "Indirect containers" do
         end
 
         describe "#first" do
-          subject { reloaded.related_objects.first }
+          subject(:first) { reloaded.related_objects.first }
           it "has the content" do
-            expect(subject.title).to eq 'HMMM'
+            expect(first.title).to eq 'HMMM'
           end
         end
       end

data/spec/integration/json_serialization_spec.rb

@@ -21,12 +21,12 @@ describe "Objects should be serialized to JSON" do
 
     before { allow(obj).to receive(:id).and_return('test-123') }
 
-    subject { JSON.parse(obj.to_json) }
+    let(:json) { JSON.parse(obj.to_json) }
 
     it "has to_json" do
-      expect(subject['id']).to eq "test-123"
-      expect(subject['title']).to eq ["My Title"]
-      expect(subject['description']).to eq "Wonderful stuff"
+      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/ntriples_datastream_spec.rb

@@ -30,7 +30,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
   end
 
-  subject { MyDatastream.new(described_class.id_to_uri('test:1')) }
+  subject(:my_datastream) { MyDatastream.new(described_class.id_to_uri('test:1')) }
 
   after do
     Object.send(:remove_const, :RdfTest)
@@ -50,44 +50,44 @@ EOF
   end
 
   it "delegates as_json to the fields" do
-    subject.title = "Title of work"
-    expect(subject.title.as_json).to eq ["Title of work"]
-    expect(subject.title.to_json).to eq "\[\"Title of work\"\]"
+    my_datastream.title = "Title of work"
+    expect(my_datastream.title.as_json).to eq ["Title of work"]
+    expect(my_datastream.title.to_json).to eq "\[\"Title of work\"\]"
   end
 
   describe "serializing" do
     it "handles dates" do
-      subject.date_uploaded = [Date.parse('2012-11-02')]
-      expect(subject.date_uploaded.first).to be_kind_of Date
+      my_datastream.date_uploaded = [Date.parse('2012-11-02')]
+      expect(my_datastream.date_uploaded.first).to be_kind_of Date
     end
     it "handles integers" do
-      subject.filesize = 12_345
-      expect(subject.filesize).to eq [12_345]
-      expect(subject.filesize.first).to be_kind_of Fixnum
+      my_datastream.filesize = 12_345
+      expect(my_datastream.filesize).to eq [12_345]
+      expect(my_datastream.filesize.first).to be_kind_of Fixnum
     end
   end
 
   it "sets and recall values" do
-    subject.title = 'War and Peace'
-    expect(subject).to be_changed
-    subject.based_near = ["Moscow, Russia"]
-    subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    subject.part = ["this is a part"]
-    subject.save
-    expect(subject.title).to eq ['War and Peace']
-    expect(subject.based_near).to eq ["Moscow, Russia"]
-    expect(subject.related_url).to eq ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    expect(subject.part).to eq ["this is a part"]
+    my_datastream.title = 'War and Peace'
+    expect(my_datastream).to be_changed
+    my_datastream.based_near = ["Moscow, Russia"]
+    my_datastream.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    my_datastream.part = ["this is a part"]
+    my_datastream.save
+    expect(my_datastream.title).to eq ['War and Peace']
+    expect(my_datastream.based_near).to eq ["Moscow, Russia"]
+    expect(my_datastream.related_url).to eq ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    expect(my_datastream.part).to eq ["this is a part"]
   end
 
   it "set, persist, and recall values" do
-    subject.title = 'War and Peace'
-    subject.based_near = ["Moscow, Russia"]
-    subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    subject.part = ["this is a part"]
-    subject.save
+    my_datastream.title = 'War and Peace'
+    my_datastream.based_near = ["Moscow, Russia"]
+    my_datastream.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
+    my_datastream.part = ["this is a part"]
+    my_datastream.save
 
-    loaded = MyDatastream.new(subject.uri)
+    loaded = MyDatastream.new(my_datastream.uri)
     expect(loaded.title).to eq ['War and Peace']
     expect(loaded.based_near).to eq ['Moscow, Russia']
     expect(loaded.related_url).to eq ['http://en.wikipedia.org/wiki/War_and_Peace']
@@ -95,32 +95,32 @@ EOF
   end
 
   it "sets multiple values" do
-    subject.part = ["part 1", "part 2"]
-    subject.save
+    my_datastream.part = ["part 1", "part 2"]
+    my_datastream.save
 
-    loaded = MyDatastream.new(subject.uri)
+    loaded = MyDatastream.new(my_datastream.uri)
     expect(loaded.part).to contain_exactly 'part 1', 'part 2'
   end
 
   it "appends values" do
-    subject.part = ["thing 1"]
-    subject.save
+    my_datastream.part = ["thing 1"]
+    my_datastream.save
 
-    subject.part << "thing 2"
-    expect(subject.part).to contain_exactly "thing 1", "thing 2"
+    my_datastream.part << "thing 2"
+    expect(my_datastream.part).to contain_exactly "thing 1", "thing 2"
   end
 
   it "is able to save a blank document" do
-    subject.title = ""
-    subject.save
+    my_datastream.title = ""
+    my_datastream.save
   end
 
   it "loads n-triples into the graph" do
     ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
 <http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
 '
-    subject.content = ntrip
-    expect(subject.graph.statements.to_a).to contain_exactly(*RDF::NTriples::Reader.new(ntrip).statements.to_a)
+    my_datastream.content = ntrip
+    expect(my_datastream.graph.statements.to_a).to contain_exactly(*RDF::NTriples::Reader.new(ntrip).statements.to_a)
   end
 
   describe "using rdf_subject" do
@@ -130,55 +130,55 @@ EOF
         rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{parent_uri(ds).split('/')[-1].split(':')[1]}") }
         property :dctype, predicate: ::RDF::Vocab::DC.type
       end
-      subject.rdf.dctype = "Frog"
-      subject.save!
+      rdf_test.rdf.dctype = "Frog"
+      rdf_test.save!
     end
 
     after do
-      subject.destroy
+      rdf_test.destroy
     end
 
-    subject { RdfTest.new('/test:99') }
+    subject(:rdf_test) { RdfTest.new('/test:99') }
 
     it "writes rdf with proper subjects" do
-      subject.reload
-      expect(subject.rdf.graph.dump(:ntriples)).to eq "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
-      subject.rdf.dctype == ['Frog']
+      rdf_test.reload
+      expect(rdf_test.rdf.graph.dump(:ntriples)).to eq "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
+      rdf_test.rdf.dctype == ['Frog']
     end
   end
 
   it "deletes values" do
-    subject.title = "Hamlet"
-    subject.related_url = ["http://psu.edu/"]
-    subject.related_url << "http://projecthydra.org/"
+    my_datastream.title = "Hamlet"
+    my_datastream.related_url = ["http://psu.edu/"]
+    my_datastream.related_url << "http://projecthydra.org/"
 
-    expect(subject.title).to eq ["Hamlet"]
-    expect(subject.related_url).to include("http://psu.edu/")
-    expect(subject.related_url).to include("http://projecthydra.org/")
+    expect(my_datastream.title).to eq ["Hamlet"]
+    expect(my_datastream.related_url).to include("http://psu.edu/")
+    expect(my_datastream.related_url).to include("http://projecthydra.org/")
 
-    subject.title = "" # empty string can be meaningful, don't assume delete.
-    expect(subject.title).to eq ['']
+    my_datastream.title = "" # empty string can be meaningful, don't assume delete.
+    expect(my_datastream.title).to eq ['']
 
-    subject.title = nil
-    subject.related_url.delete("http://projecthydra.org/")
+    my_datastream.title = nil
+    my_datastream.related_url.delete("http://projecthydra.org/")
 
-    expect(subject.title).to eq []
-    expect(subject.related_url).to eq ["http://psu.edu/"]
+    expect(my_datastream.title).to eq []
+    expect(my_datastream.related_url).to eq ["http://psu.edu/"]
   end
 
   it "deletes multiple values at once" do
-    subject.part = ["MacBeth"]
-    subject.part << "Hamlet"
-    subject.part << "Romeo & Juliet"
-    expect(subject.part).to include "MacBeth"
-    subject.part.subtract(["MacBeth", "Romeo & Juliet"])
-    expect(subject.part).to eq ["Hamlet"]
-    expect(subject.part.first).to eq "Hamlet"
+    my_datastream.part = ["MacBeth"]
+    my_datastream.part << "Hamlet"
+    my_datastream.part << "Romeo & Juliet"
+    expect(my_datastream.part).to include "MacBeth"
+    my_datastream.part.subtract(["MacBeth", "Romeo & Juliet"])
+    expect(my_datastream.part).to eq ["Hamlet"]
+    expect(my_datastream.part.first).to eq "Hamlet"
   end
   it "ignores values to be deleted that do not exist" do
-    subject.part = ["title1", "title2", "title3"]
-    subject.part.subtract(["title2", "title4", "title6"])
-    expect(subject.part).to contain_exactly "title1", "title3"
+    my_datastream.part = ["title1", "title2", "title3"]
+    my_datastream.part.subtract(["title2", "title4", "title6"])
+    expect(my_datastream.part).to contain_exactly "title1", "title3"
   end
 
   describe "term proxy methods" do
@@ -187,29 +187,29 @@ EOF
         property :title, predicate: ::RDF::Vocab::DC.title
       end
     end
-    subject { TitleDatastream.new }
-    before { subject.title = ["title1", "title2", "title3"] }
+    subject(:title_datastream) { TitleDatastream.new }
+    before { title_datastream.title = ["title1", "title2", "title3"] }
 
     after(:each) do
       Object.send(:remove_const, :TitleDatastream)
     end
 
     it "supports the count method to determine # of values" do
-      expect(subject.title.count).to eq 3
+      expect(title_datastream.title.count).to eq 3
     end
     it "iterates over multiple values" do
-      expect(subject.title).to respond_to(:each)
+      expect(title_datastream.title).to respond_to(:each)
     end
     it "evaluates equality predictably" do
-      expect(subject.title).to contain_exactly "title1", "title2", "title3"
+      expect(title_datastream.title).to contain_exactly "title1", "title2", "title3"
     end
     it "supports the empty? method" do
-      expect(subject.title).to_not be_empty
-      subject.title.subtract(["title1", "title2", "title3"])
-      expect(subject.title).to be_empty
+      expect(title_datastream.title).to_not be_empty
+      title_datastream.title.subtract(["title1", "title2", "title3"])
+      expect(title_datastream.title).to be_empty
     end
     it "supports the each method" do
-      expect(subject.title.respond_to?(:each)).to eq true
+      expect(title_datastream.title.respond_to?(:each)).to eq true
     end
   end
 end

data/spec/integration/om_datastream_spec.rb

@@ -18,40 +18,40 @@ describe ActiveFedora::OmDatastream do
     obj.destroy
   end
 
-  subject { obj.descMetadata }
+  subject(:desc_metadata) { obj.descMetadata }
 
   describe "#changed?" do
     it "is not changed when no fields have been set" do
-      expect(subject).to_not be_content_changed
+      expect(desc_metadata).to_not be_content_changed
     end
     it "is changed when a field has been set" do
-      subject.title = 'Foobar'
-      expect(subject).to be_content_changed
+      desc_metadata.title = 'Foobar'
+      expect(desc_metadata).to be_content_changed
     end
     it "is not changed if the new xml matches the old xml" do
-      subject.content = subject.content
-      expect(subject).to_not be_content_changed
+      desc_metadata.content = desc_metadata.content
+      expect(desc_metadata).to_not be_content_changed
     end
 
     it "is changed if there are minor differences in whitespace" do
-      subject.content = "<a><b>1</b></a>"
+      desc_metadata.content = "<a><b>1</b></a>"
       obj.save
-      expect(subject).to_not be_content_changed
-      subject.content = "<a>\n<b>1</b>\n</a>"
-      expect(subject).to be_content_changed
+      expect(desc_metadata).to_not be_content_changed
+      desc_metadata.content = "<a>\n<b>1</b>\n</a>"
+      expect(desc_metadata).to be_content_changed
     end
   end
 
   describe "empty datastream content" do
     it "does not break when there is empty datastream content" do
-      subject.content = ""
+      desc_metadata.content = ""
       obj.save
     end
   end
 
   describe '.update_values' do
     before do
-      subject.content = File.read(fixture('mods_articles/mods_article1.xml'))
+      desc_metadata.content = File.read(fixture('mods_articles/mods_article1.xml'))
       obj.save
       obj.reload
     end
@@ -67,7 +67,7 @@ describe ActiveFedora::OmDatastream do
 
   describe ".to_solr" do
     before do
-      subject.journal.issue.publication_date = Date.parse('2012-11-02')
+      desc_metadata.journal.issue.publication_date = Date.parse('2012-11-02')
       obj.save!
       obj.reload
     end