songkick-oauth2-provider 0.10.2 → 0.10.3

data/spec/request_helpers.rb

@@ -1,57 +1,61 @@
+require "socket"
+
 module RequestHelpers
-  require 'net/http'
-  
+  require "net/http"
+
+  SERVER_PORT = TCPServer.new(0).addr[1]
+
   def querystring(params)
-    params.map { |k,v| "#{ CGI.escape k.to_s }=#{ CGI.escape v.to_s }" }.join('&')
+    params.map { |k,v| "#{ CGI.escape k.to_s }=#{ CGI.escape v.to_s }" }.join("&")
   end
-  
+
   def get(query_params)
-    uri = URI.parse('http://localhost:8000/authorize?' + querystring(query_params))
+    uri = URI.parse("http://localhost:#{SERVER_PORT}/authorize?" + querystring(query_params))
     Net::HTTP.get_response(uri)
   end
-  
+
   def allow_or_deny(query_params)
-    Net::HTTP.post_form(URI.parse('http://localhost:8000/allow'), query_params)
+    Net::HTTP.post_form(URI.parse("http://localhost:#{SERVER_PORT}/allow"), query_params)
   end
-  
+
   def post_basic_auth(auth_params, query_params)
-    url = "http://#{ auth_params['client_id'] }:#{ auth_params['client_secret'] }@localhost:8000/authorize"
+    url = "http://#{ auth_params["client_id"] }:#{ auth_params["client_secret"] }@localhost:#{SERVER_PORT}/authorize"
     Net::HTTP.post_form(URI.parse(url), query_params)
   end
-  
+
   def post(body_params, query_params = {})
-    uri = URI.parse('http://localhost:8000/authorize?' + querystring(query_params))
+    uri = URI.parse("http://localhost:#{SERVER_PORT}/authorize?" + querystring(query_params))
     Net::HTTP.start(uri.host, uri.port) do |http|
-      http.post(uri.path + '?' + uri.query.to_s, querystring(body_params))
+      http.post(uri.path + "?" + uri.query.to_s, querystring(body_params))
     end
   end
-  
+
   def validate_response(response, status, body)
     response.code.to_i.should == status
     response.body.should == body
-    response['Cache-Control'].should == 'no-store'
+    response["Cache-Control"].should == "no-store"
   end
-  
+
   def validate_json_response(response, status, body)
     response.code.to_i.should == status
     JSON.parse(response.body).should == body
-    response['Content-Type'].should == 'application/json'
-    response['Cache-Control'].should == 'no-store'
+    response["Content-Type"].should == "application/json"
+    response["Cache-Control"].should == "no-store"
   end
-  
+
   def mock_request(request_class, stubs = {})
-    mock_request = mock(request_class)
+    mock_request = double(request_class)
     method_stubs = {
       :redirect?        => false,
       :response_body    => nil,
       :response_headers => {},
       :response_status  => 200
     }.merge(stubs)
-    
+
     method_stubs.each do |method, value|
       mock_request.should_receive(method).and_return(value)
     end
-    
+
     mock_request
   end
 end

data/spec/songkick/oauth2/model/authorization_spec.rb

@@ -6,112 +6,112 @@ describe Songkick::OAuth2::Model::Authorization do
   let(:owner)    { Factory :owner }
   let(:user)     { Factory :owner }
   let(:tester)   { Factory(:owner) }
-  
+
   let(:authorization) do
     create_authorization(:owner => tester, :client => client)
   end
-  
-  it "is vaid" do
+
+  it "is valid" do
     authorization.should be_valid
   end
-  
+
   it "is not valid without a client" do
     authorization.client = nil
     authorization.should_not be_valid
   end
-  
+
   it "is not valid without an owner" do
     authorization.owner = nil
     authorization.should_not be_valid
   end
-  
+
   describe "when there are existing authorizations" do
     before do
       create_authorization(
         :owner         => user,
         :client        => impostor,
         :access_token  => 'existing_access_token')
-        
+
       create_authorization(
         :owner         => user,
         :client        => client,
         :code          => 'existing_code')
