datacite-mapping 0.1.17.2 → 0.2.0

data/spec/unit/datacite/mapping/identifier_spec.rb

@@ -32,6 +32,15 @@ module Datacite
             expect { Identifier.new(value: doi) }.to raise_error(ArgumentError)
           end
         end
+
+        it 'strips' do
+          value = '10.14749/1407399495'
+          id = Identifier.new(value: "
+            #{value}
+          ")
+          expect(id.value).to eq(value)
+        end
+
       end
 
       describe '#from_doi' do

data/spec/unit/datacite/mapping/related_identifier_spec.rb

@@ -151,6 +151,29 @@ module Datacite
           expect(id.save_to_xml).to be_xml(expected_xml)
         end
       end
+
+      describe 'IGSN support' do
+        attr_reader :igsn_xml
+        attr_reader :id
+
+        before(:each) do
+          @igsn_xml = '<relatedIdentifier relatedIdentifierType="IGSN" relationType="References">IECUR0097</relatedIdentifier>'
+          @id = RelatedIdentifier.parse_xml(igsn_xml)
+        end
+
+        it 'reads an IGSN' do
+          expect(id.identifier_type).to eq(RelatedIdentifierType::IGSN)
+        end
+
+        it 'writes an IGSN' do
+          expect(id.save_to_xml).to be_xml(igsn_xml)
+        end
+
+        it 'writes an IGSN as a handle when using DC3 mapping' do
+          expected_xml = '<relatedIdentifier relatedIdentifierType="Handle" relationType="References">10273/IECUR0097</relatedIdentifier>'
+          expect(id.save_to_xml(mapping: :datacite_3)).to be_xml(expected_xml)
+        end
+      end
     end
   end
 end

data/spec/unit/datacite/mapping/resource_spec.rb

@@ -3,918 +3,1052 @@ require 'spec_helper'
 
 module Datacite
   module Mapping
+
     describe Resource do
 
-      before :each do
-        @id = Identifier.new(value: '10.14749/1407399495')
-        @creators = [
-          Creator.new(
-            name: 'Hedy Lamarr',
-            identifier: NameIdentifier.new(scheme: 'ISNI', scheme_uri: URI('http://isni.org/'), value: '0000-0001-1690-159X'),
-            affiliations: ['United Artists', 'Metro-Goldwyn-Mayer']
-          ),
-          Creator.new(
-            name: 'Herschlag, Natalie',
-            identifier: NameIdentifier.new(scheme: 'ISNI', scheme_uri: URI('http://isni.org/'), value: '0000-0001-0907-8419'),
-            affiliations: ['Gaumont Buena Vista International', '20th Century Fox']
-          )
-        ]
-        @titles = [
-          Title.new(value: 'An Account of a Very Odd Monstrous Calf', language: 'en-emodeng'),
-          Title.new(type: TitleType::SUBTITLE, value: 'And a Contest between Two Artists about Optick Glasses, &c', language: 'en-emodeng')
-        ]
-        @publisher = 'California Digital Library'
-        @pub_year = 2015
-      end
+      attr_reader :identifier
+      attr_reader :creators
+      attr_reader :titles
+      attr_reader :publisher
+      attr_reader :publication_year
+      attr_reader :args
 
-      # TODO: double-check all required/optional attributes
-
-      it 'correctly differentiates required and optional attributes'
-
-      # Required:
-      #
-      # <xs:element name="resource">
-      # <xs:element name="identifier">
-      # <xs:element name="creators">
-      # <xs:element name="creator" maxOccurs="unbounded">
-      # <xs:element name="creatorName">
-      # <xs:element name="titles">
-      # <xs:element name="title" maxOccurs="unbounded">
-      # <xs:element name="publisher">
-      # <xs:element name="publicationYear">
-      # <xs:element name="contributorName">
-
-      # Optional:
-      #
-      # <xs:element name="nameIdentifier" minOccurs="0">
-      # <xs:element name="affiliation" minOccurs="0" maxOccurs="unbounded"/>
-      # <xs:element name="subjects" minOccurs="0">
-      # <xs:element name="subject" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="contributors" minOccurs="0">
-      # <xs:element name="contributor" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="nameIdentifier" minOccurs="0">
-      # <xs:element name="affiliation" minOccurs="0" maxOccurs="unbounded"/>
-      # <xs:element name="dates" minOccurs="0">
-      # <xs:element name="date" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="language" type="xs:language" minOccurs="0">
-      # <xs:element name="resourceType" minOccurs="0">
-      # <xs:element name="alternateIdentifiers" minOccurs="0">
-      # <xs:element name="alternateIdentifier" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="relatedIdentifiers" minOccurs="0">
-      # <xs:element name="relatedIdentifier" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="sizes" minOccurs="0">
-      # <xs:element name="size" type="xs:string" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="formats" minOccurs="0">
-      # <xs:element name="format" type="xs:string" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="version" type="xs:string" minOccurs="0">
-      # <xs:element name="rightsList" minOccurs="0">
-      # <xs:element name="rights" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="descriptions" minOccurs="0">
-      # <xs:element name="description" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="br" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="geoLocations" minOccurs="0">
-      # <xs:element name="geoLocation" minOccurs="0" maxOccurs="unbounded">
-      # <xs:element name="geoLocationPoint" type="point" minOccurs="0"/>
-      # <xs:element name="geoLocationBox" type="box" minOccurs="0"/>
-      # <xs:element name="geoLocationPlace" minOccurs="0"/>
-
-      describe '#initialize' do
-        it 'sets the identifier' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          expect(resource.identifier).to eq(@id)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'sets the creators' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          expect(resource.creators).to eq(@creators)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'sets the titles' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          expect(resource.titles).to eq(@titles)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'sets the publisher' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          expect(resource.publisher).to eq(@publisher)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'sets the publicationYear' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          expect(resource.publication_year).to eq(@pub_year)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'requires an identifier' do
-          expect do
-            Resource.new(
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: @pub_year
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: @pub_year,
-              identifier: nil
+      describe 'fields' do
+
+        before(:each) do
+          @identifier = Identifier.new(value: '10.14749/1407399495')
+
+          @creators = [
+            Creator.new(
+              name: 'Hedy Lamarr',
+              identifier: NameIdentifier.new(scheme: 'ISNI', scheme_uri: URI('http://isni.org/'), value: '0000-0001-1690-159X'),
+              affiliations: ['United Artists', 'Metro-Goldwyn-Mayer']
+            ),
+            Creator.new(
+              name: 'Herschlag, Natalie',
+              identifier: NameIdentifier.new(scheme: 'ISNI', scheme_uri: URI('http://isni.org/'), value: '0000-0001-0907-8419'),
+              affiliations: ['Gaumont Buena Vista International', '20th Century Fox']
             )
-          end.to raise_error(ArgumentError)
+          ]
+
+          @titles = [
+            Title.new(value: 'An Account of a Very Odd Monstrous Calf', language: 'en-emodeng'),
+            Title.new(type: TitleType::SUBTITLE, value: 'And a Contest between Two Artists about Optick Glasses, &c', language: 'en-emodeng')
+          ]
+
+          @publisher = 'California Digital Library'
+          @publication_year = 2015
+
+          @args = {
+            identifier: identifier,
+            creators: creators,
+            titles: titles,
+            publisher: publisher,
+            publication_year: publication_year
+          }
         end
 
-        it 'requires creators' do
-          expect do
-            Resource.new(
-              identifier: @id,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: @pub_year
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: @pub_year,
-              creators: []
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: @pub_year,
-              creators: nil
-            )
-          end.to raise_error(ArgumentError)
+        describe '#identifier' do
+          it 'requires an identifier' do
+            args.delete(:identifier)
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'requires a non-nil identifier' do
+            args[:identifier] = nil
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'can be initialized' do
+            resource = Resource.new(args)
+            expect(resource.identifier).to eq(identifier)
+          end
+
+          it 'can be set' do
+            new_id = Identifier.new(value: '10.1594/WDCC/CCSRNIES_SRES_B2')
+            resource = Resource.new(args)
+            resource.identifier = new_id
+            expect(resource.identifier).to eq(new_id)
+          end
         end
 
-        it 'requires titles' do
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              publisher: @publisher,
-              publication_year: @pub_year
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              publisher: @publisher,
-              publication_year: @pub_year,
-              titles: nil
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              publisher: @publisher,
-              publication_year: @pub_year,
-              titles: []
-            )
-          end.to raise_error(ArgumentError)
+        describe '#creators' do
+
+          it 'requires a creator list' do
+            args.delete(:creators)
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'requires a non-nil creator list' do
+            args[:creators] = nil
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'requires a non-empty creator list' do
+            args[:creators] = []
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'can be initialized' do
+            resource = Resource.new(args)
+            expect(resource.creators).to eq(creators)
+          end
+
+          it 'can be set' do
+            new_creators = [Creator.new(
+              name: 'Danica McKellar',
+              identifier: NameIdentifier.new(scheme: 'ISNI', scheme_uri: URI('http://isni.org/'), value: '0000 0001 1678 4522'),
+              affiliations: ['Disney–ABC Television Group']
+            )]
+            resource = Resource.new(args)
+            resource.creators = new_creators
+            expect(resource.creators).to eq(new_creators)
+          end
+
+          describe 'creator convenience methods' do
+            describe '#creator_names' do
+              it 'extracts the creator names' do
+                resource = Resource.new(args)
+                expect(resource.creator_names)
+                  .to eq(['Hedy Lamarr', 'Herschlag, Natalie'])
+              end
+            end
+
+            describe '#creator_affiliations' do
+              it 'extracts the creator affiliations' do
+                resource = Resource.new(args)
+                expect(resource.creator_affiliations)
+                  .to eq([
+                    ['United Artists', 'Metro-Goldwyn-Mayer'],
+                    ['Gaumont Buena Vista International', '20th Century Fox']
+                  ])
+              end
+            end
+          end
         end
 
-        it 'requires a publisher' do
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publication_year: @pub_year
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publication_year: @pub_year,
-              publisher: nil
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publication_year: @pub_year,
-              publisher: []
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publication_year: @pub_year,
-              publisher: ''
-            )
-          end.to raise_error(ArgumentError)
+        describe '#titles' do
+          it 'requires a title list' do
+            args.delete(:titles)
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'requires a non-nil title list' do
+            args[:titles] = nil
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'requires a non-empty title list' do
+            args[:titles] = []
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+
+          it 'can be initialized' do
+            resource = Resource.new(args)
+            expect(resource.titles).to eq(titles)
+          end
+
+          it 'can be set' do
+            new_titles = [Title.new(
+              language: 'en-emodeng',
+              type: TitleType::SUBTITLE,
+              value: 'Together with an Appendix of the Same, Containing an Answer to Some Objections, Made by Severall Persons against That Hypothesis'
+            )]
+            resource = Resource.new(args)
+            resource.titles = new_titles
+            expect(resource.titles).to eq(new_titles)
+          end
+
         end
 
