doorkeeper 1.0.0.rc2 → 1.0.0

data/spec/lib/oauth/error_spec.rb

@@ -11,7 +11,7 @@ module Doorkeeper::OAuth
 
     describe :description do
       it 'is translated from translation messages' do
-        I18n.should_receive(:translate).with(:some_error, :scope => [:doorkeeper, :errors, :messages])
+        expect(I18n).to receive(:translate).with(:some_error, :scope => [:doorkeeper, :errors, :messages])
         subject.description
       end
     end

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

@@ -12,30 +12,30 @@ module Doorkeeper::OAuth::Helpers
     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
+      expect(ScopeChecker.matches?(scopes, scopes_to_match)).to 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
+      expect(ScopeChecker.matches?(scopes, scopes_to_match)).to 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
+      expect(ScopeChecker.matches?(scopes, scopes_to_match)).to 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
+      expect(ScopeChecker.matches?(scopes, scopes_to_match)).to be_false
     end
 
     it "is false when any of attributes is nil" do
-      ScopeChecker.matches?(nil, double).should be_false
-      ScopeChecker.matches?(double, nil).should be_false
+      expect(ScopeChecker.matches?(nil, double)).to be_false
+      expect(ScopeChecker.matches?(double, nil)).to be_false
     end
   end
 
@@ -44,31 +44,31 @@ module Doorkeeper::OAuth::Helpers
 
     it "is valid if scope is present" do
       server_scopes.add :scope
-      ScopeChecker.valid?("scope", server_scopes).should be_true
+      expect(ScopeChecker.valid?("scope", server_scopes)).to be_true
     end
 
     it "is invalid if includes tabs space" do
-      ScopeChecker.valid?("\tsomething", server_scopes).should be_false
+      expect(ScopeChecker.valid?("\tsomething", server_scopes)).to be_false
     end
 
     it "is invalid if scope is not present" do
-      ScopeChecker.valid?(nil, server_scopes).should be_false
+      expect(ScopeChecker.valid?(nil, server_scopes)).to be_false
     end
 
     it "is invalid if scope is blank" do
-      ScopeChecker.valid?(" ", server_scopes).should be_false
+      expect(ScopeChecker.valid?(" ", server_scopes)).to be_false
     end
 
     it "is invalid if includes return space" do
-      ScopeChecker.valid?("scope\r", server_scopes).should be_false
+      expect(ScopeChecker.valid?("scope\r", server_scopes)).to be_false
     end
 
     it "is invalid if includes new lines" do
-      ScopeChecker.valid?("scope\nanother", server_scopes).should be_false
+      expect(ScopeChecker.valid?("scope\nanother", server_scopes)).to 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
+      expect(ScopeChecker.valid?("scope another", server_scopes)).to be_false
     end
   end
 end

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

@@ -9,12 +9,12 @@ module Doorkeeper::OAuth::Helpers
 
     it "is able to customize the generator method" do
       token = UniqueToken.generate(:generator => generator)
-      token.should == "a" * 32
+      expect(token).to eq("a" * 32)
     end
 
     it "is able to customize the size of the token" do
       token = UniqueToken.generate(:generator => generator, :size => 2)
-      token.should == "aa"
+      expect(token).to eq("aa")
     end
   end
 end

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

@@ -7,75 +7,75 @@ module Doorkeeper::OAuth::Helpers
     describe ".valid?" do
       it "is valid for valid uris" do
         uri = "http://app.co"
-        URIChecker.valid?(uri).should be_true
+        expect(URIChecker.valid?(uri)).to be_true
       end
 
       it "is valid if include path param" do
         uri = "http://app.co/path"
-        URIChecker.valid?(uri).should be_true
+        expect(URIChecker.valid?(uri)).to be_true
       end
 
       it "is valid if include query param" do
         uri = "http://app.co/?query=1"
-        URIChecker.valid?(uri).should be_true
+        expect(URIChecker.valid?(uri)).to be_true
       end
 
       it "is invalid if uri includes fragment" do
         uri = "http://app.co/test#fragment"
-        URIChecker.valid?(uri).should be_false
+        expect(URIChecker.valid?(uri)).to be_false
       end
 
       it "is invalid if scheme is missing" do
         uri = "app.co"
-        URIChecker.valid?(uri).should be_false
+        expect(URIChecker.valid?(uri)).to be_false
       end
 
       it "is invalid if is a relative uri" do
         uri = "/abc/123"
-        URIChecker.valid?(uri).should be_false
+        expect(URIChecker.valid?(uri)).to be_false
       end
 
       it "is invalid if is not a url" do
         uri = "http://"
-        URIChecker.valid?(uri).should be_false
+        expect(URIChecker.valid?(uri)).to 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
+        expect(URIChecker.matches?(uri, client_uri)).to 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
+        expect(URIChecker.matches?(uri, client_uri)).to 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
+        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_true
       end
 
       it "is false if valid and mismatches" do
         uri = 'http://app.co/aaa'
         client_uri = 'http://app.co/bbb'
