couchkeeper 0.6.7

data/spec/lib/oauth/error_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'active_support/i18n'
+require 'doorkeeper/oauth/error'
+
+module Doorkeeper::OAuth
+  describe Error do
+    subject { Error.new(:some_error, :some_state) }
+
+    it { should respond_to(:name) }
+    it { should respond_to(:state) }
+
+    describe :description do
+      it 'is translated from translation messages' do
+        I18n.should_receive(:translate).with(:some_error, :scope => [:doorkeeper, :errors, :messages])
+        subject.description
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'active_support/core_ext/string'
+require 'doorkeeper/oauth/helpers/scope_checker'
+require 'doorkeeper/oauth/scopes'
+
+module Doorkeeper::OAuth::Helpers
+  describe ScopeChecker, ".matches?" do
+    def new_scope(*args)
+      Doorkeeper::OAuth::Scopes.from_array args
+    end
+
+    it "true if scopes matches" do
+      scopes = new_scope :public
+      scopes_to_match = new_scope :public
+      ScopeChecker.matches?(scopes, scopes_to_match).should be_true
+    end
+
+    it "is false when scopes differs" do
+      scopes = new_scope :public
+      scopes_to_match = new_scope :write
+      ScopeChecker.matches?(scopes, scopes_to_match).should be_false
+    end
+
+    it "is false when scope in array is missing" do
+      scopes = new_scope :public
+      scopes_to_match = new_scope :public, :write
+      ScopeChecker.matches?(scopes, scopes_to_match).should be_false
+    end
+
+    it "is false when scope in string is missing" do
+      scopes = new_scope :public, :write
+      scopes_to_match = new_scope :public
+      ScopeChecker.matches?(scopes, scopes_to_match).should be_false
+    end
+
+    it "is false when any of attributes is nil" do
+      ScopeChecker.matches?(nil, stub).should be_false
+      ScopeChecker.matches?(stub, nil).should be_false
+    end
+  end
+
+  describe ScopeChecker, ".valid?" do
+    let(:server_scopes) { Doorkeeper::OAuth::Scopes.new }
+
+    it "is valid if scope is present" do
+      server_scopes.add :scope
+      ScopeChecker.valid?("scope", server_scopes).should be_true
+    end
+
+    it "is invalid if includes tabs space" do
+      ScopeChecker.valid?("\tsomething", server_scopes).should be_false
+    end
+
+    it "is invalid if scope is not present" do
+      ScopeChecker.valid?(nil, server_scopes).should be_false
+    end
+
+    it "is invalid if scope is blank" do
+      ScopeChecker.valid?(" ", server_scopes).should be_false
+    end
+
+    it "is invalid if includes return space" do
+      ScopeChecker.valid?("scope\r", server_scopes).should be_false
+    end
+
+    it "is invalid if includes new lines" do
+      ScopeChecker.valid?("scope\nanother", server_scopes).should be_false
+    end
+
+    it "is invalid if any scope is not included in server scopes" do
+      ScopeChecker.valid?("scope another", server_scopes).should be_false
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'doorkeeper/oauth/helpers/unique_token'
+
+module Doorkeeper::OAuth::Helpers
+  describe UniqueToken do
+    let :generator do
+      lambda { |size| "a" * size }
+    end
+
+    it "is able to customize the generator method" do
+      token = UniqueToken.generate(:generator => generator)
+      token.should == "a" * 32
+    end
+
+    it "is able to customize the size of the token" do
+      token = UniqueToken.generate(:generator => generator, :size => 2)
+      token.should == "aa"
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'uri'
+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"
+        URIChecker.valid?(uri).should be_true
+      end
+
+      it "is valid if include path param" do
+        uri = "http://app.co/path"
+        URIChecker.valid?(uri).should be_true
+      end
+
+      it "is valid if include query param" do
+        uri = "http://app.co/?query=1"
+        URIChecker.valid?(uri).should be_true
+      end
+
+      it "is invalid if uri includes fragment" do
+        uri = "http://app.co/test#fragment"
+        URIChecker.valid?(uri).should be_false
+      end
+
+      it "is invalid if scheme is missing" do
+        uri = "app.co"
+        URIChecker.valid?(uri).should be_false
+      end
+
+      it "is invalid if is a relative uri" do
+        uri = "/abc/123"
+        URIChecker.valid?(uri).should be_false
+      end
+
+      it "is invalid if is not a url" do
+        uri = "http://"
+        URIChecker.valid?(uri).should be_false
+      end
+    end
+
+    describe ".matches?" do
+      it "is true if both url matches" do
+        uri = client_uri = 'http://app.co/aaa'
+        URIChecker.matches?(uri, client_uri).should be_true
+      end
+
+      it "ignores query parameter on comparsion" do
+        uri = 'http://app.co/?query=hello'
+        client_uri = 'http://app.co'
+        URIChecker.matches?(uri, client_uri).should be_true
+      end
+    end
+
+    describe ".valid_for_authorization?" do
+      it "is true if valid and matches" do
+        uri = client_uri = 'http://app.co/aaa'
+        URIChecker.valid_for_authorization?(uri, client_uri).should be_true
+      end
+    end
+  end
+end