-        it 'requires a publicationYear' do
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: nil
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: -1
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: 999
-            )
-          end.to raise_error(ArgumentError)
-          expect do
-            Resource.new(
-              identifier: @id,
-              creators: @creators,
-              titles: @titles,
-              publisher: @publisher,
-              publication_year: 10_000
-            )
-          end.to raise_error(ArgumentError)
+        describe '#publisher' do
+          it 'requires a publisher' do
+            args.delete(:publisher)
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'requires a non-nil publisher' do
+            args[:publisher] = nil
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'requires a non-blank publisher' do
+            args[:publisher] = "\n  \n"
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'can be initialized' do
+            resource = Resource.new(args)
+            expect(resource.publisher).to eq(publisher)
+          end
+          it 'can be set' do
+            new_publisher = 'University of California'
+            resource = Resource.new(args)
+            resource.publisher = new_publisher
+            expect(resource.publisher).to eq(new_publisher)
+          end
+          it 'strips on initialization' do
+            args[:publisher] = '
+            University of California
+          '
+            resource = Resource.new(args)
+            expect(resource.publisher).to eq('University of California')
+          end
+          it 'strips on set' do
+            resource = Resource.new(args)
+            resource.publisher = '
+            University of California
+          '
+            expect(resource.publisher).to eq('University of California')
+          end
         end
 
-        it 'allows subjects' do
-          subjects = [
-            Subject.new(
-              language: 'en-us',
-              scheme: 'LCSH',
-              scheme_uri: URI('http://id.loc.gov/authorities/subjects'),
-              value: 'Mammals--Embryology'
-            ),
-            Subject.new(
-              language: 'fr',
-              scheme: 'dewey',
-              scheme_uri: URI('http://dewey.info/'),
-              value: '571.8 Croissance, développement, reproduction biologique (fécondation, sexualité)'
-            )
-          ]
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            subjects: subjects
-          )
-          expect(resource.subjects).to eq(subjects)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows dates' do
-          dates = [
-            Date.new(value: DateTime.new(1914, 8, 4, 11, 01, 6.0123, '+1'), type: DateType::AVAILABLE),
-            Date.new(value: '1914-08-04T11:01:06.0123+01:00', type: DateType::AVAILABLE)
-          ]
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            dates: dates
-          )
-          expect(resource.dates).to eq(dates)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows a language' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            language: 'en-emodeng'
-          )
-          expect(resource.language).to eq('en-emodeng')
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows alternate identifiers' do
-          alternate_identifiers = [
-            AlternateIdentifier.new(type: 'URL', value: 'http://example.org'),
-            AlternateIdentifier.new(type: 'URL', value: 'http://example.com')
-          ]
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            alternate_identifiers: alternate_identifiers
-          )
-          expect(resource.alternate_identifiers).to eq(alternate_identifiers)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows sizes' do
-          sizes = ['2 petabytes', '2048 TB']
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            sizes: sizes
-          )
-          expect(resource.sizes).to eq(sizes)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows related identifiers' do
-          related_identifiers = [
-            RelatedIdentifier.new(
-              identifier_type: RelatedIdentifierType::URL,
-              relation_type: RelationType::HAS_METADATA,
-              related_metadata_scheme: 'citeproc+json',
-              scheme_type: 'Turtle',
-              scheme_uri: URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'),
-              value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full'
-            ),
-            RelatedIdentifier.new(
-              identifier_type: RelatedIdentifierType::ARXIV,
-              relation_type: RelationType::IS_REVIEWED_BY,
-              value: 'arXiv:0706.0001'
-            )
-          ]
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            related_identifiers: related_identifiers
-          )
-          expect(resource.related_identifiers).to eq(related_identifiers)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows formats' do
-          formats = %w(application/xml text/html)
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            formats: formats
-          )
-          expect(resource.formats).to eq(formats)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows a version' do
-          version = '3.1'
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            version: version
-          )
-          expect(resource.version).to eq(version)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
-        end
-
-        it 'allows rights' do
-          rights_list = [
-            Rights.new(value: 'CC0 1.0 Universal', uri: URI('http://creativecommons.org/publicdomain/zero/1.0/')),
-            Rights.new(value: 'This work is free of known copyright restrictions.', uri: URI('http://creativecommons.org/publicdomain/mark/1.0/'))
-          ]
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year,
-            rights_list: rights_list
-          )
-          expect(resource.rights_list).to eq(rights_list)
-          expect(resource.save_to_xml).to be_a(REXML::Element) # sanity check
+        describe '#publication_year' do
+          it 'requires a publication_year' do
+            args.delete(:publication_year)
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'requires a non-nil publication_year' do
+            args[:publication_year] = nil
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'requires a four-digit publication_year' do
+            args[:publication_year] = 999
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+            args[:publication_year] = 10_000
+            expect { Resource.new(args) }.to raise_error(ArgumentError)
+          end
+          it 'can be initialized' do
+            resource = Resource.new(args)
+            expect(resource.publication_year).to eq(publication_year)
+          end
+          it 'can be set' do
+            new_pub_year = 1963
+            resource = Resource.new(args)
+            resource.publication_year = new_pub_year
+            expect(resource.publication_year).to eq(new_pub_year)
+          end
+          it 'converts strings to integers' do
+            new_pub_year = 1963
+            resource = Resource.new(args)
+            resource.publication_year = "#{new_pub_year}"
+            expect(resource.publication_year).to eq(new_pub_year)
+          end
         end
