auth0 4.0.0 → 4.1.0

data/spec/lib/auth0/api/v2/user_blocks_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+describe Auth0::Api::V2::UserBlocks do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::UserBlocks)
+    @instance = dummy_instance
+  end
+
+  context '.user_blocks' do
+    it { expect(@instance).to respond_to(:user_blocks) }
+    it 'is expected to call /api/v2/user-blocks?identifier=Test' do
+      expect(@instance).to receive(:get).with('/api/v2/user-blocks', identifier: 'Test')
+      expect { @instance.user_blocks('Test') }.not_to raise_error
+    end
+    it 'expect client to raise an error when calling with empty identifier' do
+      expect { @instance.user_blocks(nil) }.to raise_error('Must specify a valid identifier')
+    end
+  end
+
+  context '.delete_user_blocks' do
+    it { expect(@instance).to respond_to(:delete_user_blocks) }
+    it 'is expected to call /api/v2/user-blocks?identifier=Test' do
+      expect(@instance).to receive(:delete).with('/api/v2/user-blocks', identifier: 'Test')
+      expect { @instance.delete_user_blocks('Test') }.not_to raise_error
+    end
+    it 'expect client to raise an error when calling with empty identifier' do
+      expect { @instance.delete_user_blocks(nil) }.to raise_error('Must specify a valid identifier')
+    end
+  end
+
+  context '.user_blocks_by_id' do
+    it { expect(@instance).to respond_to(:user_blocks_by_id) }
+    it 'is expected to call /api/v2/user-blocks/Test' do
+      expect(@instance).to receive(:get).with('/api/v2/user-blocks/Test')
+      expect { @instance.user_blocks_by_id('Test') }.not_to raise_error
+    end
+    it 'expect client to raise an error when calling with empty identifier' do
+      expect { @instance.user_blocks_by_id(nil) }.to raise_error('Must specify a valid identifier')
+    end
+  end
+
+  context '.delete_user_blocks_by_id' do
+    it { expect(@instance).to respond_to(:delete_user_blocks_by_id) }
+    it 'is expected to call /api/v2/user-blocks/Test' do
+      expect(@instance).to receive(:delete).with('/api/v2/user-blocks/Test')
+      expect { @instance.delete_user_blocks_by_id('Test') }.not_to raise_error
+    end
+    it 'expect client to raise an error when calling with empty identifier' do
+      expect { @instance.delete_user_blocks_by_id(nil) }.to raise_error('Must specify a valid identifier')
+    end
+  end
+end

data/spec/lib/auth0/api/v2/users_spec.rb

@@ -19,7 +19,8 @@ describe Auth0::Api::V2::Users do
         connection: nil,
         fields: nil,
         include_fields: nil,
-        q: nil)
+        q: nil
+      )
       expect { @instance.users }.not_to raise_error
     end
   end
@@ -41,12 +42,14 @@ describe Auth0::Api::V2::Users do
         email: 'test@test.com',
         password: 'password',
         connection: 'conn',
-        name: 'name')
+        name: 'name'
+      )
       @instance.create_user(
         'name',
         email: 'test@test.com',
         password: 'password',
-        connection: 'conn')
+        connection: 'conn'
+      )
     end
   end
 
@@ -68,7 +71,8 @@ describe Auth0::Api::V2::Users do
     it 'is expected not to call delete to /api/v2/users if user_id is blank' do
       expect(@instance).not_to receive(:delete)
       expect { @instance.delete_user('') }.to raise_exception(
-        Auth0::MissingUserId)
+        Auth0::MissingUserId
+      )
     end
   end
 
@@ -88,13 +92,15 @@ describe Auth0::Api::V2::Users do
         email: 'test@test.com',
         password: 'password',
         connection: 'conn',
-        name: 'name')
+        name: 'name'
+      )
       @instance.patch_user(
         'UserID',
         email: 'test@test.com',
         password: 'password',
         connection: 'conn',
-        name: 'name')
+        name: 'name'
+      )
     end
     it { expect { @instance.patch_user('', 'body') }.to raise_error 'Must supply a valid user_id' }
     it { expect { @instance.patch_user('UserId', '') }.to raise_error 'Must supply a valid body' }
@@ -131,4 +137,31 @@ describe Auth0::Api::V2::Users do
     end
     it { expect { @instance.delete_user_provider(nil, 'test') }.to raise_error 'Must supply a valid user_id' }
   end
+
+  context '.user_logs' do
+    it { expect(@instance).to respond_to(:user_logs) }
+    it { expect(@instance).to respond_to(:get_user_log_events) }
+    it 'is expected to call /api/v2/USER_ID/logs' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/logs',
+        user_id: 'USER_ID',
+        per_page: nil,
+        page: nil,
+        include_totals: nil,
+        sort: nil
+      )
+      expect { @instance.user_logs('USER_ID') }.not_to raise_error
+    end
+    it { expect { @instance.user_logs('') }.to raise_error 'Must supply a valid user_id' }
+    it 'is expected to raise an error when per_page is higher than 100' do
+      expect { @instance.user_logs('USER_ID', per_page: rand(101..2000)) }.to raise_error(
+        'The total amount of entries per page should be less than 100'
+      )
+    end
+    it 'is expected to raise an error when sort does not match pattern' do
+      expect { @instance.user_logs('USER_ID', sort: 'no match') }.to raise_error(
+        'Sort does not match pattern ^(([a-zA-Z0-9_\\.]+))\\:(1|-1)$'
+      )
+    end
+  end
 end