-        
+
       create_authorization(
         :owner         => owner,
         :client        => client,
         :refresh_token => 'existing_refresh_token')
     end
-    
+
     it "is valid if its access_token is unique" do
       authorization.should be_valid
     end
-    
+
     it "is valid if both access_tokens are nil" do
       Songkick::OAuth2::Model::Authorization.first.update_attribute(:access_token, nil)
       authorization.access_token = nil
       authorization.should be_valid
     end
-    
+
     it "is not valid if its access_token is not unique" do
       authorization.access_token = 'existing_access_token'
       authorization.should_not be_valid
     end
-    
+
     it "is valid if it has a unique code for its client" do
       authorization.client = impostor
       authorization.code = 'existing_code'
       authorization.should be_valid
     end
-    
+
     it "is not valid if it does not have a unique client and code" do
       authorization.code = 'existing_code'
       authorization.should_not be_valid
     end
-    
+
     it "is valid if it has a unique refresh_token for its client" do
       authorization.client = impostor
       authorization.refresh_token = 'existing_refresh_token'
       authorization.should be_valid
     end
-    
+
     it "is not valid if it does not have a unique client and refresh_token" do
       authorization.refresh_token = 'existing_refresh_token'
       authorization.should_not be_valid
     end
-    
+
     describe ".create_code" do
       before { Songkick::OAuth2.stub(:random_string).and_return('existing_code', 'new_code') }
-      
+
       it "returns the first code the client has not used" do
         Songkick::OAuth2::Model::Authorization.create_code(client).should == 'new_code'
       end
-      
+
       it "returns the first code another client has not used" do
         Songkick::OAuth2::Model::Authorization.create_code(impostor).should == 'existing_code'
       end
     end
-    
+
     describe ".create_access_token" do
       before { Songkick::OAuth2.stub(:random_string).and_return('existing_access_token', 'new_access_token') }
-      
+
       it "returns the first unused token it can find" do
         Songkick::OAuth2::Model::Authorization.create_access_token.should == 'new_access_token'
       end
     end
-    
+
     describe ".create_refresh_token" do
       before { Songkick::OAuth2.stub(:random_string).and_return('existing_refresh_token', 'new_refresh_token') }
-      
+
       it "returns the first refresh_token the client has not used" do
         Songkick::OAuth2::Model::Authorization.create_refresh_token(client).should == 'new_refresh_token'
       end
-      
+
       it "returns the first refresh_token another client has not used" do
         Songkick::OAuth2::Model::Authorization.create_refresh_token(impostor).should == 'existing_refresh_token'
       end
     end
-    
+
     describe "duplicate records" do
       it "raises an error if a duplicate authorization is created" do
         lambda {
@@ -121,7 +121,7 @@ describe Songkick::OAuth2::Model::Authorization do
           authorization.save
         }.should raise_error
       end
-      
+
       it "finds an existing record after a race" do
         user.stub(:oauth2_authorization_for) do
           user.unstub(:oauth2_authorization_for)
@@ -133,19 +133,19 @@ describe Songkick::OAuth2::Model::Authorization do
       end
     end
   end
-  
+
   describe "#exchange!" do
     it "saves the record" do
       authorization.should_receive(:save!)
       authorization.exchange!
     end
-    
+
     it "uses its helpers to find unique tokens" do
       Songkick::OAuth2::Model::Authorization.should_receive(:create_access_token).and_return('access_token')
       authorization.exchange!
       authorization.access_token.should == 'access_token'
     end
-    
+
     it "updates the tokens correctly" do
       authorization.exchange!
       authorization.should be_valid
@@ -153,84 +153,84 @@ describe Songkick::OAuth2::Model::Authorization do
       authorization.refresh_token.should be_nil
     end
   end
-  
+
   describe "#expired?" do
     it "returns false when not expiry is set" do
       authorization.should_not be_expired
     end
-    
+
     it "returns false when expiry is in the future" do
       authorization.expires_at = 2.days.from_now
       authorization.should_not be_expired
     end