-      end
 
-      describe '#parse_xml' do
-        before(:each) do
-          identifier = Identifier.new(value: '10.5072/example-full').save_to_xml
+        describe '#subjects' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.subjects).to eq([])
+          end
 
-          creators = REXML::Element.new('creators')
-          creators.add_element(Creator.new(
-            name: 'Miller, Elizabeth',
-            identifier: NameIdentifier.new(scheme: 'ORCID', scheme_uri: URI('http://orcid.org'), value: '0000-0001-5000-0007'),
-            affiliations: ['DataCite']
-          ).save_to_xml)
+          describe 'subjects:' do
+            it 'can be initialized' do
+              subjects = [
+                Subject.new(
+                  language: 'en-us',
+                  scheme: 'LCSH',
+                  scheme_uri: URI('http://identifier.loc.gov/authorities/subjects'),
+                  value: 'Mammals--Embryology'
+                ),
+                Subject.new(
+                  language: 'fr',
+                  scheme: 'dewey',
+                  scheme_uri: URI('http://dewey.info/'),
+                  value: '571.8 Croissance, développement, reproduction biologique (fécondation, sexualité)'
+                )
+              ]
+              args[:subjects] = subjects
+              resource = Resource.new(args)
+              expect(resource.subjects).to eq(subjects)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:subjects] = nil
+              resource = Resource.new(args)
+              expect(resource.subjects).to eq([])
+            end
 
-          titles = REXML::Element.new('titles')
-          titles.add_element(Title.new(
-            language: 'en-us',
-            value: 'Full DataCite XML Example'
-          ).save_to_xml)
-          titles.add_element(Title.new(
-            language: 'en-us',
-            type: TitleType::SUBTITLE,
-            value: 'Demonstration of DataCite Properties.'
-          ).save_to_xml)
+            it 'ignores subjects without values' do
+              subjects = [
+                Subject.allocate,
+                Subject.new(value: 'Mammals--Embryology'),
+                Subject.allocate
+              ]
+              args[:subjects] = subjects
+              resource = Resource.new(args)
+              expect(resource.subjects).to eq([subjects[1]])
+            end
+          end
 
-          publisher = REXML::Element.new('publisher')
-          publisher.text = 'DataCite'
+          describe '#subjects=' do
+            it 'can be set' do
+              subjects = [
+                Subject.new(
+                  language: 'en-us',
+                  scheme: 'LCSH',
+                  scheme_uri: URI('http://identifier.loc.gov/authorities/subjects'),
+                  value: 'Mammals--Embryology'
+                ),
+                Subject.new(
+                  language: 'fr',
+                  scheme: 'dewey',
+                  scheme_uri: URI('http://dewey.info/'),
+                  value: '571.8 Croissance, développement, reproduction biologique (fécondation, sexualité)'
+                )
+              ]
+              resource = Resource.new(args)
+              resource.subjects = subjects
+              expect(resource.subjects).to eq(subjects)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.subjects = nil
+              expect(resource.subjects).to eq([])
+            end
+            it 'ignores subjects without values' do
+              subjects = [
+                Subject.allocate,
+                Subject.new(value: 'Mammals--Embryology'),
+                Subject.allocate
+              ]
+              resource = Resource.new(args)
+              resource.subjects = subjects
+              expect(resource.subjects).to eq([subjects[1]])
+            end
+          end
+        end
 
-          publication_year = REXML::Element.new('publicationYear')
-          publication_year.text = '2014'
+        describe '#funding_references' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.funding_references).to eq([])
+          end
 
-          resource = REXML::Element.new('resource')
-          resource.add_namespace('http://datacite.org/schema/kernel-3')
-          resource.add_namespace('xsi', 'http://www.w3.org/2001/XMLSchema-instance')
-          resource.add_attribute('xsi:schemaLocation', 'http://datacite.org/schema/kernel-3 http://schema.datacite.org/meta/kernel-3/metadata.xsd')
-          resource.add_element(identifier)
-          resource.add_element(creators)
-          resource.add_element(titles)
-          resource.add_element(publisher)
-          resource.add_element(publication_year)
+          describe 'funding_references:' do
+            it 'can be initialized' do
+              funding_references = [
+                FundingReference.new(name: 'Ministry of Magic', award_number: '9¾'),
+                FundingReference.new(name: 'НИИЧАВО', award_number: '164070')
+              ]
+              args[:funding_references] = funding_references
+              resource = Resource.new(args)
+              expect(resource.funding_references).to eq(funding_references)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:funding_references] = nil
+              resource = Resource.new(args)
+              expect(resource.funding_references).to eq([])
+            end
+          end
 
-          @required_xml = resource
+          describe '#funding_references=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              funding_references = [
+                FundingReference.new(name: 'Ministry of Magic', award_number: '9¾'),
+                FundingReference.new(name: 'НИИЧАВО', award_number: '164070')
+              ]
+              resource.funding_references = funding_references
+              expect(resource.funding_references).to eq(funding_references)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.funding_references = nil
+              expect(resource.funding_references).to eq([])
+            end
+          end
         end
 
-        it 'parses a resource with only required attributes' do
-          resource = Resource.parse_xml(@required_xml)
-          expect(resource.language).to eq('en')
+        describe '#language' do
+          it 'defaults to nil' do
+            resource = Resource.new(args)
+            expect(resource.language).to be_nil
+          end
+
+          it 'can be initialized' do
+            args[:language] = 'en-emodeng'
+            resource = Resource.new(args)
+            expect(resource.language).to eq('en-emodeng')
+          end
+
+          it 'can be set' do
+            resource = Resource.new(args)
+            resource.language = 'en-emodeng'
+            expect(resource.language).to eq('en-emodeng')
+          end
         end
 
-        it 'correctly differentiates required and optional attributes'
+        describe '#contributors' do
+
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.funding_references).to eq([])
+          end
+
+          describe 'contributors:' do
+            it 'can be initialized' do
+              contributors = [
+                Contributor.new(name: 'Hershlag, Natalie', type: ContributorType::PROJECT_MEMBER),
+                Contributor.new(name: 'Hedy Lamarr', type: ContributorType::RESEARCHER)
+              ]
+              args[:contributors] = contributors
+              resource = Resource.new(args)
+              expect(resource.contributors).to eq(contributors)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:contributors] = nil
+              resource = Resource.new(args)
+              expect(resource.contributors).to eq([])
+            end
+          end
+
+          describe '#contributors=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              contributors = [
+                Contributor.new(name: 'Hershlag, Natalie', type: ContributorType::PROJECT_MEMBER),
+                Contributor.new(name: 'Hedy Lamarr', type: ContributorType::RESEARCHER)
+              ]
+              resource.contributors = contributors
+              expect(resource.contributors).to eq(contributors)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.contributors = nil
+              expect(resource.contributors).to eq([])
+            end
+          end
+
+          describe 'contributor convenience methods' do
+            before(:each) do
+              @resource = Resource.new(args)
+              @funder = Contributor.new(
+                name: 'The Ministry of Magic',
+                identifier: NameIdentifier.new(
+                  scheme: 'IATI',
+                  scheme_uri: URI('http://iatistandard.org/201/codelists/OrganisationIdentifier/'),
+                  value: 'GR-9¾'
+                ),
+                type: ContributorType::FUNDER)
+              @resource.contributors << @funder
+            end
 
