datacite-mapping 0.1.0

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+
+    describe GeoLocation do
+      describe '#initialize' do
+        it 'accepts a point' do
+          point = GeoLocationPoint.new(47.61, -122.33)
+          loc = GeoLocation.new(point: point)
+          expect(loc.point).to eq(point)
+        end
+        it 'accepts a box' do
+          box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          loc = GeoLocation.new(box: box)
+          expect(loc.box).to eq(box)
+        end
+        it 'accepts a place' do
+          place = 'Ouagadougou'
+          loc = GeoLocation.new(place: place)
+          expect(loc.place).to eq(place)
+        end
+        it 'allows an empty location' do
+          loc = GeoLocation.new
+          expect(loc.point).to be_nil
+          expect(loc.box).to be_nil
+          expect(loc.place).to be_nil
+        end
+      end
+
+      describe '#point=' do
+        it 'sets the point' do
+          point = GeoLocationPoint.new(47.61, -122.33)
+          loc = GeoLocation.new
+          loc.point = point
+          expect(loc.point).to eq(point)
+        end
+        it 'accepts nil' do
+          loc = GeoLocation.new(point: GeoLocationPoint.new(47.61, -122.33))
+          loc.point = nil
+          expect(loc.point).to be_nil
+        end
+      end
+
+      describe '#box=' do
+        it 'sets the box' do
+          box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          loc = GeoLocation.new
+          loc.box = box
+          expect(loc.box).to eq(box)
+        end
+        it 'accepts nil' do
+          loc = GeoLocation.new(box: GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67))
+          loc.box = nil
+          expect(loc.box).to be_nil
+        end
+      end
+
+      describe '#place=' do
+        it 'sets the place' do
+          place = 'Ouagadougou'
+          loc = GeoLocation.new
+          loc.place = place
+          expect(loc.place).to eq(place)
+        end
+        it 'accepts nil' do
+          loc = GeoLocation.new(place: 'Ouagadougou')
+          loc.place = nil
+          expect(loc.place).to be_nil
+        end
+      end
+
+      describe '#load_from_xml' do
+        it 'parses XML' do
+          xml_text = '<geoLocation>
+                        <geoLocationPoint>31.233 -67.302</geoLocationPoint>
+                        <geoLocationBox>41.090 -71.032 42.893 -68.211</geoLocationBox>
+                        <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
+                      </geoLocation>'
+          xml = REXML::Document.new(xml_text).root
+          loc = GeoLocation.load_from_xml(xml)
+          expect(loc.point).to eq(GeoLocationPoint.new(31.233, -67.302))
+          expect(loc.box).to eq(GeoLocationBox.new(41.09, -71.032, 42.893, -68.211))
+          expect(loc.place).to eq('Atlantic Ocean')
+        end
+
+        it 'trims place-name whitespace' do
+          xml_text = '<geoLocation>
+                        <geoLocationPlace>
+                          Atlantic Ocean
+                        </geoLocationPlace>
+                      </geoLocation>'
+          xml = REXML::Document.new(xml_text).root
+          loc = GeoLocation.load_from_xml(xml)
+          expect(loc.place).to eq('Atlantic Ocean')
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'writes XML' do
+          loc = GeoLocation.new(
+            point: GeoLocationPoint.new(31.233, -67.302),
+            box: GeoLocationBox.new(41.09, -71.032, 42.893, -68.211),
+            place: 'Atlantic Ocean'
+          )
+          expected_xml = '<geoLocation>
+                            <geoLocationPoint>31.233 -67.302</geoLocationPoint>
+                            <geoLocationBox>41.09 -71.032 42.893 -68.211</geoLocationBox>
+                            <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
+                          </geoLocation>'
+          expect(loc.save_to_xml).to be_xml(expected_xml)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe Identifier do
+
+      describe '#initialize' do
+        it 'sets the value' do
+          value = '10.14749/1407399495'
+          id = Identifier.new(value: value)
+          expect(id.value).to eq(value)
+        end
+
+        it 'sets the type' do
+          id = Identifier.new(value: '10.14749/1407399495')
+          expect(id.identifier_type).to eq('DOI')
+        end
+
+        it 'disallows bad DOIs' do
+          bad_dois = %w(
+            20.14749/1407399495
+            11.14749/1407399495
+            10./1407399495
+            10.14749\1407399495
+            10.14749/
+          )
+          bad_dois.each do |doi|
+            expect { Identifier.new(value: doi) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      describe '#value=' do
+        it 'sets the value' do
+          id = Identifier.allocate
+          id.value = '10.14749/1407399495'
+          expect(id.value).to eq('10.14749/1407399495')
+        end
+        it 'disallows bad DOIs' do
+          id = Identifier.allocate
+          bad_dois = %w(
+            20.14749/1407399495
+            11.14749/1407399495
+            10./1407399495
+            10.14749\1407399495
+            10.14749/
+          )
+          bad_dois.each do |doi|
+            expect { id.value = doi }.to raise_error(ArgumentError)
+            expect(id.value).to be_nil
+          end
+        end
+      end
+
+      describe '#load_from_xml' do
+        it 'parses XML' do
+          xml_text = "<identifier identifierType='DOI'>10.14749/1407399498</identifier>"
+          xml = REXML::Document.new(xml_text).root
+          id = Identifier.load_from_xml(xml)
+          expect(id.identifier_type).to eq('DOI')
+          expect(id.value).to eq('10.14749/1407399498')
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'writes XML' do
+          id = Identifier.new(value: '10.14749/1407399498')
+          xml = id.save_to_xml
+          expect(xml).to be_xml("<identifier identifierType='DOI'>10.14749/1407399498</identifier>")
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe NameIdentifier do
+
+      describe '#initialize' do
+        it 'sets the identifier scheme and value' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect(id.scheme).to eq('ORCID')
+          expect(id.value).to eq('0000-0003-1632-8708')
+        end
+
+        it 'accepts a scheme URI' do
+          id = NameIdentifier.new(scheme: 'ORCID', scheme_uri: URI('http://orcid.org/'), value: '0000-0003-1632-8708')
+          expect(id.scheme_uri).to eq(URI('http://orcid.org/'))
+        end
+
+        it 'defaults to a nil scheme URI' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect(id.scheme_uri).to be_nil
+        end
+
+        it 'requires a scheme' do
+          expect { NameIdentifier.new(value: '0000-0003-1632-8708') }.to raise_error(ArgumentError)
+        end
+
+        it 'requires a non-empty scheme' do
+          expect { NameIdentifier.new(scheme: '', value: '0000-0003-1632-8708') }.to raise_error(ArgumentError)
+        end
+
+        it 'requires a value' do
+          expect { NameIdentifier.new(scheme: 'ORCID') }.to raise_error(ArgumentError)
+        end
+
+        it 'requires a non-empty value' do
+          expect { NameIdentifier.new(scheme: '', scheme: 'ORCID') }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#scheme=' do
+        it 'requires a scheme' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect { id.scheme = nil }.to raise_error(ArgumentError)
+          expect(id.scheme).to eq('ORCID')
+        end
+
+        it 'requires a non-empty scheme' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect { id.scheme = '' }.to raise_error(ArgumentError)
+          expect(id.scheme).to eq('ORCID')
+        end
+      end
+
+      describe '#value=' do
+        it 'requires a value' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect { id.value = nil }.to raise_error(ArgumentError)
+          expect(id.value).to eq('0000-0003-1632-8708')
+        end
+
+        it 'requires a non-empty value' do
+          id = NameIdentifier.new(scheme: 'ORCID', value: '0000-0003-1632-8708')
+          expect { id.value = '' }.to raise_error(ArgumentError)
+          expect(id.value).to eq('0000-0003-1632-8708')
+        end
+      end
+
+      describe '#load_from_xml' do
+        it 'parses XML' do
+          xml_text = '<nameIdentifier schemeURI="http://orcid.org/" nameIdentifierScheme="ORCID">0000-0003-1632-8708</nameIdentifier>'
+          xml = REXML::Document.new(xml_text).root
+          id = NameIdentifier.load_from_xml(xml)
+          expect(id.scheme).to eq('ORCID')
+          expect(id.scheme_uri).to eq(URI('http://orcid.org/'))
+          expect(id.value).to eq('0000-0003-1632-8708')
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'writes XML' do
+          id = NameIdentifier.new(scheme: 'ORCID', scheme_uri: URI('http://orcid.org/'), value: '0000-0003-1632-8708')
+          xml = id.save_to_xml
+          expect(xml).to be_xml('<nameIdentifier schemeURI="http://orcid.org/" nameIdentifierScheme="ORCID">0000-0003-1632-8708</nameIdentifier>')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe RelatedIdentifier do
+      describe '#initialize' do
+        it 'sets the relatedIdentifierType' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect(ri.identifier_type).to eq(RelatedIdentifierType::ARXIV)
+        end
+        it 'sets the relationType' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect(ri.relation_type).to eq(RelationType::IS_REVIEWED_BY)
+        end
+        it 'sets the relatedMetadataScheme' do
+          ri = RelatedIdentifier.new(related_metadata_scheme: 'citeproc+json', identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          expect(ri.related_metadata_scheme).to eq('citeproc+json')
+        end
+        it 'sets the schemeURI' do
+          ri = RelatedIdentifier.new(scheme_uri: URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'), identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          expect(ri.scheme_uri).to eq(URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'))
+        end
+        it 'sets the schemeType' do
+          ri = RelatedIdentifier.new(scheme_type: 'Turtle', identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          expect(ri.scheme_type).to eq('Turtle')
+        end
+        it 'sets the value' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect(ri.value).to eq('arXiv:0706.0001')
+        end
+        it 'requires a relatedIdentifierType' do
+          expect { RelatedIdentifier.new(relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001') }.to raise_error(ArgumentError)
+        end
+        it 'requires a relationType' do
+          expect { RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, value: 'arXiv:0706.0001') }.to raise_error(ArgumentError)
+        end
+        it 'requires a value' do
+          expect { RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe 'value=' do
+        it 'sets the value' do
+          ri = RelatedIdentifier.allocate
+          ri.value = 'arXiv:0706.0001'
+          expect(ri.value).to eq('arXiv:0706.0001')
+        end
+        it 'requires a value' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect { ri.value = nil }.to raise_error(ArgumentError)
+          expect(ri.value).to eq('arXiv:0706.0001')
+        end
+        it 'requires a non-empty value' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect { ri.value = '' }.to raise_error(ArgumentError)
+          expect(ri.value).to eq('arXiv:0706.0001')
+        end
+      end
+      describe 'identifier_type=' do
+        it 'sets the relatedIdentifierType' do
+          ri = RelatedIdentifier.allocate
+          ri.identifier_type = RelatedIdentifierType::ARXIV
+          expect(ri.identifier_type).to eq(RelatedIdentifierType::ARXIV)
+        end
+        it 'requires a relatedIdentifierType' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect { ri.identifier_type = nil }.to raise_error(ArgumentError)
+          expect(ri.identifier_type).to eq(RelatedIdentifierType::ARXIV)
+        end
+      end
+      describe 'relation_type=' do
+        it 'sets the relationType' do
+          ri = RelatedIdentifier.allocate
+          ri.relation_type = RelationType::IS_REVIEWED_BY
+          expect(ri.relation_type).to eq(RelationType::IS_REVIEWED_BY)
+        end
+        it 'requires a relationType' do
+          ri = RelatedIdentifier.new(identifier_type: RelatedIdentifierType::ARXIV, relation_type: RelationType::IS_REVIEWED_BY, value: 'arXiv:0706.0001')
+          expect { ri.relation_type = nil }.to raise_error(ArgumentError)
+          expect(ri.relation_type).to eq(RelationType::IS_REVIEWED_BY)
+        end
+      end
+      describe 'related_metadata_scheme=' do
+        it 'sets the relatedMetadataScheme' do
+          ri = RelatedIdentifier.allocate
+          ri.related_metadata_scheme = 'citeproc+json'
+          expect(ri.related_metadata_scheme).to eq('citeproc+json')
+        end
+        it 'allows a nil relatedMetadataScheme' do
+          ri = RelatedIdentifier.new(related_metadata_scheme: 'citeproc+json', identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          ri.related_metadata_scheme = nil
+          expect(ri.related_metadata_scheme).to be_nil
+        end
+      end
+      describe 'scheme_uri=' do
+        it 'sets the schemeURI' do
+          ri = RelatedIdentifier.allocate
+          ri.scheme_uri = URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json')
+          expect(ri.scheme_uri).to eq(URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'))
+        end
+        it 'allows a nil schemeURI' do
+          ri = RelatedIdentifier.new(scheme_uri: URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json'), identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          ri.scheme_uri = nil
+          expect(ri.scheme_uri).to be_nil
+        end
+      end
+      describe 'scheme_type=' do
+        it 'sets the schemeType' do
+          ri = RelatedIdentifier.allocate
+          ri.scheme_type = 'Turtle'
+          expect(ri.scheme_type).to eq('Turtle')
+        end
+        it 'allows a nil schemeType' do
+          ri = RelatedIdentifier.new(scheme_type: 'Turtle', identifier_type: 'URL', relation_type: RelationType::HAS_METADATA, value: 'http://data.datacite.org/application/citeproc+json/10.5072/example-full')
+          ri.scheme_type = nil
+          expect(ri.scheme_type).to be_nil
+        end
+      end
+
+      describe '#load_from_xml' do
+        it 'parses XML' do
+          xml_text = '<relatedIdentifier relatedIdentifierType="URL" relationType="HasMetadata" relatedMetadataScheme="citeproc+json" schemeType="Turtle" schemeURI="https://github.com/citation-style-language/schema/raw/master/csl-data.json">http://data.datacite.org/application/citeproc+json/10.5072/example-full</relatedIdentifier>'
+          xml = REXML::Document.new(xml_text).root
+          id = RelatedIdentifier.load_from_xml(xml)
+
+          expected_id_type = RelatedIdentifierType::URL
+          expected_rel_type = RelationType::HAS_METADATA
+          expected_scheme = 'citeproc+json'
+          expected_scheme_uri = URI('https://github.com/citation-style-language/schema/raw/master/csl-data.json')
+          expected_value = 'http://data.datacite.org/application/citeproc+json/10.5072/example-full'
+
+          expect(id.identifier_type).to eq(expected_id_type)
+          expect(id.relation_type).to eq(expected_rel_type)
+          expect(id.related_metadata_scheme).to eq(expected_scheme)
+          expect(id.scheme_type).to eq('Turtle')
+          expect(id.scheme_uri).to eq(expected_scheme_uri)
+          expect(id.value).to eq(expected_value)
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'writes XML' do
+          id = 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'
+          )
+          expected_xml = '<relatedIdentifier relatedIdentifierType="URL" relationType="HasMetadata" relatedMetadataScheme="citeproc+json" schemeType="Turtle" schemeURI="https://github.com/citation-style-language/schema/raw/master/csl-data.json">http://data.datacite.org/application/citeproc+json/10.5072/example-full</relatedIdentifier>'
+          expect(id.save_to_xml).to be_xml(expected_xml)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,727 @@
+# coding: utf-8
+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
+
+      # 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
+            )
+          end.to raise_error(ArgumentError)
+        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)
+        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)
+        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)
+        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)
+        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
+        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"
+      end
+
+      describe 'identifier' do
+        it 'returns the identifier'
+      end
+
+      describe 'identifier=' do
+        it 'sets the identifier'
+        it 'rejects nil'
+      end
+
+      describe 'creators' do
+        it 'returns the creator list'
+        it 'returns an editable list'
+      end
+
+      describe 'creators=' do
+        it 'overwrites the creator list'
+        it 'requires at least one creator'
+      end
+
+      describe 'titles' do
+        it 'returns the title list'
+        it 'returns an editable list'
+      end
+
+      describe 'titles=' do
+        it 'overwrites the title list'
+        it 'requires at least one title'
+      end
+
+      describe 'publisher' do
+        it 'returns the publisher'
+      end
+
+      describe 'publisher=' do
+        it 'sets the publisher'
+        it 'rejects nil'
+        it 'rejects the empty string'
+      end
+
+      describe 'publication_year' do
+        it 'returns the publication year'
+        it 'rejects nil'
+        it 'accepts only 4-digit integers'
+      end
+
+      describe 'publication_year=' do
+        it 'sets the publication year'
+      end
+
+      describe 'subjects' do
+        it 'returns the subject list'
+        it 'returns an editable list'
+      end
+
+      describe 'subjects=' do
+        it 'overwrites the subject list'
+        it 'accepts an empty list'
+      end
+
+      describe 'dates' do
+        it 'returns the date list'
+        it 'returns an editable list'
+      end
+
+      describe 'dates=' do
+        it 'overwrites the date list'
+        it 'accepts an empty list'
+      end
+
+      describe 'language' do
+        it 'returns the language'
+      end
+
+      describe 'language=' do
+        it 'sets the languge'
+        it 'requires a language'
+      end
+
+      describe 'resource_type' do
+        it 'returns the resource type'
+      end
+
+      describe 'resource_type=' do
+        it 'sets the resource type'
+        it 'requires a resource type'
+      end
+
+      describe 'alternate_identifiers' do
+        it 'returns the alternate identifier list'
+        it 'returns an editable list'
+      end
+
+      describe 'alternate_identifiers=' do
+        it 'overwrites the alternate identifier list'
+        it 'accepts an empty list'
+      end
+
+      describe 'related_identifiers' do
+        it 'returns the related identifier list'
+        it 'returns an editable list'
+      end
+
+      describe 'related_identifiers=' do
+        it 'overwrites the related identifier list'
+        it 'accepts an empty list'
+      end
+
+      describe 'sizes' do
+        it 'returns the size list'
+        it 'returns an editable list'
+      end
+
+      describe 'sizes=' do
+        it 'overwrites the size list'
+        it 'accepts an empty list'
+      end
+
+      describe 'formats' do
+        it 'returns the size list'
+        it 'returns an editable list'
+      end
+
+      describe 'formats=' do
+        it 'overwrites the size list'
+        it 'accepts an empty list'
+      end
+
+      describe 'version' do
+        it 'returns the version'
+      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 'rights=' do
+        it 'overwrites the rights list'
+        it 'accepts an empty list'
+      end
+
+      describe 'descriptions' do
+        it 'returns the description list'
+        it 'returns an editable list'
+      end
+
+      describe 'descriptions=' do
+        it 'overwrites the description list'
+        it 'accepts an empty list'
+      end
+
+      describe 'geo_locations' do
+        it 'returns the geolocation list'
+        it 'returns an editable list'
+      end
+
+      describe 'geo_locations=' do
+        it 'overwrites the geolocation list'
+        it 'accepts an empty list'
+      end
+
+      describe 'XML mapping' do
+
+        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).'
+                )
+              ]
+            )
+
+            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>'
+
+            expect(resource.save_to_xml).to be_xml(expected_xml)
+          end
+        end
+
+        it 'round-trips' do
+          xml_text = File.read('spec/data/resource.xml')
+          xml = REXML::Document.new(xml_text).root
+          resource = Resource.load_from_xml(xml)
+          expect(resource.save_to_xml).to be_xml(xml_text)
+        end
+      end
+    end
+  end
+end