spdocgen 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  metadata.gz: c2f64220f543247a047013d39dc6cebee4390b8fcc531b67cd5e8a86073298a4f401b0c7fd6abe97894a736f9449219c04460dc631a99a6f492942c8d5c4acfa
+  data.tar.gz: ee878ee4a4a915378cb266ed2b1f0cd0cbd36a4086ced6178a020dc199288a198966da9a96c0285178fb1d5d328e7e084e57dc0211ef0e3328bba69039fdccbf
+SHA1: 
+  metadata.gz: f084863ea5fc6784ac2bf2a57e800d6cddcf4a1b
+  data.tar.gz: 72ba51d7f0976b343ed747a95abcf96751fdf8d7

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spdocgen.gemspec
+gemspec
+
+gem 'rspec'
+gem 'rack'
+gem 'thin'
+gem 'uuid'
+
+gem 'net-ssh'
+gem 'net-scp'
+gem 'highline'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Software Projects
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# SP Docgen for Ruby
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'spdocgen'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spdocgen
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require 'net/ssh'
+require 'net/ssh/authentication/methods/password'
+require 'net/scp'
+require 'highline/import'
+
+task :push => :build do
+  def upload(ssh)
+    filename = "spdocgen-#{SPDocgen::VERSION}.gem"
+    print "Uploading #{filename}..."
+    u = ssh.scp.upload("pkg/#{filename}", "/var/www/rubygems/gems/#{filename}") do
+      print '.'
+    end
+    u.wait
+    puts
+    ssh.exec! '/usr/local/rvm/bin/gem generate_index --directory=/var/www/rubygems'
+  end
+
+  opts = Net::SSH.configuration_for('sp43.sp.local')
+  begin
+    Net::SSH.start('sp43.sp.local', 'rubygems', :auth_methods => %w[publickey]) {|o| upload(o)}
+  rescue
+    password = ask("rubygems@sp43.sp.local's password: ") { |q| q.echo = false }
+    Net::SSH.start('sp43.sp.local', 'rubygems', :password => password) {|o| upload(o)}
+  end
+end

data/lib/spdocgen.rb

@@ -0,0 +1,15 @@
+require "spdocgen/version"
+
+module SPDocgen
+  autoload :Configuration, 'spdocgen/configuration'
+  autoload :Document, 'spdocgen/document'
+  autoload :DocumentSet, 'spdocgen/document_set'
+  autoload :Protocol, 'spdocgen/protocol'
+
+  autoload :DownloadRequest, 'spdocgen/download_request'
+  autoload :DownloadResponse, 'spdocgen/download_response'
+  autoload :RenderRequest, 'spdocgen/render_request'
+  autoload :RenderResponse, 'spdocgen/render_response'
+  autoload :StatusRequest, 'spdocgen/status_request'
+  autoload :StatusResponse, 'spdocgen/status_response'
+end

data/lib/spdocgen/configuration.rb

@@ -0,0 +1,31 @@
+module SPDocgen
+  class Configuration
+    class <<self
+      attr_accessor :configuration_file
+
+      def current
+        env = nil
+        env = Rails.env if defined? Rails
+        env ||= ENV['RAILS_ENV']
+        env ||= ENV['RACK_ENV']
+        raise 'Unable to determine environment' if env.nil?
+
+        c = read
+        raise "Environment not defined in SPDocgen configuration: #{env}" if c[env].nil?
+        (c['global'] || {}).merge(c[env])
+      end
+
+      private
+
+      def read
+        if defined? Rails
+          self.configuration_file ||= File.join(Rails.root, 'config', 'spdocgen.yml')
+        elsif self.configuration_file.nil?
+          raise 'Unable to determine a default location for SPDocgen configuration'
+        end
+
+        @configuration ||= YAML.load_file(self.configuration_file)
+      end
+    end
+  end
+end

data/lib/spdocgen/document.rb

@@ -0,0 +1,13 @@
+module SPDocgen
+  class Document
+    attr_reader :xmlns, :data_sources
+    def initialize
+      @xmlns = {}
+      @data_sources = []
+    end
+
+    def build(xml)
+      raise "#{self.class.name} does not define a 'build' method"
+    end
+  end
+end

data/lib/spdocgen/document_set.rb