-        it 'parses a Datacite 4.0 document with FundingReference' do
-          resource = Resource.parse_xml(File.read('spec/data/kernel-4.0/datacite-example-fundingReference-v.4.0.xml'))
-          funding_references = resource.funding_references
-          expect(funding_references.size).to eq(2)
-          funding_references.each do |fref|
-            expect(fref).to be_a(FundingReference)
+            describe 'funder_contrib' do
+              it 'extracts the funder contrib' do
+                expect(@resource.funder_contrib).to eq(@funder)
+              end
+            end
+
+            describe 'funder_name' do
+              it 'extracts the funder name' do
+                expect(@resource.funder_name).to eq(@funder.name)
+              end
+            end
+
+            describe 'funder_id' do
+              it 'extracts the funder id' do
+                expect(@resource.funder_id).to eq(@funder.identifier)
+              end
+            end
+
+            describe 'funder_id_value' do
+              it 'extracts the funder id value' do
+                expect(@resource.funder_id_value).to eq(@funder.identifier.value)
+              end
+            end
           end
         end
-      end
 
-      describe '#save_to_xml' do
-        it 'sets the namespace to http://datacite.org/schema/kernel-3'
-        it "doesn't clobber the namespace on the various xml:lang attributes"
+        describe '#dates' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.funding_references).to eq([])
+          end
 
-        # TODO: make this work; maybe it's the language that's the issue?
-        xit 'round-trips a Datacite 4.0 document with FundingReference' do
-          xml_text = File.read('spec/data/kernel-4.0/datacite-example-fundingReference-v.4.0.xml')
-          resource = Resource.parse_xml(xml_text)
-          saved_xml = resource.save_to_xml
-          expect(saved_xml).to be_xml(xml_text)
+          describe 'dates:' do
+            it 'can be initialized' do
+              dates = [
+                Date.new(value: DateTime.new(1914, 8, 4, 11, 01, 6.0123, '+1'), type: DateType::AVAILABLE),
+                Date.new(value: '1914-08-04T11:01:06.0123+01:00', type: DateType::AVAILABLE)
+              ]
+              args[:dates] = dates
+              resource = Resource.new(args)
+              expect(resource.dates).to eq(dates)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:dates] = nil
+              resource = Resource.new(args)
+              expect(resource.dates).to eq([])
+            end
+          end
+
+          describe '#dates=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              dates = [
+                Date.new(value: DateTime.new(1914, 8, 4, 11, 01, 6.0123, '+1'), type: DateType::AVAILABLE),
+                Date.new(value: '1914-08-04T11:01:06.0123+01:00', type: DateType::AVAILABLE)
+              ]
+              resource.dates = dates
+              expect(resource.dates).to eq(dates)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.dates = nil
+              expect(resource.dates).to eq([])
+            end
+          end
         end
-      end
 
-      describe 'identifier' do
-        it 'returns the identifier'
-      end
+        describe '#resource_type' do
+          it 'can be initialized' do
+            resource_type = ResourceType.new(resource_type_general: ResourceTypeGeneral::DATASET, value: 'Dataset')
+            args[:resource_type] = resource_type
+            resource = Resource.new(args)
+            expect(resource.resource_type).to eq(resource_type)
+          end
 
-      describe 'identifier=' do
-        it 'sets the identifier'
-        it 'rejects nil'
-      end
+          it 'can be set' do
+            resource_type = ResourceType.new(resource_type_general: ResourceTypeGeneral::DATASET, value: 'Dataset')
+            resource = Resource.new(args)
+            resource.resource_type = resource_type
+            expect(resource.resource_type).to eq(resource_type)
+          end
+        end
 
-      describe 'creators' do
-        it 'returns the creator list'
-        it 'returns an editable list'
-      end
+        describe '#alternate_identifiers' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.alternate_identifiers).to eq([])
+          end
 
-      describe 'creators=' do
-        it 'overwrites the creator list'
-        it 'requires at least one creator'
-      end
+          describe 'alternate_identifiers:' do
+            it 'can be initialized' do
+              alternate_identifiers = [
+                AlternateIdentifier.new(type: 'URL', value: 'http://example.org'),
+                AlternateIdentifier.new(type: 'URL', value: 'http://example.com')
+              ]
+              args[:alternate_identifiers] = alternate_identifiers
+              resource = Resource.new(args)
+              expect(resource.alternate_identifiers).to eq(alternate_identifiers)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:alternate_identifiers] = nil
+              resource = Resource.new(args)
+              expect(resource.alternate_identifiers).to eq([])
+            end
+          end
 
-      describe 'titles' do
-        it 'returns the title list'
-        it 'returns an editable list'
-      end
+          describe '#alternate_identifiers=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              alternate_identifiers = [
+                AlternateIdentifier.new(type: 'URL', value: 'http://example.org'),
+                AlternateIdentifier.new(type: 'URL', value: 'http://example.com')
+              ]
+              resource.alternate_identifiers = alternate_identifiers
+              expect(resource.alternate_identifiers).to eq(alternate_identifiers)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.alternate_identifiers = nil
+              expect(resource.alternate_identifiers).to eq([])
+            end
+          end
+        end
 
-      describe 'titles=' do
-        it 'overwrites the title list'
-        it 'requires at least one title'
-      end
+        describe '#related_identifiers' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.related_identifiers).to eq([])
+          end
 
-      describe 'publisher' do
-        it 'returns the publisher'
-      end
+          describe 'related_identifiers:' do
+            it 'can be initialized' do
+              related_identifiers = [
+                RelatedIdentifier.new(
+                  identifier_type: RelatedIdentifierType::URL,
+                  relation_type: RelationType::HAS_METADATA,
+                  related_metadata_scheme: 'citeproc+json',
+                  scheme_type: 'Turtle',
+                  scheme_uri: URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'),
+                  value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full'
+                ),
+                RelatedIdentifier.new(
+                  identifier_type: RelatedIdentifierType::ARXIV,
+                  relation_type: RelationType::IS_REVIEWED_BY,
+                  value: 'arXiv:0706.0001'
+                )
+              ]
+              args[:related_identifiers] = related_identifiers
+              resource = Resource.new(args)
+              expect(resource.related_identifiers).to eq(related_identifiers)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:related_identifiers] = nil
+              resource = Resource.new(args)
+              expect(resource.related_identifiers).to eq([])
+            end
+          end
 
-      describe 'publisher=' do
-        it 'sets the publisher'
-        it 'rejects nil'
-        it 'rejects the empty string'
-      end
+          describe '#related_identifiers=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              related_identifiers = [
+                RelatedIdentifier.new(
+                  identifier_type: RelatedIdentifierType::URL,
+                  relation_type: RelationType::HAS_METADATA,
+                  related_metadata_scheme: 'citeproc+json',
+                  scheme_type: 'Turtle',
+                  scheme_uri: URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'),
+                  value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full'
+                ),
+                RelatedIdentifier.new(
+                  identifier_type: RelatedIdentifierType::ARXIV,
+                  relation_type: RelationType::IS_REVIEWED_BY,
+                  value: 'arXiv:0706.0001'
+                )
+              ]
+              resource.related_identifiers = related_identifiers
+              expect(resource.related_identifiers).to eq(related_identifiers)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.related_identifiers = nil
+              expect(resource.related_identifiers).to eq([])
+            end
+          end
+        end
 
-      describe 'publication_year' do
-        it 'returns the publication year'
-        it 'rejects nil'
-        it 'accepts only 4-digit integers'
-      end
+        describe '#sizes' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.sizes).to eq([])
+          end
 
