pandexio 0.0.7 → 0.0.8

data/lib/http_client.rb

@@ -0,0 +1,308 @@
+require 'net/http'
+require 'json'
+require 'stringio'
+require 'open-uri'
+require_relative 'request.rb'
+require_relative 'scope_patterns.rb'
+require_relative 'signer.rb'
+require_relative 'signing_mechanisms.rb'
+
+module Pandexio
+
+    HOSTED_HOST = "hosted.pandexio.com"
+    PLATFORM_HOST = "platform.pandexio.com"
+
+    class DocumentSource
+
+        def initialize(params = {})
+            @id = params.fetch(:id, nil)
+            @name = params.fetch(:name, nil)
+            @content = params.fetch(:content, nil)
+            @location = params.fetch(:location, nil)
+        end
+
+        attr_accessor :id
+        attr_accessor :name
+        attr_accessor :content
+        attr_accessor :location
+
+    end
+
+    class Document
+
+        def initialize(params = {})
+            @document_id = params.fetch(:document_id, nil)
+            @name = params.fetch(:name, nil)
+            @page_count = params.fetch(:page_count, nil)
+            @content_type = params.fetch(:content_type, nil)
+            @content_length = params.fetch(:content_length, nil)
+            @cover = params.fetch(:cover, nil)
+        end
+
+        attr_accessor :document_id
+        attr_accessor :name
+        attr_accessor :page_count
+        attr_accessor :content_type
+        attr_accessor :content_length
+        attr_accessor :cover
+
+    end
+
+    class HttpClient
+
+        private
+
+        def build_headers(headers, content_type)
+
+            items = {'Content-Type' => content_type}
+
+            headers.each do |key, value|
+                items[key] = value.to_s
+            end
+
+            return items
+        end
+
+        def build_query_string(query_parameters)
+
+            query_string_builder = StringIO.new
+
+            query_parameters.each do |key, value|
+                query_string_builder << "&" if query_string_builder.length > 0
+                encodedKey = URI::encode(key.to_s)
+                encodedValue = URI::encode(value.to_s)
+                query_string_builder << "#{encodedKey}=#{encodedValue}"
+            end
+
+            return query_string_builder.string
+        end
+
+        public
+
+        def load_document(source_document, signing_options)
+
+            raise ArgumentError, "Document source is nil." if source_document.nil?
+            raise ArgumentError, "Signing options is nil." if signing_options.nil?
+
+            id = source_document.id.to_s
+            name = source_document.name.to_s
+            content = source_document.content.to_s
+            location = source_document.location.to_s
+
+            raise ArgumentError, "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}." if !source_document.id.is_a?(String) || id.nil? || id.empty? || !id.strip!.nil? || id.match(Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN).nil?
+            raise ArgumentError, "Document name is not a string or is nil or empty." if !source_document.name.is_a?(String) || name.nil? || name.empty? || !name.strip!.nil?
+            raise ArgumentError, "Document content is not a string or is nil or empty." if !source_document.content.is_a?(String) || content.nil? || content.empty? || !content.strip!.nil?
+            raise ArgumentError, "Document location must be AWS, Azure, Internet, or Inline." unless location == "AWS" || location == "Azure" || location == "Internet" || location == "Inline"
+
+            path = "/api/documents/#{id}"
+            payload = {
+                "name" => name,
+                "content" => content,
+                "location" => location
+            }.to_json
+
+            normalized_request = Pandexio::Request.new(
+                :method => "PUT",
+                :path => path,
+                :query_parameters => { },
+                :headers => { "Host" => HOSTED_HOST },
+                :payload => payload)
+
+            signer = Pandexio::Signer.new()
+
+            authorized_request = signer.sign(normalized_request, signing_options)
+
+            headers = build_headers(authorized_request.headers, 'application/json; charset=utf-8')
+            query_string = build_query_string(authorized_request.query_parameters)
+
+            http = Net::HTTP.new(HOSTED_HOST, 443)
+            http.use_ssl = true
+            http.open_timeout = 60
+            http.read_timeout = 600
+
+            req = Net::HTTP::Put.new("#{path}?#{query_string}", initheader = headers)
+            req.body = payload
+            res = http.start {|http| http.request(req)}
+
+            case res.code
+                when "202"
+                    data = JSON.parse(res.body)
+                    document = Pandexio::Document.new(
+                        :document_id => data['documentId'],
+                        :name => data['name'],
+                        :page_count => data['pageCount'],
+                        :content_type => data['contentType'],
+                        :content_length => data['contentLength'],
+                        :cover => data['cover'])
+                else
+                    raise StandardError, "Failed to load document."
+            end
+
+        end
+
+        def get_document(document_id, cover_size, signing_options)
+
+            raise ArgumentError, "Signing options is nil." if signing_options.nil?
+
+            id = document_id.to_s
+
+            raise ArgumentError, "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}." if !document_id.is_a?(String) || id.nil? || id.empty? || !id.strip!.nil? || id.match(Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN).nil?
+            raise ArgumentError, "Document cover size must be xs, s, m, l, or xl." unless cover_size == 'xs' || cover_size == 's' || cover_size == 'm' || cover_size == 'l' || cover_size == 'xl'
+
+            path = "/v2/documents/#{id}"
+
+            normalized_request = Pandexio::Request.new(
+                :method => "GET",
+                :path => path,
+                :query_parameters => { "coverSize" => cover_size },
+                :headers => { "Host" => PLATFORM_HOST },
+                :payload => '')
+
+            signer = Pandexio::Signer.new()
+
+            authorized_request = signer.sign(normalized_request, signing_options)
+
+            headers = build_headers(authorized_request.headers, 'application/json; charset=utf-8')
+            query_string = build_query_string(authorized_request.query_parameters)
+
+            http = Net::HTTP.new(PLATFORM_HOST, 443)
+            http.use_ssl = true
+            http.open_timeout = 60
+            http.read_timeout = 120
+
+            req = Net::HTTP::Get.new("#{path}?#{query_string}", initheader = headers)
+            res = http.start {|http| http.request(req)}
+
+            case res.code
+                when "200"
+                    data = JSON.parse(res.body)
+                    document = Pandexio::Document.new(
+                        :document_id => data['documentId'],
+                        :name => data['name'],
+                        :page_count => data['pageCount'],
+                        :content_type => data['contentType'],
+                        :content_length => data['contentLength'],
+                        :cover => data['cover'])
+                when "404"
+                    return nil
+                else
+                    raise StandardError, "Failed to get document."
+            end
+
+        end
+
+        def get_document_cover(document_id, cover_size, signing_options)
+
+            raise ArgumentError, "Signing options is nil." if signing_options.nil?
+
+            id = document_id.to_s
+
+            raise ArgumentError, "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}." if !document_id.is_a?(String) || id.nil? || id.empty? || !id.strip!.nil? || id.match(Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN).nil?
+            raise ArgumentError, "Document cover size must be xs, s, m, l, or xl." unless cover_size == 'xs' || cover_size == 's' || cover_size == 'm' || cover_size == 'l' || cover_size == 'xl'
+
+            path = "/v2/documents/#{id}/cover"
+
+            normalized_request = Pandexio::Request.new(
+                :method => "GET",
+                :path => path,
+                :query_parameters => { "coverSize" => cover_size },
+                :headers => { "Host" => PLATFORM_HOST },
+                :payload => '')
+
+            signer = Pandexio::Signer.new()
+
+            authorized_request = signer.sign(normalized_request, signing_options)
+
+            headers = build_headers(authorized_request.headers, 'image/png')
+            query_string = build_query_string(authorized_request.query_parameters)
+
+            http = Net::HTTP.new(PLATFORM_HOST, 443)
+            http.use_ssl = true
+            http.open_timeout = 60
+            http.read_timeout = 120
+
+            req = Net::HTTP::Get.new("#{path}?#{query_string}", initheader = headers)
+            res = http.start {|http| http.request(req)}
+
+            case res.code
+                when "200"
+                    return res.body
+                when "404"
+                    return nil
+                else
+                    raise StandardError, "Failed to get document cover."
+            end
+
+        end
+
+        def get_document_cover_url(document_id, cover_size, signing_options)
+
+            id = document_id.to_s
+
+            raise ArgumentError, "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}." if !document_id.is_a?(String) || id.nil? || id.empty? || !id.strip!.nil? || id.match(Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN).nil?
+            raise ArgumentError, "Document cover size must be xs, s, m, l, or xl." unless cover_size == 'xs' || cover_size == 's' || cover_size == 'm' || cover_size == 'l' || cover_size == 'xl'
+
+            raise ArgumentError, "Signing options is nil." if signing_options.nil?
+            raise ArgumentError, "Signing mechanism must be QueryString." unless signing_options.mechanism == Pandexio::SigningMechanisms::QUERY_STRING
+
+            path = "/v2/documents/#{id}/cover"
+
+            normalized_request = Pandexio::Request.new(
+                :method => "GET",
+                :path => path,
+                :query_parameters => { "coverSize" => cover_size },
+                :headers => { "Host" => PLATFORM_HOST },
+                :payload => '')
+
+            signer = Pandexio::Signer.new()
+
+            authorized_request = signer.sign(normalized_request, signing_options)
+
+            query_string = build_query_string(authorized_request.query_parameters)
+
+            return "https://#{PLATFORM_HOST}#{path}?#{query_string}"
+
+        end
+
+        def get_document_snip_count(document_id, signing_options)
+
+            raise ArgumentError, "Signing options is nil." if signing_options.nil?
+
+            id = document_id.to_s
+
+            raise ArgumentError, "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}." if !document_id.is_a?(String) || id.nil? || id.empty? || !id.strip!.nil? || id.match(Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN).nil?
+
+            path = "/v2/documents/#{id}/snips/count"
+
+            normalized_request = Pandexio::Request.new(
+                :method => "GET",
+                :path => path,
+                :query_parameters => {},
+                :headers => { "Host" => PLATFORM_HOST },
+                :payload => '')
+
+            signer = Pandexio::Signer.new()
+
+            authorized_request = signer.sign(normalized_request, signing_options)
+
+            headers = build_headers(authorized_request.headers, 'application/json; charset=utf-8')
+            query_string = build_query_string(authorized_request.query_parameters)
+
+            http = Net::HTTP.new(PLATFORM_HOST, 443)
+            http.use_ssl = true
+
+            req = Net::HTTP::Get.new("#{path}?#{query_string}", initheader = headers)
+            res = http.start {|http| http.request(req)}
+
+            case res.code
+                when "200"
+                    return res.body.to_i
+                else
+                    raise StandardError, "Failed to get document snip count."
+            end
+
+        end
+
+    end
+
+end

