active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -38,25 +38,25 @@ describe "Nesting attribute behavior of RDF resources" do
   end
 
   context "with an AT resource as a property" do
-    subject { ComplexResource.new }
+    subject(:complex_resource) { ComplexResource.new }
 
     let(:params) { [{ subject: 'Foo' }, { subject: 'Bar' }] }
 
     before do
       ComplexResource.accepts_nested_attributes_for(*args)
-      subject.topic_attributes = params
+      complex_resource.topic_attributes = params
     end
 
     context "when no options are set" do
       let(:args) { [:topic] }
 
       it "sets the attributes" do
-        expect(subject.topic.size).to eq 2
-        expect(subject.topic.map(&:subject)).to contain_exactly ['Foo'], ['Bar']
+        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(subject.changed_attributes.keys).to eq ["topic"]
+        expect(complex_resource.changed_attributes.keys).to eq ["topic"]
       end
     end
 
@@ -66,7 +66,7 @@ describe "Nesting attribute behavior of RDF resources" do
       let(:params) { [{ subject: 'Foo' }, { subject: 'Bar' }] }
 
       it "does not add terms for which the proc is true" do
-        expect(subject.topic.map(&:subject)).to eq [['Foo']]
+        expect(complex_resource.topic.map(&:subject)).to eq [['Foo']]
       end
     end
   end

data/spec/integration/relation_delegation_spec.rb

@@ -25,30 +25,30 @@ describe ActiveFedora::Base do
     let!(:instance2) { TestClass.create!(foo: ['Alpha'], bar: ['Peanuts']) }
     let!(:instance3) { TestClass.create!(foo: ['Sigma'], bar: ['Peanuts']) }
 
-    subject { TestClass.where(bar: 'Peanuts') }
+    subject(:peanuts) { TestClass.where(bar: 'Peanuts') }
 
     it "maps" do
-      expect(subject.map(&:id)).to contain_exactly instance2.id, instance3.id
+      expect(peanuts.map(&:id)).to contain_exactly instance2.id, instance3.id
     end
 
     it "collects" do
-      expect(subject.collect(&:id)).to contain_exactly instance2.id, instance3.id
+      expect(peanuts.collect(&:id)).to contain_exactly instance2.id, instance3.id
     end
 
     it "has each" do
       t = double
       expect(t).to receive(:foo).twice
-      subject.each { t.foo }
+      peanuts.each { t.foo }
     end
 
     it "has all?" do
-      expect(subject.all? { |t| t.foo == ['Alpha'] }).to be false
-      expect(subject.all? { |t| t.bar == ['Peanuts'] }).to be true
+      expect(peanuts.all? { |t| t.foo == ['Alpha'] }).to be false
+      expect(peanuts.all? { |t| t.bar == ['Peanuts'] }).to be true
     end
 
     it "has include?" do
-      expect(subject.include?(instance1)).to be false
-      expect(subject.include?(instance2)).to be true
+      expect(peanuts.include?(instance1)).to be false
+      expect(peanuts.include?(instance2)).to be true
     end
   end
 end

data/spec/integration/relation_spec.rb

@@ -15,15 +15,13 @@ describe ActiveFedora::Base do
     Object.send(:remove_const, :Book)
   end
 
-  subject { Library.all }
+  subject(:libraries) { Library.all }
 
   it "is a relation" do
-    expect(subject.class).to be ActiveFedora::Relation
+    expect(libraries.class).to be ActiveFedora::Relation
   end
 
-  it "is enumerable" do
-    expect(subject).to respond_to(:each_with_index)
-  end
+  it { is_expected.to respond_to(:each_with_index) }
 
   context "when some records exist" do
     before do
@@ -34,43 +32,42 @@ describe ActiveFedora::Base do
 
     describe "is cached" do
       before do
-        subject.to_a # trigger initial load
+        libraries.to_a # trigger initial load
       end
 
-      it "is loaded" do
-        expect(subject).to be_loaded
-      end
+      it { is_expected.to be_loaded }
+
       it "does not reload" do
         expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
-        subject[0]
+        libraries[0]
       end
     end
 
     describe "#find" do
       it "finds one of them" do