@@ -0,0 +1,23 @@
+module SPDocgen
+  class DocumentSet
+    attr_reader :xmlns, :data_sources
+    attr_accessor :documents
+
+    def initialize
+      @xmlns = {}
+      @data_sources = []
+    end
+
+    def all_data_sources
+      mapped = (data_sources + documents.collect(&:data_sources).flatten).inject({}) do |map, ds|
+        map[ds.id] = ds
+        map
+      end
+      mapped.values.sort_by(&:id)
+    end
+
+    def all_xmlns
+      documents.inject(@xmlns){|map, doc| map.merge(doc.xmlns)}
+    end
+  end
+end

data/lib/spdocgen/download_request.rb

@@ -0,0 +1,15 @@
+require 'uri'
+
+module SPDocgen
+  class DownloadRequest
+    attr_accessor :uri
+
+    def initialize(uri)
+      self.uri = uri
+    end
+
+    def download
+      SPDocgen::Protocol.instance.download(URI.parse(self.uri))
+    end
+  end
+end

data/lib/spdocgen/download_response.rb

@@ -0,0 +1,12 @@
+module SPDocgen
+  class DownloadResponse
+    attr_accessor :body, :content_type, :content_encoding, :content_disposition
+
+    def initialize(body, content_type, content_encoding, content_disposition)
+      self.body = body
+      self.content_type = content_type
+      self.content_encoding = content_encoding
+      self.content_disposition = content_disposition
+    end
+  end
+end

data/lib/spdocgen/protocol.rb

@@ -0,0 +1,80 @@
+require 'net/http'
+require 'net/https'
+
+module SPDocgen
+  class Protocol
+    def self.instance
+      @instance ||= self.new Configuration.current
+    end
+
+    def initialize(config)
+      @base_url = config['base_url']
+      @render_path = config['render_path']
+      @username = config['username']
+      @password = config['password']
+
+      url = URI.parse @base_url
+      @http = Net::HTTP.new url.host, url.port
+      @http.use_ssl = (url.scheme =~ /https/i)
+
+      @downloaders = {}
+    end
+
+    def download(parsed_uri)
+      with_downloader_for(parsed_uri) do |http|
+        req = Net::HTTP::Get.new parsed_uri.request_uri
+        req['Accept'] = '*/*'
+        req.basic_auth @username, @password
+
+        response = http.request(req)
+
+        raise "Unable to download: #{parsed_uri.to_s} .. Response was #{response.code} #{response.message} : #{response.body ? response.body : ''} - request is #{req.to_s}" unless response.is_a? Net::HTTPOK
+
+        SPDocgen::DownloadResponse.new response.body, response.content_type, response['content-encoding'], response['content-disposition']
+      end
+    end
+
+    def submit(xml)
+      request = Net::HTTP::Post.new render_url
+      request.body = xml
+      request['Content-Type'] = 'application/xml'
+
+      SPDocgen::RenderResponse.new do_request(request).body
+    end
+
+    def poll(uri)
+      request = Net::HTTP::Get.new uri
+      SPDocgen::StatusResponse.new do_request(request).body
+    end
+
+    private
+
+    def http
+      @http.start unless @http.started?
+      @http
+    end
+
+    def render_url
+      URI.join(@base_url, @render_path).to_s
+    end
+
+    def with_downloader_for(u, &block)
+      host = u.class.new(u.scheme, nil, u.host, u.port, nil, '', nil, nil, nil, false).to_s
+
+      downloader = Net::HTTP.new(u.host, u.port)
+      downloader.use_ssl = (u.scheme =~ /https/i)
+
+      downloader.start(&block)
+    end
+
+    def do_request(request)
+      request['Accept'] = 'application/xml'
+      request.basic_auth @username, @password
+
+      response = http.request request
+      raise 'Response did not contain XML' unless response.code == '200' and response['content-type'] =~ /xml/i
+
+      response
+    end
+  end
+end

data/lib/spdocgen/render_request.rb