-      describe 'publication_year=' do
-        it 'sets the publication year'
-      end
+          describe 'sizes:' do
+            it 'can be initialized' do
+              sizes = %w(48K 128K)
+              args[:sizes] = sizes
+              resource = Resource.new(args)
+              expect(resource.sizes).to eq(sizes)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:sizes] = nil
+              resource = Resource.new(args)
+              expect(resource.sizes).to eq([])
+            end
+          end
 
-      describe 'subjects' do
-        it 'returns the subject list'
-        it 'returns an editable list'
-
-        describe 'nonvalidating mode' do
-          it 'filters out empty subjects' do
-            xml_text = "<resource xsi:schemaLocation='http://datacite.org/schema/kernel-3 http://schema.datacite.org/meta/kernel-3/metadata.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://datacite.org/schema/kernel-3'>
-                        <identifier identifierType='DOI'>10.14749/1407399495</identifier>
-                        <creators>
-                          <creator>
-                            <creatorName>Hedy Lamarr</creatorName>
-                          </creator>
-                          <creator>
-                            <creatorName>Herschlag, Natalie</creatorName>
-                          </creator>
-                        </creators>
-                        <titles>
-                          <title>An Account of a Very Odd Monstrous Calf</title>
-                        </titles>
-                        <publisher>California Digital Library</publisher>
-                        <publicationYear>2015</publicationYear>
-                        <subjects>
-                          <subject subjectScheme='LCSH' schemeURI='http://id.loc.gov/authorities/subjects' xml:lang='en-us'>Mammals--Embryology</subject>
-                          <subject/>
-                          <subject subjectScheme='dewey' schemeURI='http://dewey.info/' xml:lang='fr'>571.8 Croissance, développement, reproduction biologique (fécondation, sexualité)</subject>
-                          <subject subjectScheme='dewey' schemeURI='http://dewey.info/'></subject>
-                        </subjects>
-                       <language>en</language>
-                      </resource>"
-            resource = Resource.parse_xml(xml_text, mapping: :nonvalidating)
-
-            expected = [
-              Subject.new(
-                language: 'en-us',
-                scheme: 'LCSH',
-                scheme_uri: URI('http://id.loc.gov/authorities/subjects'),
-                value: 'Mammals--Embryology'
-              ),
-              Subject.new(
-                language: 'fr',
-                scheme: 'dewey',
-                scheme_uri: URI('http://dewey.info/'),
-                value: '571.8 Croissance, développement, reproduction biologique (fécondation, sexualité)'
-              )
-            ]
-
-            subjects = resource.subjects
-            expect(subjects.size).to eq(expected.size)
-            expected.each_with_index do |ex, i|
-              expect(subjects[i].language).to eq(ex.language)
-              expect(subjects[i].scheme).to eq(ex.scheme)
-              expect(subjects[i].scheme_uri).to eq(ex.scheme_uri)
-              expect(subjects[i].value).to eq(ex.value)
+          describe '#sizes=' do
+            it 'can be set' do
+              sizes = %w(48K 128K)
+              resource = Resource.new(args)
+              resource.sizes = sizes
+              expect(resource.sizes).to eq(sizes)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.sizes = nil
+              expect(resource.sizes).to eq([])
             end
           end
         end
 
-      end
+        describe '#formats' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.formats).to eq([])
+          end
 
-      describe 'subjects=' do
-        it 'overwrites the subject list'
-        it 'accepts an empty list'
-      end
+          describe 'formats:' do
+            it 'can be initialized' do
+              formats = %w(D64 DSK)
+              args[:formats] = formats
+              resource = Resource.new(args)
+              expect(resource.formats).to eq(formats)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:formats] = nil
+              resource = Resource.new(args)
+              expect(resource.formats).to eq([])
+            end
+          end
 
-      describe 'dates' do
-        it 'returns the date list'
-        it 'returns an editable list'
-      end
+          describe '#formats=' do
+            it 'can be set' do
+              formats = %w(D64 DSK)
+              resource = Resource.new(args)
+              resource.formats = formats
+              expect(resource.formats).to eq(formats)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.formats = nil
+              expect(resource.formats).to eq([])
+            end
+          end
+        end
 
-      describe 'dates=' do
-        it 'overwrites the date list'
-        it 'accepts an empty list'
-      end
+        describe '#version' do
+          it 'defaults to nil' do
+            resource = Resource.new(args)
+            expect(resource.version).to be_nil
+          end
+          it 'can be initialized' do
+            args[:version] = '9.2.2'
+            resource = Resource.new(args)
+            expect(resource.version).to eq('9.2.2')
+          end
+          it 'can be set' do
+            new_version = '9.2.2'
+            resource = Resource.new(args)
+            resource.version = new_version
+            expect(resource.version).to eq(new_version)
+          end
+          it 'strips on initialization' do
+            args[:version] = '
+            9.2.2
+          '
+            resource = Resource.new(args)
+            expect(resource.version).to eq('9.2.2')
+          end
+          it 'strips on set' do
+            resource = Resource.new(args)
+            resource.version = '
+            9.2.2
+          '
+            expect(resource.version).to eq('9.2.2')
+          end
+        end
 
-      describe 'language' do
-        it 'returns the language'
-      end
+        describe '#rights_list' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.rights_list).to eq([])
+          end
 
-      describe 'language=' do
-        it 'sets the languge'
-        it 'requires a language'
-      end
+          describe('rights_list:') do
+            it 'can be initialized' do
+              rights_list = [
+                Rights.new(value: 'CC0 1.0 Universal', uri: URI('http://creativecommons.org/publicdomain/zero/1.0/')),
+                Rights.new(value: 'This work is free of known copyright restrictions.', uri: URI('http://creativecommons.org/publicdomain/mark/1.0/'))
+              ]
+              args[:rights_list] = rights_list
+              resource = Resource.new(args)
+              expect(resource.rights_list).to eq(rights_list)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:rights_list] = nil
+              resource = Resource.new(args)
+              expect(resource.rights_list).to eq([])
+            end
+          end
 
-      describe 'resource_type' do
-        it 'returns the resource type'
-      end
+          describe '#rights_list=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              rights_list = [
+                Rights.new(value: 'CC0 1.0 Universal', uri: URI('http://creativecommons.org/publicdomain/zero/1.0/')),
+                Rights.new(value: 'This work is free of known copyright restrictions.', uri: URI('http://creativecommons.org/publicdomain/mark/1.0/'))
+              ]
+              resource.rights_list = rights_list
+              expect(resource.rights_list).to eq(rights_list)
+            end
 
-      describe 'resource_type=' do
-        it 'sets the resource type'
-        it 'requires a resource type'
-      end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.rights_list = nil
+              expect(resource.rights_list).to eq([])
+            end
+          end
 
-      describe 'alternate_identifiers' do
-        it 'returns the alternate identifier list'
-        it 'returns an editable list'
-      end
+        end
 
-      describe 'alternate_identifiers=' do
-        it 'overwrites the alternate identifier list'
-        it 'accepts an empty list'
-      end
+        describe '#descriptions' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.descriptions).to eq([])
+          end
 
-      describe 'related_identifiers' do
-        it 'returns the related identifier list'
-        it 'returns an editable list'
-      end
+          describe 'descriptions:' do
+            it 'can be initialized' do
+              descriptions = [
+                Description.new(language: 'en-us', type: DescriptionType::ABSTRACT, value: 'Exterminate all the brutes!'),
+                Description.new(language: 'en-us', type: DescriptionType::METHODS, value: 'unsound')
+              ]
+              args[:descriptions] = descriptions
+              resource = Resource.new(args)
+              expect(resource.descriptions).to eq(descriptions)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:descriptions] = nil
+              resource = Resource.new(args)
+              expect(resource.descriptions).to eq([])
+            end
 
