resync 0.1.0

data/spec/unit/resync/shared/descriptor_examples.rb

@@ -0,0 +1,122 @@
+module Resync
+  RSpec.shared_examples Descriptor do
+
+    # TODO: Find a better way to express this
+    def new_instance(**args)
+      required_args = (defined? required_arguments) ? required_arguments : {}
+      args = required_args.merge(args)
+      described_class.new(**args)
+    end
+
+    describe 'modified_time' do
+      it 'accepts a modified timestamp' do
+        modified_time = Time.utc(1997, 7, 16, 19, 20, 30.45)
+        descriptor = new_instance(modified_time: modified_time)
+        expect(descriptor.modified_time).to be_time(modified_time)
+      end
+
+      it 'defaults to nil if no modified timestamp is specified' do
+        descriptor = new_instance
+        expect(descriptor.modified_time).to be_nil
+      end
+
+      it 'fails if the modified timestamp is not a time' do
+        expect { new_instance(modified_time: '12:45 pm') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'length' do
+      it 'accepts a length' do
+        length = 12_345
+        descriptor = new_instance(length: length)
+        expect(descriptor.length).to eq(length)
+      end
+
+      it 'defaults to nil if no length is specified' do
+        descriptor = new_instance
+        expect(descriptor.length).to be_nil
+      end
+
+      it 'fails if length is not a non-negative integer' do
+        expect { new_instance(length: -12_345) }.to raise_error(ArgumentError)
+        expect { new_instance(length: 123.45) }.to raise_error(ArgumentError)
+        expect { new_instance(length: 'I am not a number') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'mime_type' do
+      it 'accepts a standard MIME type' do
+        mt = MIME::Types['text/plain'].first
+        descriptor = new_instance(mime_type: mt)
+        expect(descriptor.mime_type).to eq(mt)
+      end
+
+      it 'accepts a non-standard MIME type' do
+        mt = MIME::Type.new('elvis/presley')
+        descriptor = new_instance(mime_type: mt)
+        expect(descriptor.mime_type).to eq(mt)
+      end
+
+      it 'accepts a MIME type as a string' do
+        mt_string = 'elvis/presley'
+        descriptor = new_instance(mime_type: mt_string)
+        expect(descriptor.mime_type).to eq(MIME::Type.new(mt_string))
+      end
+
+      it 'defaults to nil if no MIME type is specified' do
+        descriptor = new_instance
+        expect(descriptor.length).to be_nil
+      end
+
+      it 'fails if mime_type isn\'t a MIME type' do
+        mt_string = 'I am not a mime type'
+        expect { new_instance(mime_type: mt_string) }.to raise_error(MIME::Type::InvalidContentType)
+      end
+    end
+
+    describe 'encoding' do
+      it 'accepts an encoding' do
+        encoding = 'utf-8'
+        descriptor = new_instance(encoding: encoding)
+        expect(descriptor.encoding).to eq(encoding)
+      end
+
+      it 'defaults to nil if no encoding specified' do
+        descriptor = new_instance
+        expect(descriptor.encoding).to be_nil
+      end
+    end
+
+    describe 'hash' do
+      it 'accepts a hash of hashes' do
+        hashes = {
+          'md5' => '1e0d5cb8ef6ba40c99b14c0237be735e',
+          'sha-256' => '854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784'
+        }
+        descriptor = new_instance(hashes: hashes)
+        expect(descriptor.hashes).to eq(hashes)
+        expect(descriptor.hash('md5')). to eq('1e0d5cb8ef6ba40c99b14c0237be735e')
+        expect(descriptor.hash('sha-256')). to eq('854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784')
+      end
+
+      it 'defaults to an empty hash if no hash specified' do
+        descriptor = new_instance
+        expect(descriptor.hashes).to eq({})
+      end
+    end
+
+    describe 'path' do
+      it 'accepts a path' do
+        path = '/resources/res2'
+        descriptor = new_instance(path: path)
+        expect(descriptor.path).to eq(path)
+      end
+
+      it 'defaults to nil if no path specified' do
+        descriptor = new_instance
+        expect(descriptor.path).to be_nil
+      end
+    end
+
+  end
+end

data/spec/unit/resync/shared/descriptor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Resync
+  describe Descriptor do
+    describe 'hash_of_hashcodes' do
+      it 'extracts a hash' do
+        hash_str = 'md5:1e0d5cb8ef6ba40c99b14c0237be735e'
+        hashes = Descriptor.hash_of_hashcodes(hash_str)
+        expect(hashes['md5']).to eq('1e0d5cb8ef6ba40c99b14c0237be735e')
+      end
+
+      it 'extracts multiple hashes separated by a space' do
+        hash_str = 'md5:1e0d5cb8ef6ba40c99b14c0237be735e sha-256:854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784'
+        hashes = Descriptor.hash_of_hashcodes(hash_str)
+        expect(hashes['md5']).to eq('1e0d5cb8ef6ba40c99b14c0237be735e')
+        expect(hashes['sha-256']).to eq('854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784')
+      end
+
+      it 'extracts multiple hashes separated by arbitrary whitespace' do
+        hash_str = 'md5:1e0d5cb8ef6ba40c99b14c0237be735e
+                    sha-256:854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784'
+        hashes = Descriptor.hash_of_hashcodes(hash_str)
+        expect(hashes['md5']).to eq('1e0d5cb8ef6ba40c99b14c0237be735e')
+        expect(hashes['sha-256']).to eq('854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784')
+      end
+
+      it 'leaves a hash of hashes alone' do
+        hashes = { 'md5' => '1e0d5cb8ef6ba40c99b14c0237be735e', 'sha-256' => '854f61290e2e197a11bc91063afce22e43f8ccc655237050ace766adc68dc784' }
+        expect(Descriptor.hash_of_hashcodes(hashes)).to eq(hashes)
+      end
+    end
+  end
+end

data/spec/unit/resync/shared/sorted_list_examples.rb

@@ -0,0 +1,134 @@
+require_relative 'base_resource_list_examples'
+
+module Resync
+
+  RSpec.shared_examples SortedResourceList do
+
+    # ------------------------------------------------------
+    # Superclass conformance
+
+    it_behaves_like BaseResourceList
+
+    def new_instance(**args)
+      required_args = (defined? required_arguments) ? required_arguments : {}
+      args = required_args.merge(args)
+      described_class.new(**args)
+    end
+
+    # ------------------------------------------------------
+    # Tests
+
+    describe '#new' do
+      describe 'resources' do
+        it 'sorts resources by modified_time' do
+          resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+          resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+          list = new_instance(resources: [resource1, resource0])
+          expect(list.resources).to eq([resource0, resource1])
+        end
+
+        it 'sorts resources with modified_time before resources without' do
+          resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+          resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+          resource2 = Resource.new(uri: 'http://example.com')
+          list = new_instance(resources: [resource1, resource2, resource0])
+          expect(list.resources).to eq([resource0, resource1, resource2])
+        end
+      end
+    end
+
+    describe '#resources_by_uri' do
+      it 'groups resources by uri' do
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+        resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+        resource2 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1994, 7, 16, 19, 20, 30.45))
+        resource3 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1995, 7, 16, 19, 20, 30.45))
+        list = new_instance(resources: [resource0, resource1, resource2, resource3])
+
+        by_uri = list.resources_by_uri
+        expect(by_uri.size).to eq(2)
+
+        uri0 = by_uri.keys[0]
+        expect(uri0).to eq(URI('http://example.com'))
+        rs0 = by_uri[uri0]
+        expect(rs0).to eq([resource2, resource3])
+
+        uri1 = by_uri.keys[1]
+        expect(uri1).to eq(URI('http://example.org'))
+        rs1 = by_uri[uri1]
+        expect(rs1).to eq([resource0, resource1])
+      end
+
+      it 'updates when the list is updated' do
+        list = new_instance
+        expect(list.resources_by_uri).to eq({})
+
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+        list.resources = [resource0]
+
+        by_uri = list.resources_by_uri
+        expect(by_uri.size).to eq(1)
+        rs0 = by_uri[URI('http://example.org')]
+        expect(rs0).to eq([resource0])
+      end
+    end
+
+    describe '#latest_for' do
+      it 'retrieves the last-modified-instance for a specified URI' do
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+        resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+        resource2 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1994, 7, 16, 19, 20, 30.45))
+        resource3 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1995, 7, 16, 19, 20, 30.45))
+        resource4 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(2003, 7, 16, 19, 20, 30.45))
+        list = new_instance(resources: [resource0, resource1, resource2, resource3, resource4])
+
+        expect(list.latest_for(uri: URI('http://example.org'))).to eq(resource1)
+        expect(list.latest_for(uri: 'http://example.com')).to eq(resource4)
+      end
+
+      it 'works when loading from XML' do
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30))
+        resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30))
+        resource2 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1994, 7, 16, 19, 20, 30))
+        resource3 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1995, 7, 16, 19, 20, 30))
+        resource4 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(2003, 7, 16, 19, 20, 30))
+        list = new_instance(resources: [resource0, resource1, resource2, resource3, resource4])
+        xml = list.save_to_xml
+        list = described_class.load_from_xml(xml)
+
+        latest_org = list.latest_for(uri: URI('http://example.org'))
+        expect(latest_org.uri).to eq(resource1.uri)
+        expect(latest_org.modified_time).to be_time(resource1.modified_time)
+        latest_com = list.latest_for(uri: 'http://example.com')
+        expect(latest_com.uri).to eq(resource4.uri)
+        expect(latest_com.modified_time).to be_time(resource4.modified_time)
+      end
+    end
+
+    describe '#all_uris' do
+      it 'retrieves the set of all URIs' do
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+        resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+        resource2 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1994, 7, 16, 19, 20, 30.45))
+        resource3 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1995, 7, 16, 19, 20, 30.45))
+        resource4 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(2003, 7, 16, 19, 20, 30.45))
+        list = new_instance(resources: [resource0, resource1, resource2, resource3, resource4])
+        expect(list.all_uris).to eq([URI('http://example.org'), URI('http://example.com')])
+      end
+
+      it 'works when loading from XML' do
+        resource0 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1997, 7, 16, 19, 20, 30.45))
+        resource1 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1998, 7, 16, 19, 20, 30.45))
+        resource2 = Resource.new(uri: 'http://example.org', modified_time: Time.utc(1994, 7, 16, 19, 20, 30.45))
+        resource3 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(1995, 7, 16, 19, 20, 30.45))
+        resource4 = Resource.new(uri: 'http://example.com', modified_time: Time.utc(2003, 7, 16, 19, 20, 30.45))
+        list = new_instance(resources: [resource0, resource1, resource2, resource3, resource4])
+        xml = list.save_to_xml
+        list = described_class.load_from_xml(xml)
+
+        expect(list.all_uris).to eq([URI('http://example.org'), URI('http://example.com')])
+      end
+    end
+  end
+
+end