-        URIChecker.valid_for_authorization?(uri, client_uri).should be_false
+        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_false
       end
 
       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"
-        URIChecker.valid_for_authorization?(uri, client_uri).should be_true
+        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_true
       end
 
       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"
-        URIChecker.valid_for_authorization?(uri, client_uri).should be_false
+        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_false
       end
     end
   end

data/spec/lib/oauth/invalid_token_response_spec.rb

@@ -5,18 +5,23 @@ require 'doorkeeper/oauth/invalid_token_response'
 
 module Doorkeeper::OAuth
   describe InvalidTokenResponse do
-    its(:name)  { should == :invalid_token }
-    its(:status) { should == :unauthorized }
+    describe '#name' do
+      it  { expect(subject.name).to eq(:invalid_token) }
+    end
+
+    describe '#status' do
+      it { expect(subject.status).to eq(:unauthorized) }
+    end
 
     describe :from_access_token do
       it 'revoked' do
         response = InvalidTokenResponse.from_access_token double(:revoked? => true, :expired? => true)
-        response.description.should include("revoked")
+        expect(response.description).to include("revoked")
       end
 
       it 'expired' do
         response = InvalidTokenResponse.from_access_token double(:revoked? => false, :expired? => true)
-        response.description.should include("expired")
+        expect(response.description).to include("expired")
       end
     end
   end

data/spec/lib/oauth/password_access_token_request_spec.rb

@@ -30,18 +30,18 @@ module Doorkeeper::OAuth
         subject.authorize
       }.to_not change { Doorkeeper::AccessToken.count }
 
-      subject.error.should == :invalid_client
+      expect(subject.error).to eq(:invalid_client)
     end
 
     it 'requires the owner' do
       subject.resource_owner = nil
       subject.validate
-      subject.error.should == :invalid_resource_owner
+      expect(subject.error).to eq(:invalid_resource_owner)
     end
 
     it 'optionally accepts the client' do
       subject.credentials = nil
-      subject.should be_valid
+      expect(subject).to be_valid
     end
 
     describe "with scopes" do
@@ -50,17 +50,17 @@ module Doorkeeper::OAuth
       end
 
       it 'validates the current scope' do
-        server.stub :scopes => Doorkeeper::OAuth::Scopes.from_string('another')
+        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string('another'))
         subject.validate
-        subject.error.should == :invalid_scope
+        expect(subject.error).to eq(:invalid_scope)
       end
 
       it 'creates the token with scopes' do
-        server.stub :scopes => Doorkeeper::OAuth::Scopes.from_string("public")
+        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string("public"))
         expect {
           subject.authorize
         }.to change { Doorkeeper::AccessToken.count }.by(1)
-        Doorkeeper::AccessToken.last.scopes.should include('public')
+        expect(Doorkeeper::AccessToken.last.scopes).to include('public')
       end
     end
   end

data/spec/lib/oauth/pre_authorization_spec.rb

@@ -18,63 +18,63 @@ module Doorkeeper::OAuth
     end
 
     it 'is authorizable when request is valid' do
-      subject.should be_authorizable
+      expect(subject).to be_authorizable
     end
 
     it 'accepts code as response type' do
       subject.response_type = 'code'
-      subject.should be_authorizable
+      expect(subject).to be_authorizable
     end
 
     it 'accepts token as response type' do
       subject.response_type = 'token'
-      subject.should be_authorizable
+      expect(subject).to be_authorizable
     end
 
     it 'accepts valid scopes' do
       subject.scope = 'public'
-      subject.should be_authorizable
+      expect(subject).to be_authorizable
     end
 
     it 'uses default scopes when none is required' do
-      server.stub :default_scopes => Scopes.from_string('default')
+      allow(server).to receive(:default_scopes).and_return(Scopes.from_string('default'))
       subject.scope = nil
-      subject.scope.should  == 'default'
-      subject.scopes.should == Scopes.from_string('default')
+      expect(subject.scope).to  eq('default')
+      expect(subject.scopes).to eq(Scopes.from_string('default'))
     end
 
     it 'accepts test uri' do
       subject.redirect_uri = 'urn:ietf:wg:oauth:2.0:oob'
-      subject.should be_authorizable
+      expect(subject).to be_authorizable
     end
 
     it "matches the redirect uri against client's one" do
       subject.redirect_uri = 'http://nothesame.com'
-      subject.should_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
 
     it 'stores the state' do
-      subject.state.should == 'save-this'
+      expect(subject.state).to eq('save-this')
     end
 
     it 'rejects if response type is not allowed' do
       subject.response_type = 'whops'
-      subject.should_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
 
     it 'requires an existing client' do
       subject.client = nil
-      subject.should_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
 
     it 'requires a redirect uri' do
       subject.redirect_uri = nil
-      subject.should_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
 
     it 'rejects non-valid scopes' do
       subject.scope = 'invalid'
-      subject.should_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
   end
 end

data/spec/lib/oauth/refresh_token_request_spec.rb

@@ -26,32 +26,32 @@ module Doorkeeper::OAuth
     it 'requires the refresh token' do
       subject.refresh_token = nil
       subject.validate
