rightsignature 0.1.6 → 0.1.7

data/README.md

@@ -8,12 +8,12 @@ gem install rightsignature
 ```
 or in your Gemfile
 ```
-gem 'rightsignature', '~> 0.1.6'
+gem 'rightsignature', '~> 0.1.7'
 ```
 
 Setup
 -----
-After getting an API key from RightSignature, you can use the Secure Token or generate an Access Token with the OAuth key and secret using RightSignature::load_configuration.
+After getting an API key from RightSignature, you can use the Secure Token or generate an Access Token with the OAuth key and secret using RightSignature::load_configuration. Below are examples on how to use the gem as yourself.
 
 #####Using Token authentication
 ```
@@ -31,8 +31,36 @@ RightSignature::load_configuration(
 ```
 Note: if the both OAuth credentials and api_token are set, the default action is to use Token Authentication.
 
+#####Getting Access Token
+Make sure you have a server that is can recieve the parameters from RightSignature and the callback is setup correctly in the RightSignature API settings (https://rightsignature.com/oauth_clients).
+```
+request_token = RightSignature::OauthConnection.new_request_token
+```
+
+Now Visit the url generated from
+```
+RightSignature::OauthConnection.request_token.authorize_url
+```
+and log into the site.
+
+After approving the application, you will be redirected to the callback url that is in the RightSignature API settings (https://rightsignature.com/oauth_clients). The OAuth verifier should be in the params "oauth_verifier". Put the verifier in:
+```
+RightSignature::OauthConnection.generate_access_token(params[:oauth_verifer])
+```
+
+Now, you should have your Connection setup. You can save the access token and access token secret for later use and skip the previous steps.
+```
+RightSignature::OauthConnection.access_token.token
+RightSignature::OauthConnection.access_token.secret
+```
+Will give you the Access Token's token and secret.
+
+You can also load the Access Token and Secret by calling
+```
+RightSignature::OauthConnection.set_access_token(token, secret)
+```
 
-After loading the configuration, you can use wrappers in RightSignature::Document or RightSignature::Template to call the API. Or use RightSignature::Connection for a more custom call.
+After loading the configuration, you can use wrappers in RightSignature::Document, RightSignature::Template, or RightSignature::Account to call the API. Or use RightSignature::Connection for a more custom call.
 
 Documents
 ---------
@@ -393,4 +421,3 @@ $:.push File.expand_path("../lib", __FILE__); require "rightsignature"; RightSig
 TODO:
 -----
 * Parse error message from response body on unsuccessful requests
-* Have a way for to generate an OAuth Access Token from RightSignature

data/lib/rightsignature/connection/oauth_connection.rb

@@ -2,7 +2,10 @@ module RightSignature
   class OauthConnection
 
     class << self
+      attr_reader :request_token
+      
       def oauth_consumer
+        check_credentials unless RightSignature::configuration[:consumer_key] && RightSignature::configuration[:consumer_secret]
         @oauth_consumer ||= OAuth::Consumer.new(
           RightSignature::configuration[:consumer_key],
           RightSignature::configuration[:consumer_secret],
@@ -18,7 +21,28 @@ module RightSignature
       end
       
       def access_token
-        @access_token ||= OAuth::AccessToken.new(oauth_consumer,  RightSignature::configuration[:access_token],  RightSignature::configuration[:access_secret])
+        check_credentials
+        @access_token = OAuth::AccessToken.new(oauth_consumer,  RightSignature::configuration[:access_token],  RightSignature::configuration[:access_secret])
+      end
+      
+      def access_token
+        check_credentials
+        @access_token ||= OAuth::AccessToken.new(oauth_consumer, RightSignature::configuration[:access_token],  RightSignature::configuration[:access_secret])
+      end
+      
+      def set_access_token(access_token, access_secret)
+        RightSignature::configuration[:access_token] = access_token
+        RightSignature::configuration[:access_secret] = access_secret
+        @access_token = OAuth::AccessToken.new(oauth_consumer, RightSignature::configuration[:access_token],  RightSignature::configuration[:access_secret])
+      end
+      
+      def new_request_token
+        @request_token = RightSignature::OauthConnection.oauth_consumer.get_request_token
+      end
+      
+      def generate_access_token(oauth_verifier)
+        raise "Please set request token with new_request_token" unless @request_token
+        @access_token = @request_token.get_access_token(:oauth_verifier =>  oauth_verifier)
       end
       
       def request(method, *options)
@@ -28,6 +52,11 @@ module RightSignature
 
         self.access_token.__send__(method, *options)
       end
+      
+    private
+      def check_credentials
+        raise "Please set load_configuration with #{RightSignature::oauth_keys.join(', ')}" unless RightSignature::has_oauth_credentials?
+      end
     end
 
   end

data/lib/rightsignature/connection/token_connection.rb

@@ -6,6 +6,8 @@ module RightSignature
 
     class <<self
       def request(method, url, options)
+        raise "Please set load_configuration with #{RightSignature::api_token_keys.join(', ')}" unless RightSignature::has_api_token?
+        
         options[:headers] ||= {}
         options[:headers]['api-token'] = RightSignature::configuration[:api_token]
         options[:headers]["Accept"] ||= "*/*"

data/lib/rightsignature/connection.rb

@@ -8,7 +8,30 @@ module RightSignature
           RightSignature::OauthConnection.oauth_consumer.site
         end
       end
-      
+
+      def put(url, body={}, headers={})
+        if RightSignature::has_api_token?
+          options = {}
+          options[:headers] = headers
+          options[:body] = XmlFu.xml(body)
+          
+          parse_response(RightSignature::TokenConnection.request(:put, url, options))
+        else
+          parse_response(RightSignature::OauthConnection.request(:put, url, XmlFu.xml(body), headers))
+        end
+      end
+
+      def delete(url, headers={})
+        if RightSignature::has_api_token?
+          options = {}
+          options[:headers] = headers
+
+          parse_response(RightSignature::TokenConnection.request(:delete, url, options))
+        else
+          parse_response(RightSignature::OauthConnection.request(:delete, url, headers))
+        end
+      end
+
       def get(url, params={}, headers={})
         RightSignature::check_credentials
         
@@ -16,13 +39,12 @@ module RightSignature
           options = {}
           options[:headers] = headers
           options[:query] = params
-          RightSignature::TokenConnection.request(:get, url, options).parsed_response
+          parse_response(RightSignature::TokenConnection.request(:get, url, options))
         else
           unless params.empty?
             url = "#{url}?#{params.sort.map{|param| URI.escape("#{param[0]}=#{param[1]}")}.join('&')}"
           end
-          res = RightSignature::OauthConnection.request(:get, url, headers)
-          MultiXml.parse(res.body)
+          parse_response(RightSignature::OauthConnection.request(:get, url, headers))
         end
       end
 
@@ -33,26 +55,30 @@ module RightSignature
           options = {}
           options[:headers] = headers
           options[:body] = XmlFu.xml(body)
-          res = RightSignature::TokenConnection.request(:post, url, options)
-
-          unless res.success?
-            puts res.body
-            raise RightSignature::ResponseError.new(res)
+          parse_response(RightSignature::TokenConnection.request(:post, url, options))
+        else
+          parse_response(RightSignature::OauthConnection.request(:post, url, XmlFu.xml(body), headers))
+        end
+      end
+      
+      def parse_response(response)
+        if response.is_a? Net::HTTPResponse
+          unless response.is_a? Net::HTTPSuccess
+            puts response.body
+            raise RightSignature::ResponseError.new(response)
           end
 
-          res.parsed_response
+          MultiXml.parse(response.body)
         else
-          res = RightSignature::OauthConnection.request(:post, url, XmlFu.xml(body), headers)
-
-          unless res.is_a? Net::HTTPSuccess
-            puts res.body
-            raise RightSignature::ResponseError.new(res)
+          unless response.success?
+            puts response.body
+            raise RightSignature::ResponseError.new(response)
           end
-
-          MultiXml.parse(res.body)
+          
+          response.parsed_response
         end
       end
+      
     end
-    
   end
 end

data/lib/rightsignature/version.rb

@@ -1,3 +1,3 @@
 module RightSignature
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/rightsignature.rb

@@ -51,7 +51,6 @@ module RightSignature
       return true
     end
     
-  private
     def oauth_keys
       [:consumer_key, :consumer_secret, :access_token, :access_secret].freeze
     end

data/spec/api_token_connection_spec.rb

@@ -1,6 +1,11 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe RightSignature::TokenConnection do
+  it "should raise error if no configuration is set" do
+    RightSignature::configuration = {}
+    lambda{RightSignature::TokenConnection.request(:get, "path", {:query => {:search => 'hey there'}})}.should raise_error(Exception, "Please set load_configuration with api_token")
+  end
+
   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'}})

data/spec/connection_spec.rb

@@ -1,23 +1,29 @@
 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", :parsed_response => nil, :body => '', :success? => true)
+  end
+
   describe "GET" do
     describe "connection method" do
-      it "should default to RightSignature::OauthConnection if no api_token was specified" do
+      it "should default to RightSignature::57 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::OauthConnection.should_receive(:request).and_return(@net_http_response)
         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::TokenConnection.should_receive(:request).and_return(@httparty_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::TokenConnection.should_receive(:request).and_return(@httparty_response)
         RightSignature::Connection.get("/path")
       end
     end
@@ -30,13 +36,16 @@ describe RightSignature::Connection do
     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>'))
+        @net_http_response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+        RightSignature::OauthConnection.should_receive(:request).with(:get, "/path?page=1&q=search%20me", {}).and_return(@net_http_response)
         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>'))
+        response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+        response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+        RightSignature::OauthConnection.should_receive(:request).with(:get, "/path?page=1&q=search%20me", {}).and_return(response)
         RightSignature::Connection.get("/path", {:q => 'search me', :page => 1}).should == {'document' => {'subject' => "My Subject"}}
       end
     end
@@ -44,13 +53,14 @@ describe RightSignature::Connection do
     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::TokenConnection.should_receive(:request).with(:get, "/path", {:query => {:q => 'search me', :page => 1}, :headers => {"User-Agent" => "me"}}).and_return(@httparty_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"}}))
+        @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+        RightSignature::TokenConnection.stub(:request).and_return(@httparty_response)
         RightSignature::Connection.get("/path", {:q => 'search me', :page => 1}).should == {'document' => {'subject' => "My Subject"}}
       end
     end
@@ -59,9 +69,6 @@ describe RightSignature::Connection do
   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
@@ -89,7 +96,126 @@ describe RightSignature::Connection do
         lambda{RightSignature::Connection.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
+          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.delete("/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(@httparty_response)
+          RightSignature::Connection.delete("/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(@httparty_response)
+          RightSignature::Connection.delete("/path")
+        end
+      end
+
+      it "should raise error if no configuration is set" do
+        RightSignature::configuration = nil
+        lambda{RightSignature::Connection.delete("/path")}.should raise_error
+      end
+
+      describe "using OauthConnection" do
+        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"}
+          response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+          response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          RightSignature::OauthConnection.should_receive(:request).with(:delete, "/path", {}).and_return(response)
+          RightSignature::Connection.delete("/path").should == {'document' => {'subject' => "My Subject"}}
+        end
+
+        it "should pass headers" do
+          RightSignature::configuration = {: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>')
+          RightSignature::OauthConnection.should_receive(:request).with(:delete, "/path", {"User-Agent" => "custom"}).and_return(response)
+          RightSignature::Connection.delete("/path", {"User-Agent" => "custom"}).should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+
+      describe "using TokenConnection" do
+        it "should append headers into headers option" do
+          RightSignature::configuration = {:api_token => 'token'}
+          RightSignature::TokenConnection.should_receive(:request).with(:delete, "/path", {:headers => {"User-Agent" => "me"}}).and_return(@httparty_response)
+          RightSignature::Connection.delete("/path", {"User-Agent" => "me"})
+        end
+
+        it "should return converted parsed_response from response" do
+          RightSignature::configuration = {:api_token => 'token'}
+          @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+          RightSignature::TokenConnection.stub(:request).and_return(@httparty_response)
+          RightSignature::Connection.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
+          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.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(@httparty_response)
+          RightSignature::Connection.put("/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(@httparty_response)
+          RightSignature::Connection.put("/path")
+        end
+      end
+
+      it "should raise error if no configuration is set" do
+        RightSignature::configuration = nil
+        lambda{RightSignature::Connection.put("/path")}.should raise_error
+      end
+
+      describe "using OauthConnection" do
+        it "should convert body into XML" do
+          RightSignature::configuration = {: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>')
+          RightSignature::OauthConnection.should_receive(:request).with(:put, "/path", "<document><something>else</something><page>1</page></document>", {}).and_return(@net_http_response)
+          RightSignature::Connection.put("/path", {:document => {:something => "else", :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"}
+          response = Net::HTTPSuccess.new('1.1', 200, 'OK')
+          response.stub(:body).and_return('<document><subject>My Subject</subject></document>')
+          RightSignature::OauthConnection.should_receive(:request).with(:put, "/path", "<document><something>else</something><page>1</page></document>", {}).and_return(response)
+          RightSignature::Connection.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
+          RightSignature::configuration = {:api_token => 'token'}
+          RightSignature::TokenConnection.should_receive(:request).with(:put, "/path", {:body => "<document><something>else</something><page>1</page></document>", :headers => {"User-Agent" => "me"}}).and_return(@httparty_response)
+          RightSignature::Connection.put("/path", {:document => {:something => "else", :page => 1}}, {"User-Agent" => "me"})
+        end
+
+        it "should return converted parsed_response from response" do
+          RightSignature::configuration = {:api_token => 'token'}
+          @httparty_response.should_receive(:parsed_response).and_return({'document' => {'subject' => "My Subject"}})
+          RightSignature::TokenConnection.stub(:request).and_return(@httparty_response)
+          RightSignature::Connection.put("/path", {:document => {:something => "else", :page => 1}}).should == {'document' => {'subject' => "My Subject"}}
+        end
+      end
+    end
     
   end
 end

data/spec/oauth_connnection_spec.rb

@@ -6,8 +6,19 @@ describe RightSignature::OauthConnection do
     @access_token_mock = mock(OAuth::AccessToken)
   end
 
-  describe "access_token" do
-    it "should create OAuth access token with credentials" do
+  describe "oauth_consumer" do
+    after do
+      # Reset caching of oauth_consumer
+      RightSignature::OauthConnection.instance_variable_set("@oauth_consumer", nil)
+    end
+
+    it "should raise error if no configuration is set" do
+      RightSignature::configuration = {}
+      lambda{RightSignature::OauthConnection.oauth_consumer}.should raise_error(Exception, "Please set load_configuration with consumer_key, consumer_secret, access_token, access_secret")
+    end
+    
+    it "should return consumer if consumer_key and consumer_secret is set" do
+      RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098"}
       OAuth::Consumer.should_receive(:new).with(
         "Consumer123",
         "Secret098",
@@ -19,13 +30,79 @@ describe RightSignature::OauthConnection do
          :access_token_path =>'/oauth/access_token', 
          :request_token_path=>'/oauth/request_token'
         }).and_return(@consumer_mock)
+      RightSignature::OauthConnection.oauth_consumer.should == @consumer_mock
+    end
+  end
+
+  describe "access_token" do
+    after do
+      # Reset caching of oauth_consumer
+      RightSignature::OauthConnection.instance_variable_set("@access_token", nil)
+      RightSignature::OauthConnection.instance_variable_set("@oauth_consumer", nil)
+    end
+    
+    it "should raise error if access_token is not set" do
+      RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_secret => "Secret098"}
+      lambda{RightSignature::OauthConnection.access_token}.should raise_error(Exception, "Please set load_configuration with consumer_key, consumer_secret, access_token, access_secret")
+    end
+
+    it "should raise error if access_secret is not set" do
+      RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098"}
+      lambda{RightSignature::OauthConnection.access_token}.should raise_error(Exception, "Please set load_configuration with consumer_key, consumer_secret, access_token, access_secret")
+    end
+    
+    it "should create OAuth access token with credentials" do
+      RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+      OAuth::Consumer.should_receive(:new).and_return(@consumer_mock)
       OAuth::AccessToken.should_receive(:new).with(@consumer_mock, 'AccessToken098', 'AccessSecret123')
 
       RightSignature::OauthConnection.access_token
     end
+    
+    describe "set_access_token" do
+      it "should create new access_token with given token and secret" do
+        OAuth::Consumer.stub(:new).and_return(@consumer_mock)
+        OAuth::AccessToken.should_receive(:new).with(@consumer_mock, "newAToken", "newASecret").and_return(@access_token_mock)
+
+        RightSignature::OauthConnection.set_access_token("newAToken","newASecret")
+        RightSignature::OauthConnection.access_token.should == @access_token_mock
+      end
+    end
+  end
+  
+  describe "new_request_token" do
+    it "should generate new RequestToken from consumer" do
+      request_mock = mock(OAuth::RequestToken)
+      OAuth::Consumer.stub(:new).and_return(@consumer_mock)
+      @consumer_mock.should_receive(:get_request_token).and_return(request_mock)
+      RightSignature::OauthConnection.new_request_token
+      RightSignature::OauthConnection.request_token.should == request_mock
+    end
+  end
+
+  describe "generate_access_token" do
+    it "should raise error if there is no request_token" do
+      # Reset request_token cache"
+      RightSignature::OauthConnection.instance_variable_set("@request_token", nil)
+      lambda{RightSignature::OauthConnection.generate_access_token("verifi123")}.should raise_error(Exception, "Please set request token with new_request_token")
+    end
+
+    it "should get access token from request token with given verifier" do
+      request_token_mock = mock(OAuth::RequestToken)
+      request_token_mock.should_receive(:get_access_token).with({:oauth_verifier => "verifi123"}).and_return(@access_token_mock)
+      RightSignature::OauthConnection.instance_variable_set("@request_token", request_token_mock)
+
+      RightSignature::OauthConnection.generate_access_token("verifi123")
+      RightSignature::OauthConnection.access_token.should == @access_token_mock
+    end
   end
 
   describe "request" do
+    it "should raise error if no configuration is set" do
+      RightSignature::configuration = {}
+      lambda{RightSignature::OauthConnection.request(:get, "path", {"User-Agent" => 'My own'})}.should raise_error(Exception, "Please set load_configuration with consumer_key, consumer_secret, access_token, access_secret")
+    end
+    
     it "should create GET request with access token and path with custom headers as 3rd argument" do
       @access_token_mock.should_receive(:get).with('path', {"User-Agent" => 'My own', "Accept"=>"*/*", "content-type"=>"application/xml"})
       RightSignature::OauthConnection.stub(:access_token).and_return(@access_token_mock)

data/spec/template_spec.rb

@@ -301,10 +301,10 @@ describe RightSignature::Template do
           ]
         }}).and_return(@sent_document_response)
       RightSignature::Connection.should_receive(:get).with("/api/documents/ABCDEFGH123/signer_links.xml", {}).and_return({"document" => {
-        "signer_links" => [
-          {"signer_link" => {"name" => "John Bellingham", "role" => "signer_A", "signer_token" => "slkfj2"}},
-          {"signer_link" => {"name" => "Tim Else", "role" => "signer_B", "signer_token" => "asfd1"}}
-        ]
+        "signer_links" => {"signer_link" => [
+          {"name" => "John Bellingham", "role" => "signer_A", "signer_token" => "slkfj2"},
+          {"name" => "Tim Else", "role" => "signer_B", "signer_token" => "asfd1"}
+        ]}
       }})
       
       
@@ -331,10 +331,10 @@ describe RightSignature::Template do
           ]
         }}).and_return(@sent_document_response)
       RightSignature::Connection.should_receive(:get).with("/api/documents/ABCDEFGH123/signer_links.xml", {}).and_return({"document" => {
-        "signer_links" => [
-          {"signer_link" => {"name" => "John Bellingham", "email" => "dontchange@example.com", "role" => "signer_A", "signer_token" => "slkfj2"}},
-          {"signer_link" => {"name" => "Tim Else", "role" => "signer_B", "signer_token" => "asfd1"}}
-        ]
+        "signer_links" => {"signer_link" => [
+          {"name" => "John Bellingham", "email" => "dontchange@example.com", "role" => "signer_A", "signer_token" => "slkfj2"},
+          {"name" => "Tim Else", "role" => "signer_B", "signer_token" => "asfd1"}
+        ]}
       }})
       
       results = RightSignature::Template.send_as_embedded_signers("TGUID", [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rightsignature
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-26 00:00:00.000000000 Z
+date: 2012-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler