resync-client 0.1.0

data/spec/unit/resync/client/bitstream_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'mime/type'
+require 'zip'
+
+module Resync
+  describe Bitstream do
+
+    # ------------------------------------------------------------
+    # Fixture
+
+    before(:each) do
+      @zipfile = instance_double(Zip::File)
+
+      @metadata = instance_double(Metadata)
+      @path = 'path/to/resource'
+      allow(@metadata).to receive(:path).and_return(@path)
+
+      @zip_entry = instance_double(Zip::Entry)
+      allow(@zipfile).to receive(:find_entry).with(@path).and_return(@zip_entry)
+
+      @resource = instance_double(Resource)
+      allow(@resource).to receive(:metadata).and_return(@metadata)
+
+      @bitstream = Bitstream.new(zipfile: @zipfile, resource: @resource)
+    end
+
+    # ------------------------------------------------------------
+    # Tests
+
+    describe '#new' do
+      it 'requires a zipfile' do
+        expect { Bitstream.new(resource: @resource) }.to raise_error
+      end
+
+      it 'requires a resource' do
+        expect { Bitstream.new(zipfile: @zipfile) }.to raise_error
+      end
+    end
+
+    describe '#size' do
+      it 'returns the size of the zip entry' do
+        expect(@zip_entry).to receive(:size).and_return(123)
+        expect(@bitstream.size).to eq(123)
+      end
+    end
+
+    describe '#stream' do
+      it 'returns the input stream from the zip entry' do
+        stream = instance_double(Zip::InputStream)
+        expect(@zip_entry).to receive(:get_input_stream).and_return(stream)
+        expect(@bitstream.stream).to be(stream)
+      end
+
+      it 'returns the same stream each time' do
+        stream = instance_double(Zip::InputStream)
+        expect(@zip_entry).to receive(:get_input_stream).and_return(stream)
+        expect(@bitstream.stream).to be(stream)
+        expect(@bitstream.stream).to be(stream)
+      end
+    end
+
+    describe '#content' do
+      it 'gets the content of the stream' do
+        stream = instance_double(Zip::InputStream)
+        content = 'I am the content of the zip stream'
+        allow(stream).to receive(:read).and_return(content)
+        expect(@zip_entry).to receive(:get_input_stream).and_return(stream)
+        expect(@bitstream.content).to eq(content)
+      end
+
+      it 'gets the content of the stream only once' do
+        stream = instance_double(Zip::InputStream)
+        content = 'I am the content of the zip stream'
+        allow(stream).to receive(:read).and_return(content)
+        expect(@zip_entry).to receive(:get_input_stream).and_return(stream)
+        expect(@bitstream.content).to eq(content)
+        expect(@bitstream.content).to eq(content)
+      end
+    end
+
+    describe '#mime_type' do
+      it 'returns the MIME type of the metadata' do
+        mime_type = instance_double(MIME::Type)
+        allow(@metadata).to receive(:mime_type).and_return(mime_type)
+        expect(@bitstream.mime_type).to be(mime_type)
+      end
+    end
+
+  end
+end