@@ -0,0 +1,76 @@
+require 'nokogiri'
+
+module SPDocgen
+  class RenderRequest
+    attr_accessor :metadata, :xml
+
+    def initialize(document_set)
+      raise "Document set should inherit from #{DocumentSet.name}" unless document_set.is_a? DocumentSet
+      raise "Documents should inherit from #{Document.name}" unless document_set.documents.all?{|doc| doc.is_a? Document}
+
+      @document_set = document_set
+      @xmlns = {
+        'xmlns:dgr' => 'http://www.sp.com.au/docgen/schemas/wsh',
+        'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
+      }.merge(document_set.all_xmlns)
+
+      raise 'XML namespace definitions should start with xmlns:' unless @xmlns.keys.all?{|k| k.start_with? 'xmlns:'}
+
+      @metadata = {}
+      if document_set.respond_to? :metadata
+        @metadata = document_set.metadata
+      end
+    end
+
+    def build
+      raise 'Already built' if @xml
+      raise 'No data sources' if @document_set.nil? or @document_set.documents.nil? or @document_set.documents.empty?
+
+      builder = Nokogiri::XML::Builder.new :encoding => 'utf-8' do |xml|
+        # Clients that treat this as a real builder sometimes need to call 'tag!'
+        # That's ok.
+        def xml.tag!(*args, &bl)
+          # Handle reserved names correctly
+          name = args.shift + '_'
+          send name, *args, &bl
+        end
+
+        xml.DocGenRequest @xmlns do
+          # See http://stackoverflow.com/questions/1829425/creating-an-xml-document-with-a-namespaced-root-element-with-nokogiri-builder
+          xml.parent.namespace = xml.parent.namespace_definitions.find{|ns| ns.prefix == 'dgr'}
+          dgr = xml['dgr']
+          dgr.MetaData do
+            self.metadata.each do |k,v|
+              dgr.MetaDataEntry do
+                dgr.Key k
+                dgr.Value v
+              end
+            end
+          end
+
+          dgr.SharedXmlDataSources do
+            @document_set.all_data_sources.each do |data_source|
+              dgr.SharedXmlDataSource 'sharedXmlDataSourceId' => data_source.id do
+                data_source.build(xml)
+              end
+            end
+          end
+
+          dgr.DocumentRequests do
+            @document_set.documents.each do |document|
+              document.build(xml)
+            end
+          end
+        end
+      end
+
+      @xml = builder.to_xml
+    end
+
+    def submit
+      raise 'Request needs to be built first' unless @xml
+
+      SPDocgen::Protocol.instance.submit @xml
+    end
+  end
+end

data/lib/spdocgen/render_response.rb

@@ -0,0 +1,17 @@
+require 'nokogiri'
+
+module SPDocgen
+  class RenderResponse
+    attr_reader :uuid, :uri
+
+    def initialize(xml)
+      document = Nokogiri::XML.parse(xml, nil, 'UTF-8')
+      raise 'Not a render response' unless document.root.name == 'RenderResponse'
+
+      @uuid = document.xpath('/RenderResponse/Uuid').text
+      @uri = document.xpath('/RenderResponse/StatusUri').text
+
+      raise "Invalid render response #{xml}" unless !@uuid.blank? && !@uri.blank?
+    end
+  end
+end

data/lib/spdocgen/status_request.rb

@@ -0,0 +1,11 @@
+module SPDocgen
+  class StatusRequest
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def poll
+      SPDocgen::Protocol.instance.poll @uri
+    end
+  end
+end

data/lib/spdocgen/status_response.rb