-      describe 'related_identifiers=' do
-        it 'overwrites the related identifier list'
-        it 'accepts an empty list'
-      end
+            it 'ignores descriptions without values' do
+              descriptions = [
+                Description.allocate,
+                Description.new(language: 'en-us', type: DescriptionType::METHODS, value: 'unsound'),
+                Description.allocate
+              ]
+              args[:descriptions] = descriptions
+              resource = Resource.new(args)
+              expect(resource.descriptions).to eq([descriptions[1]])
+            end
+          end
 
-      describe 'sizes' do
-        it 'returns the size list'
-        it 'returns an editable list'
-      end
+          describe '#descriptions=' do
+            it 'can be set' do
+              descriptions = [
+                Description.new(language: 'en-us', type: DescriptionType::ABSTRACT, value: 'Exterminate all the brutes!'),
+                Description.new(language: 'en-us', type: DescriptionType::METHODS, value: 'unsound')
+              ]
+              resource = Resource.new(args)
+              resource.descriptions = descriptions
+              expect(resource.descriptions).to eq(descriptions)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.descriptions = nil
+              expect(resource.descriptions).to eq([])
+            end
 
-      describe 'sizes=' do
-        it 'overwrites the size list'
-        it 'accepts an empty list'
-      end
+            it 'ignores descriptions without values' do
+              descriptions = [
+                Description.allocate,
+                Description.new(language: 'en-us', type: DescriptionType::METHODS, value: 'unsound'),
+                Description.allocate
+              ]
+              resource = Resource.new(args)
+              resource.descriptions = descriptions
+              expect(resource.descriptions).to eq([descriptions[1]])
+            end
+          end
+        end
 
-      describe 'formats' do
-        it 'returns the size list'
-        it 'returns an editable list'
-      end
+        describe '#geo_locations' do
+          it 'defaults to empty' do
+            resource = Resource.new(args)
+            expect(resource.geo_locations).to eq([])
+          end
 
-      describe 'formats=' do
-        it 'overwrites the size list'
-        it 'accepts an empty list'
-      end
+          describe 'geo_locations:' do
+            it 'can be initialized' do
+              geo_locations = [
+                GeoLocation.new(point: GeoLocationPoint.new(47.61, -122.33)),
+                GeoLocation.new(box: GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67))
+              ]
+              args[:geo_locations] = geo_locations
+              resource = Resource.new(args)
+              expect(resource.geo_locations).to eq(geo_locations)
+            end
+            it 'can\'t be initialized to nil' do
+              args[:geo_locations] = nil
+              resource = Resource.new(args)
+              expect(resource.geo_locations).to eq([])
+            end
+            it 'ignores empty locations' do
+              geo_locations = [
+                GeoLocation.new,
+                GeoLocation.new(point: GeoLocationPoint.new(47.61, -122.33)),
+                GeoLocation.new
+              ]
+              args[:geo_locations] = geo_locations
+              resource = Resource.new(args)
+              expect(resource.geo_locations).to eq([geo_locations[1]])
+            end
+          end
 
-      describe 'version' do
-        it 'returns the version'
-      end
+          describe '#geo_locations=' do
+            it 'can be set' do
+              resource = Resource.new(args)
+              geo_locations = [
+                GeoLocation.new(point: GeoLocationPoint.new(47.61, -122.33)),
+                GeoLocation.new(box: GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67))
+              ]
+              resource.geo_locations = geo_locations
+              expect(resource.geo_locations).to eq(geo_locations)
+            end
+            it 'can\'t be set to nil' do
+              resource = Resource.new(args)
+              resource.geo_locations = nil
+              expect(resource.geo_locations).to eq([])
+            end
+            it 'ignores empty locations' do
+              resource = Resource.new(args)
+              geo_locations = [
+                GeoLocation.new,
+                GeoLocation.new(point: GeoLocationPoint.new(47.61, -122.33)),
+                GeoLocation.new
+              ]
+              resource.geo_locations = geo_locations
+              expect(resource.geo_locations).to eq([geo_locations[1]])
+            end
+          end
+        end
 
-      describe 'version=' do
-        it 'sets the languge'
-        it 'accepts nil'
       end
 
-      describe 'rights' do
-        it 'returns the rights list'
-        it 'returns an editable list'
-      end
+      describe 'compatibility' do
 
-      describe 'rights=' do
-        it 'overwrites the rights list'
-        it 'accepts an empty list'
-      end
+        def xml_text_from(file, fix_dash1)
+          xml_text = File.read(file)
+          xml_text = fix_dash1(xml_text) if fix_dash1
+          xml_text
+        end
 
-      describe 'descriptions' do
-        it 'returns the description list'
-        it 'returns an editable list'
-      end
+        def parse_file(xml_text, basename)
+          return Resource.parse_xml(xml_text)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          warn "Error parsing #{basename}: #{e}"
+          File.open("tmp/#{basename}-xml_text.xml", 'w') { |t| t.write(xml_text) }
+          File.open("tmp/#{basename}-parse_error.xml", 'w') { |t| t.write(xml_text) }
+          raise
+        end
 
-      describe 'descriptions=' do
-        it 'overwrites the description list'
-        it 'accepts an empty list'
-      end
+        def write_xml(resource, basename, options)
+          # Workaround for Dash 1 datacite.xml with missing DOI
+          resource.identifier = Identifier.from_doi('10.5555/12345678') unless resource.identifier
+          return resource.write_xml(options)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          warn "Error writing #{basename}: #{e}"
+          raise
+        end
 
-      describe 'geo_locations' do
-        it 'returns the geolocation list'
-        it 'returns an editable list'
-      end
+        def normalize(xml_str)
+          xml_str
+            .gsub(%r{<([^>]+tude)>([0-9.-]+?)(0?)0+</\1>}, '<\\1>\\2\\3</\\1>') # strip trailing coordinate zeroes
+            .gsub(/ "([^"]+)"/, ' &quot;\\1&quot;') # entity-escape quotes in text
+            .gsub('&lt;br /&gt;', '<br/>') # entity-de-escape <br/> tags
+            .gsub('"', "'") # swap double for single quotes
+            .gsub(%r{<(geoLocation[^>]+)>[^<]+</\1>}) { |loc| loc.gsub(/([0-9\-]+\.[0-9]+?)0+([^0-9])/, '\\1\\2') } # strip trailing coordinate zeroes
+        end
 
-      describe 'geo_locations=' do
-        it 'overwrites the geolocation list'
-        it 'accepts an empty list'
-      end
+        def fix_dash1(xml_str)
+          # Workaround for Dash 1 datacite.xml with:
+          # - missing DOI
+          # - empty tags
+          # - nested contributors instead of contributorNames
+          xml_str
+            .gsub(%r{<[^>]+/>}, '') # remove empty tags
+            .gsub(%r{<([^>]+)>\s+</\1>}, '') # remove empty tag pairs
+            .gsub(%r{(<date[^>]*>)(\d{4})-(\d{4})(</date>)}, '\\1\\2/\\3\\4') # fix date ranges
+            .gsub(%r{(<contributor[^>/]+>\s*)<contributor>([^<]+)</contributor>(\s*</contributor>)}, '\\1<contributorName>\\2</contributorName>\\3') # fix broken contributors
+        end
 