data/spec/lib/oauth/password_access_token_request_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper_integration'
+
+module Doorkeeper::OAuth
+  describe PasswordAccessTokenRequest do
+    let(:server) { mock :server, :default_scopes => Doorkeeper::OAuth::Scopes.new, :access_token_expires_in => 2.hours, :refresh_token_enabled? => false }
+    let(:client) { FactoryGirl.create(:application) }
+    let(:owner)  { mock :owner, :id => 99 }
+
+    subject do
+      PasswordAccessTokenRequest.new(server, client, owner)
+    end
+
+    it 'issues a new token for the client' do
+      expect do
+        subject.authorize
+      end.to change { client.access_tokens.count }.by(1)
+    end
+
+    it "requires the owner" do
+      subject.resource_owner = nil
+      subject.validate
+      subject.error.should == :invalid_resource_owner
+    end
+
+    it 'requires the client' do
+      subject.client = nil
+      subject.validate
+      subject.error.should == :invalid_client
+    end
+
+    it 'skips token creation if there is already one' do
+      FactoryGirl.create(:access_token, :application_id => client.id, :resource_owner_id => owner.id)
+      expect do
+        subject.authorize
+      end.to_not change { Doorkeeper::AccessToken.count }
+    end
+
+    it 'revokes old token if expired' do
+      token = FactoryGirl.create(:access_token, :application_id => client.id, :resource_owner_id => owner.id, :expires_in => -100)
+      expect do
+        subject.authorize
+      end.to change { token.reload.revoked? }
+    end
+
+    describe "with scopes" do
+      subject do
+        PasswordAccessTokenRequest.new(server, client, owner, :scope => 'public')
+      end
+
+      it 'validates the current scope' do
+        server.stub :scopes => Doorkeeper::OAuth::Scopes.from_string('another')
+        subject.validate
+        subject.error.should == :invalid_scope
+      end
+
+      it 'creates the token with scopes' do
+        server.stub :scopes => Doorkeeper::OAuth::Scopes.from_string("public")
+        expect {
+          subject.authorize
+        }.to change { Doorkeeper::AccessToken.count }.by(1)
+        Doorkeeper::AccessToken.last.scopes.should include(:public)
+      end
+    end
+  end
+end

data/spec/lib/oauth/pre_authorization_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper_integration"
+
+module Doorkeeper::OAuth
+  describe PreAuthorization do
+    let(:server) { mock :server, :default_scopes => Scopes.new, :scopes => Scopes.from_string('public') }
+    let(:client) { mock :client, :redirect_uri => 'http://tst.com/auth' }
+
+    let :attributes do
+      {
+        :response_type => 'code',
+        :redirect_uri => 'http://tst.com/auth',
+        :state => 'save-this'
+      }
+    end
+
+    subject do
+      PreAuthorization.new(server, client, attributes)
+    end
+
+    it 'is authorizable when request is valid' do
+      subject.should be_authorizable
+    end
+
+    it 'accepts code as response type' do
+      subject.response_type = 'code'
+      subject.should be_authorizable
+    end
+
+    it 'accepts token as response type' do
+      subject.response_type = 'token'
+      subject.should be_authorizable
+    end
+
+    it 'accepts valid scopes' do
+      subject.scope = 'public'
+      subject.should be_authorizable
+    end
+
+    it 'uses default scopes when none is required' do
+      server.stub :default_scopes => Scopes.from_string('default')
+      subject.scope = nil
+      subject.scope.should  == 'default'
+      subject.scopes.should == Scopes.from_string('default')
+    end
+
+    it 'accepts test uri' do
+      subject.redirect_uri = 'urn:ietf:wg:oauth:2.0:oob'
+      subject.should be_authorizable
+    end
+
+    it "matches the redirect uri against client's one" do
+      subject.redirect_uri = 'http://nothesame.com'
+      subject.should_not be_authorizable
+    end
+
+    it 'stores the state' do
+      subject.state.should == 'save-this'
+    end
+
+    it 'rejects if response type is not allowed' do
+      subject.response_type = 'whops'
+      subject.should_not be_authorizable
+    end
+
+    it 'requires an existing client' do
+      subject.client = nil
+      subject.should_not be_authorizable
+    end
+
+    it 'requires a redirect uri' do
+      subject.redirect_uri = nil
+      subject.should_not be_authorizable
+    end
+
+    it 'rejects non-valid scopes' do
+      subject.scope = 'invalid'
+      subject.should_not be_authorizable
+    end
+  end
+end