@@ -0,0 +1,74 @@
+require 'nokogiri'
+
+module SPDocgen
+  class StatusResponse
+    #<StatusResponse>
+    #<DocGenRequestStatuses>
+    #<DocGenRequestStatus>
+    #<Uuid>9f576898-8d74-432e-80b8-dacbaf8d7bf6</Uuid>
+    #<State>Failed</State>
+    #<DocumentRequests>
+    #<DocumentRequest ServerId='5614' ClientId='b3b98dc0-449c-012f-238b-0026b92085d1' State='Timeout'>
+    #<Documents></Documents>
+    #</DocumentRequest>
+    #</DocumentRequests>
+    #</DocGenRequestStatus>
+    #</DocGenRequestStatuses>
+    #</StatusResponse>
+    def initialize(xml)
+      document = Nokogiri::XML.parse(xml, nil, 'UTF-8')
+      raise 'Not a render response' unless document.root.name == 'StatusResponse'
+
+      document.xpath('/StatusResponse/DocGenRequestStatuses/DocGenRequestStatus').each do |node|
+        uuid = node.xpath('Uuid').text
+        state = node.xpath('State').text
+        requests = node.xpath('DocumentRequests/DocumentRequest').collect do |req|
+          documents = req.xpath('Documents/Document').collect do |doc|
+            name = doc.xpath('Name')
+            uri = doc.xpath('Uri')
+            metadata = doc.xpath('MetaDataEntries/MetaDataEntry').inject({}) do |map,md|
+              map[md.xpath('Key').text] = md.xpath('Value').text
+              map
+            end
+
+            {
+              :reference => doc['Reference'],
+              :num_pages => doc['NumPages'].to_i,
+              :name => name.text,
+              :uri => uri.text,
+              :metadata => metadata
+            }
+          end
+
+          {
+            :server_id => req['ServerId'],
+            :request_guid => req['ClientId'],
+            :state => req['State'],
+            :documents => documents
+          }
+        end
+
+        record_status uuid, state, requests
+      end
+    end
+
+    def uuids
+      @uuids ||= []
+    end
+
+    def status(uuid)
+      @status ||= {}
+      @status[uuid] ||= {}
+    end
+
+    private
+    def record_status(uuid, state, requests)
+      self.uuids << uuid
+      self.status(uuid).merge!(
+        :uuid => uuid,
+        :state => state,
+        :requests => requests
+      )
+    end
+  end
+end

data/lib/spdocgen/version.rb

@@ -0,0 +1,4 @@
+module SPDocgen
+  # Please use Semantic Versioning - http://semver.org/
+  VERSION = "1.1.2"
+end

data/spdocgen.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spdocgen/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "spdocgen"
+  gem.version       = SPDocgen::VERSION
+  gem.authors       = ["Shaun Mangelsdorf"]
+  gem.email         = ["smangelsdorf@sp.com.au"]
+  gem.description   = %q{Ruby client library for rendering and downloading documents from SP Docgen}
+  gem.summary       = %q{SP Docgen client library}
+  gem.homepage      = "http://sp.docgen.net.au"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'nokogiri'
+end

data/spec/config.yml

@@ -0,0 +1,4 @@
+test:
+  username: test
+  password: test
+  render_path: /render

data/spec/download_request_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe SPDocgen::DownloadRequest do
+  subject do
+    SPDocgen::DownloadRequest.new server.url('/download/file.txt')
+  end
+
+  it 'downloads the file' do
+    server.response = [200, {'content-type' => 'text/plain'}, "test file"]
+
+    response = subject.download
+    response.should be_a SPDocgen::DownloadResponse
+    response.body.should == "test file"
+    response.content_type.should == 'text/plain'
+    response.content_encoding.should be_nil
+  end
+
+  it 'includes the content encoding' do
+    server.response = [200, {'content-type' => 'text/plain', 'content-encoding' => 'gzip'}, "test file"]
+
+    response = subject.download
+    response.should be_a SPDocgen::DownloadResponse
+    response.body.should == "test file"
+    response.content_type.should == 'text/plain'
+    response.content_encoding.should == 'gzip'
+  end
+
+  it 'includes the content disposition' do
+    server.response = [200, {'content-type' => 'text/plain', 'content-disposition' => 'attachment; filename=test.txt'}, 'test file']
+    response = subject.download
+    response.should be_a SPDocgen::DownloadResponse
+    response.content_disposition.should == 'attachment; filename=test.txt'
+  end
+end

