doorkeeper 1.1.0 → 1.2.0

data/spec/lib/oauth/helpers/uri_checker_spec.rb

@@ -4,73 +4,73 @@ require 'doorkeeper/oauth/helpers/uri_checker'
 
 module Doorkeeper::OAuth::Helpers
   describe URIChecker do
-    describe ".valid?" do
-      it "is valid for valid uris" do
-        uri = "http://app.co"
+    describe '.valid?' do
+      it 'is valid for valid uris' do
+        uri = 'http://app.co'
         expect(URIChecker.valid?(uri)).to be_true
       end
 
-      it "is valid if include path param" do
-        uri = "http://app.co/path"
+      it 'is valid if include path param' do
+        uri = 'http://app.co/path'
         expect(URIChecker.valid?(uri)).to be_true
       end
 
-      it "is valid if include query param" do
-        uri = "http://app.co/?query=1"
+      it 'is valid if include query param' do
+        uri = 'http://app.co/?query=1'
         expect(URIChecker.valid?(uri)).to be_true
       end
 
-      it "is invalid if uri includes fragment" do
-        uri = "http://app.co/test#fragment"
+      it 'is invalid if uri includes fragment' do
+        uri = 'http://app.co/test#fragment'
         expect(URIChecker.valid?(uri)).to be_false
       end
 
-      it "is invalid if scheme is missing" do
-        uri = "app.co"
+      it 'is invalid if scheme is missing' do
+        uri = 'app.co'
         expect(URIChecker.valid?(uri)).to be_false
       end
 
-      it "is invalid if is a relative uri" do
-        uri = "/abc/123"
+      it 'is invalid if is a relative uri' do
+        uri = '/abc/123'
         expect(URIChecker.valid?(uri)).to be_false
       end
 
-      it "is invalid if is not a url" do
-        uri = "http://"
+      it 'is invalid if is not a url' do
+        uri = 'http://'
         expect(URIChecker.valid?(uri)).to be_false
       end
     end
 
-    describe ".matches?" do
-      it "is true if both url matches" do
+    describe '.matches?' do
+      it 'is true if both url matches' do
         uri = client_uri = 'http://app.co/aaa'
         expect(URIChecker.matches?(uri, client_uri)).to be_true
       end
 
-      it "ignores query parameter on comparsion" do
+      it 'ignores query parameter on comparsion' do
         uri = 'http://app.co/?query=hello'
         client_uri = 'http://app.co'
         expect(URIChecker.matches?(uri, client_uri)).to be_true
       end
 
-      context "allows wildcard redirect_uri" do
+      context 'allows wildcard redirect_uri' do
         before do
-          Doorkeeper.configuration.stub(wildcard_redirect_uri: true )
+          Doorkeeper.configuration.stub(wildcard_redirect_uri: true)
         end
 
-        it "ignores query parameter on comparison" do
+        it 'ignores query parameter on comparison' do
           uri = 'http://app.co/?query=hello'
           client_uri = 'http://app.co'
           expect(URIChecker.matches?(uri, client_uri)).to be true
         end
 
-        it "doesn't allow non-matching domains through" do
+        it 'doesn\'t allow non-matching domains through' do
           uri = 'http://app.abc/?query=hello'
           client_uri = 'http://app.co'
           expect(URIChecker.matches?(uri, client_uri)).to be false
         end
 
-        it "doesn't allow non-matching domains that don't start at the beginning" do
+        it 'doesn\'t allow non-matching domains that don\'t start at the beginning' do
           uri = 'http://app.co/?query=hello'
           client_uri = 'http://example.com?app.co=test'
           expect(URIChecker.matches?(uri, client_uri)).to be false
@@ -78,46 +78,46 @@ module Doorkeeper::OAuth::Helpers
       end
     end
 
-    describe ".valid_for_authorization?" do
-      it "is true if valid and matches" do
+    describe '.valid_for_authorization?' do
+      it 'is true if valid and matches' do
         uri = client_uri = 'http://app.co/aaa'
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_true
       end
 
-      it "is false if valid and mismatches" do
+      it 'is false if valid and mismatches' do
         uri = 'http://app.co/aaa'
         client_uri = 'http://app.co/bbb'
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_false
       end
 
-      it "is true if valid and included in array" do
+      it 'is true if valid and included in array' do
         uri = 'http://app.co/aaa'
         client_uri = "http://example.com/bbb\nhttp://app.co/aaa"
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_true
       end
 
-      it "is false if valid and not included in array" do
+      it 'is false if valid and not included in array' do
         uri = 'http://app.co/aaa'
         client_uri = "http://example.com/bbb\nhttp://app.co/cc"
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_false
       end
 
