rightsignature-railstyle 1.1.9

data/lib/rightsignature/version.rb

@@ -0,0 +1,3 @@
+module RightSignature
+  VERSION = "1.1.9"
+end

data/rightsignature-api.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rightsignature/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rightsignature-railstyle"
+  s.version     = RightSignature::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nick Barone"]
+  s.email       = [""]
+  s.homepage    = "http://github.com/narfanator/rightsignature-api"
+  s.summary     = "API wrapper for RightSignature"
+  s.description = "Provides a wrapper for the RightSignature API."
+  s.license     = 'MIT'
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", ">= 2.11.0"
+
+  s.add_dependency "oauth", ">= 0.4.0"
+  s.add_dependency "httparty", ">= 0.9.0"
+  s.add_dependency 'xml-fu', '>= 0.2.0'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_path = 'lib'
+end

data/spec/account_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RightSignature::Account do
+  describe "user_details" do
+    it "should GET /api/users/user_details.xml" do
+      @rs.should_receive(:get).with('/api/users/user_details.xml')
+      @rs.user_details
+    end
+  end
+
+  describe "add_user" do
+    it "should POST /api/users.xml with user email and name in hash" do
+      @rs.should_receive(:post).with('/api/users.xml', {:user => {:name => "Jimmy Cricket", :email => "jimmy@example.com"}})
+      @rs.add_user("Jimmy Cricket", "jimmy@example.com")
+    end
+  end
+  
+  describe "usage_report" do
+    it "should GET /api/account/usage_report.xml" do
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {})
+      @rs.usage_report
+    end
+
+    it "should GET /api/account/usage_report.xml with acceptable param for :since" do
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "week"})
+      @rs.usage_report("week")
+
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "month"})
+      @rs.usage_report("month")
+
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "day"})
+      @rs.usage_report("day")
+
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {})
+      @rs.usage_report("1/4/90")
+    end
+    
+    it "should GET /api/account/usage_report.xml with param :signed" do
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
+      @rs.usage_report(nil, true)
+
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "false"})
+      @rs.usage_report(nil, false)
+    end
+
+    it "should GET /api/account/usage_report.xml with params :since and :signed" do
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
+      @rs.usage_report(nil, true)
+
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "false"})
+      @rs.usage_report(nil, false)
+    end
+  end
+end