data/spec/render_request_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+require 'uuid'
+
+describe SPDocgen::RenderRequest do
+  class TestDocumentSet < SPDocgen::DocumentSet
+  end
+
+  class BadTestDocument < SPDocgen::Document
+  end
+  class TestDocument < SPDocgen::Document
+    def build(xml)
+      xml.DocumentRequest 'test-xml'
+    end
+  end
+  class NamespaceDocument < SPDocgen::Document
+    def initialize
+      super
+      xmlns['xmlns:test'] = 'http://example.org/test'
+    end
+
+    def build(xml)
+      xml.DocumentRequest do
+        xml['test'].TestXml
+      end
+    end
+  end
+
+  before :each do
+    @uuid = UUID.generate
+  end
+
+  subject do
+  end
+
+  it 'should reject document sets of the wrong type' do
+    lambda {
+      set = Object.new
+      SPDocgen::RenderRequest.new set
+    }.should raise_error(RuntimeError, /should inherit from/)
+  end
+
+  it 'should reject documents of the wrong type' do
+    lambda {
+      set = TestDocumentSet.new
+      set.documents = [Object.new]
+      SPDocgen::RenderRequest.new set
+    }.should raise_error(RuntimeError, /should inherit from/)
+  end
+
+  it 'should not build a bad implementation' do
+    set = TestDocumentSet.new
+    set.documents = [BadTestDocument.new]
+    req = SPDocgen::RenderRequest.new set
+    lambda {
+      req.build
+    }.should raise_error(RuntimeError, /does not define/)
+  end
+
+  it 'should build' do
+    set = TestDocumentSet.new
+    set.documents = [TestDocument.new]
+    req = SPDocgen::RenderRequest.new set
+    req.build
+    req.xml.should match /test-xml/
+  end
+
+  it 'should build with namespaces' do
+    set = TestDocumentSet.new
+    set.documents = [NamespaceDocument.new]
+    req = SPDocgen::RenderRequest.new set
+    req.build
+    req.xml.should match /<test:TestXml\/>/
+  end
+
+  it 'should submit' do
+    server.response = [200, {'content-type' => 'application/xml'}, %{
+      <RenderResponse>
+        <Uuid>#{@uuid}</Uuid>
+        <StatusUri>#{server.url("/status/#{@uuid}")}</StatusUri>
+      </RenderResponse>
+    }]
+
+    set = TestDocumentSet.new
+    set.documents = [TestDocument.new]
+    req = SPDocgen::RenderRequest.new set
+    req.build
+
+    response = req.submit
+    response.should be_a SPDocgen::RenderResponse
+    response.uuid.should == @uuid
+    response.uri.should end_with @uuid
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'spdocgen'
+require 'test_server'
+
+require 'tempfile'
+require 'yaml'
+
+RSpec.configure do |config|
+  config.add_setting :server
+  config.add_setting :spdocgen_configuration
+
+  config.server = SPDocgen::TestServer.new
+  config.server.start
+
+  config.include SPDocgen::TestServerHelper
+
+  config.before :suite do
+    ENV['RACK_ENV'] = 'test'
+
+    yml = Tempfile.new(['spdocgen-config', '.yml'])
+    template = YAML.load_file File.join(File.dirname(__FILE__), 'config.yml')
+    template['test'].merge!('base_url' => config.server.base_url)
+    yml.write YAML.dump(template)
+    yml.close
+
+    config.spdocgen_configuration = yml
+    SPDocgen::Configuration.configuration_file = yml.path
+  end
+
+  config.after :suite do
+    config.spdocgen_configuration.unlink
+  end
+end