-        expect(subject.find(library1.id)).to eq library1
+        expect(libraries.find(library1.id)).to eq library1
       end
       it "finds with a block" do
-        expect(subject.find { |l| l.id == library1.id }).to eq library1
+        expect(libraries.find { |l| l.id == library1.id }).to eq library1
       end
     end
 
     describe "#select" do
       it "finds with a block" do
-        expect(subject.select { |l| l.id == library1.id }).to eq [library1]
+        expect(libraries.select { |l| l.id == library1.id }).to eq [library1]
       end
     end
 
     context "unpermitted methods" do
       it "excludes them" do
-        expect { subject.sort! }.to raise_error NoMethodError
+        expect { libraries.sort! }.to raise_error NoMethodError
       end
     end
 
     context "when limit is applied" do
-      subject { Library.create books: [Book.create, Book.create] }
+      subject(:libraries) { Library.create books: [Book.create, Book.create] }
       it "limits the number of books" do
-        expect(subject.books.limit(1).size).to eq 1
+        expect(libraries.books.limit(1).size).to eq 1
       end
     end
   end

data/spec/integration/solr_hit_spec.rb

@@ -19,14 +19,14 @@ describe ActiveFedora::SolrHit do
   ) }
 
   let(:doc) { obj.to_solr }
-  let(:solr_hit) { described_class.new(doc) }
+  subject(:solr_hit) { described_class.new(doc) }
 
   describe "#reify" do
-    subject { solr_hit.reify }
+    let(:solr_reified) { solr_hit.reify }
 
     it "finds the document in solr" do
-      expect(subject).to be_instance_of Foo
-      expect(subject.title).to eq 'My Title'
+      expect(solr_reified).to be_instance_of Foo
+      expect(solr_reified.title).to eq 'My Title'
     end
   end
 end

data/spec/integration/versionable_spec.rb

@@ -12,45 +12,45 @@ describe ActiveFedora::Versionable do
       Object.send(:remove_const, :WithVersions)
     end
 
-    subject { WithVersions.new }
+    subject(:object) { WithVersions.new }
 
     let(:current_year) { DateTime.now.year.to_s }
 
     context "saved with no versions" do
       it "does not have versions" do
-        subject.update(title: ["Greetings Earthlings"])
-        expect(subject).not_to have_versions
+        object.update(title: ["Greetings Earthlings"])
+        expect(object).not_to have_versions
       end
     end
 
     context "saved with versions" do
       it "has versions" do
-        subject.update(title: ["Greetings Earthlings"])
-        subject.create_version
-        expect(subject).to have_versions
+        object.update(title: ["Greetings Earthlings"])
+        object.create_version
+        expect(object).to have_versions
       end
     end
 
     describe 'sorting versions' do
       before do
-        allow(subject).to receive(:fedora_versions) { versions }
+        allow(graph).to receive(:fedora_versions) { versions }
       end
 
       let(:version1) { double('version1', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e711aa993d-e1d2-4a65-93ee-3a12fc9541ab', label: 'version1', created: '2015-04-02T19:54:45.962Z') }
       let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '2015-04-02T19:54:45.96Z') }
       let(:versions) { [version1, version2] }
 
-      subject { ActiveFedora::VersionsGraph.new }
+      subject(:graph) { ActiveFedora::VersionsGraph.new }
 
       it 'sorts by DateTime' do
-        expect(subject.first).to eq version2
+        expect(graph.first).to eq version2
       end
 
       context 'with an unparseable created date' do
         let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2', created: '') }
 
         it 'raises an exception' do