-      describe 'XML mapping' do
-
-        describe '#parse_xml' do
-          it 'handles all Dash 1 documents' do
-            versions = []
-
-            Dir.glob('spec/data/dash1-datacite-xml/*mrt-datacite.xml') do |f|
-              basename = File.basename(f)
-              bad_contrib_regex = Regexp.new('<contributor contributorType="([^"]+)">\p{Space}*<contributor>([^<]+)</contributor>\p{Space}*</contributor>', Regexp::MULTILINE)
-              good_contrib_replacement = "<contributor contributorType=\"\\1\">\n<contributorName>\\2</contributorName>\n</contributor>"
-              xml_text = File.read(f).gsub(bad_contrib_regex, good_contrib_replacement)
-
-              resource = nil
-              begin
-                resource = Resource.parse_xml(xml_text, mapping: :nonvalidating)
-              rescue Exception => e # rubocop:disable Lint/RescueException:
-                puts "Error parsing #{basename}: #{e}"
-                File.open("tmp/#{basename}-parse_error.xml", 'w') { |t| t.write(xml_text) }
-                raise
-              end
-              next unless resource
+        def it_round_trips(file:, mapping: :_default, fix_dash1: false) # rubocop:disable Metrics/AbcSize
+          options = { mapping: mapping }
+          basename = File.basename(file)
+          xml_text = xml_text_from(file, fix_dash1)
+          resource = parse_file(xml_text, basename)
+          actual_xml = write_xml(resource, basename, options)
+          expected_xml = normalize(xml_text)
+          expected_xml.gsub!(/(<resource[^>]+>)\s+(<creators>)/, "\\1\n  <identifier identifierType=\"DOI\">10.5555/12345678</identifier>\n  \\2") if fix_dash1
+          begin
+            expect(actual_xml).to be_xml(expected_xml)
+          rescue Exception # rubocop:disable Lint/RescueException
+            File.open("tmp/#{basename}-expected.xml", 'w') { |t| t.write(expected_xml) }
+            File.open("tmp/#{basename}-actual.xml", 'w') { |t| t.write(actual_xml) }
+            raise
+          end
+        end
+
+        it 'reads all datacite 4 example documents' do
+          Dir.glob('spec/data/datacite4/datacite-example-*.xml') { |f| it_round_trips(file: f) }
+        end
+        it 'reads all datacite 3 example documents' do
+          Dir.glob('spec/data/datacite3/datacite-example-*.xml') { |f| it_round_trips(file: f, mapping: :datacite_3) }
+        end
+        it 'reads all dash 1 docs, with caveats' do
+          Dir.glob('spec/data/dash1/*.xml') { |f| it_round_trips(file: f, mapping: :datacite_3, fix_dash1: true) }
+        end
 
-              versions << resource.version if resource.version
+        describe 'DC4 to DC3' do
 
-              actual_xml = nil
-              begin
-                actual_xml = resource.write_xml
-              rescue Exception => e # rubocop:disable Lint/RescueException:
-                puts "Error writing #{basename}: #{e}"
-                raise
-              end
-              next unless actual_xml
-
-              actual_tidy = actual_xml
-                            .gsub('<dcs:language>en</dcs:language>', '')
-                            .gsub(" xml:lang='en'", '')
-                            .gsub('<language>en</language>', '')
-              expected_tidy = xml_text
-                              .gsub('<br/>', '[BREAK]')
-                              .gsub(Regexp.new('<[a-zA-Z]+/>'), '')
-                              .gsub('[BREAK]', '<br/>')
-                              .gsub(Regexp.new('<subjects>\p{space}</subjects>', Regexp::MULTILINE), '')
-                              .gsub("'", '&apos;')
-                              .gsub('"', "'")
-                              .gsub("<subject schemeURI='http://www.nlm.nih.gov/mesh/' subjectScheme='MeSH'/>", '')
-
-              begin
-                expect(actual_tidy).to be_xml(expected_tidy)
-              rescue Exception  # rubocop:disable Lint/RescueException:
-                File.open("tmp/#{basename}-original.xml", 'w') { |t| t.write(expected_tidy) }
-                File.open("tmp/#{basename}-roundtrip.xml", 'w') { |t| t.write(actual_tidy) }
-                raise
-              end
+          attr_reader :resource
+          attr_reader :rexml
+          attr_reader :warnings
+
+          def warnings_including(substring)
+            warnings.select { |w| w.include?(substring) }
+          end
+
+          def expect_warning(substring, count, include_matches = false)
+            matches = warnings_including(substring)
+            found_count = matches.size
+            msg = "expected #{count} warnings including '#{substring}', found #{found_count}"
+            msg << ": #{matches}" if include_matches
+            expect(found_count).to eq(count), msg
+          end
+
+          def expect_matches(xpath, count, include_matches = false)
+            matches = REXML::XPath.match(rexml, xpath)
+            found_count = matches.size
+            msg = "expected #{count} matches for XPath '#{xpath}', found #{found_count}"
+            msg << ": #{matches}" if include_matches
+            expect(found_count).to eq(count), msg
+          end
+
+          before(:each) do
+            @warnings = []
+            allow(ReadOnlyNodes).to receive(:warn) do |w|
+              warnings << w
+              Kernel.warn(w) # for debugging
+            end
+
+            xml = File.read('spec/data/datacite-4-synthetic.xml')
+            @resource = Resource.parse_xml(xml)
+            @rexml = resource.save_to_xml(mapping: :datacite_3)
+          end
+
+          it 'sets the kernel-3 namespace' do
+            expect(rexml.namespace).to eq(DATACITE_3_NAMESPACE.uri)
+          end
+
+          it 'warns about givenNames and familyNames' do
+            name_tags = %w(givenName familyName)
+            name_tags.each do |tag|
+              expect_matches("//#{tag}", 0, true)
+              expect_warning(tag, 1)
             end
           end
+
+          it 'warns about FundingReferences' do
+            expect_matches('//fundingReferences', 0, true)
+            expect_warning('fundingReferences', 1)
+          end
+
+          it 'warns about IGSN identifiers' do
+            expect_warning('IGSN', 1)
+          end
+
+          it 'warns about geoLocationPolygons' do
+            expect_warning('geoLocationPolygon', 1)
+          end
+
         end
 
-        describe '#save_to_xml' do
-          it 'writes XML' do
-            resource = Resource.new(
-              identifier: Identifier.new(value: '10.5072/D3P26Q35R-Test'),
-              creators: [
-                Creator.new(name: 'Fosmire, Michael'),
-                Creator.new(name: 'Wertz, Ruth'),
-                Creator.new(name: 'Purzer, Senay')
-              ],
-              titles: [
-                Title.new(value: 'Critical Engineering Literacy Test (CELT)')
-              ],
-              publisher: 'Purdue University Research Repository (PURR)',
-              publication_year: 2013,
-              subjects: [
-                Subject.new(value: 'Assessment'),
-                Subject.new(value: 'Information Literacy'),
-                Subject.new(value: 'Engineering'),
-                Subject.new(value: 'Undergraduate Students'),
-                Subject.new(value: 'CELT'),
-                Subject.new(value: 'Purdue University')
-              ],
-              language: 'en',
-              resource_type: ResourceType.new(resource_type_general: ResourceTypeGeneral::DATASET, value: 'Dataset'),
-              version: '1',
-              descriptions: [
-                Description.new(
-                  type: DescriptionType::ABSTRACT,
-                  value: 'We developed an instrument, Critical Engineering Literacy Test (CELT), which is a multiple choice instrument
-              designed to measure undergraduate students’ scientific and information literacy skills. It requires students to
-              first read a technical memo and, based on the memo’s arguments, answer eight multiple choice and six open-ended
-              response questions. We collected data from 143 first-year engineering students and conducted an item analysis. The
-              KR-20 reliability of the instrument was .39. Item difficulties ranged between .17 to .83. The results indicate low
-              reliability index but acceptable levels of item difficulties and item discrimination indices. Students were most
-              challenged when answering items measuring scientific and mathematical literacy (i.e., identifying incorrect
-              information).'
-                )
-              ]
-            )
+        describe 'DC3 to DC4' do
+          attr_reader :resource
+          attr_reader :rexml
 