data/spec/unit/resync/shared/uri_field_examples.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Resync
+  RSpec.shared_examples 'a URI field' do
+
+    # TODO: Find a better way to express this
+    def new_instance(**args)
+      required_args = (defined? required_arguments) ? required_arguments : {}
+      required_args.delete(:uri)
+      args = required_args.merge(args)
+      described_class.new(**args)
+    end
+
+    it 'accepts a URI' do
+      uri = URI('http://example.org/')
+      instance = new_instance(uri: uri)
+      expect(instance.uri).to eq(uri)
+    end
+
+    it 'accepts a string URI' do
+      uri = 'http://example.org/'
+      instance = new_instance(uri: uri)
+      expect(instance.uri).to eq(URI(uri))
+    end
+
+    it 'rejects an invalid URI' do
+      invalid_url = 'I am not a valid URI'
+      expect { new_instance(uri: invalid_url) }.to raise_error(URI::InvalidURIError)
+    end
+
+    it 'requires a URI' do
+      expect { new_instance }.to raise_error(ArgumentError)
+    end
+
+  end
+end

data/spec/unit/resync/source_description_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require_relative 'shared/base_resource_list_examples'
+require_relative 'shared/augmented_examples'
+
+module Resync
+  describe SourceDescription do
+    it_behaves_like BaseResourceList
+
+    describe 'links' do
+      it_behaves_like Augmented
+    end
+
+    describe 'XML conversion' do
+      describe '#from_xml' do
+        it 'parses an XML string' do
+          data = File.read('spec/data/examples/example-12.xml')
+          list = SourceDescription.load_from_xml(XML.element(data))
+
+          links = list.links
+          expect(links.size).to eq(1)
+          link = links[0]
+          expect(link.rel).to eq('describedby')
+          expect(link.uri).to eq(URI('http://example.com/info_about_source.xml'))
+
+          md = list.metadata
+          expect(md.capability).to eq('description')
+
+          urls = list.resources
+          expect(urls.size).to eq(3)
+
+          (0..2).each do |i|
+            url = urls[i]
+            expect(url.uri).to eq(URI("http://example.com/capabilitylist#{i + 1}.xml"))
+            md = url.metadata
+            expect(md.capability).to eq('capabilitylist')
+            links = url.links
+            expect(links.size).to eq(1)
+            link = links[0]
+            expect(link.rel).to eq('describedby')
+            expect(link.uri).to eq(URI("http://example.com/info_about_set#{i + 1}_of_resources.xml"))
+          end
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'can round-trip to XML' do
+          data = File.read('spec/data/examples/example-12.xml')
+          list = SourceDescription.load_from_xml(XML.element(data))
+          xml = list.save_to_xml
+          expect(xml).to be_xml(data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/resync/xml/timenode_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Resync
+  module XML
+
+    class Elem
+      include ::XML::Mapping
+      time_node :time, '@time', default_value: nil
+
+      def self.from_str(time_str)
+        xml_string = "<elem time='#{time_str}'/>"
+        doc = REXML::Document.new(xml_string)
+        load_from_xml(doc.root)
+      end
+    end
+
+    describe TimeNode do
+
+      def time(str)
+        Elem.from_str(str).time
+      end
+
+      it 'parses a date with hours, minutes, and seconds' do
+        actual = time('1997-07-16T19:20:30')
+        expected = Time.new(1997, 7, 16, 19, 20, 30)
+        expect(actual).to be_time(expected)
+      end
+
+      it 'parses a date with hours, minutes, seconds, and fractional seconds' do
+        actual = time('1997-07-16T19:20:30.45')
+        expected = Time.new(1997, 7, 16, 19, 20, 30.45)
+        expect(actual).to be_time(expected)
+      end
+
+      it 'parses a UTC "zulu" time (time zone designator "Z")' do
+        actual = time('1997-07-16T19:20:30.45Z')
+        expected = Time.new(1997, 7, 16, 19, 20, 30.45, '+00:00')
+        expect(actual).to be_time(expected)
+      end
+
+      it 'parses a time with a numeric timezone offset' do
+        actual = time('1997-07-16T19:20:30.45+01:30')
+        expected = Time.new(1997, 7, 16, 19, 20, 30.45, '+01:30')
+        expect(actual).to be_time(expected)
+      end
+    end
+  end
+end

data/spec/unit/resync/xml/xml_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Resync
+  describe XML do
+    describe '#element' do
+      it 'returns an element unchanged' do
+        elem = REXML::Element.new('foo')
+        expect(XML.element(elem)).to be(elem)
+      end
+
+      it 'returns the root element of a string document' do
+        xml_str = '<?xml version="1.0"?><foo><bar/><baz/></foo>'
+        elem = XML.element(xml_str)
+        expect(elem).to be_a(REXML::Element)
+        expect(elem).to be_xml('<foo><bar/><baz/></foo>')
+      end
+
+      it 'returns the root element of a REXML::Document' do
+        xml_str = '<?xml version="1.0"?><foo><bar/><baz/></foo>'
+        doc = REXML::Document.new(xml_str)
+        elem = XML.element(doc)
+        expect(elem).to be_a(REXML::Element)
+        expect(elem).to be_xml(doc.root)
+      end
+
+      it 'parses an XML fragment as an element' do
+        xml_str = '<foo><bar/><baz/></foo>'
+        elem = XML.element(xml_str)
+        expect(elem).to be_a(REXML::Element)
+        expect(elem).to be_xml(xml_str)
+      end
+
+      it 'fails when it gets something other than XML' do
+        data = 12_345
+        expect { XML.element(data) }.to raise_exception
+      end
+
+    end
+  end
+end

data/spec/unit/resync/xml_parser_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Resync
+  describe XMLParser do
+
+    describe '#parse' do
+      it 'parses an XML document' do
+        data = File.read('spec/data/examples/example-1.xml')
+        doc = REXML::Document.new(data)
+        urlset = XMLParser.parse(doc)
+        expect(urlset).to be_a(ResourceList)
+      end
+
+      it 'parses a urlset' do
+        data = File.read('spec/data/examples/example-1.xml')
+        root = REXML::Document.new(data).root
+        urlset = XMLParser.parse(root)
+        expect(urlset).to be_a(ResourceList)
+      end
+
+      it 'parses a sitemapindex' do
+        data = File.read('spec/data/examples/example-8.xml')
+        root = REXML::Document.new(data).root
+        sitemapindex = XMLParser.parse(root)
+        expect(sitemapindex).to be_a(ResourceListIndex)
+      end
+
+      it 'parses a String' do
+        data = File.read('spec/data/examples/example-1.xml')
+        urlset = XMLParser.parse(data)
+        expect(urlset).to be_a(ResourceList)
+      end
+
+      it 'parses an XML fragment' do
+        data = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:rs="http://www.openarchives.org/rs/terms/">
+                  <rs:md capability="resourcelist" at="2013-01-03T09:00:00Z"/>
+                  <url><loc>http://example.com/res1</loc></url>
+                </urlset>'
+        urlset = XMLParser.parse(data)
+        expect(urlset).to be_a(ResourceList)
+      end
+
+      it 'fails if the root element has no metadata' do
+        data = '<?xml version="1.0" encoding="UTF-8"?>
+                <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:rs="http://www.openarchives.org/rs/terms/">
+                  <url><loc>http://example.com/res1</loc></url>
+                </urlset>'
+        expect { XMLParser.parse(data) }.to raise_error(ArgumentError)
+      end
+
+      it 'fails if the root element\'s metadata has no capability attribute' do
+        data = '<?xml version="1.0" encoding="UTF-8"?>
+                <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:rs="http://www.openarchives.org/rs/terms/">
+                  <rs:md at="2013-01-03T09:00:00Z"/>
+                  <url><loc>http://example.com/res1</loc></url>
+                </urlset>'
+        expect { XMLParser.parse(data) }.to raise_error(ArgumentError)
+      end
+
+      it 'fails if the root element\'s metadata has an unknown capability attribute' do
+        data = '<?xml version="1.0" encoding="UTF-8"?>
+                <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:rs="http://www.openarchives.org/rs/terms/">
+                  <rs:md capability="NOT A CAPABILITY" at="2013-01-03T09:00:00Z"/>
+                  <url><loc>http://example.com/res1</loc></url>
+                </urlset>'
+        expect { XMLParser.parse(data) }.to raise_error(ArgumentError)
+      end
+
+      it 'fails when it gets something other than a <urlset/> or <sitemapindex/>' do
+        data = '<loc>http://example.com/resourcelist-part1.xml</loc>'
+        expect { XMLParser.parse(data) }.to raise_error(ArgumentError)
+      end
+
+      it 'fails when it gets something other than XML' do
+        data = 12_345
+        expect { XMLParser.parse(data) }.to raise_error(ArgumentError)
+      end
+
+    end
+
+  end
+end