-    
+
     it "returns true when expiry is in the past" do
       authorization.expires_at = 2.days.ago
       authorization.should be_expired
     end
   end
-  
+
   describe "#grants_access?" do
     it "returns true given the right user" do
-      authorization.grants_access?(tester).should be_true
+      authorization.grants_access?(tester).should be(true)
     end
-    
+
     it "returns false given the wrong user" do
-      authorization.grants_access?(user).should be_false
+      authorization.grants_access?(user).should be(false)
     end
-    
+
     describe "when the authorization is expired" do
       before { authorization.expires_at = 2.days.ago }
-      
+
       it "returns false in all cases" do
-        authorization.grants_access?(tester).should be_false
-        authorization.grants_access?(user).should be_false
+        authorization.grants_access?(tester).should be(false)
+        authorization.grants_access?(user).should be(false)
       end
     end
   end
-  
+
   describe "with a scope" do
     before { authorization.scope = 'foo bar' }
-    
+
     describe "#in_scope?" do
       it "returns true for authorized scopes" do
         authorization.should be_in_scope('foo')
         authorization.should be_in_scope('bar')
       end
-      
+
       it "returns false for unauthorized scopes" do
         authorization.should_not be_in_scope('qux')
         authorization.should_not be_in_scope('fo')
       end
     end
-    
+
     describe "#grants_access?" do
       it "returns true given the right user and all authorization scopes" do
-        authorization.grants_access?(tester, 'foo', 'bar').should be_true
+        authorization.grants_access?(tester, 'foo', 'bar').should be(true)
       end
-      
+
       it "returns true given the right user and some authorization scopes" do
-        authorization.grants_access?(tester, 'bar').should be_true
+        authorization.grants_access?(tester, 'bar').should be(true)
       end
-      
+
       it "returns false given the right user and some unauthorization scopes" do
-        authorization.grants_access?(tester, 'foo', 'bar', 'qux').should be_false
+        authorization.grants_access?(tester, 'foo', 'bar', 'qux').should be(false)
       end
-      
+
       it "returns false given an unauthorized scope" do
-        authorization.grants_access?(tester, 'qux').should be_false
+        authorization.grants_access?(tester, 'qux').should be(false)
       end
-      
+
       it "returns true given the right user" do
-        authorization.grants_access?(tester).should be_true
+        authorization.grants_access?(tester).should be(true)
       end
-      
+
       it "returns false given the wrong user" do
-        authorization.grants_access?(user).should be_false
+        authorization.grants_access?(user).should be(false)
       end
-      
+
       it "returns false given the wrong user and an authorized scope" do
-        authorization.grants_access?(user, 'foo').should be_false
+        authorization.grants_access?(user, 'foo').should be(false)
       end
     end
   end

data/spec/songkick/oauth2/model/client_spec.rb

@@ -6,47 +6,47 @@ describe Songkick::OAuth2::Model::Client do
     @owner  = Factory(:owner)
     Songkick::OAuth2::Model::Authorization.for(@owner, @client)
   end
-  
+
   it "is valid" do
     @client.should be_valid
   end
-  
+
   it "is invalid without a name" do
     @client.name = nil
     @client.should_not be_valid
   end
-  
+
   it "is invalid without a redirect_uri" do
     @client.redirect_uri = nil
     @client.should_not be_valid
   end
-  
+
   it "is invalid with a non-URI redirect_uri" do
     @client.redirect_uri = 'foo'
     @client.should_not be_valid
   end
-  
+
   # http://en.wikipedia.org/wiki/HTTP_response_splitting
   it "is invalid if the URI contains HTTP line breaks" do
     @client.redirect_uri = "http://example.com/c\r\nb"
     @client.should_not be_valid
   end
-  
+
   it "cannot mass-assign client_id" do
     @client.update_attributes(:client_id => 'foo')
     @client.client_id.should_not == 'foo'
   end
-  
+
   it "cannot mass-assign client_secret" do
     @client.update_attributes(:client_secret => 'foo')
     @client.client_secret.should_not == 'foo'
   end