-          expect { subject.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
+          expect { graph.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
         end
       end
 
@@ -63,62 +63,62 @@ describe ActiveFedora::Versionable do
         let(:version2) { double('version2', uri: 'http://localhost:8983/fedora/rest/test/84/61/63/98/84616398-f63a-4572-ba01-0689339e4fcb/fcr:versions/87a0a8c317f1e790373a67-c9ee-447d-b740-4faa882b1a1f', label: 'version2') }
 
         it 'raises an exception' do
-          expect { subject.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
+          expect { graph.first }.to raise_error(ActiveFedora::VersionLacksCreateDate)
         end
       end
     end
 
     context "after saving" do
       before do
-        subject.title = ["Greetings Earthlings"]
-        subject.save
-        subject.create_version
+        object.title = ["Greetings Earthlings"]
+        object.save
+        object.create_version
       end
 
       it { is_expected.to have_versions }
 
       it "has one version" do
-        expect(subject.versions).to be_kind_of ActiveFedora::VersionsGraph
-        expect(subject.versions.all.first).to be_kind_of ActiveFedora::VersionsGraph::ResourceVersion
-        expect(subject.versions.all.first.label).to eql "version1"
-        expect(subject.versions.all.first.created).to start_with current_year
+        expect(object.versions).to be_kind_of ActiveFedora::VersionsGraph
+        expect(object.versions.all.first).to be_kind_of ActiveFedora::VersionsGraph::ResourceVersion
+        expect(object.versions.all.first.label).to eql "version1"
+        expect(object.versions.all.first.created).to start_with current_year
       end
 
       context "two times" do
         before do
-          subject.title = ["Surrender and prepare to be boarded"]
-          subject.save
-          subject.create_version
+          object.title = ["Surrender and prepare to be boarded"]
+          object.save
+          object.create_version
         end
 
         it "has two versions" do
-          expect(subject.versions.all.size).to eq 2
-          subject.versions.all.each_index do |index|
-            expect(subject.versions.all[index].label).to end_with "version" + (index + 1).to_s
-            expect(subject.versions.all[index].created).to start_with current_year
+          expect(object.versions.all.size).to eq 2
+          object.versions.all.each_index do |index|
+            expect(object.versions.all[index].label).to end_with "version" + (index + 1).to_s
+            expect(object.versions.all[index].created).to start_with current_year
           end
         end
 
         context "then restoring" do
           let(:first_version) { "version1" }
           before do
-            subject.restore_version(first_version)
+            object.restore_version(first_version)
           end
 
           it "will return to the first version's values" do
-            expect(subject.title).to eq(["Greetings Earthlings"])
+            expect(object.title).to eq(["Greetings Earthlings"])
           end
 
           context "and creating additional versions" do
             before do
-              subject.title = ["Now, surrender and prepare to be boarded"]
-              subject.save!
-              subject.create_version
+              object.title = ["Now, surrender and prepare to be boarded"]
+              object.save!
+              object.create_version
             end
 
             it "has three versions" do
-              expect(subject.versions.all.size).to eq 3
-              expect(subject.title).to eq(["Now, surrender and prepare to be boarded"])
+              expect(object.versions.all.size).to eq 3
+              expect(object.title).to eq(["Now, surrender and prepare to be boarded"])
             end
           end
         end
@@ -146,7 +146,7 @@ describe ActiveFedora::Versionable do
       MockAFBase.create
     end
 
-    subject { test_object.descMetadata }
+    subject(:desc_metadata) { test_object.descMetadata }
 
     let(:current_year) { DateTime.now.year.to_s }
 
@@ -155,96 +155,96 @@ describe ActiveFedora::Versionable do
 
       context "before creating the file" do
         it "does not have versions" do
-          expect(subject.versions).to be_empty
+          expect(desc_metadata.versions).to be_empty
         end
         it "does not have a title" do
-          expect(subject.title).to be_empty
+          expect(desc_metadata.title).to be_empty
         end
       end
 
       context "after creating the file" do
         before do
-          subject.title = "Greetings Earthlings"
-          subject.save
-          subject.create_version
-          @original_size = subject.size
+          desc_metadata.title = "Greetings Earthlings"
+          desc_metadata.save
+          desc_metadata.create_version
+          @original_size = desc_metadata.size
         end
 
         it "links to versions endpoint" do
-          expect(subject.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
+          expect(desc_metadata.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
         end
 
         it "has one version" do
-          expect(subject.versions.first.label).to eql "version1"
+          expect(desc_metadata.versions.first.label).to eql "version1"
         end
 
         it "has a title" do
-          expect(subject.title).to eq(["Greetings Earthlings"])
+          expect(desc_metadata.title).to eq(["Greetings Earthlings"])
         end
 
         it "has a size" do
-          expect(subject.size).to_not be_nil
+          expect(desc_metadata.size).to_not be_nil
         end
 
         context "two times" do
           before do
-            subject.title = "Surrender and prepare to be boarded"
-            subject.save
-            subject.create_version
+            desc_metadata.title = "Surrender and prepare to be boarded"
+            desc_metadata.save
+            desc_metadata.create_version
           end
 
           it "has two versions" do
-            expect(subject.versions.all.size).to eq 2
-            subject.versions.all.each_index do |index|
-              expect(subject.versions.all[index].label).to end_with "version" + (index + 1).to_s
-              expect(subject.versions.all[index].created).to start_with current_year
+            expect(desc_metadata.versions.all.size).to eq 2
+            desc_metadata.versions.all.each_index do |index|
+              expect(desc_metadata.versions.all[index].label).to end_with "version" + (index + 1).to_s
+              expect(desc_metadata.versions.all[index].created).to start_with current_year
             end
           end
 
           it "has the new title" do
-            expect(subject.title).to eq(["Surrender and prepare to be boarded"])
+            expect(desc_metadata.title).to eq(["Surrender and prepare to be boarded"])
           end
 
           it "has a new size" do
-            expect(subject.size).to_not be_nil
-            expect(subject.size).to_not eq(@original_size)
+            expect(desc_metadata.size).to_not be_nil
+            expect(desc_metadata.size).to_not eq(@original_size)
           end
 
           context "then restoring" do
             let(:first_version) { "version1" }
             before do
-              subject.restore_version(first_version)
+              desc_metadata.restore_version(first_version)
             end
 
             it "has two unique versions" do
-              expect(subject.versions.all.size).to eq 2
+              expect(desc_metadata.versions.all.size).to eq 2
             end
 
             it "loads the restored file's content" do
-              expect(subject.title).to eq(["Greetings Earthlings"])
+              expect(desc_metadata.title).to eq(["Greetings Earthlings"])
             end
 
             it "is the same size as the original file" do
-              expect(subject.size).to eq @original_size
+              expect(desc_metadata.size).to eq @original_size
             end
 
             context "and creating additional versions" do
               before do
-                subject.title = "Now, surrender and prepare to be boarded"
-                subject.save
-                subject.create_version
+                desc_metadata.title = "Now, surrender and prepare to be boarded"
+                desc_metadata.save
+                desc_metadata.create_version
               end
 
               it "has three unique versions" do
-                expect(subject.versions.all.size).to eq 3
+                expect(desc_metadata.versions.all.size).to eq 3
               end
 
               it "has a new title" do
-                expect(subject.title).to eq(["Now, surrender and prepare to be boarded"])
+                expect(desc_metadata.title).to eq(["Now, surrender and prepare to be boarded"])
               end
 
               it "has a new size" do
-                expect(subject.size).to_not eq @original_size
+                expect(desc_metadata.size).to_not eq @original_size
               end
             end
           end
@@ -272,7 +272,7 @@ describe ActiveFedora::Versionable do
       Object.send(:remove_const, :VersionableDatastream)
     end
 
-    subject { test_object.descMetadata }
+    subject(:desc_metadata) { test_object.descMetadata }
 
     let(:current_year) { DateTime.now.year.to_s }
 
@@ -281,97 +281,97 @@ describe ActiveFedora::Versionable do
 
       context "before creating the file" do
         it "does not have versions" do
-          expect(subject.versions).to be_empty
+          expect(desc_metadata.versions).to be_empty
         end
         it "does not have a title" do
-          expect(subject.title).to be_empty
+          expect(desc_metadata.title).to be_empty
         end
       end
 
       context "after creating the file" do
         before do
-          subject.title = "Greetings Earthlings"
-          subject.save
-          subject.create_version
-          @original_size = subject.size
+          desc_metadata.title = "Greetings Earthlings"
+          desc_metadata.save
+          desc_metadata.create_version
+          @original_size = desc_metadata.size
         end
 
         it "links to versions endpoint" do
-          expect(subject.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
+          expect(desc_metadata.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
         end
 
         it "has one version" do
-          expect(subject.versions.first.label).to eql "version1"
-          expect(subject.versions.first.created).to start_with current_year
+          expect(desc_metadata.versions.first.label).to eql "version1"
+          expect(desc_metadata.versions.first.created).to start_with current_year
         end
 
         it "has a title" do
-          expect(subject.title).to eql(["Greetings Earthlings"])
+          expect(desc_metadata.title).to eql(["Greetings Earthlings"])
         end
 
         it "has a size" do
-          expect(subject.size).to_not be_nil
+          expect(desc_metadata.size).to_not be_nil
         end
 
         context "two times" do
           before do
-            subject.title = "Surrender and prepare to be boarded"
-            subject.save
-            subject.create_version
+            desc_metadata.title = "Surrender and prepare to be boarded"
+            desc_metadata.save
+            desc_metadata.create_version
           end
 
           it "has two unique versions" do
-            expect(subject.versions.all.size).to eq 2
-            subject.versions.all.each_index do |index|
-              expect(subject.versions.all[index].label).to end_with "version" + (index + 1).to_s
-              expect(subject.versions.all[index].created).to start_with current_year
+            expect(desc_metadata.versions.all.size).to eq 2
+            desc_metadata.versions.all.each_index do |index|
+              expect(desc_metadata.versions.all[index].label).to end_with "version" + (index + 1).to_s
+              expect(desc_metadata.versions.all[index].created).to start_with current_year
             end
           end
 
           it "has the new title" do
-            expect(subject.title).to eql(["Surrender and prepare to be boarded"])
+            expect(desc_metadata.title).to eql(["Surrender and prepare to be boarded"])
           end
 
           it "has a new size" do
-            expect(subject.size).to_not be_nil
-            expect(subject.size).to_not eq(@original_size)
+            expect(desc_metadata.size).to_not be_nil
+            expect(desc_metadata.size).to_not eq(@original_size)
           end
 
           context "then restoring" do
             let(:first_version) { "version1" }
             before do
-              subject.restore_version(first_version)
+              desc_metadata.restore_version(first_version)
             end
 
             it "stills have two unique versions" do
-              expect(subject.versions.all.size).to eq 2
+              expect(desc_metadata.versions.all.size).to eq 2
             end
 
             it "loads the restored file's content" do
-              expect(subject.title).to eql(["Greetings Earthlings"])
+              expect(desc_metadata.title).to eql(["Greetings Earthlings"])
             end
 
             it "is the same size as the original file" do
-              expect(subject.size).to eq @original_size
+              expect(desc_metadata.size).to eq @original_size
             end
 
             context "and creating additional versions" do
               before do
-                subject.title = "Now, surrender and prepare to be boarded"
-                subject.save
-                subject.create_version
+                desc_metadata.title = "Now, surrender and prepare to be boarded"
+                desc_metadata.save
+                desc_metadata.create_version
               end
 
               it "has three unique versions" do
-                expect(subject.versions.all.size).to eq 3
+                expect(desc_metadata.versions.all.size).to eq 3
               end
 
               it "has a new title" do
-                expect(subject.title).to eql(["Now, surrender and prepare to be boarded"])
+                expect(desc_metadata.title).to eql(["Now, surrender and prepare to be boarded"])
               end
 
               it "has a new size" do
-                expect(subject.size).to_not eq @original_size
+                expect(desc_metadata.size).to_not eq @original_size
               end
             end
           end
@@ -395,7 +395,7 @@ describe ActiveFedora::Versionable do
       Object.send(:remove_const, :BinaryDatastream)
     end
 
-    subject { test_object.content }
+    let(:content) { test_object.content }
 
     let(:current_year) { DateTime.now.year.to_s }
 
@@ -404,7 +404,7 @@ describe ActiveFedora::Versionable do
 
       context "before creating the file" do
         it "does not have versions" do
-          expect(subject.versions).to be_empty
+          expect(content.versions).to be_empty
         end
       end
 
@@ -412,48 +412,48 @@ describe ActiveFedora::Versionable do
         let(:first_file) { File.new(File.join(File.dirname(__FILE__), "../fixtures/dino.jpg")) }
         let(:first_name) { "dino.jpg" }
         before do
-          subject.content = first_file
-          subject.original_name = first_name
-          subject.save
-          subject.create_version
+          content.content = first_file
+          content.original_name = first_name
+          content.save
+          content.create_version
         end
 
         it "links to versions endpoint" do
-          expect(subject.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
+          expect(content.metadata.ldp_source.graph.query(predicate: ::RDF::Vocab::Fcrepo4.hasVersions).objects).to_not be_empty
         end
 
         it "has one version" do
-          expect(subject.versions.all.size).to eq 1
-          expect(subject.original_name).to eql(first_name)
-          expect(subject.content.size).to eq first_file.size
-          expect(subject.versions.first.label).to eql "version1"
-          expect(subject.versions.first.created).to start_with current_year
+          expect(content.versions.all.size).to eq 1
+          expect(content.original_name).to eql(first_name)
+          expect(content.content.size).to eq first_file.size
+          expect(content.versions.first.label).to eql "version1"
+          expect(content.versions.first.created).to start_with current_year
         end
 
         context "two times" do
           let(:second_file) { File.new(File.join(File.dirname(__FILE__), "../fixtures/minivan.jpg")) }
           let(:second_name) { "minivan.jpg" }
           before do
-            subject.content = second_file
-            subject.original_name = second_name
-            subject.save
-            subject.create_version
+            content.content = second_file
+            content.original_name = second_name
+            content.save
+            content.create_version
           end
 
           it "has two unique versions" do
-            expect(subject.versions.all.size).to eq 2
-            expect(subject.original_name).to eql(second_name)
-            expect(subject.content.size).to eq second_file.size
-            subject.versions.all.each_index do |index|
-              expect(subject.versions.all[index].label).to end_with "version" + (index + 1).to_s
-              expect(subject.versions.all[index].created).to start_with current_year
+            expect(content.versions.all.size).to eq 2
+            expect(content.original_name).to eql(second_name)
+            expect(content.content.size).to eq second_file.size
+            content.versions.all.each_index do |index|
+              expect(content.versions.all[index].label).to end_with "version" + (index + 1).to_s
+              expect(content.versions.all[index].created).to start_with current_year
             end
           end
 
           context "with fixity checking" do
             let(:results) do
               results = []
-              subject.versions.all.each do |version|
+              content.versions.all.each do |version|
                 results << ActiveFedora::FixityService.new(version.uri).check
               end
               return results
@@ -469,36 +469,36 @@ describe ActiveFedora::Versionable do
           context "then restoring" do
             let(:first_version) { "version1" }
             before do
-              subject.restore_version(first_version)
+              content.restore_version(first_version)
             end
 
             it "stills have two unique versions" do
-              expect(subject.versions.all.size).to eq 2
+              expect(content.versions.all.size).to eq 2
             end
 
             it "loads the restored file's content" do
-              expect(subject.content.size).to eq first_file.size
+              expect(content.content.size).to eq first_file.size
             end
 
             it "loads the restored file's original name" do
-              expect(subject.original_name).to eql(first_name)
+              expect(content.original_name).to eql(first_name)
             end
 
             context "and creating additional versions" do
               before do
-                subject.content = first_file
-                subject.original_name = first_name
-                subject.save
-                subject.create_version
+                content.content = first_file
+                content.original_name = first_name
+                content.save
+                content.create_version
               end
 
               it "has three unique versions" do
-                expect(subject.versions.all.size).to eq 3
-                expect(subject.original_name).to eql(first_name)
-                expect(subject.content.size).to eq first_file.size
-                subject.versions.all.each_index do |index|
-                  expect(subject.versions.all[index].label).to end_with "version" + (index + 1).to_s
-                  expect(subject.versions.all[index].created).to start_with current_year
+                expect(content.versions.all.size).to eq 3
+                expect(content.original_name).to eql(first_name)
+                expect(content.content.size).to eq first_file.size
+                content.versions.all.each_index do |index|
+                  expect(content.versions.all[index].label).to end_with "version" + (index + 1).to_s
+                  expect(content.versions.all[index].created).to start_with current_year
                 end
               end
             end