data/spec/lib/oauth/refresh_token_request_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper_integration'
+
+module Doorkeeper::OAuth
+  describe RefreshTokenRequest do
+    let(:server)         { mock :server, :access_token_expires_in => 2.minutes }
+    let!(:refresh_token) { FactoryGirl.create(:access_token, :use_refresh_token => true) }
+    let(:client)         { refresh_token.application }
+
+    subject do
+      RefreshTokenRequest.new server, refresh_token, client
+    end
+
+    it 'issues a new token for the client' do
+      expect do
+        subject.authorize
+      end.to change { client.access_tokens.count }.by(1)
+    end
+
+    it 'revokes the previous token' do
+      expect do
+        subject.authorize
+      end.to change { refresh_token.revoked? }.from(false).to(true)
+    end
+
+    it 'requires the refresh token' do
+      subject.refresh_token = nil
+      subject.validate
+      subject.error.should == :invalid_request
+    end
+
+    it 'requires client' do
+      subject.client = nil
+      subject.validate
+      subject.error.should == :invalid_client
+    end
+
+    it "requires the token's client and current client to match" do
+      subject.client = FactoryGirl.create(:application)
+      subject.validate
+      subject.error.should == :invalid_client
+    end
+
+    it 'rejects revoked tokens' do
+      refresh_token.revoke
+      subject.validate
+      subject.error.should == :invalid_request
+    end
+
+    it 'accepts expired tokens' do
+      refresh_token.expires_in = -1
+      refresh_token.save
+      subject.validate
+      subject.should be_valid
+    end
+  end
+end

data/spec/lib/oauth/scopes_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/string'
+require 'doorkeeper/oauth/scopes'
+
+module Doorkeeper::OAuth
+  describe Scopes do
+    describe :add do
+      it 'allows you to add scopes with symbols' do
+        subject.add :public
+        subject.all.should == [:public]
+      end
+
+      it 'allows you to add scopes with strings' do
+        subject.add "public"
+        subject.all.should == [:public]
+      end
+
+      it 'do not add already included scopes' do
+        subject.add :public
+        subject.add :public
+        subject.all.should == [:public]
+      end
+    end
+
+    describe :exists do
+      before do
+        subject.add :public
+      end
+
+      it 'returns true if scope with given name is present' do
+        subject.exists?("public").should be_true
+      end
+
+      it 'returns false if scope with given name does not exist' do
+        subject.exists?("other").should be_false
+      end
+
+      it 'handles symbols' do
+        subject.exists?(:public).should be_true
+        subject.exists?(:other).should be_false
+      end
+    end
+
+    describe ".from_string" do
+      let(:string) { "public write" }
+
+      subject { Scopes.from_string(string) }
+
+      it { should be_a(Scopes) }
+      its(:all) { should == [:public, :write] }
+    end
+
+    describe :+ do
+      it "can add to another scope object" do
+        scopes = Scopes.from_string("public") + Scopes.from_string("admin")
+        scopes.all.should == [:public, :admin]
+      end
+
+      it "does not change the existing object" do
+        origin = Scopes.from_string("public")
+        new_scope = origin + Scopes.from_string("admin")
+        origin.to_s.should == "public"
+      end
+
+      it "raises an error if cannot handle addition" do
+        expect {
+          Scopes.from_string("public") + "admin"
+        }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe :== do
+      it 'is equal to another set of scopes' do
+        Scopes.from_string("public").should == Scopes.from_string("public")
+      end
+
+      it 'is equal to another set of scopes with no particular order' do
+        Scopes.from_string("public write").should == Scopes.from_string("write public")
+      end
+
+      it 'differs from another set of scopes when scopes are not the same' do
+        Scopes.from_string("public write").should_not == Scopes.from_string("write")
+      end
+    end
+
+    describe :has_scopes? do
+      subject { Scopes.from_string("public admin") }
+
+      it "returns true when at least one scope is included" do
+        subject.has_scopes?(Scopes.from_string("public")).should be_true
+      end
+
+      it "returns true when all scopes are included" do
+        subject.has_scopes?(Scopes.from_string("public admin")).should be_true
+      end
+
+      it "is true if all scopes are included in any order" do
+        subject.has_scopes?(Scopes.from_string("admin public")).should be_true
+      end
+
+      it "is false if no scopes are included" do
+        subject.has_scopes?(Scopes.from_string("notexistent")).should be_false
+      end
+
+      it "returns false when any scope is not included" do
+        subject.has_scopes?(Scopes.from_string("public nope")).should be_false
+      end
+
+      it "is false if no scopes are included even for existing ones" do
+        subject.has_scopes?(Scopes.from_string("public admin notexistent")).should be_false
+      end
+    end
+  end
+end