data/lib/request.rb

@@ -2,6 +2,9 @@ module Pandexio
 
     class Request
 
+        LINE_BREAK = "\r\n"
+        private_constant :LINE_BREAK
+
         def initialize(params = {})
             @method = params.fetch(:method, nil)
             @path = params.fetch(:path, nil)

data/lib/scope_patterns.rb

@@ -1,6 +1,7 @@
 module Pandexio
 
     class ScopePatterns
+        DOCUMENT_ID_PATTERN = /^[a-zA-Z0-9\-_]+$/i
         DOCUMENT_PATH_PATTERN = /(\/.*?documents\/)(?<documentid>[a-zA-Z0-9\-_]+)/i
     end
 

data/test/test_header_signing.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'minitest/autorun'
-require_relative '../lib/pandexio.rb'
+require 'pandexio'
 
 describe Pandexio do
     describe "#to_authorized_request" do

data/test/test_http_client.rb

@@ -0,0 +1,1238 @@
+# encoding: utf-8
+
+require 'time'
+require 'uuid'
+require 'minitest/autorun'
+#require 'pandexio'
+require_relative 'test_config.rb'
+require_relative '../lib/http_client.rb'
+require_relative '../lib/scope_patterns.rb'
+require_relative '../lib/signing_options.rb'
+require_relative '../lib/signing_algorithms.rb'
+require_relative '../lib/signing_mechanisms.rb'
+
+describe Pandexio::HttpClient do
+
+    describe "#load_document" do
+
+        describe "when id is nil" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => nil, :name => "test_name", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is empty" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "", :name => "test_name", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is blank" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => " ", :name => "test_name", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is not a string" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => 123, :name => "test_name", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id does not match RegEx" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "123^%$*abc", :name => "test_name", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when name is nil" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => nil, :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document name is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when name is empty" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document name is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when name is blank" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => " ", :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document name is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when name is not a string" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => 123, :content => "test_content", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document name is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when content is nil" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "test_name", :content => nil, :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document content is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when content is empty" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "test_name", :content => "", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document content is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when content is blank" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "test_name", :content => " ", :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document content is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when content is not a string" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "test_name", :content => 123, :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document content is not a string or is nil or empty."
+            end
+
+        end
+
+        describe "when location is not AWS" do
+
+            before do
+                document_source = Pandexio::DocumentSource.new(:id => "test_id", :name => "test_name", :content => "test_content", :location => "AUUS")
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @load_document.must_raise ArgumentError
+                err.message.must_match "Document location must be AWS, Azure, Internet, or Inline."
+            end
+
+        end
+
+        describe "when content is data URL" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should return document details" do
+                doc = @load_document.call
+                doc.document_id.must_equal @id
+                doc.name.must_equal "test_name_#{@id}.txt"
+                doc.page_count.must_equal 1
+                doc.content_type.must_equal "text/plain"
+                doc.content_length.must_equal 11
+                doc.cover[0..29].must_equal 'data:image/png;base64,iVBORw0K'
+                doc.cover.length.must_equal 24846
+            end
+
+        end
+
+        describe "when content is HTTP URL" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.pdf",
+                    :content => "http://martinfowler.com/ieeeSoftware/whenType.pdf",
+                    :location => "Internet")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @load_document = ->{ http_client.load_document(document_source, signing_options) }
+            end
+
+            it "should return document details" do
+                doc = @load_document.call
+                doc.document_id.must_equal @id
+                doc.name.must_equal "test_name_#{@id}.pdf"
+                doc.page_count.must_equal 2
+                doc.content_type.must_equal "application/pdf"
+                doc.content_length.must_equal 289041
+                doc.cover[0..29].must_equal 'data:image/png;base64,iVBORw0K'
+                doc.cover.length.must_equal 436650
+            end
+
+        end
+
+    end
+
+    describe "#get_document" do
+
+        describe "when id is nil" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document(nil, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is empty" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document("", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is blank" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document(" ", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is not a string" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document(123, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id does not match RegEx" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document("123^%$*abc", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when cover_size is invalid" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document('test_id', 'abc', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document.must_raise ArgumentError
+                err.message.must_match "Document cover size must be xs, s, m, l, or xl."
+            end
+
+        end
+
+        describe "when document does not exist" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                id = UUID.new.generate
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @get_document = ->{ http_client.get_document(id, 'm', signing_options) }
+            end
+
+            it "should return nil" do
+                doc = @get_document.call
+                doc.must_be_nil
+            end
+
+        end
+
+        describe "when document exists" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document = ->{ http_client.get_document(@id, 'm', signing_options) }
+            end
+
+            it "should return document details" do
+                doc = @get_document.call
+                doc.document_id.must_equal @id
+                doc.name.must_equal "test_name_#{@id}.txt"
+                doc.page_count.must_equal 1
+                doc.content_type.must_equal "text/plain"
+                doc.content_length.must_equal 11
+                doc.cover[0..29].must_equal 'data:image/png;base64,iVBORw0K'
+                doc.cover.length.must_equal 2542
+            end
+
+        end
+
+        describe "when cover size is xs" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document = ->{ http_client.get_document(@id, 'xs', signing_options) }
+            end
+
+            it "should return document details" do
+                doc = @get_document.call
+                doc.document_id.must_equal @id
+                doc.name.must_equal "test_name_#{@id}.txt"
+                doc.page_count.must_equal 1
+                doc.content_type.must_equal "text/plain"
+                doc.content_length.must_equal 11
+                doc.cover[0..29].must_equal 'data:image/png;base64,iVBORw0K'
+                doc.cover.length.must_equal 370
+            end
+
+        end
+
+    end
+
+    describe "#get_document_cover" do
+
+        describe "when id is nil" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover(nil, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is empty" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover("", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is blank" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover(" ", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is not a string" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover(123, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id does not match RegEx" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover("123^%$*abc", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when cover_size is invalid" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover('test_id', 'abc', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover.must_raise ArgumentError
+                err.message.must_match "Document cover size must be xs, s, m, l, or xl."
+            end
+
+        end
+
+        describe "when document does not exist" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                id = UUID.new.generate
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover = ->{ http_client.get_document_cover(id, 'm', signing_options) }
+            end
+
+            it "should return nil" do
+                doc = @get_document_cover.call
+                doc.must_be_nil
+            end
+
+        end
+
+        describe "when cover size is xs" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_cover = ->{ http_client.get_document_cover(@id, 'xs', signing_options) }
+            end
+
+            it "should return document details" do
+                cover = @get_document_cover.call
+                cover.length.must_equal 259
+            end
+
+        end
+
+        describe "when cover size is s" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_cover = ->{ http_client.get_document_cover(@id, 's', signing_options) }
+            end
+
+            it "should return document details" do
+                cover = @get_document_cover.call
+                cover.length.must_equal 808
+            end
+
+        end
+
+        describe "when cover size is m" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_cover = ->{ http_client.get_document_cover(@id, 'm', signing_options) }
+            end
+
+            it "should return document details" do
+                cover = @get_document_cover.call
+                cover.length.must_equal 1888
+            end
+
+        end
+
+        describe "when cover size is l" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_cover = ->{ http_client.get_document_cover(@id, 'l', signing_options) }
+            end
+
+            it "should return document details" do
+                cover = @get_document_cover.call
+                cover.length.must_equal 3726
+            end
+
+        end
+
+        describe "when cover size is xl" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_cover = ->{ http_client.get_document_cover(@id, 'xl', signing_options) }
+            end
+
+            it "should return document details" do
+                cover = @get_document_cover.call
+                cover.length.must_equal 7089
+            end
+
+        end
+
+    end
+
+    describe "#get_document_cover_url" do
+
+        describe "when id is nil" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url(nil, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is empty" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url("", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is blank" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url(" ", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is not a string" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url(123, 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id does not match RegEx" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url("123^%$*abc", 'm', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when cover_size is invalid" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url('test_id', 'abc', signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Document cover size must be xs, s, m, l, or xl."
+            end
+
+        end
+
+        describe "when signing_mechanism is Header" do
+
+            before do
+                id = UUID.new.generate
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @get_document_cover_url = ->{ http_client.get_document_cover_url(id, 'm', signing_options) }
+            end
+
+            it "should return nil" do
+                err = @get_document_cover_url.must_raise ArgumentError
+                err.message.must_match "Signing mechanism must be QueryString."
+            end
+
+        end
+
+        describe "when cover size is xs" do
+
+            before do
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::QUERY_STRING,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @document_cover_url = http_client.get_document_cover_url(@id, 'xs', signing_options)
+            end
+
+            it "should return document details" do
+                (@document_cover_url.include? "/v2/documents/#{@id}/cover").must_equal true
+                (@document_cover_url.include? "coverSize=xs").must_equal true
+                (@document_cover_url.include? "X-Pdx-Originator=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-EmailAddress=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-DisplayName=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-Expires=90").must_equal true
+                (@document_cover_url.include? "X-Pdx-Credential=#{TestConfig::DOMAIN_ID}").must_equal true
+                (@document_cover_url.include? "X-Pdx-Signature=").must_equal true
+            end
+
+        end
+
+        describe "when cover size is s" do
+
+            before do
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::QUERY_STRING,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @document_cover_url = http_client.get_document_cover_url(@id, 's', signing_options)
+            end
+
+            it "should return document details" do
+                (@document_cover_url.include? "/v2/documents/#{@id}/cover").must_equal true
+                (@document_cover_url.include? "coverSize=s").must_equal true
+                (@document_cover_url.include? "X-Pdx-Originator=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-EmailAddress=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-DisplayName=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-Expires=90").must_equal true
+                (@document_cover_url.include? "X-Pdx-Credential=#{TestConfig::DOMAIN_ID}").must_equal true
+                (@document_cover_url.include? "X-Pdx-Signature=").must_equal true
+            end
+
+        end
+
+        describe "when cover size is m" do
+
+            before do
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::QUERY_STRING,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @document_cover_url = http_client.get_document_cover_url(@id, 'm', signing_options)
+            end
+
+            it "should return document details" do
+                (@document_cover_url.include? "/v2/documents/#{@id}/cover").must_equal true
+                (@document_cover_url.include? "coverSize=m").must_equal true
+                (@document_cover_url.include? "X-Pdx-Originator=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-EmailAddress=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-DisplayName=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-Expires=90").must_equal true
+                (@document_cover_url.include? "X-Pdx-Credential=#{TestConfig::DOMAIN_ID}").must_equal true
+                (@document_cover_url.include? "X-Pdx-Signature=").must_equal true
+            end
+
+        end
+
+        describe "when cover size is l" do
+
+            before do
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::QUERY_STRING,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @document_cover_url = http_client.get_document_cover_url(@id, 'l', signing_options)
+            end
+
+            it "should return document details" do
+                (@document_cover_url.include? "/v2/documents/#{@id}/cover").must_equal true
+                (@document_cover_url.include? "coverSize=l").must_equal true
+                (@document_cover_url.include? "X-Pdx-Originator=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-EmailAddress=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-DisplayName=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-Expires=90").must_equal true
+                (@document_cover_url.include? "X-Pdx-Credential=#{TestConfig::DOMAIN_ID}").must_equal true
+                (@document_cover_url.include? "X-Pdx-Signature=").must_equal true
+            end
+
+        end
+
+        describe "when cover size is xl" do
+
+            before do
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::QUERY_STRING,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @document_cover_url = http_client.get_document_cover_url(@id, 'xl', signing_options).to_s
+            end
+
+            it "should return document details" do
+                (@document_cover_url.include? "/v2/documents/#{@id}/cover").must_equal true
+                (@document_cover_url.include? "coverSize=xl").must_equal true
+                (@document_cover_url.include? "X-Pdx-Originator=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-EmailAddress=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-DisplayName=HttpClientTest").must_equal true
+                (@document_cover_url.include? "X-Pdx-Expires=90").must_equal true
+                (@document_cover_url.include? "X-Pdx-Credential=#{TestConfig::DOMAIN_ID}").must_equal true
+                (@document_cover_url.include? "X-Pdx-Signature=").must_equal true
+            end
+
+        end
+
+    end
+
+    describe "#get_document_snip_count" do
+
+        describe "when id is nil" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count(nil, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_snip_count.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is empty" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count("", signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_snip_count.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is blank" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count(" ", signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_snip_count.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id is not a string" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count(123, signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_snip_count.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when id does not match RegEx" do
+
+            before do
+                signing_options = Pandexio::SigningOptions.new()
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count("123^%$*abc", signing_options) }
+            end
+
+            it "should raise ArgumentError" do
+                err = @get_document_snip_count.must_raise ArgumentError
+                err.message.must_match "Document ID is not a string, is nil or empty, or does not match RegEx pattern: #{Pandexio::ScopePatterns::DOCUMENT_ID_PATTERN}."
+            end
+
+        end
+
+        describe "when document does not exist" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                id = UUID.new.generate
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                @get_document_snip_count = ->{ http_client.get_document_snip_count(id, signing_options) }
+            end
+
+            it "should return ." do
+                count = @get_document_snip_count.call
+                count.must_equal 0
+            end
+
+        end
+
+        describe "when document exists" do
+
+            before do
+                skip("skip integration tests") if TestConfig::SKIP_INTEGRATION_TESTS
+                @id = UUID.new.generate
+                document_source = Pandexio::DocumentSource.new(
+                    :id => @id,
+                    :name => "test_name_#{@id}.txt",
+                    :content => "data:text/plain;base64,dGVzdGluZyAxMjM=",
+                    :location => "Inline")
+                signing_options = Pandexio::SigningOptions.new(
+                    :algorithm => Pandexio::SigningAlgorithms::PDX_HMAC_SHA256,
+                    :mechanism => Pandexio::SigningMechanisms::HEADER,
+                    :domain_id => TestConfig::DOMAIN_ID,
+                    :domain_key => TestConfig::DOMAIN_KEY,
+                    :date => Time.now.utc,
+                    :expires => 90,
+                    :originator => "HttpClientTest",
+                    :email_address => "HttpClientTest",
+                    :display_name => "HttpClientTest")
+                http_client = Pandexio::HttpClient.new()
+                http_client.load_document(document_source, signing_options)
+                sleep(3)
+                @get_document_snip_count = ->{ http_client.get_document_snip_count(@id, signing_options) }
+            end
+
+            it "should return document details" do
+                count = @get_document_snip_count.call
+                count.must_equal 0
+            end
+
+        end
+
+    end
+
+end