data/spec/lib/auth0/client_spec.rb

@@ -48,7 +48,8 @@ describe Auth0::Client do
 
     context 'with namespace' do
       let(:subject) do
-        Auth0::Client.new(client_id: 'client_id', client_secret: 'client_secret', namespace: 'samples.auth0.com')
+        Auth0::Client.new(protocols: 'v1', client_id: 'client_id', client_secret: 'client_secret',
+                          namespace: 'samples.auth0.com')
       end
 
       it_should_behave_like 'v1 API client'
@@ -57,7 +58,8 @@ describe Auth0::Client do
 
     context 'with domain' do
       let(:subject) do
-        Auth0::Client.new(client_id: 'client_id', client_secret: 'client_secret', domain: 'samples.auth0.com')
+        Auth0::Client.new(protocols: 'v1', client_id: 'client_id', client_secret: 'client_secret',
+                          domain: 'samples.auth0.com')
       end
 
       it_should_behave_like 'v1 API client'
@@ -70,7 +72,8 @@ describe Auth0::Client do
           client_id: 'client_id',
           client_secret: 'client_secret',
           domain: 'samples.auth0.com',
-          api_version: 1)
+          api_version: 1
+        )
       end
       it_should_behave_like 'v1 API client'
       it_should_behave_like 'authentication API client'
@@ -83,13 +86,13 @@ describe Auth0::Client do
     end
 
     context 'with namespace' do
-      let(:subject) { Auth0::Client.new(protocols: 'v2', access_token: 'access_token', namespace: 'samples.auth0.com') }
+      let(:subject) { Auth0::Client.new(access_token: 'access_token', namespace: 'samples.auth0.com') }
       it_should_behave_like 'v2 API client'
       it_should_behave_like 'authentication API client'
     end
 
     context 'with domain' do
-      let(:subject) { Auth0::Client.new(protocols: 'v2', access_token: 'access_token', domain: 'samples.auth0.com') }
+      let(:subject) { Auth0::Client.new(access_token: 'access_token', domain: 'samples.auth0.com') }
       it_should_behave_like 'v2 API client'
       it_should_behave_like 'authentication API client'
     end

data/spec/lib/auth0/mixins/httpproxy_spec.rb