-      it "is true if valid and matches" do
+      it 'is true if valid and matches' do
         uri = client_uri = 'http://app.co/aaa'
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be true
       end
 
-      it "is false if invalid" do
+      it 'is false if invalid' do
         uri = client_uri = 'http://app.co/aaa?waffles=abc'
         expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be false
       end
 
-      context "allows wildcard redirect_uri" do
+      context 'allows wildcard redirect_uri' do
         before do
-          Doorkeeper.configuration.stub(wildcard_redirect_uri: true )
+          Doorkeeper.configuration.stub(wildcard_redirect_uri: true)
         end
 
-        it "is true if valid, matches and contains a query parameter" do
+        it 'is true if valid, matches and contains a query parameter' do
           uri = client_uri = 'http://app.co/aaa?waffles=abc'
           expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be true
         end

data/spec/lib/oauth/invalid_token_response_spec.rb

@@ -15,13 +15,13 @@ module Doorkeeper::OAuth
 
     describe :from_access_token do
       it 'revoked' do
-        response = InvalidTokenResponse.from_access_token double(:revoked? => true, :expired? => true)
-        expect(response.description).to include("revoked")
+        response = InvalidTokenResponse.from_access_token double(revoked?: true, expired?: true)
+        expect(response.description).to include('revoked')
       end
 
       it 'expired' do
-        response = InvalidTokenResponse.from_access_token double(:revoked? => false, :expired? => true)
-        expect(response.description).to include("expired")
+        response = InvalidTokenResponse.from_access_token double(revoked?: false, expired?: true)
+        expect(response.description).to include('expired')
       end
     end
   end

data/spec/lib/oauth/password_access_token_request_spec.rb

@@ -2,33 +2,33 @@ require 'spec_helper_integration'
 
 module Doorkeeper::OAuth
   describe PasswordAccessTokenRequest do
-    let(:server) { double :server, :default_scopes => Doorkeeper::OAuth::Scopes.new, :access_token_expires_in => 2.hours, :refresh_token_enabled? => false }
+    let(:server) { double :server, default_scopes: Doorkeeper::OAuth::Scopes.new, access_token_expires_in: 2.hours, refresh_token_enabled?: false }
     let(:credentials) { Client::Credentials.new(client.uid, client.secret) }
     let(:client) { FactoryGirl.create(:application) }
-    let(:owner)  { double :owner, :id => 99 }
+    let(:owner)  { double :owner, id: 99 }
 
     subject do
       PasswordAccessTokenRequest.new(server, credentials, owner)
     end
 
     it 'issues a new token for the client' do
-      expect {
+      expect do
         subject.authorize
-      }.to change { client.access_tokens.count }.by(1)
+      end.to change { client.access_tokens.count }.by(1)
     end
 
     it 'issues a new token without a client' do
-      expect {
+      expect do
         subject.credentials = nil
         subject.authorize
-      }.to change { Doorkeeper::AccessToken.count }.by(1)
+      end.to change { Doorkeeper::AccessToken.count }.by(1)
     end
 
     it 'does not issue a new token with an invalid client' do
-      expect {
+      expect do
         subject.client = nil
         subject.authorize
-      }.to_not change { Doorkeeper::AccessToken.count }
+      end.to_not change { Doorkeeper::AccessToken.count }
 
       expect(subject.error).to eq(:invalid_client)
     end
@@ -44,9 +44,9 @@ module Doorkeeper::OAuth
       expect(subject).to be_valid
     end
 
-    describe "with scopes" do
+    describe 'with scopes' do
       subject do
-        PasswordAccessTokenRequest.new(server, client, owner, :scope => 'public')
+        PasswordAccessTokenRequest.new(server, client, owner, scope: 'public')
       end
 
       it 'validates the current scope' do
@@ -56,10 +56,10 @@ module Doorkeeper::OAuth
       end
 
       it 'creates the token with scopes' do
-        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string("public"))
-        expect {
+        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string('public'))
+        expect do
           subject.authorize
-        }.to change { Doorkeeper::AccessToken.count }.by(1)
+        end.to change { Doorkeeper::AccessToken.count }.by(1)
         expect(Doorkeeper::AccessToken.last.scopes).to include('public')
       end
     end

data/spec/lib/oauth/pre_authorization_spec.rb

@@ -1,15 +1,21 @@
-require "spec_helper_integration"
+require 'spec_helper_integration'
 
 module Doorkeeper::OAuth
   describe PreAuthorization do