data/spec/status_request_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+require 'uuid'
+
+describe SPDocgen::StatusRequest do
+  subject do
+    SPDocgen::StatusRequest.new server.url('/download/file.txt')
+  end
+
+  before :each do
+    @request = UUID.generate
+    @uuid = UUID.generate
+  end
+
+  def status_response(state, request_state, documents)
+    doc_xml = documents.collect do |doc|
+      %{<Document Reference='#{doc[:reference]}' NumPages='#{doc[:num_pages] || 1}'>
+        <Name>#{doc[:name]}</Name>
+        <Uri>#{doc[:uri]}</Uri>
+        <MetaDataEntries>
+        <MetaDataEntry>
+        <Key>test</Key>
+        <Value>this is a test</Value>
+        </MetaDataEntry>
+        </MetaDataEntries>
+        </Document>}
+    end.join('')
+
+    %{<StatusResponse>
+      <DocGenRequestStatuses>
+      <DocGenRequestStatus>
+      <Uuid>#{@uuid}</Uuid>
+      <State>#{state}</State>
+      <DocumentRequests>
+      <DocumentRequest ServerId='1' ClientId='#{@request}' State='#{request_state}'>
+        <Documents>#{doc_xml}</Documents>
+      </DocumentRequest>
+      </DocumentRequests>
+      </DocGenRequestStatus>
+      </DocGenRequestStatuses>
+      </StatusResponse>
+    }
+  end
+
+  it 'polls for status' do
+    response_body = status_response('Failed', 'Timeout', [])
+    server.response = [200, {'content-type' => 'application/xml'}, response_body]
+    response = subject.poll
+
+    response.should be_a SPDocgen::StatusResponse
+  end
+
+  it 'determines a request has failed' do
+    response_body = status_response('Failed', 'Timeout', [])
+    server.response = [200, {'content-type' => 'application/xml'}, response_body]
+    response = subject.poll
+
+    response.status(@uuid)[:state].should == 'Failed'
+    req_status = response.status(@uuid)[:requests].first
+    req_status[:request_guid].should == @request
+    req_status[:state].should == 'Timeout'
+    req_status[:documents].should be_empty
+  end
+
+  it 'determines a request has succeeded' do
+    doc_uuid = UUID.generate
+
+    documents = []
+    documents << {:reference => doc_uuid, :num_pages => 5, :name => 'Test.file', :uri => server.url('/test.file')}
+
+    response_body = status_response('Completed', 'Completed', documents)
+    server.response = [200, {'content-type' => 'application/xml'}, response_body]
+    response = subject.poll
+
+    response.status(@uuid)[:state].should == 'Completed'
+    req_status = response.status(@uuid)[:requests].first
+    req_status[:request_guid].should == @request
+    req_status[:state].should == 'Completed'
+    req_status[:documents].should_not be_empty
+
+    doc_status = req_status[:documents].first
+    doc_status[:name].should == 'Test.file'
+    doc_status[:uri].should end_with '/test.file'
+    doc_status[:reference].should == doc_uuid
+    doc_status[:num_pages].should == 5
+    doc_status[:metadata].should_not be_empty
+    doc_status[:metadata]['test'].should == 'this is a test'
+  end
+end

data/spec/test_server.rb

@@ -0,0 +1,52 @@
+require 'net/http'
+require 'rack'
+require 'rack/handler/thin'
+
+module SPDocgen
+  class TestServer
+    attr_accessor :env, :response
+
+    def initialize
+      @host = '127.0.0.1'
+      @port = find_available_port
+    end
+
+    def base_url
+      "http://#{@host}:#{@port}"
+    end
+
+    def url(path)
+      URI.join(base_url, path).to_s
+    end
+
+    def call(env)
+      self.env = env
+      response.tap{self.response = nil}
+    end
+
+    def start
+      @thread = Thread.new do
+        Rack::Handler::Thin.run self, :Host => @host, :Port => @port do |server|
+          @server = server
+        end
+      end
+      sleep(0.1) until @server and @server.running?
+    end
+
+    private
+
+    # Stolen from Capybara
+    def find_available_port
+      server = TCPServer.new(@host, 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+  end
+
+  module TestServerHelper
+    def server
+      RSpec.configuration.server
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: spdocgen
+version: !ruby/object:Gem::Version 
+  version: 1.1.2
+platform: ruby
+authors: 
+- Shaun Mangelsdorf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-11-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id002 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Ruby client library for rendering and downloading documents from SP Docgen
+email: 
+- smangelsdorf@sp.com.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/spdocgen.rb
+- lib/spdocgen/configuration.rb
+- lib/spdocgen/document.rb
+- lib/spdocgen/document_set.rb
+- lib/spdocgen/download_request.rb
+- lib/spdocgen/download_response.rb
+- lib/spdocgen/protocol.rb
+- lib/spdocgen/render_request.rb
+- lib/spdocgen/render_response.rb
+- lib/spdocgen/status_request.rb
+- lib/spdocgen/status_response.rb
+- lib/spdocgen/version.rb
+- spdocgen.gemspec
+- spec/config.yml
+- spec/download_request_spec.rb
+- spec/render_request_spec.rb
+- spec/spec_helper.rb
+- spec/status_request_spec.rb
+- spec/test_server.rb
+homepage: http://sp.docgen.net.au
+licenses: []
+
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.11
+signing_key: 
+specification_version: 4
+summary: SP Docgen client library
+test_files: 
+- spec/config.yml
+- spec/download_request_spec.rb
+- spec/render_request_spec.rb
+- spec/spec_helper.rb
+- spec/status_request_spec.rb
+- spec/test_server.rb