-  
+
   it "has client_id and client_secret filled in" do
     @client.client_id.should_not be_nil
     @client.client_secret.should_not be_nil
   end
-  
+
   it "destroys its authorizations on destroy" do
     @client.destroy
     Songkick::OAuth2::Model::Authorization.count.should be_zero

data/spec/songkick/oauth2/model/helpers_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Songkick::OAuth2::Model::Helpers do
+  subject { Songkick::OAuth2::Model::Helpers }
+
+  describe '.count' do
+    let(:owner) { Factory(:owner) }
+
+    before do
+      3.times { Factory(:client, :owner => owner) }
+    end
+
+    context 'when conditions are not passed' do
+      it 'returns count of total rows' do
+        subject.count(owner.oauth2_clients).should == 3
+      end
+    end
+
+    context 'when conditions are passed' do
+      it 'returns count of rows satisfying supplied conditions' do
+        subject.count(Songkick::OAuth2::Model::Client, :client_id => Songkick::OAuth2::Model::Client.first.client_id).should == 1
+      end
+    end
+  end
+end
+

data/spec/songkick/oauth2/model/resource_owner_spec.rb

@@ -5,29 +5,29 @@ describe Songkick::OAuth2::Model::ResourceOwner do
     @owner  = Factory(:owner)
     @client = Factory(:client)
   end
-  
+
   describe "#grant_access!" do
     it "raises an error when passed an invalid client argument" do
       lambda{ @owner.grant_access!('client') }.should raise_error(ArgumentError)
     end
-    
+
     it "creates an authorization between the owner and the client" do
       authorization = Songkick::OAuth2::Model::Authorization.__send__(:new)
       Songkick::OAuth2::Model::Authorization.should_receive(:new).and_return(authorization)
       @owner.grant_access!(@client)
     end
-    
-    # This is hacky, but mocking ActiveRecord turns out to get messy
+
+    # This is hacky, but doubleing ActiveRecord turns out to get messy
     it "creates an Authorization" do
       Songkick::OAuth2::Model::Authorization.count.should == 0
       @owner.grant_access!(@client)
       Songkick::OAuth2::Model::Authorization.count.should == 1
     end
-    
+
     it "returns the authorization" do
       @owner.grant_access!(@client).should be_kind_of(Songkick::OAuth2::Model::Authorization)
     end
-    
+
     # This method must return the same owner object, since the assertion
     # handler may modify it -- either by changing its attributes or by extending
     # it with new methods. These changes must be returned to the app calling the
@@ -36,34 +36,34 @@ describe Songkick::OAuth2::Model::ResourceOwner do
       authorization = @owner.grant_access!(@client)
       authorization.owner.should be_equal(@owner)
     end
-    
+
     it "sets the duration of the authorization" do
       authorization = @owner.grant_access!(@client, :duration => 5.hours)
       authorization.expires_at.to_i.should == (Time.now + 5.hours.to_i).to_i
     end
   end
-  
+
   describe "when there is an existing authorization" do
     before do
       @authorization = create_authorization(:owner => @owner, :client => @client)
     end
-    
+
     it "does not create a new one" do
       Songkick::OAuth2::Model::Authorization.should_not_receive(:new)
       @owner.grant_access!(@client)
     end
-    
+
     it "updates the authorization with scopes" do
       @owner.grant_access!(@client, :scopes => ['foo', 'bar'])
       @authorization.reload
       @authorization.scopes.should == Set.new(['foo', 'bar'])
     end
-    
+
     describe "with scopes" do
       before do
         @authorization.update_attribute(:scope, 'foo bar')
       end
-      
+
       it "merges the new scopes with the existing ones" do
         @owner.grant_access!(@client, :scopes => ['qux'])
         @authorization.reload
@@ -78,7 +78,7 @@ describe Songkick::OAuth2::Model::ResourceOwner do
       end
     end
   end
-  
+
   it "destroys its authorizations on destroy" do
     Songkick::OAuth2::Model::Authorization.for(@owner, @client)
     @owner.destroy