auth0 4.4.0 → 5.1.2

data/spec/lib/auth0/client_spec.rb

@@ -3,43 +3,221 @@ require 'spec_helper'
 describe Auth0::Client do
   shared_examples_for 'v2 API client' do
     it { should be_a Auth0::Api::V2 }
+    it { should be_a Auth0::Api::V2::Blacklists }
     it { should be_a Auth0::Api::V2::Clients }
-    it { should be_a Auth0::Api::V2::Users }
-    it { should be_a Auth0::Api::V2::Stats }
+    it { should be_a Auth0::Api::V2::ClientGrants }
+    it { should be_a Auth0::Api::V2::Connections }
+    it { should be_a Auth0::Api::V2::DeviceCredentials }
+    it { should be_a Auth0::Api::V2::Emails }
     it { should be_a Auth0::Api::V2::Jobs }
-    it { should be_a Auth0::Api::V2::Blacklists }
+    it { should be_a Auth0::Api::V2::Logs }
+    it { should be_a Auth0::Api::V2::ResourceServers }
+    it { should be_a Auth0::Api::V2::Rules }
+    it { should be_a Auth0::Api::V2::Stats }
+    it { should be_a Auth0::Api::V2::Tenants }
+    it { should be_a Auth0::Api::V2::Tickets }
+    it { should be_a Auth0::Api::V2::UserBlocks }
+    it { should be_a Auth0::Api::V2::Users }
+    it { should be_a Auth0::Api::V2::UsersByEmail }
   end
 
-  shared_examples_for 'authentication API client' do
+  shared_examples_for 'Authentication API client' do
     it { should be_a Auth0::Api::AuthenticationEndpoints }
   end
 
   let(:domain) { 'samples.auth0.com' }
-  let(:client_id) { 'client_id' }
-  let(:client_secret) { 'client_secret' }
-  let(:access_token) { 'token' }
+  let(:client_id) { '__test_client_id__' }
+  let(:client_secret) { '__test_client_secret__' }
+  let(:access_token) { '__test_access_token__' }
+  let(:organization) { '__test_organization__'}
+
+  describe 'V2 client with token' do
 
-  describe 'V2 client' do
     before :each do
-      expect_any_instance_of(Auth0::Api::AuthenticationEndpoints).not_to receive(:obtain_access_token)
+      expect_any_instance_of(Auth0::Api::AuthenticationEndpoints)
+        .not_to receive(:obtain_access_token)
+    end
+
+    context 'and namespace' do
+      let(:subject) do
+        Auth0::Client.new(
+          access_token: access_token,
+          namespace: domain
+        )
+      end
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'Authentication API client'
     end
 
-    context 'with namespace' do
-      let(:subject) { Auth0::Client.new(access_token: 'access_token', namespace: 'samples.auth0.com') }
+    context 'and domain' do
+      let(:subject) do
+        Auth0::Client.new(
+          access_token: access_token,
+          domain: domain
+        )
+      end
       it_should_behave_like 'v2 API client'
-      it_should_behave_like 'authentication API client'
+      it_should_behave_like 'Authentication API client'
     end
 
-    context 'with domain' do
-      let(:subject) { Auth0::Client.new(access_token: 'access_token', domain: 'samples.auth0.com') }
+    context 'and version' do
+      let(:subject) do
+        Auth0::Client.new(
+          api_version: 2,
+          access_token: access_token,
+          domain: domain
+        )
+      end
       it_should_behave_like 'v2 API client'
-      it_should_behave_like 'authentication API client'
+      it_should_behave_like 'Authentication API client'
     end
 
-    context 'with version' do
-      let(:subject) { Auth0::Client.new(api_version: 2, access_token: 'access_token', domain: 'samples.auth0.com') }
+    context 'with token' do
+      let(:subject) do
+        Auth0::Client.new(
+          api_version: 2,
+          token: access_token,
+          domain: domain
+        )
+      end
       it_should_behave_like 'v2 API client'
-      it_should_behave_like 'authentication API client'
+      it_should_behave_like 'Authentication API client'
     end