-    let(:server) { double :server, :default_scopes => Scopes.new, :scopes => Scopes.from_string('public') }
-    let(:client) { double :client, :redirect_uri => 'http://tst.com/auth' }
+    let(:server) {
+      server = Doorkeeper.configuration
+      server.stub(:default_scopes) { Scopes.new }
+      server.stub(:scopes) { Scopes.from_string('public') }
+      server
+    }
+
+    let(:client) { double :client, redirect_uri: 'http://tst.com/auth' }
 
     let :attributes do
       {
-        :response_type => 'code',
-        :redirect_uri => 'http://tst.com/auth',
-        :state => 'save-this'
+        response_type: 'code',
+        redirect_uri: 'http://tst.com/auth',
+        state: 'save-this'
       }
     end
 
@@ -31,6 +37,40 @@ module Doorkeeper::OAuth
       expect(subject).to be_authorizable
     end
 
+    context 'when using default grant flows' do
+      it 'accepts "code" as response type' do
+        subject.response_type = 'code'
+        expect(subject).to be_authorizable
+      end
+
+      it 'accepts "token" as response type' do
+        subject.response_type = 'token'
+        expect(subject).to be_authorizable
+      end
+    end
+
+    context 'when authorization code grant flow is disabled' do
+      before do
+        server.stub(:grant_flows) { ['implicit'] }
+      end
+
+      it 'does not accept "code" as response type' do
+        subject.response_type = 'code'
+        expect(subject).not_to be_authorizable
+      end
+    end
+
+    context 'when implicit grant flow is disabled' do
+      before do
+        server.stub(:grant_flows) { ['authorization_code'] }
+      end
+
+      it 'does not accept "token" as response type' do
+        subject.response_type = 'token'
+        expect(subject).not_to be_authorizable
+      end
+    end
+
     it 'accepts valid scopes' do
       subject.scope = 'public'
       expect(subject).to be_authorizable
@@ -48,7 +88,7 @@ module Doorkeeper::OAuth
       expect(subject).to be_authorizable
     end
 
-    it "matches the redirect uri against client's one" do
+    it 'matches the redirect uri against client\'s one' do
       subject.redirect_uri = 'http://nothesame.com'
       expect(subject).not_to be_authorizable
     end

data/spec/lib/oauth/refresh_token_request_spec.rb

@@ -2,25 +2,21 @@ require 'spec_helper_integration'
 
 module Doorkeeper::OAuth
   describe RefreshTokenRequest do
-    let(:server)         { double :server, :access_token_expires_in => 2.minutes }
-    let!(:refresh_token) { FactoryGirl.create(:access_token, :use_refresh_token => true) }
+    let(:server)         { double :server, access_token_expires_in: 2.minutes }
+    let!(:refresh_token) { FactoryGirl.create(:access_token, use_refresh_token: true) }
     let(:client)         { refresh_token.application }
     let(:credentials)    { Client::Credentials.new(client.uid, client.secret) }
 
-    subject {
-      RefreshTokenRequest.new server, refresh_token, credentials
-    }
+    subject { RefreshTokenRequest.new server, refresh_token, credentials }
 
     it 'issues a new token for the client' do
-      expect {
+      expect do
         subject.authorize
-      }.to change { client.access_tokens.count }.by(1)
+      end.to change { client.access_tokens.count }.by(1)
     end
 
     it 'revokes the previous token' do
-      expect {
-        subject.authorize
-      }.to change { refresh_token.revoked? }.from(false).to(true)
+      expect { subject.authorize } .to change { refresh_token.revoked? }.from(false).to(true)
     end
 
     it 'requires the refresh token' do
@@ -55,25 +51,19 @@ module Doorkeeper::OAuth
     end
 
     context 'clientless access tokens' do
-      let!(:refresh_token) { FactoryGirl.create(:clientless_access_token, :use_refresh_token => true) }
+      let!(:refresh_token) { FactoryGirl.create(:clientless_access_token, use_refresh_token: true) }
 
-      subject {
-        RefreshTokenRequest.new server, refresh_token, nil
-      }
+      subject { RefreshTokenRequest.new server, refresh_token, nil }
 
       it 'issues a new token without a client' do
-        expect {
-          subject.authorize
-        }.to change { Doorkeeper::AccessToken.count }.by(1)
+        expect { subject.authorize }.to change { Doorkeeper::AccessToken.count }.by(1)
       end
     end
 
     context 'with scopes' do
-      let!(:refresh_token) { FactoryGirl.create(:access_token, :use_refresh_token => true, :scopes => 'public write') }
+      let!(:refresh_token) { FactoryGirl.create(:access_token, use_refresh_token: true, scopes: 'public write') }
       let(:parameters) { {} }
-      subject {
-        RefreshTokenRequest.new server, refresh_token, credentials, parameters
-      }
+      subject { RefreshTokenRequest.new server, refresh_token, credentials, parameters }
 
       it 'transfers scopes from the old token to the new token' do
         subject.authorize

data/spec/lib/oauth/scopes_spec.rb