-            expected_xml = '<resource xsi:schemaLocation=\'http://datacite.org/schema/kernel-3 http://schema.datacite.org/meta/kernel-3/metadata.xsd\' xmlns=\'http://datacite.org/schema/kernel-3\' xmlns:xsi=\'http://www.w3.org/2001/XMLSchema-instance\'>
-                              <identifier identifierType=\'DOI\'>10.5072/D3P26Q35R-Test</identifier>
-                              <creators>
-                                <creator>
-                                  <creatorName>Fosmire, Michael</creatorName>
-                                </creator>
-                                <creator>
-                                  <creatorName>Wertz, Ruth</creatorName>
-                                </creator>
-                                <creator>
-                                  <creatorName>Purzer, Senay</creatorName>
-                                </creator>
-                              </creators>
-                              <titles>
-                                <title xml:lang=\'en\'>Critical Engineering Literacy Test (CELT)</title>
-                              </titles>
-                              <publisher>Purdue University Research Repository (PURR)</publisher>
-                              <publicationYear>2013</publicationYear>
-                              <subjects>
-                                <subject xml:lang=\'en\'>Assessment</subject>
-                                <subject xml:lang=\'en\'>Information Literacy</subject>
-                                <subject xml:lang=\'en\'>Engineering</subject>
-                                <subject xml:lang=\'en\'>Undergraduate Students</subject>
-                                <subject xml:lang=\'en\'>CELT</subject>
-                                <subject xml:lang=\'en\'>Purdue University</subject>
-                              </subjects>
-                              <language>en</language>
-                              <resourceType resourceTypeGeneral=\'Dataset\'>Dataset</resourceType>
-                              <version>1</version>
-                              <descriptions>
-                                <description descriptionType=\'Abstract\' xml:lang=\'en\'>We developed an instrument, Critical Engineering Literacy Test (CELT), which is a multiple choice instrument designed to measure undergraduate students’ scientific and information literacy skills. It requires students to first read a technical memo and, based on the memo’s arguments, answer eight multiple choice and six open-ended response questions. We collected data from 143 first-year engineering students and conducted an item analysis. The KR-20 reliability of the instrument was .39. Item difficulties ranged between .17 to .83. The results indicate low reliability index but acceptable levels of item difficulties and item discrimination indices. Students were most challenged when answering items measuring scientific and mathematical literacy (i.e., identifying incorrect information).</description>
-                              </descriptions>
-                            </resource>'
-
-            actual_xml = resource.write_xml
-            begin
-              expect(actual_xml).to be_xml(expected_xml)
-            rescue Exception  # rubocop:disable Lint/RescueException:
-              File.open('tmp/expected.xml', 'w') { |t| t.write(expected_xml) }
-              File.open('tmp/actual.xml', 'w') { |t| t.write(actual_xml) }
-              raise
-            end
-          end
-        end
-
-        it 'round-trips' do
-          xml_text = File.read('spec/data/resource.xml')
-          resource = Resource.parse_xml(xml_text)
-          expect(resource.save_to_xml).to be_xml(xml_text)
+          before(:each) do
+            @resource = Resource.load_from_file('spec/data/datacite3/datacite-example-full-v3.1.xml')
+            @rexml = resource.save_to_xml
+          end
+
+          it 'writes a DC3 document as DC4' do
+            expect(rexml.namespace).to eq(DATACITE_4_NAMESPACE.uri)
+          end
         end
+      end
 
-        it 'allows a namespace prefix' do
-          resource = Resource.new(
-            identifier: @id,
-            creators: @creators,
-            titles: @titles,
-            publisher: @publisher,
-            publication_year: @pub_year
-          )
-          Resource.namespace_prefix = 'dcs'
-          expect(Resource.namespace.prefix).to eq('dcs')
+      describe '#namespace_prefix=' do
 
-          expected = '<dcs:resource xmlns:dcs="http://datacite.org/schema/kernel-3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://datacite.org/schema/kernel-3 http://schema.datacite.org/meta/kernel-3/metadata.xsd">
+        attr_reader :dcs3_xml
+        attr_reader :dcs4_xml
+
+        before(:each) do
+          @dcs3_xml = '<dcs:resource xmlns:dcs="http://datacite.org/schema/kernel-3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://datacite.org/schema/kernel-3 http://schema.datacite.org/meta/kernel-3/metadata.xsd">
                         <dcs:identifier identifierType="DOI">10.14749/1407399495</dcs:identifier>
                         <dcs:creators>
                           <dcs:creator>
@@ -938,61 +1072,47 @@ module Datacite
                         <dcs:publicationYear>2015</dcs:publicationYear>
                         <dcs:language>en</dcs:language>
                       </dcs:resource>'
-
-          expect(resource.save_to_xml).to be_xml(expected)
-        end
-      end
-
-      describe 'convenience accessors' do
-
-        before :each do
-          xml_text = File.read('spec/data/resource.xml')
-          @resource = Resource.parse_xml(xml_text)
-
-          @funder = Contributor.new(
-            name: 'The Ministry of Magic',
-            identifier: NameIdentifier.new(
-              scheme: 'IATI',
-              scheme_uri: URI('http://iatistandard.org/201/codelists/OrganisationIdentifier/'),
-              value: 'GR-9¾'
-            ),
-            type: ContributorType::FUNDER)
-          @resource.contributors << @funder
+          @dcs4_xml = dcs3_xml.gsub('kernel-3', 'kernel-4')
         end
 
-        describe 'creator_names' do
-          it 'extracts the creator names' do
-            expect(@resource.creator_names).to eq(['Miller, Elizabeth'])
-          end
+        it 'reads DC3 with namespace prefix' do
+          resource = Resource.parse_xml(dcs3_xml)
+          expect(resource.save_to_xml(mapping: :datacite_3)).to be_xml(dcs3_xml)
         end
 
-        describe 'creator_affiliations' do
-          it 'extracts the creator affiliations' do
-            expect(@resource.creator_affiliations).to eq([['DataCite']])
-          end
+        it 'writes DC3 with namespace prefix' do
+          resource = Resource.parse_xml(dcs3_xml)
+          resource.namespace_prefix = 'dcs'
+          xml = resource.write_xml(mapping: :datacite_3)
+          expect(xml).not_to match(%r{<[a-z "=/]+>})
+          expect(xml).to match(%r{<dcs:[a-z "=/]+>})
         end
 
-        describe 'funder_contrib' do
-          it 'extracts the funder contrib' do
-            expect(@resource.funder_contrib).to eq(@funder)
-          end
+        it 'reads DC4 with namespace prefix' do
+          resource = Resource.parse_xml(dcs4_xml)
+          expect(resource.save_to_xml).to be_xml(dcs4_xml)
         end
 
-        describe 'funder_name' do
-          it 'extracts the funder name' do
-            expect(@resource.funder_name).to eq(@funder.name)
-          end
+        it 'writes DC4 with namespace prefix' do
+          resource = Resource.parse_xml(dcs4_xml)
+          resource.namespace_prefix = 'dcs'
+          xml = resource.write_xml
+          expect(xml).not_to match(%r{<[a-z "=/]+>})
+          expect(xml).to match(%r{<dcs:[a-z "=/]+>})
         end
 
-        describe 'funder_id' do
-          it 'extracts the funder id' do
-            expect(@resource.funder_id).to eq(@funder.identifier)
-          end
-        end
+      end
 
-        describe 'funder_id_value' do
-          it 'extracts the funder id value' do
-            expect(@resource.funder_id_value).to eq(@funder.identifier.value)
+      describe '#save_to_file' do
+        it 'saves to a file' do
+          xml_text =  File.read('spec/data/datacite4/datacite-example-full-v4.0.xml')
+          resource = Resource.parse_xml(xml_text)
+          Dir.mktmpdir('resource_spec') do |dir|
+            path = "#{dir}/resource.xml"
+            resource.save_to_file(path)
+            actual = File.read(path)
+            expected = xml_text.gsub('41.090', '41.09')
+            expect(actual).to be_xml(expected)
           end
         end
       end