@@ -0,0 +1,225 @@
+require 'json'
+require 'spec_helper'
+
+describe Auth0::Mixins::HTTPProxy do
+  before :each do
+    dummy_instance = DummyClassForProxy.new
+    dummy_instance.extend(Auth0::Mixins::HTTPProxy)
+    @instance = dummy_instance
+    @exception = DummyClassForRestClient.new
+  end
+
+  %i(get delete).each do |http_method|
+    context ".#{http_method}" do
+      it { expect(@instance).to respond_to(http_method.to_sym) }
+      it "should call send http #{http_method} method to path defined through HTTP" do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+          .and_return(StubResponse.new({}, true, 200))
+        expect { @instance.send(http_method, '/test') }.not_to raise_error
+      end
+
+      it 'should not raise exception if data returned not in json format (should be fixed in v2)' do
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: { params: {} },
+                                                             payload: nil)
+          .and_return(StubResponse.new('Some random text here', true, 200))
+        expect { @instance.send(http_method, '/test') }.not_to raise_error
+        expect(@instance.send(http_method, '/test')).to eql('Some random text here')
+      end
+
+      it "should raise Auth0::Unauthorized on send http #{http_method}
+        method to path defined through HTTP when 401 status received" do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+          .and_return(StubResponse.new({}, false, 401))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unauthorized)
+      end
+
+      it "should raise Auth0::NotFound on send http #{http_method} method
+        to path defined through HTTP when 404 status received" do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+          .and_return(StubResponse.new({}, false, 404))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound)
+      end
+
+      it "should raise Auth0::Unsupported on send http #{http_method} method
+        to path defined through HTTP when 418 or other unknown status received" do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+          .and_return(StubResponse.new({}, false, 418))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unsupported)
+      end
+
+      it "should raise Auth0::BadRequest on send http #{http_method} method
+        to path defined through HTTP when 400 or other unknown status received" do
+        @exception.response = StubResponse.new({}, false, 400)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: { params: {} },
+                                                             payload: nil)
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::BadRequest)
+      end
+
+      it "should raise Auth0::AccessDenied on send http #{http_method} method
+        to path defined through HTTP when 403" do
+        @exception.response = StubResponse.new({}, false, 403)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: { params: {} },
+                                                             payload: nil)
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::AccessDenied)
+      end
+      it "should raise Auth0::ServerError on send http #{http_method} method
+        to path defined through HTTP when 500 received" do
+        @exception.response = StubResponse.new({}, false, 500)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: { params: {} },
+                                                             payload: nil)
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
+      end
+
+      it 'should escape path with URI.escape' do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/te%20st',
+                                                              timeout: nil,
+                                                              headers: { params: {} },
+                                                              payload: nil)
+          .and_return(StubResponse.new({}, true, 200))
+        expect { @instance.send(http_method, '/te st') }.not_to raise_error
+      end
+    end
+  end
+
+  %i(post put patch).each do |http_method|
+    context ".#{http_method}" do
+      it { expect(@instance).to respond_to(http_method.to_sym) }
+      it "should call send http #{http_method} method to path defined through HTTP" do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: nil,
+                                                              payload: '{}')
+          .and_return(StubResponse.new({}, true, 200))
+        expect { @instance.send(http_method, '/test') }.not_to raise_error
+      end
+
+      it 'should not raise exception if data returned not in json format (should be fixed in v2)' do
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_return(StubResponse.new('Some random text here', true, 200))
+        expect { @instance.send(http_method, '/test') }.not_to raise_error
+        expect(@instance.send(http_method, '/test')).to eql('Some random text here')
+      end
+
+      it "should raise Auth0::Unauthorized on send http #{http_method} method
+        to path defined through HTTP when 401 status received" do
+        @exception.response = StubResponse.new({}, false, 401)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unauthorized)
+      end
+
+      it "should raise Auth0::NotFound on send http #{http_method} method
+        to path defined through HTTP when 404 status received" do
+        @exception.response = StubResponse.new({}, false, 404)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound)
+      end
+
+      it "should raise Auth0::Unsupported on send http #{http_method} method
+        to path defined through HTTP when 418 or other unknown status received" do
+        @exception.response = StubResponse.new({}, false, 418)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unsupported)
+      end
+
+      it "should raise Auth0::BadRequest on send http #{http_method} method
+        to path defined through HTTP when 400 or other unknown status received" do
+        @exception.response = StubResponse.new({}, false, 400)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::BadRequest)
+      end
+
+      it "should raise Auth0::ServerError on send http #{http_method} method
+        to path defined through HTTP when 500 received" do
+        @exception.response = StubResponse.new({}, false, 500)
+        allow(RestClient::Request).to receive(:execute).with(method: http_method, url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(@exception)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
+      end
+
+      it 'should escape path with URI.escape' do
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/te%20st',
+                                                              timeout: nil,
+                                                              headers: nil,
+                                                              payload: '{}')
+          .and_return(StubResponse.new({}, true, 200))
+        expect { @instance.send(http_method, '/te st') }.not_to raise_error
+      end
+
+      it 'should give the JSON representation of the error as the error message' do
+        res = JSON.generate('statusCode' => 404,
+                            'error' => 'Bad Request',
+                            'message' => "Path validation error: 'String does not match pattern ^.+\\|.+$:
+                                            3241312' on property id (The user_id of the user to retrieve).",
+                            'errorCode' => 'invalid_uri')
+        expect(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                              url: '/test',
+                                                              timeout: nil,
+                                                              headers: nil,
+                                                              payload: '{}')
+          .and_return(StubResponse.new(res, true, 404))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::NotFound, res)
+      end
+    end
+  end
+end

data/spec/lib/auth0/mixins/initializer_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 class MockClass
   attr_reader :token
   include Auth0::Mixins::Initializer
-  include HTTMultiParty
+  include Auth0::Mixins::HTTPProxy
 end
 
 describe Auth0::Mixins::Initializer do

data/spec/spec_helper_full.rb

@@ -16,8 +16,8 @@ require 'faker'
 require 'auth0'
 require 'pry'
 
-Dir[('./lib/**/*.rb')].each { |f| require f }
-Dir[('./spec/support/**/*.rb')].each { |f| require f }
+Dir['./lib/**/*.rb'].each { |f| require f }
+Dir['./spec/support/**/*.rb'].each { |f| require f }
 
 def entity_suffix
   (ENV['TRAVIS_JOB_ID'] || 'local').delete('_')
@@ -33,7 +33,8 @@ RSpec.configure do |config|
   config.after(:suite) do
     puts "Cleaning up for #{entity_suffix}"
     v2_client = Auth0Client.new(
-      token: ENV['MASTER_JWT'], api_version: 2, domain: ENV['DOMAIN'])
+      token: ENV['MASTER_JWT'], api_version: 2, domain: ENV['DOMAIN']
+    )
     v2_client
       .clients
       .select { |client| client['name'] != 'DefaultApp' && !client['global'] && client['name'].include?(entity_suffix) }
@@ -45,3 +46,11 @@ RSpec.configure do |config|
     puts "Finished cleaning up for #{entity_suffix}"
   end
 end
+
+def wait(time, increment = 5, elapsed_time = 0, &block)
+  yield
+rescue RSpec::Expectations::ExpectationNotMetError => e
+  raise e if elapsed_time >= time
+  sleep increment
+  wait(time, increment, elapsed_time + increment, &block)
+end