+
+    context 'with token and client_secret' do
+      let(:subject) do
+        Auth0::Client.new(
+          token: access_token,
+          domain: domain,
+          client_secret: client_secret,
+        )
+      end
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'Authentication API client'
+    end
+  end
+
+  describe 'V2 client without token' do
+    context 'should try to get an API token' do
+      before do
+        stub_api_token
+      end
+
+      let(:subject) do
+        Auth0::Client.new(
+          domain: domain,
+          client_id: client_id,
+          client_secret: client_secret,
+        )
+      end
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'Authentication API client'
+    end
+
+    context 'when try to get an API tokenwith api_identifier' do
+      let(:api_identifier) { 'https://samples.api_identifier/api/v2/' }
+
+      before do
+        stub_api_token_with_api_identifier 
+      end
+
+      let(:subject) do
+        Auth0::Client.new(
+          domain: domain,
+          client_id: client_id,
+          client_secret: client_secret,
+          api_identifier: api_identifier
+        )
+      end
+
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'Authentication API client'  
+    end
+
+    context 'when try to get an API tokenwith organization' do
+      before do
+        stub_api_token_with_organization
+      end
+
+      let(:subject) do
+        Auth0::Client.new(
+          domain: domain,
+          client_id: client_id,
+          client_secret: client_secret,
+          organization: organization
+        )
+      end
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'Authentication API client'
+    end
+
+    context 'should fail if' do
+
+      it 'does not have a client_secret' do
+        expect do
+          Auth0::Client.new(
+            domain: domain,
+            client_id: client_id,
+          )
+        end.to raise_error('Must supply a valid API token')
+      end
+    end
+  end
+
+  def stub_api_token
+    stub_request(:post, "https://#{domain}/oauth/token")
+      .with(
+        body: hash_including(
+          {
+            grant_type: 'client_credentials',
+            client_id: client_id,
+            client_secret: client_secret,
+            audience: "https://#{domain}/api/v2/"
+          }
+        )
+      )
+      .to_return(
+        headers: { 'Content-Type' => 'application/json' },
+        body: '{"access_token":"__test_access_token__"}',
+        status: 200
+      )
+  end
+
+  def stub_api_token_with_api_identifier
+    stub_request(:post, "https://#{domain}/oauth/token")
+      .with(
+        body: hash_including(
+          {
+            grant_type: 'client_credentials',
+            client_id: client_id,
+            client_secret: client_secret,
+            audience: api_identifier
+          }
+        )
+      )
+      .to_return(
+        headers: { 'Content-Type' => 'application/json' },
+        body: '{"access_token":"__test_access_token__"}',
+        status: 200
+      )
+  end
+
+  def stub_api_token_with_organization
+    stub_request(:post, "https://#{domain}/oauth/token")
+      .with(
+        body: hash_including(
+          {
+            grant_type: 'client_credentials',
+            client_id: client_id,
+            client_secret: client_secret,
+            organization: organization
+          }
+        )
+      )
+      .to_return(
+        headers: { 'Content-Type' => 'application/json' },
+        body: '{"access_token":"__test_access_token__"}',
+        status: 200
+      )
   end
 end

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

@@ -66,8 +66,19 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unsupported)
       end
 
+      it "should raise Auth0::RequestTimeout on send http #{http_method} method
+        to path defined through HTTP when RestClient::RequestTimeout received" do
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: { params: {} },
+                                                             payload: nil)
+          .and_raise(RestClient::Exceptions::OpenTimeout.new)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::RequestTimeout)
+      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
+        to path defined through HTTP when 400 status received" do
         @exception.response = StubResponse.new({}, false, 400)
         allow(RestClient::Request).to receive(:execute).with(method: http_method,
                                                              url: '/test',
@@ -89,6 +100,35 @@ describe Auth0::Mixins::HTTPProxy do
           .and_raise(@exception)
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::AccessDenied)
       end
+
+      it "should raise Auth0::RateLimitEncountered on send http #{http_method} method
+        to path defined through HTTP when 429 recieved" do
+        headers = {
+          :x_ratelimit_limit     => 10,
+          :x_ratelimit_remaining => 0,
+          :x_ratelimit_reset     => 1560564149
+        }
+        @exception.response = StubResponse.new({}, false, 429, headers)
+        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 { |error|
+          expect(error).to be_a(Auth0::RateLimitEncountered)
+          expect(error).to have_attributes(
+            error_data: {
+              headers: headers,
+              code: 429
+            },
+            headers: headers,
+            http_code: 429,
+            reset: Time.at(1560564149)
+          )
+        }
+      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)
@@ -101,7 +141,7 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it 'should escape path with URI.escape' do
+      it 'should escape path with Addressable::URI.escape' do
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
                                                               url: '/te%20st',
                                                               timeout: nil,
@@ -149,6 +189,34 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unauthorized)
       end
 
+      it "should raise Auth0::RateLimitEncountered on send http #{http_method} method
+        to path defined through HTTP when 429 status received" do
+        headers = {
+          :x_ratelimit_limit     => 10,
+          :x_ratelimit_remaining => 0,
+          :x_ratelimit_reset     => 1560564149
+        }
+        @exception.response = StubResponse.new({}, false, 429,headers)
+        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 { |error|
+          expect(error).to be_a(Auth0::RateLimitEncountered)
+          expect(error).to have_attributes(
+            error_data: {
+              headers: headers,
+              code: 429
+            },
+            headers: headers,
+            http_code: 429,
+            reset: Time.at(1560564149)
+          )
+        }
+      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)
@@ -173,8 +241,19 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::Unsupported)
       end
 
+      it "should raise Auth0::RequestTimeout on send http #{http_method} method
+        to path defined through HTTP when RestClient::RequestTimeout received" do
+        allow(RestClient::Request).to receive(:execute).with(method: http_method,
+                                                             url: '/test',
+                                                             timeout: nil,
+                                                             headers: nil,
+                                                             payload: '{}')
+          .and_raise(RestClient::Exceptions::OpenTimeout.new)
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::RequestTimeout)
+      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
+        to path defined through HTTP when 400 status received" do
         @exception.response = StubResponse.new({}, false, 400)
         allow(RestClient::Request).to receive(:execute).with(method: http_method,
                                                              url: '/test',
@@ -196,7 +275,7 @@ describe Auth0::Mixins::HTTPProxy do
         expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it 'should escape path with URI.escape' do
+      it 'should escape path with Addressable::URI.escape' do
         expect(RestClient::Request).to receive(:execute).with(method: http_method,
                                                               url: '/te%20st',
                                                               timeout: nil,

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

@@ -4,6 +4,7 @@ class MockClass
   attr_reader :token
   include Auth0::Mixins::Initializer
   include Auth0::Mixins::HTTPProxy
+  include Auth0::Mixins::Headers
 end
 
 describe Auth0::Mixins::Initializer do