rightsignature 0.1.0

data/lib/rightsignature/version.rb

@@ -0,0 +1,3 @@
+module RightSignature
+  VERSION = "0.1.0"
+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"
+  s.version     = RightSignature::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alex Chee", "Geoff Ereth", "Cary Dunn"]
+  s.email       = ["dev@rightsignature.com"]
+  s.homepage    = "http://github.com/alexchee/rightsignature-api"
+  s.summary     = "API wrapper for RightSignature"
+  s.description = "Provides a wrapper for the RightSignature API."
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", ">= 2.11.0"
+
+  s.add_dependency "bundler", ">= 1.0.0"
+  s.add_dependency "oauth", "= 0.4.3"
+  s.add_dependency "httparty", ">= 0.9.0"
+  s.add_dependency 'xml-fu', '>= 0.1.7'
+
+  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/api_token_connection_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RightSignature::TokenConnection do
+  it "should create 'api-token' to headers with :api_token credentials, accept of '*/*', and content-type of xml with given method" do
+    RightSignature::TokenConnection.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))
+    RightSignature::TokenConnection.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
+    RightSignature::TokenConnection.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))
+    RightSignature::TokenConnection.request(:get, "path", {:query => {:search => 'hey there'}, :headers => {:my_header => "someHeader"}})
+  end
+
+  it "should create 'api-token' to headers with :api_token credentials, accept of '*/*', and content-type of xml to POST method" do
+    RightSignature::TokenConnection.should_receive(:post).with("path", {:body => {:document => {:roles => []}}, :headers => {"api-token" => "APITOKEN", "Accept" => "*/*", "content-type" => "application/xml"}}).and_return(stub("HTTPartyResponse", :parsed_response => nil))
+    RightSignature::TokenConnection.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::configuration do
+  describe "load_configuration" do
+    it "should load api_token into configurations[:api_token]" do
+      RightSignature::load_configuration(:api_token => "MyToken")
+      RightSignature::configuration[:api_token].should == "MyToken"
+    end
+  
+    it "should load OAuth consumer key, consumer secret, access token and access secret" do
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      RightSignature::configuration[:consumer_key].should == "key"
+      RightSignature::configuration[:consumer_secret].should == "secret"
+      RightSignature::configuration[:access_token].should == "atoken"
+      RightSignature::configuration[:access_secret].should == "asecret"
+    end
+  end
+
+  describe "check_credentials" do
+    it "should raise error if configuration is not set" do
+      RightSignature::load_configuration()
+      lambda {RightSignature::check_credentials}.should raise_error
+    end
+
+    it "should raise error if api_token is blank and oauth credentials are not set" do
+      RightSignature::load_configuration(:api_token => " ")
+      lambda {RightSignature::check_credentials}.should raise_error
+    end
+
+    it "should raise error if consumer_key, consumer_secret, access_token, or access_secret is not set" do
+      RightSignature::load_configuration(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      lambda {RightSignature::check_credentials}.should raise_error
+
+      RightSignature::load_configuration(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
+      lambda {RightSignature::check_credentials}.should raise_error
+
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
+      lambda {RightSignature::check_credentials}.should raise_error
+
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken")
+      lambda {RightSignature::check_credentials}.should raise_error
+    end
+
+    it "should not raise error if consumer_key, consumer_secret, access_token, and access_secret is set" do
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      RightSignature::check_credentials
+    end
+
+    it "should not raise error if api_token is set" do
+      RightSignature::load_configuration(:api_token => "asdf")
+      RightSignature::check_credentials
+    end
+  end
+  
+  describe "has_api_token?" do
+    it "should be false if configuration is not set" do
+      RightSignature::load_configuration()
+      RightSignature::has_api_token?.should be_false
+    end
+
+    it "should be false if api_token is blank" do
+      RightSignature::load_configuration(:api_token => "   ")
+      RightSignature::has_api_token?.should be_false
+    end
+
+    it "should be true if api_token is set" do
+      RightSignature::load_configuration(:api_token => "abc")
+      RightSignature::has_api_token?.should be_true
+    end
+    
+  end
+
+  describe "has_oauth_credentials?" do
+    it "should be false if configuration is not set" do
+      RightSignature::load_configuration()
+      RightSignature::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
+      RightSignature::load_configuration(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      RightSignature::has_oauth_credentials?.should be_false
+
+      RightSignature::load_configuration(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
+      RightSignature::has_oauth_credentials?.should be_false
+
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
+      RightSignature::has_oauth_credentials?.should be_false
+
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken")
+      RightSignature::has_oauth_credentials?.should be_false
+    end
+
+    it "should be true if consumer_key, consumer_secret, access_token, and access_secret is set" do
+      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      RightSignature::has_oauth_credentials?.should be_true
+    end
+  end
+end

data/spec/connection_spec.rb

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

data/spec/document_spec.rb

@@ -0,0 +1,256 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RightSignature::Document do
+  describe "list" do
+    it "should GET /documents.xml" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents.xml', {})
+      RightSignature::Document.list
+    end
+    
+    it "should pass search options to /api/templates.xml" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents.xml', {:search => "search", :page => 2})
+      RightSignature::Document.list(:search => "search", :page => 2)
+    end
+
+    it "should convert array in options :tags into a string" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents.xml', {:tags => "hello,what_is:up"})
+      RightSignature::Document.list(:tags => ['hello', {'what_is' => "up"}])
+    end
+
+    it "should convert array of options :state into a string" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents.xml', {:state => 'pending,trashed'})
+      RightSignature::Document.list(:state => ['pending', 'trashed'])
+    end
+  end
+  
+  describe "details" do
+    it "should GET /api/documentsMYGUID.xml" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents/MYGUID.xml')
+      RightSignature::Document.details('MYGUID')
+    end
+  end
+  
+  describe "details" do
+    it "should GET /api/documentsMYGUID.xml" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents/MYGUID.xml')
+      RightSignature::Document.details('MYGUID')
+    end
+  end
+
+  describe "batch_details" do
+    it "should GET /api/documentsMYGUID1,MYGUID2.xml" do
+      RightSignature::Connection.should_receive(:get).with('/api/documents/MYGUID1,MYGUID2/batch_details.xml')
+      RightSignature::Document.batch_details(['MYGUID1','MYGUID2'])
+    end
+  end
+
+  describe "send_reminder" do
+    it "should POST /api/documentsMYGUID/send_reminders.xml" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/send_reminders.xml', {})
+      RightSignature::Document.send_reminder('MYGUID')
+    end
+  end
+  
+  describe "trash" do
+    it "should POST /api/documents/MYGUID/trash.xml" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/trash.xml', {})
+      RightSignature::Document.trash('MYGUID')
+    end
+  end
+  
+  describe "extend_expiration" do
+    it "should POST /api/documents/MYGUID/extend_expiration.xml" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/extend_expiration.xml', {})
+      RightSignature::Document.extend_expiration('MYGUID')
+    end
+  end
+  
+  describe "update_tags" do
+    it "should POST /api/documents/MYGUID/update_tags.xml" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {:tags => []})
+      RightSignature::Document.update_tags('MYGUID', [])
+    end
+
+    it "should normalize tags array into expected hash format" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {
+        :tags => [{:tag => {:name => 'myNewOne'}}, {:tag => {:name => 'should_replace', :value => 'the_old_new'}}]
+      })
+      RightSignature::Document.update_tags('MYGUID', ["myNewOne", {"should_replace" => "the_old_new"}])
+    end
+
+    it "should allow empty tags array" do
+      RightSignature::Connection.should_receive(:post).with('/api/documents/MYGUID/update_tags.xml', {
+        :tags => []
+      })
+      RightSignature::Document.update_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
+      RightSignature::Connection.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"}
+      RightSignature::Document.send_document("subby", [], document_data)
+    end
+
+    it "should POST /api/documents.xml should convert recipients into normalized format" do
+      RightSignature::Connection.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"}]
+
+      RightSignature::Document.send_document("subby", recipients, document_data)
+    end
+
+    it "should POST /api/documents.xml with options" do
+      RightSignature::Connection.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"
+      }
+      RightSignature::Document.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
+      RightSignature::Connection.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"
+        }
+      })
+      RightSignature::Document.send_document_from_data("THIS IS MY data", "my fresh upload.pdf", "subby", [])
+    end
+
+    it "should POST /api/documents.xml with options" do
+      RightSignature::Connection.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"
+      }
+      RightSignature::Document.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)
+      RightSignature::Connection.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 => []
+        }
+      })
+
+      RightSignature::Document.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)
+      RightSignature::Connection.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 => []
+        }
+      })
+      RightSignature::Document.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)
+      RightSignature::Connection.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"
+      }
+      RightSignature::Document.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
+      RightSignature::Connection.should_receive(:post).with("/api/documents.xml", {
+        :document => {
+          :subject => "subjy",
+          :action => "redirect",
+          :document_data => {},
+          :recipients => [],
+        }
+      }).and_return({"document"=>{"redirect_token" => "REDIRECT_TOKEN"}})
+      RightSignature::Document.generate_document_redirect_url("subjy", [], {}).should == "#{RightSignature::Connection.site}/builder/new?rt=REDIRECT_TOKEN"
+    end
+  end
+end