rightsignature 0.1.8 → 1.0.0

data/lib/rightsignature/version.rb

@@ -1,3 +1,3 @@
 module RightSignature
-  VERSION = "0.1.8"
+  VERSION = "1.0.0"
 end

data/spec/account_spec.rb

@@ -3,52 +3,52 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe RightSignature::Account do
   describe "user_details" do
     it "should GET /api/users/user_details.xml" do
-      RightSignature::Connection.should_receive(:get).with('/api/users/user_details.xml')
-      RightSignature::Account.user_details
+      @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
-      RightSignature::Connection.should_receive(:post).with('/api/users.xml', {:user => {:name => "Jimmy Cricket", :email => "jimmy@example.com"}})
-      RightSignature::Account.add_user("Jimmy Cricket", "jimmy@example.com")
+      @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
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {})
-      RightSignature::Account.usage_report
+      @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
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:since => "week"})
-      RightSignature::Account.usage_report("week")
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "week"})
+      @rs.usage_report("week")
 
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:since => "month"})
-      RightSignature::Account.usage_report("month")
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "month"})
+      @rs.usage_report("month")
 
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:since => "day"})
-      RightSignature::Account.usage_report("day")
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:since => "day"})
+      @rs.usage_report("day")
 
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {})
-      RightSignature::Account.usage_report("1/4/90")
+      @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
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
-      RightSignature::Account.usage_report(nil, true)
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
+      @rs.usage_report(nil, true)
 
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "false"})
-      RightSignature::Account.usage_report(nil, false)
+      @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
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
-      RightSignature::Account.usage_report(nil, true)
+      @rs.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "true"})
+      @rs.usage_report(nil, true)
 
-      RightSignature::Connection.should_receive(:get).with('/api/account/usage_report.xml', {:signed => "false"})
-      RightSignature::Account.usage_report(nil, false)
+      @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

@@ -2,23 +2,26 @@ 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")
+    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' 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'}})
+  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.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
-    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"}})
+    token_connection = RightSignature::TokenConnection.new('APITOKEN')
+    token_connection.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' 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 => []}}})
+  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.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

@@ -1,98 +1,98 @@
 require File.dirname(__FILE__) + '/../lib/rightsignature'
 
-describe RightSignature::configuration do
+describe RightSignature 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"
+      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
-      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"
+      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
-      RightSignature::load_configuration()
-      lambda {RightSignature::check_credentials}.should raise_error
+      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
-      RightSignature::load_configuration(:api_token => " ")
-      lambda {RightSignature::check_credentials}.should raise_error
+      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
-      RightSignature::load_configuration(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
-      lambda {RightSignature::check_credentials}.should raise_error
+      rs = RightSignature::Connection.new(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      lambda {rs.check_credentials}.should raise_error
 
-      RightSignature::load_configuration(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
-      lambda {RightSignature::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
 
-      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
-      lambda {RightSignature::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
 
-      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken")
-      lambda {RightSignature::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
-      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
-      RightSignature::check_credentials
+      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
-      RightSignature::load_configuration(:api_token => "asdf")
-      RightSignature::check_credentials
+      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
-      RightSignature::load_configuration()
-      RightSignature::has_api_token?.should be_false
+      rs = RightSignature::Connection.new()
+      rs.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
+      rs = RightSignature::Connection.new(:api_token => "   ")
+      rs.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
+      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
-      RightSignature::load_configuration()
-      RightSignature::has_oauth_credentials?.should be_false
+      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
-      RightSignature::load_configuration(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
-      RightSignature::has_oauth_credentials?.should be_false
+      rs = RightSignature::Connection.new(:consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
+      rs.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
+      rs = RightSignature::Connection.new(:consumer_key => "key", :access_token => "atoken", :access_secret => "asecret")
+      rs.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
+      rs = RightSignature::Connection.new(:consumer_key => "key", :consumer_secret => "secret", :access_secret => "asecret")
+      rs.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
+      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
-      RightSignature::load_configuration(:consumer_key => "key", :consumer_secret => "secret", :access_token => "atoken", :access_secret => "asecret")
-      RightSignature::has_oauth_credentials?.should be_true
+      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

@@ -10,58 +10,58 @@ describe RightSignature::Connection do
   describe "GET" 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")
+        @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 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.get("/path")
+      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 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.get("/path")
+      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
-      RightSignature::configuration = nil
-      lambda{RightSignature::Connection.get("/path")}.should raise_error
+      @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
-        RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+        @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>')
-        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})
+        @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
-        RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+        @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>')
-        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"}}
+        @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
-        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(@httparty_response)
-        RightSignature::Connection.get("/path", {:q => 'search me', :page => 1}, {"User-Agent" => "me"})
+        @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
-        RightSignature::configuration = {:api_token => 'token'}
+        @rs = RightSignature::Connection.new({: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.get("/path", {:q => 'search me', :page => 1}).should == {'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
@@ -69,31 +69,31 @@ describe RightSignature::Connection do
   describe "POST" do
     describe "connection method" do
       before do
-        RightSignature::TokenConnection.stub(:request => @net_http_response)
-        RightSignature::OauthConnection.stub(:request => @httparty_response)
+        @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 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")
+      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 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")
+      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 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")
+      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
-        RightSignature::configuration = nil
-        lambda{RightSignature::Connection.post("/path")}.should raise_error
+        @rs = RightSignature::Connection.new({})
+        lambda{@rs.post("/path")}.should raise_error
       end
     end
 
@@ -101,59 +101,59 @@ describe RightSignature::Connection do
     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")
+          @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 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")
+        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 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")
+        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
-        RightSignature::configuration = nil
-        lambda{RightSignature::Connection.delete("/path")}.should raise_error
+        @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
-          RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+          @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>')
-          RightSignature::OauthConnection.should_receive(:request).with(:delete, "/path", {}).and_return(response)
-          RightSignature::Connection.delete("/path").should == {'document' => {'subject' => "My Subject"}}
+          @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
-          RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+          @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>')
-          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"}}
+          @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
-          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"})
+          @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
-          RightSignature::configuration = {:api_token => 'token'}
+          @rs = RightSignature::Connection.new({: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"}}
+          @rs.token_connection.stub(:request).and_return(@httparty_response)
+          @rs.delete("/path").should == {'document' => {'subject' => "My Subject"}}
         end
       end
     end
@@ -161,58 +161,58 @@ describe RightSignature::Connection do
     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")
+          @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 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")
+        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 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")
+        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
-        RightSignature::configuration = nil
-        lambda{RightSignature::Connection.put("/path")}.should raise_error
+        @rs = RightSignature::Connection.new({})
+        lambda{@rs.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"}
+          @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>')
-          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}})
+          @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
-          RightSignature::configuration = {:consumer_key => "Consumer123", :consumer_secret => "Secret098", :access_token => "AccessToken098", :access_secret => "AccessSecret123"}
+          @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>')
-          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"}}
+          @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
-          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"})
+          @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
-          RightSignature::configuration = {:api_token => 'token'}
+          @rs = RightSignature::Connection.new({: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"}}
+          @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