data/spec/api_token_connection_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RightSignature::TokenConnection do
+  it "should raise error if no configuration is set" do
+    token_connection = RightSignature::TokenConnection.new('')
+    lambda{token_connection.request(:get, "path", {:query => {:search => 'hey there'}})}.should raise_error(Exception, "Please set api_token")
+  end
+
+  it "should create 'api-token' in headers with :api_token credentials, accept of '*/*', and content-type of xml with given method" do
+    token_connection = RightSignature::TokenConnection.new('APITOKEN')
+    token_connection.class.should_receive(:get).with("path", {:query => {:search => 'hey there'}, :headers => {"api-token" => "APITOKEN", "Accept" => "*/*", "content-type" => "application/xml"}}).and_return(stub("HTTPartyResponse", :parsed_response => nil))
+    token_connection.request(:get, "path", {:query => {:search => 'hey there'}})
+  end
+  
+  it "should add 'api-token' to headers with :api_token credentials, accept of '*/*', and content-type of xml with given method" do
+    token_connection = RightSignature::TokenConnection.new('APITOKEN')
+    token_connection.class.should_receive(:get).with("path", {:query => {:search => 'hey there'}, :headers => {"api-token" => "APITOKEN", "Accept" => "*/*", "content-type" => "application/xml", :my_header => "someHeader"}}).and_return(stub("HTTPartyResponse", :parsed_response => nil))
+    token_connection.request(:get, "path", {:query => {:search => 'hey there'}, :headers => {:my_header => "someHeader"}})
+  end
+
+  it "should create 'api-token' in headers with :api_token credentials, accept of '*/*', and content-type of xml to POST method" do
+    token_connection = RightSignature::TokenConnection.new('APITOKEN')
+    token_connection.class.should_receive(:post).with("path", {:body => {:document => {:roles => []}}, :headers => {"api-token" => "APITOKEN", "Accept" => "*/*", "content-type" => "application/xml"}}).and_return(stub("HTTPartyResponse", :parsed_response => nil))
+    token_connection.request(:post, "path", {:body => {:document => {:roles => []}}})
+  end
+  
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/../lib/rightsignature'
+
+describe RightSignature do
+  describe "load_configuration" do
+    it "should load api_token into configurations[:api_token]" do
+      rs = RightSignature::Connection.new(:api_token => "MyToken")
+      rs.configuration[:api_token].should == "MyToken"
+    end
+
+    it "should load OAuth consumer key, consumer secret, access token and access secret" do
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      rs.configuration[:consumer_key].should == "key"
+      rs.configuration[:consumer_secret].should == "secret"
+      rs.configuration[:access_token].should == "atoken"
+      rs.configuration[:access_secret].should == "asecret"
+    end
+  end
+
+  describe "check_credentials" do
+    it "should raise error if configuration is not set" do
+      rs = RightSignature::Connection.new()
+      lambda {rs.check_credentials}.should raise_error
+    end
+
+    it "should raise error if api_token is blank and oauth credentials are not set" do
+      rs = RightSignature::Connection.new(:api_token => " ")
+      lambda {rs.check_credentials}.should raise_error
+    end
+
+    it "should raise error if consumer_key, consumer_secret, access_token, or access_secret is not set" do
+      rs = RightSignature::Connection.new(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      lambda {rs.check_credentials}.should raise_error
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
+      lambda {rs.check_credentials}.should raise_error
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
+      lambda {rs.check_credentials}.should raise_error
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken")
+      lambda {rs.check_credentials}.should raise_error
+    end
+
+    it "should not raise error if consumer_key, consumer_secret, access_token, and access_secret is set" do
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      rs.check_credentials
+    end
+
+    it "should not raise error if api_token is set" do
+      rs = RightSignature::Connection.new(:api_token => "asdf")
+      rs.check_credentials
+    end
+  end
+
+  describe "has_api_token?" do
+    it "should be false if configuration is not set" do
+      rs = RightSignature::Connection.new()
+      rs.has_api_token?.should be false
+    end
+
+    it "should be false if api_token is blank" do
+      rs = RightSignature::Connection.new(:api_token => "   ")
+      rs.has_api_token?.should be false
+    end
+
+    it "should be true if api_token is set" do
+      rs = RightSignature::Connection.new(:api_token => "abc")
+      rs.has_api_token?.should be true
+    end
+
+  end
+
+  describe "has_oauth_credentials?" do
+    it "should be false if configuration is not set" do
+      rs = RightSignature::Connection.new()
+      rs.has_oauth_credentials?.should be false
+    end
+
+    it "should be false if consumer_key, consumer_secret, access_token, or access_secret is not set" do
+      rs = RightSignature::Connection.new(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      rs.has_oauth_credentials?.should be false
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
+      rs.has_oauth_credentials?.should be false
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
+      rs.has_oauth_credentials?.should be false
+
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken")
+      rs.has_oauth_credentials?.should be false
+    end
+
+    it "should be true if consumer_key, consumer_secret, access_token, and access_secret is set" do
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      rs.has_oauth_credentials?.should be true
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/../lib/rightsignature'
+
+describe RightSignature::Connection do
+  before do
+    @net_http_response = Net::HTTPOK.new('1.1', 200, 'OK')
+    @net_http_response.stub(:body => '')
+
+    @httparty_response = stub("HTTPartyResponse", :body => '')
+    @httparty_response.stub(:parsed_response) {nil}
+    @httparty_response.stub(:success?) {true}
+  end
+
+  describe "GET" do
+    describe "connection method" do
+      it "should default to RightSignature::57 if no api_token was specified" do
+        @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        @rs.oauth_connection.should_receive(:request).and_return(@net_http_response)
+        @rs.get("/path")
+      end
+
+      it "should use Token Connection if api_token was specified" do
+        @rs = RightSignature::Connection.new({:api_token => "APITOKEN", :consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+        @rs.get("/path")
+      end
+
+      it "should use Token Connection if only api_token was specified" do
+        @rs = RightSignature::Connection.new({:api_token => "APITOKEN"})
+        @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+        @rs.get("/path")
+      end
+    end
+
+    it "should raise error if no configuration is set" do
+      @rs = RightSignature::Connection.new({})
+      lambda{@rs.get("/path")}.should raise_error
+    end
+
+    describe "using OauthConnection" do
+      it "should append params into path alphabetically and URI escaped" do
+        @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        @net_http_response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+        @rs.oauth_connection.should_receive(:request).with(:get, "/path?page=1&q=search%20me", {}).and_return(@net_http_response)
+        @rs.get("/path", {:q => 'search me', :page => 1})
+      end
+
+      it "should return converted response body from XML to hash" do
+        @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+        response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+        @rs.oauth_connection.should_receive(:request).with(:get, "/path?page=1&q=search%20me", {}).and_return(response)
+        @rs.get("/path", {:q => 'search me', :page => 1}).should == {'document' => {'subject' => "My Subject"}}
+      end
+    end
+
+    describe "using TokenConnection" do
+      it "should append params and header into query option and header option" do
+        @rs = RightSignature::Connection.new({:api_token => 'token'})
+        @rs.token_connection.should_receive(:request).with(:get, "/path", {:query => {:q => 'search me', :page => 1}, :headers => {"User-Agent" => "me"}}).and_return(@httparty_response)
+        @rs.get("/path", {:q => 'search me', :page => 1}, {"User-Agent" => "me"})
+      end
+
+      it "should return converted parsed_response from response" do
+        @rs = RightSignature::Connection.new({:api_token => 'token'})
+        @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+        @rs.token_connection.stub(:request).and_return(@httparty_response)
+        @rs.get("/path", {:q => 'search me', :page => 1}).should == {'document' => {'subject' => "My Subject"}}
+      end
+    end
+  end
+
+  describe "POST" do
+    describe "connection method" do
+      before do
+        @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        @rs.token_connection.stub(:request => @net_http_response)
+        @rs.oauth_connection.stub(:request => @httparty_response)
+      end
+
+      it "should default to Oauth Connection if no api_token was specified" do
+        @rs.oauth_connection.should_receive(:request).and_return(@net_http_response)
+        @rs.post("/path")
+      end
+
+      it "should default to Token Connection if api_token was specified" do
+        @rs = RightSignature::Connection.new({:api_token => "APITOKEN", :consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+        @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+        @rs.post("/path")
+      end
+
+      it "should default to Token Connection if only api_token was specified" do
+        @rs = RightSignature::Connection.new({:api_token => "APITOKEN"})
+        @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+        @rs.post("/path")
+      end
+
+      it "should raise error if no configuration is set" do
+        @rs = RightSignature::Connection.new({})
+        lambda{@rs.post("/path")}.should raise_error
+      end
+    end
+
+
+    describe "DELETE" do
+      describe "connection method" do
+        it "should default to RightSignature::57 if no api_token was specified" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          @rs.oauth_connection.should_receive(:request).and_return(@net_http_response)
+          @rs.delete("/path")
+        end
+
+        it "should use Token Connection if api_token was specified" do
+          @rs = RightSignature::Connection.new({:api_token => "APITOKEN", :consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+          @rs.delete("/path")
+        end
+
+        it "should use Token Connection if only api_token was specified" do
+          @rs = RightSignature::Connection.new({:api_token => "APITOKEN"})
+          @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+          @rs.delete("/path")
+        end
+      end
+
+      it "should raise error if no configuration is set" do
+        @rs = RightSignature::Connection.new({})
+        lambda{@rs.delete("/path")}.should raise_error
+      end
+
+      describe "using OauthConnection" do
+        it "should return converted response body from XML to hash" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+          response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          @rs.oauth_connection.should_receive(:request).with(:delete, "/path", {}).and_return(response)
+          @rs.delete("/path").should == {'document' => {'subject' => "My Subject"}}
+        end
+
+        it "should pass headers" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+          response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          @rs.oauth_connection.should_receive(:request).with(:delete, "/path", {"User-Agent" => "custom"}).and_return(response)
+          @rs.delete("/path", {"User-Agent" => "custom"}).should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+
+      describe "using TokenConnection" do
+        it "should append headers into headers option" do
+          @rs = RightSignature::Connection.new({:api_token => 'token'})
+          @rs.token_connection.should_receive(:request).with(:delete, "/path", {:headers => {"User-Agent" => "me"}}).and_return(@httparty_response)
+          @rs.delete("/path", {"User-Agent" => "me"})
+        end
+
+        it "should return converted parsed_response from response" do
+          @rs = RightSignature::Connection.new({:api_token => 'token'})
+          @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+          @rs.token_connection.stub(:request).and_return(@httparty_response)
+          @rs.delete("/path").should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+    end
+
+    describe "PUT" do
+      describe "connection method" do
+        it "should default to RightSignature::57 if no api_token was specified" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          @rs.oauth_connection.should_receive(:request).and_return(@net_http_response)
+          @rs.get("/path")
+        end
+
+        it "should use Token Connection if api_token was specified" do
+          @rs = RightSignature::Connection.new({:api_token => "APITOKEN", :consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+          @rs.put("/path")
+        end
+
+        it "should use Token Connection if only api_token was specified" do
+          @rs = RightSignature::Connection.new({:api_token => "APITOKEN"})
+          @rs.token_connection.should_receive(:request).and_return(@httparty_response)
+          @rs.put("/path")
+        end
+      end
+
+      it "should raise error if no configuration is set" do
+        @rs = RightSignature::Connection.new({})
+        lambda{@rs.put("/path")}.should raise_error
+      end
+
+      describe "using OauthConnection" do
+        it "should convert body into XML" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          @net_http_response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          @rs.oauth_connection.should_receive(:request).with(:put, "/path", "<document><something>else</something><page>1</page></document>", {}).and_return(@net_http_response)
+          @rs.put("/path", {:document => {:something => "else", :page => 1}})
+        end
+
+        it "should return converted response body from XML to hash" do
+          @rs = RightSignature::Connection.new({:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"})
+          response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+          response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          @rs.oauth_connection.should_receive(:request).with(:put, "/path", "<document><something>else</something><page>1</page></document>", {}).and_return(response)
+          @rs.put("/path", {:document => {:something => "else", :page => 1}}).should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+
+      describe "using TokenConnection" do
+        it "should append params and header into query option and header option" do
+          @rs = RightSignature::Connection.new({:api_token => 'token'})
+          @rs.token_connection.should_receive(:request).with(:put, "/path", {:body => "<document><something>else</something><page>1</page></document>", :headers => {"User-Agent" => "me"}}).and_return(@httparty_response)
+          @rs.put("/path", {:document => {:something => "else", :page => 1}}, {"User-Agent" => "me"})
+        end
+
+        it "should return converted parsed_response from response" do
+          @rs = RightSignature::Connection.new({:api_token => 'token'})
+          @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+          @rs.token_connection.stub(:request).and_return(@httparty_response)
+          @rs.put("/path", {:document => {:something => "else", :page => 1}}).should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+    end
+
+  end
+end

data/spec/document_spec.rb

@@ -0,0 +1,301 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RightSignature::Document do
+  describe "documents_list" do
+    it "should GET /documents.xml" do
+      @rs.should_receive(:get).with('/api/documents.xml', {})
+      @rs.documents_list
+    end
+
+    it "should pass search options to /api/templates.xml" do
+      @rs.should_receive(:get).with('/api/documents.xml', {:search => "search", :page => 2})
+      @rs.documents_list(:search => "search", :page => 2)
+    end
+
+    it "should convert array in options :tags into a string" do
+      @rs.should_receive(:get).with('/api/documents.xml', {:tags => "hello,what_is:up"})
+      @rs.documents_list(:tags => ['hello', {'what_is' => "up"}])
+    end
+
+    it "should convert array of options :state into a string" do
+      @rs.should_receive(:get).with('/api/documents.xml', {:state => 'pending,trashed'})
+      @rs.documents_list(:state => ['pending', 'trashed'])
+    end
+  end
+
+  describe "details" do
+    it "should GET /api/documentsMYGUID.xml" do
+      @rs.should_receive(:get).with('/api/documents/MYGUID.xml')
+      @rs.document_details('MYGUID')
+    end
+  end
+
+  describe "details" do
+    it "should GET /api/documentsMYGUID.xml" do
+      @rs.should_receive(:get).with('/api/documents/MYGUID.xml')
+      @rs.document_details('MYGUID')
+    end
+  end
+
+  describe "documents_batch_details" do
+    it "should GET /api/documentsMYGUID1,MYGUID2.xml" do
+      @rs.should_receive(:get).with('/api/documents/MYGUID1,MYGUID2/batch_details.xml')
+      @rs.documents_batch_details(['MYGUID1','MYGUID2'])
+    end
+  end
+
+  describe "send_reminder" do
+    it "should POST /api/documentsMYGUID/send_reminders.xml" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/send_reminders.xml', {})
+      @rs.send_reminder('MYGUID')
+    end
+  end
+
+  describe "trash" do
+    it "should POST /api/documents/MYGUID/trash.xml" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/trash.xml', {})
+      @rs.trash_document('MYGUID')
+    end
+  end
+
+  describe "extend_document_expiration" do
+    it "should POST /api/documents/MYGUID/extend_expiration.xml" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/extend_expiration.xml', {})
+      @rs.extend_document_expiration('MYGUID')
+    end
+  end
+
+  describe "update_document_tags" do
+    it "should POST /api/documents/MYGUID/update_tags.xml" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {:tags => []})
+      @rs.update_document_tags('MYGUID', [])
+    end
+
+    it "should normalize tags array into expected hash format" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {
+        :tags => [{:tag => {:name => 'myNewOne'}}, {:tag => {:name => 'should_replace', :value => 'the_old_new'}}]
+      })
+      @rs.update_document_tags('MYGUID', ["myNewOne", {"should_replace" => "the_old_new"}])
+    end
+
+    it "should allow empty tags array" do
+      @rs.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {
+        :tags => []
+      })
+      @rs.update_document_tags('MYGUID', [])
+    end
+  end
+
+  describe "send_document" do
+    it "should POST /api/documents.xml with document hash containing given subject, document data, recipients, and action of 'send'" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :document_data => {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"},
+          :recipients => [],
+          :action => "send"
+        }
+      })
+      document_data = {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"}
+      @rs.send_document("subby", [], document_data)
+    end
+
+    it "should POST /api/documents.xml should convert recipients into normalized format" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :document_data => {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"},
+          :recipients => [
+            {:recipient => {:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}},
+            {:recipient =>{:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}}
+          ],
+          :action => "send"
+        }
+      })
+      document_data = {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"}
+      recipients = [{:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}, {:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}]
+
+      @rs.send_document("subby", recipients, document_data)
+    end
+
+    it "should POST /api/documents.xml with options" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :document_data => {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"},
+          :recipients => [
+            {:recipient => {:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}},
+            {:recipient =>{:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}}
+          ],
+          :action => "send",
+          :description => "My descript",
+          :callback_url => "http://example.com/call"
+        }
+      })
+      document_data = {:type => 'base64', :filename => "originalfile.pdf", :value => "mOio90cv"}
+      recipients = [{:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}, {:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}]
+
+      options = {
+        :description => "My descript",
+        :callback_url => "http://example.com/call"
+      }
+      @rs.send_document("subby", recipients, document_data, options)
+    end
+  end
+
+  describe "send_document_from_data" do
+    it "should POST /api/documents.xml with document hash containing given subject, Base64 encoded version of document data, recipients, and action of 'send'" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :document_data => {:type => 'base64', :filename => "my fresh upload.pdf", :value => Base64::encode64("THIS IS MY data")},
+          :recipients => [],
+          :action => "send"
+        }
+      })
+      @rs.send_document_from_data("THIS IS MY data", "my fresh upload.pdf", "subby", [])
+    end
+
+    it "should POST /api/documents.xml with options" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :action => "send",
+          :document_data => {:type => 'base64', :filename => "uploaded.pdf", :value => Base64::encode64("THIS")},
+          :recipients => [
+            {:recipient => {:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}},
+            {:recipient =>{:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}}
+          ],
+          :description => "My descript",
+          :callback_url => "http://example.com/call"
+        }
+      })
+
+      recipients = [{:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}, {:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}]
+      options = {
+        :description => "My descript",
+        :callback_url => "http://example.com/call"
+      }
+      @rs.send_document_from_data("THIS", "uploaded.pdf", "subby", recipients, options)
+    end
+  end
+
+  describe "send_document_from_file" do
+    it "should open File and base64 encode it" do
+      # Probably get a fixture or something here
+      file = File.new(File.dirname(__FILE__) + '/spec_helper.rb')
+      fake_data = "abc"
+      File.should_receive(:read).with(file).and_return(fake_data)
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :action => "send",
+          :document_data => {:type => 'base64', :filename => "spec_helper.rb", :value => Base64::encode64(fake_data)},
+          :recipients => []
+        }
+      })
+
+      @rs.send_document_from_file(file, "subby", [])
+    end
+
+    it "should open path to file and base64 encode it" do
+      file_path = '/tmp/temp.pdf'
+      fake_data = "abc"
+      File.should_receive(:read).with(file_path).and_return(fake_data)
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :action => "send",
+          :document_data => {:type => 'base64', :filename => "temp.pdf", :value => Base64::encode64(fake_data)},
+          :recipients => []
+        }
+      })
+      @rs.send_document_from_file(file_path, "subby", [])
+    end
+
+    it "should POST /api/documents.xml with options" do
+      file_path = '/tmp/temp.pdf'
+      fake_data = "abc"
+      File.should_receive(:read).with(file_path).and_return(fake_data)
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subby",
+          :action => "send",
+          :document_data => {:type => 'base64', :filename => "temp.pdf", :value => Base64::encode64(fake_data)},
+          :recipients => [
+            {:recipient => {:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}},
+            {:recipient =>{:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}}
+          ],
+          :description => "My descript",
+          :callback_url => "http://example.com/call"
+        }
+      })
+
+      recipients = [{:name => "Signy Sign", :email => "signy@example.com", :role => "signer"}, {:name => "Cee Cee", :email => "ccme@example.com", :role => "cc"}]
+      options = {
+        :description => "My descript",
+        :callback_url => "http://example.com/call"
+      }
+      @rs.send_document_from_file(file_path, "subby", recipients, options)
+    end
+  end
+
+  describe "generate_document_url" do
+    it "should POST /api/documents.xml with redirect action and return https://rightsignature.com/builder/new?rt=REDIRECT_TOKEN" do
+      @rs.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subjy",
+          :action => "redirect",
+          :document_data => {},
+          :recipients => [],
+        }
+      }).and_return({"document"=>{"redirect_token" => "REDIRECT_TOKEN"}})
+      @rs.generate_document_redirect_url("subjy", [], {}).should == "#{@rs.site}/builder/new?rt=REDIRECT_TOKEN"
+    end
+  end
+
+  describe "get_document_signer_links_for" do
+    it "should GET /api/documents/GUID123/signer_links.xml and return urls for signers" do
+      @rs.should_receive(:get).with("/api/documents/GUID123/signer_links.xml", {}).and_return({'document' => {'signer_links' => {'signer_link' => [
+        {"signer_token" => "avx37", "name" => "John Bellingham"},
+        {"signer_token" => "fdh89", "name" => "Righty Jones"}]
+      }}})
+
+      response = @rs.get_document_signer_links_for("GUID123")
+      response.size.should == 2
+      response.include?({"name" => "John Bellingham", "url" => "#{@rs.site}/signatures/embedded?rt=avx37"}).should be true
+      response.include?({"name" => "Righty Jones", "url" => "#{@rs.site}/signatures/embedded?rt=fdh89"}).should be true
+    end
+
+    it "should GET /api/documents/GUID123/signer_links.xml with URI encoded redirect location and return urls for signers" do
+      @rs.should_receive(:get).with("/api/documents/GUID123/signer_links.xml", {:redirect_location => "http://google.com/redirected%20location"}
+      ).and_return({'document' => {'signer_links' => {'signer_link' => [
+        {"signer_token" => "avx37", "name" => "John Bellingham"},
+        {"signer_token" => "fdh89", "name" => "Righty Jones"}]
+      }}})
+
+      response = @rs.get_document_signer_links_for("GUID123", "http://google.com/redirected location")
+      response.size.should == 2
+      response.include?({"name" => "John Bellingham", "url" => "#{@rs.site}/signatures/embedded?rt=avx37"}).should be true
+      response.include?({"name" => "Righty Jones", "url" => "#{@rs.site}/signatures/embedded?rt=fdh89"}).should be true
+    end
+
+    it "should GET /api/documents/GUID123/signer_links.xml and return [] for no signers" do
+      @rs.should_receive(:get).with("/api/documents/GUID123/signer_links.xml", {}).and_return({'document' => {'signer_links' => nil}})
+
+      response = @rs.get_document_signer_links_for("GUID123")
+      response.should == []
+    end
+
+    it "should GET /api/documents/GUID123/signer_links.xml with URI encoded redirect location and return urls for 1 signer_link" do
+      @rs.should_receive(:get).with("/api/documents/GUID123/signer_links.xml", {:redirect_location => "http://google.com/redirected%20location"}
+      ).and_return({'document' => {'signer_links' => {'signer_link' =>
+        {"signer_token" => "fdh89", "name" => "Righty Jones"}
+      }}})
+
+      response = @rs.get_document_signer_links_for("GUID123", "http://google.com/redirected location")
+      response.size.should == 1
+      response.include?({"name" => "Righty Jones", "url" => "#{@rs.site}/signatures/embedded?rt=fdh89"}).should be true
+    end
+  end
+end