data/spec/unit/resync/client/client_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+module Resync
+  describe Client do
+    before(:each) do
+      @helper = instance_double(HTTPHelper)
+      @client = Client.new(helper: @helper)
+    end
+
+    describe '#get' do
+      it 'retrieves a CapabilityList' do
+        uri = URI('http://example.org/capability-list.xml')
+        data = File.read('spec/data/examples/capability-list.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::CapabilityList)
+      end
+
+      it 'retrieves a ChangeDump' do
+        uri = URI('http://example.org/change-dump.xml')
+        data = File.read('spec/data/examples/change-dump.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ChangeDump)
+      end
+
+      it 'retrieves a ChangeDumpManifest' do
+        uri = URI('http://example.org/change-dump-manifest.xml')
+        data = File.read('spec/data/examples/change-dump-manifest.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ChangeDumpManifest)
+      end
+
+      it 'retrieves a ChangeList' do
+        uri = URI('http://example.org/change-list.xml')
+        data = File.read('spec/data/examples/change-list.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ChangeList)
+      end
+
+      it 'retrieves a ResourceDump' do
+        uri = URI('http://example.org/resource-dump.xml')
+        data = File.read('spec/data/examples/resource-dump.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ResourceDump)
+      end
+
+      it 'retrieves a ResourceDumpManifest' do
+        uri = URI('http://example.org/resource-dump-manifest.xml')
+        data = File.read('spec/data/examples/resource-dump-manifest.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ResourceDumpManifest)
+      end
+
+      it 'retrieves a ResourceList' do
+        uri = URI('http://example.org/resource-list.xml')
+        data = File.read('spec/data/examples/resource-list.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ResourceList)
+      end
+
+      it 'retrieves a SourceDescription' do
+        uri = URI('http://example.org/source-description.xml')
+        data = File.read('spec/data/examples/source-description.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::SourceDescription)
+      end
+
+      it 'retrieves a ChangeListIndex' do
+        uri = URI('http://example.org/change-list-index.xml')
+        data = File.read('spec/data/examples/change-list-index.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ChangeListIndex)
+      end
+
+      it 'retrieves a ResourceListIndex' do
+        uri = URI('http://example.org/resource-list-index.xml')
+        data = File.read('spec/data/examples/resource-list-index.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc).to be_a(Resync::ResourceListIndex)
+      end
+
+      it 'injects the client into the returned document' do
+        uri = URI('http://example.org/resource-list-index.xml')
+        data = File.read('spec/data/examples/resource-list-index.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        expect(doc.client).to be(@client)
+      end
+    end
+
+    describe '#new' do
+      it 'creates its own connection if none is provided' do
+        uri = URI('http://example.org/capability-list.xml')
+        data = File.read('spec/data/examples/capability-list.xml')
+        expect(HTTPHelper).to receive(:new).and_return(@helper)
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        client = Client.new
+        client.get_and_parse(uri)
+      end
+    end
+
+    describe '#download_to_temp_file' do
+      it 'delegates to the helper' do
+        uri = 'http://example.org/capability-list.xml'
+        path = '/tmp/whatever.zip'
+        expect(@helper).to receive(:fetch_to_file).with(uri: URI(uri)).and_return(path)
+        expect(@client.download_to_temp_file(uri)).to eq(path)
+      end
+    end
+
+    describe '#download_to_file' do
+      it 'delegates to the helper' do
+        uri = 'http://example.org/capability-list.xml'
+        path = '/tmp/whatever.zip'
+        expect(@helper).to receive(:fetch_to_file).with(uri: URI(uri), path: path).and_return(path)
+        expect(@client.download_to_file(uri: uri, path: path)).to eq(path)
+      end
+    end
+
+  end
+end

data/spec/unit/resync/client/dump_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Resync
+  describe Dump do
+    it 'transparently extracts bitstreams' do
+      package_uri = URI('http://example.com/resourcedump.zip')
+      client = instance_double(Client)
+      expect(client).to receive(:download_to_temp_file).once.with(package_uri).and_return('spec/data/resourcedump/resourcedump.zip')
+
+      resource_dump = XMLParser.parse(File.read('spec/data/resourcedump/resourcedump.xml'))
+      resource_dump.client = client
+
+      zip_packages = resource_dump.zip_packages
+      expect(zip_packages.size).to eq(1)
+
+      zip_package = zip_packages[0]
+      expect(zip_package).to be_a(ZipPackage)
+
+      bitstreams = zip_package.bitstreams
+      expect(bitstreams.size).to eq(2)
+
+      stream1 = bitstreams[0]
+      expect(stream1.content).to eq(File.read('spec/data/resourcedump/resources/res1'))
+    end
+  end
+end

data/spec/unit/resync/client/http_helper_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+module Resync
+  describe HTTPHelper do
+
+    # ------------------------------------------------------------
+    # Fixture
+
+    attr_writer :user_agent
+
+    def user_agent
+      @user_agent ||= 'elvis'
+    end
+
+    attr_writer :helper
+
+    def helper
+      @helper ||= HTTPHelper.new(user_agent: user_agent)
+    end
+
+    # ------------------------------------------------------------
+    # Tests
+
+    describe '#fetch' do
+
+      # ------------------------------
+      # Fixture
+
+      before(:each) do
+        @http = instance_double(Net::HTTP)
+        allow(Net::HTTP).to receive(:new).and_return(@http)
+        allow(@http).to receive(:start).and_yield(@http)
+        @success = Net::HTTPOK.allocate
+        @body = 'I am the body of the response'
+        allow(@success).to receive(:body).and_return(@body)
+      end
+
+      # ------------------------------
+      # Tests
+
+      it 'requests the specified URI' do
+        uri = URI('http://example.org/')
+        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+        helper.fetch(uri: uri)
+      end
+
+      it 'gets a response' do
+        expect(@http).to receive(:request).and_yield(@success)
+        expect(helper.fetch(uri: URI('http://example.org/'))).to be(@body)
+      end
+
+      it 'sets the User-Agent header' do
+        agent = 'Not Elvis'
+        helper = HTTPHelper.new(user_agent: agent)
+        expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
+        helper.fetch(uri: URI('http://example.org/'))
+      end
+
+      it 'uses SSL for https requests' do
+        uri = URI('https://example.org/')
+        expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
+        expect(@http).to receive(:request).and_yield(@success)
+        helper.fetch(uri: uri)
+      end
+
+      it 're-requests on receiving a 1xx' do
+        uri = URI('http://example.org/')
+        @info = Net::HTTPContinue.allocate
+
+        expected = [@info, @success]
+        expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
+          block.call(expected.shift)
+        end
+
+        expect(helper.fetch(uri: uri)).to be(@body)
+      end
+
+      it 'redirects on receiving a 3xx' do
+        uri = URI('http://example.org/')
+        uri2 = URI('http://example.org/new')
+        @redirect = Net::HTTPMovedPermanently.allocate
+        allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
+        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
+        expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
+        expect(helper.fetch(uri: uri)).to be(@body)
+      end
+
+      it 'only redirects a limited number of times' do
+        uri = URI('http://example.org/')
+        @redirect = Net::HTTPMovedPermanently.allocate
+        allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
+        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
+        expect { helper.fetch(uri: uri) }.to raise_error
+      end
+
+      it 'fails on a 4xx' do
+        @error = Net::HTTPForbidden
+        allow(@error).to receive(:code).and_return(403)
+        allow(@error).to receive(:message).and_return('Forbidden')
+        expect(@http).to receive(:request).and_yield(@error)
+        uri = URI('http://example.org/')
+        expect { helper.fetch(uri: uri) }.to raise_error
+      end
+
+      it 'fails on a 5xx' do
+        @error = Net::HTTPServerError
+        allow(@error).to receive(:code).and_return(500)
+        allow(@error).to receive(:message).and_return('Internal Server Error')
+        expect(@http).to receive(:request).and_yield(@error)
+        uri = URI('http://example.org/')
+        expect { helper.fetch(uri: uri) }.to raise_error
+      end
+    end
+
+    describe '#fetch_to_file' do
+
+      # ------------------------------
+      # Fixture
+
+      before(:each) do
+        @path = nil
+        @http = instance_double(Net::HTTP)
+        allow(Net::HTTP).to receive(:new).and_return(@http)
+        allow(@http).to receive(:start).and_yield(@http)
+
+        @data = (0...100).map { ('a'..'z').to_a[rand(26)] }.join
+        @success = Net::HTTPOK.allocate
+        allow(@success).to receive(:[]).with('Content-Type').and_return('text/plain')
+        stub = allow(@success).to receive(:read_body)
+        (0...10).each do |i|
+          chunk = @data[10 * i, 10]
+          stub = stub.and_yield(chunk)
+        end
+      end
+
+      after(:each) do
+        File.delete(@path) if @path
+      end
+
+      # ------------------------------
+      # Tests
+
+      it 'requests the specified URI' do
+        uri = URI('http://example.org/')
+        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+        @path = helper.fetch_to_file(uri: uri)
+      end
+
+      it 'returns the path to a file containing the response' do
+        uri = URI('http://example.org/')
+        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+        @path = helper.fetch_to_file(uri: uri)
+        expect(File.read(@path)).to eq(@data)
+      end
+
+      it 'sets the User-Agent header' do
+        agent = 'Not Elvis'
+        helper = HTTPHelper.new(user_agent: agent)
+        expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
+        @path = helper.fetch_to_file(uri: URI('http://example.org/'))
+      end
+
+      it 'uses SSL for https requests' do
+        uri = URI('https://example.org/')
+        expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
+        expect(@http).to receive(:request).and_yield(@success)
+        @path = helper.fetch_to_file(uri: uri)
+      end
+
+      it 're-requests on receiving a 1xx' do
+        uri = URI('http://example.org/')
+        @info = Net::HTTPContinue.allocate
+
+        expected = [@info, @success]
+        expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
+          block.call(expected.shift)
+        end
+
+        @path = helper.fetch_to_file(uri: uri)
+        expect(File.read(@path)).to eq(@data)
+      end
+
+      it 'redirects on receiving a 3xx' do
+        uri = URI('http://example.org/')
+        uri2 = URI('http://example.org/new')
+        @redirect = Net::HTTPMovedPermanently.allocate
+        allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
+        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
+        expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
+        @path = helper.fetch_to_file(uri: uri)
+        expect(File.read(@path)).to eq(@data)
+      end
+
+      it 'only redirects a limited number of times' do
+        uri = URI('http://example.org/')
+        @redirect = Net::HTTPMovedPermanently.allocate
+        allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
+        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
+        expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
+        expect(@path).to be_nil
+      end
+
+      it 'fails on a 4xx' do
+        @error = Net::HTTPForbidden
+        allow(@error).to receive(:code).and_return(403)
+        allow(@error).to receive(:message).and_return('Forbidden')
+        expect(@http).to receive(:request).and_yield(@error)
+        uri = URI('http://example.org/')
+        expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
+        expect(@path).to be_nil
+      end
+
+      it 'fails on a 5xx' do
+        @error = Net::HTTPServerError
+        allow(@error).to receive(:code).and_return(500)
+        allow(@error).to receive(:message).and_return('Internal Server Error')
+        expect(@http).to receive(:request).and_yield(@error)
+        uri = URI('http://example.org/')
+        expect { helper.fetch_to_file(uri: uri) }.to raise_error
+      end
+
+      it 'accepts a file path argument' do
+        Dir.mktmpdir do |dir|
+          expect(Dir.exist?(dir)).to be(true)
+          path = "#{dir}/http_helper_spec.out"
+          uri = URI('http://example.org/')
+          expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+          helper.fetch_to_file(uri: uri, path: path)
+          expect(File.read(path)).to eq(@data)
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/resync/client/resync_extensions_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module Resync
+  describe 'extensions' do
+
+    # ------------------------------------------------------------
+    # Fixture
+
+    before(:each) do
+      @resources = [
+        Resource.new(uri: 'http://example.com/dataset1/resourcelist.xml', metadata: Metadata.new(capability: 'resourcelist')),
+        Resource.new(uri: 'http://example.com/dataset1/resourcedump.xml', metadata: Metadata.new(capability: 'resourcedump')),
+        Resource.new(uri: 'http://example.com/dataset1/changelist.xml', metadata: Metadata.new(capability: 'changelist')),
+        Resource.new(uri: 'http://example.com/dataset1/changedump.xml', metadata: Metadata.new(capability: 'changedump'))
+      ]
+      @links = [
+        Link.new(rel: 'describedby', uri: 'http://example.org/desc1'),
+        Link.new(rel: 'duplicate', uri: 'http://example.com/dup1'),
+        Link.new(rel: 'describedby', uri: 'http://example.org/desc2'),
+        Link.new(rel: 'duplicate', uri: 'http://example.com/dup2')
+      ]
+      @list = ResourceList.new(resources: @resources, links: @links)
+    end
+
+    # ------------------------------------------------------------
+    # Tests
+
+    describe BaseResourceList do
+      it 'proxies all resource client requests to its own client' do
+        client = instance_double(Resync::Client)
+        @list.client = client
+        @resources.each do |r|
+          expect(r.client).to be(client)
+        end
+        client2 = instance_double(Resync::Client)
+        @list.client = client2
+        @resources.each do |r|
+          expect(r.client).to be(client2)
+        end
+      end
+    end
+
+    describe Augmented do
+      it 'proxies all link client requests to its own client' do
+        client = instance_double(Resync::Client)
+        @list.client = client
+        @links.each do |l|
+          expect(l.client).to be(client)
+        end
+        client2 = instance_double(Resync::Client)
+        @list.client = client2
+        @links.each do |l|
+          expect(l.client).to be(client2)
+        end
+      end
+
+      it 'defaults to a new client' do
+        client = instance_double(Resync::Client)
+        expect(Resync::Client).to receive(:new) { client }
+        expect(@list.client).to be(client)
+      end
+    end
+
+    describe Resource do
+      describe '#get_and_parse' do
+        it 'gets the resource using the injected client' do
+          client = instance_double(Resync::Client)
+          resource = instance_double(Resync::ResourceList)
+          @list.client = client
+          expect(client).to receive(:get_and_parse).with(@resources[0].uri) { resource }
+          expect(@resources[0].get_and_parse).to be(resource)
+        end
+      end
+
+      describe '#get' do
+        it 'gets the resource contents using the injected client' do
+          data = 'I am the contents of a resource'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:get).with(@resources[0].uri) { data }
+          expect(@resources[0].get).to be(data)
+        end
+      end
+
+      describe '#download_to_temp_file' do
+        it 'downloads the resource contents to a file using the injected client' do
+          path = '/tmp/whatever.zip'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:download_to_temp_file).with(@resources[0].uri) { path }
+          expect(@resources[0].download_to_temp_file).to be(path)
+        end
+      end
+
+      describe '#download_to_file' do
+        it 'delegates to the injected client' do
+          path = '/tmp/whatever.zip'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:download_to_file).with(uri: @resources[0].uri, path: path) { path }
+          expect(@resources[0].download_to_file(path)).to be(path)
+        end
+      end
+    end
+
+    describe Link do
+      describe '#get_and_parse' do
+        it 'gets the link using the injected client' do
+          client = instance_double(Resync::Client)
+          resource = instance_double(Resync::ResourceList)
+          @list.client = client
+          expect(client).to receive(:get_and_parse).with(@links[0].uri) { resource }
+          expect(@links[0].get_and_parse).to be(resource)
+        end
+      end
+
+      describe '#get' do
+        it 'gets the link contents using the injected client' do
+          data = 'I am the contents of a link'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:get).with(@links[0].uri) { data }
+          expect(@links[0].get).to be(data)
+        end
+      end
+
+      describe '#download_to_temp_file' do
+        it 'downloads the link contents to a file using the injected client' do
+          path = '/tmp/whatever.zip'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:download_to_temp_file).with(@links[0].uri) { path }
+          expect(@links[0].download_to_temp_file).to be(path)
+        end
+      end
+
+      describe '#download_to_file' do
+        it 'delegates to the injected client' do
+          path = '/tmp/whatever.zip'
+          client = instance_double(Resync::Client)
+          @list.client = client
+          expect(client).to receive(:download_to_file).with(uri: @links[0].uri, path: path) { path }
+          expect(@links[0].download_to_file(path)).to be(path)
+        end
+      end
+    end
+  end
+end

data/spec/unit/resync/client/zip_package_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'resync/client/zip_package'
+
+module Resync
+  describe ZipPackage do
+    describe '#new' do
+      it 'accepts a path to a ZIP file' do
+        path = 'spec/data/resourcedump/resourcedump.zip'
+        pkg = ZipPackage.new(path)
+        zipfile = pkg.zipfile
+        expect(zipfile).to be_a(Zip::File)
+        expect(zipfile.name).to eq(path)
+      end
+
+      it 'accepts a Zip::File object' do
+        zipfile = Zip::File.open('spec/data/resourcedump/resourcedump.zip')
+        pkg = ZipPackage.new(zipfile)
+        expect(pkg.zipfile).to eq(zipfile)
+      end
+
+      it 'extracts a manifest' do
+        pkg = ZipPackage.new('spec/data/resourcedump/resourcedump.zip')
+        manifest = pkg.manifest
+        expect(manifest).to be_a(Resync::ResourceDumpManifest)
+      end
+
+      it 'extracts entries' do
+        pkg = ZipPackage.new('spec/data/resourcedump/resourcedump.zip')
+        bitstreams = pkg.bitstreams
+        expect(bitstreams.size).to eq(2)
+
+        bs0 = bitstreams[0]
+        expect(bs0.path).to eq('resources/res1')
+        expect(bs0.size).to eq(446)
+        expect(bs0.content).to eq(File.read('spec/data/resourcedump/resources/res1'))
+
+        bs1 = bitstreams[1]
+        expect(bs1.path).to eq('resources/res2')
+        expect(bs1.size).to eq(447)
+        expect(bs1.content).to eq(File.read('spec/data/resourcedump/resources/res2'))
+      end
+    end
+  end
+end