@@ -12,7 +12,7 @@ module Doorkeeper::OAuth
       end
 
       it 'allows you to add scopes with strings' do
-        subject.add "public"
+        subject.add 'public'
         expect(subject.all).to eq(['public'])
       end
 
@@ -29,11 +29,11 @@ module Doorkeeper::OAuth
       end
 
       it 'returns true if scope with given name is present' do
-        expect(subject.exists?("public")).to be_true
+        expect(subject.exists?('public')).to be_true
       end
 
       it 'returns false if scope with given name does not exist' do
-        expect(subject.exists?("other")).to be_false
+        expect(subject.exists?('other')).to be_false
       end
 
       it 'handles symbols' do
@@ -42,8 +42,8 @@ module Doorkeeper::OAuth
       end
     end
 
-    describe ".from_string" do
-      let(:string) { "public write" }
+    describe '.from_string' do
+      let(:string) { 'public write' }
 
       subject { Scopes.from_string(string) }
 
@@ -60,63 +60,63 @@ module Doorkeeper::OAuth
     end
 
     describe :+ do
-      it "can add to another scope object" do
-        scopes = Scopes.from_string("public") + Scopes.from_string("admin")
-        expect(scopes.all).to eq(['public', 'admin'])
+      it 'can add to another scope object' do
+        scopes = Scopes.from_string('public') + Scopes.from_string('admin')
+        expect(scopes.all).to eq(%w(public admin))
       end
 
-      it "does not change the existing object" do
-        origin = Scopes.from_string("public")
-        new_scope = origin + Scopes.from_string("admin")
-        expect(origin.to_s).to eq("public")
+      it 'does not change the existing object' do
+        origin = Scopes.from_string('public')
+        new_scope = origin + Scopes.from_string('admin')
+        expect(origin.to_s).to eq('public')
       end
 
-      it "raises an error if cannot handle addition" do
-        expect {
-          Scopes.from_string("public") + "admin"
-        }.to raise_error(NoMethodError)
+      it 'raises an error if cannot handle addition' do
+        expect do
+          Scopes.from_string('public') + 'admin'
+        end.to raise_error(NoMethodError)
       end
     end
 
     describe :== do
       it 'is equal to another set of scopes' do
-        expect(Scopes.from_string("public")).to eq(Scopes.from_string("public"))
+        expect(Scopes.from_string('public')).to eq(Scopes.from_string('public'))
       end
 
       it 'is equal to another set of scopes with no particular order' do
-        expect(Scopes.from_string("public write")).to eq(Scopes.from_string("write public"))
+        expect(Scopes.from_string('public write')).to eq(Scopes.from_string('write public'))
       end
 
       it 'differs from another set of scopes when scopes are not the same' do
-        expect(Scopes.from_string("public write")).not_to eq(Scopes.from_string("write"))
+        expect(Scopes.from_string('public write')).not_to eq(Scopes.from_string('write'))
       end
     end
 
     describe :has_scopes? do
-      subject { Scopes.from_string("public admin") }
+      subject { Scopes.from_string('public admin') }
 
-      it "returns true when at least one scope is included" do
-        expect(subject.has_scopes?(Scopes.from_string("public"))).to be_true
+      it 'returns true when at least one scope is included' do
+        expect(subject.has_scopes?(Scopes.from_string('public'))).to be_true
       end
 
-      it "returns true when all scopes are included" do
-        expect(subject.has_scopes?(Scopes.from_string("public admin"))).to be_true
+      it 'returns true when all scopes are included' do
+        expect(subject.has_scopes?(Scopes.from_string('public admin'))).to be_true
       end
 
-      it "is true if all scopes are included in any order" do
-        expect(subject.has_scopes?(Scopes.from_string("admin public"))).to be_true
+      it 'is true if all scopes are included in any order' do
+        expect(subject.has_scopes?(Scopes.from_string('admin public'))).to be_true
       end
 
-      it "is false if no scopes are included" do
-        expect(subject.has_scopes?(Scopes.from_string("notexistent"))).to be_false
+      it 'is false if no scopes are included' do
+        expect(subject.has_scopes?(Scopes.from_string('notexistent'))).to be_false
       end
 
-      it "returns false when any scope is not included" do
-        expect(subject.has_scopes?(Scopes.from_string("public nope"))).to be_false
+      it 'returns false when any scope is not included' do
+        expect(subject.has_scopes?(Scopes.from_string('public nope'))).to be_false
       end
 
-      it "is false if no scopes are included even for existing ones" do
-        expect(subject.has_scopes?(Scopes.from_string("public admin notexistent"))).to be_false
+      it 'is false if no scopes are included even for existing ones' do
+        expect(subject.has_scopes?(Scopes.from_string('public admin notexistent'))).to be_false
       end
     end
   end