-      subject.error.should == :invalid_request
+      expect(subject.error).to eq(:invalid_request)
     end
 
     it 'requires credentials to be valid if provided' do
       subject.client = nil
       subject.validate
-      subject.error.should == :invalid_client
+      expect(subject.error).to eq(: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_grant
+      expect(subject.error).to eq(:invalid_grant)
     end
 
     it 'rejects revoked tokens' do
       refresh_token.revoke
       subject.validate
-      subject.error.should == :invalid_request
+      expect(subject.error).to eq(:invalid_request)
     end
 
     it 'accepts expired tokens' do
       refresh_token.expires_in = -1
       refresh_token.save
       subject.validate
-      subject.should be_valid
+      expect(subject).to be_valid
     end
 
     context 'clientless access tokens' do
@@ -77,20 +77,20 @@ module Doorkeeper::OAuth
 
       it 'transfers scopes from the old token to the new token' do
         subject.authorize
-        Doorkeeper::AccessToken.last.scopes.should == [:public, :write]
+        expect(Doorkeeper::AccessToken.last.scopes).to eq([:public, :write])
       end
 
       it 'reduces scopes to the provided scopes' do
         parameters[:scopes] = 'public'
         subject.authorize
-        Doorkeeper::AccessToken.last.scopes.should == [:public]
+        expect(Doorkeeper::AccessToken.last.scopes).to eq([:public])
       end
 
       it 'validates that scopes are included in the original access token' do
         parameters[:scopes] = 'public update'
 
         subject.validate
-        subject.error.should == :invalid_scope
+        expect(subject.error).to eq(:invalid_scope)
       end
     end
 

data/spec/lib/oauth/scopes_spec.rb

@@ -8,18 +8,18 @@ module Doorkeeper::OAuth
     describe :add do
       it 'allows you to add scopes with symbols' do
         subject.add :public
-        subject.all.should == ['public']
+        expect(subject.all).to eq(['public'])
       end
 
       it 'allows you to add scopes with strings' do
         subject.add "public"
-        subject.all.should == ['public']
+        expect(subject.all).to eq(['public'])
       end
 
       it 'do not add already included scopes' do
         subject.add :public
         subject.add :public
-        subject.all.should == ['public']
+        expect(subject.all).to eq(['public'])
       end
     end
 
@@ -29,16 +29,16 @@ module Doorkeeper::OAuth
       end
 
       it 'returns true if scope with given name is present' do
-        subject.exists?("public").should be_true
+        expect(subject.exists?("public")).to be_true
       end
 
       it 'returns false if scope with given name does not exist' do
-        subject.exists?("other").should be_false
+        expect(subject.exists?("other")).to be_false
       end
 
       it 'handles symbols' do
-        subject.exists?(:public).should be_true
-        subject.exists?(:other).should be_false
+        expect(subject.exists?(:public)).to be_true
+        expect(subject.exists?(:other)).to be_false
       end
     end
 
@@ -48,19 +48,27 @@ module Doorkeeper::OAuth
       subject { Scopes.from_string(string) }
 
       it { should be_a(Scopes) }
-      its(:all) { should == ['public', 'write'] }
+
+      describe '#all' do
+        it 'should be an array of the expected scopes' do
+          scopes_array = subject.all
+          expect(scopes_array.size).to eq(2)
+          expect(scopes_array).to include('public')
+          expect(scopes_array).to include('write')
+        end
+      end
     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']
+        expect(scopes.all).to eq(['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"
+        expect(origin.to_s).to eq("public")
       end
 
       it "raises an error if cannot handle addition" do
@@ -72,15 +80,15 @@ module Doorkeeper::OAuth
 
     describe :== do
       it 'is equal to another set of scopes' do
-        Scopes.from_string("public").should == 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
-        Scopes.from_string("public write").should == 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
-        Scopes.from_string("public write").should_not == Scopes.from_string("write")
+        expect(Scopes.from_string("public write")).not_to eq(Scopes.from_string("write"))
       end
     end
 
@@ -88,27 +96,27 @@ module Doorkeeper::OAuth
       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
+        expect(subject.has_scopes?(Scopes.from_string("public"))).to be_true
       end
 
       it "returns true when all scopes are included" do
-        subject.has_scopes?(Scopes.from_string("public admin")).should be_true
+        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
-        subject.has_scopes?(Scopes.from_string("admin public")).should be_true
+        expect(subject.has_scopes?(Scopes.from_string("admin public"))).to be_true
       end
 
       it "is false if no scopes are included" do
-        subject.has_scopes?(Scopes.from_string("notexistent")).should be_false
+        expect(subject.has_scopes?(Scopes.from_string("notexistent"))).to be_false
       end
 
       it "returns false when any scope is not included" do
-        subject.has_scopes?(Scopes.from_string("public nope")).should be_false
+        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
-        subject.has_scopes?(Scopes.from_string("public admin notexistent")).should be_false
+        expect(subject.has_scopes?(Scopes.from_string("public admin notexistent"))).to be_false
       end
     end
   end