auth0 4.11.0 → 5.20.0

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

@@ -1,304 +0,0 @@
-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::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 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::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)
-        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::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)
-        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::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 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

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-class MockClass
-  attr_reader :token
-  include Auth0::Mixins::Initializer
-  include Auth0::Mixins::HTTPProxy
-  include Auth0::Mixins::Headers
-end
-
-describe Auth0::Mixins::Initializer do
-  let(:params) { { namespace: 'samples.auth0.com' } }
-  let(:instance) { DummyClassForProxy.send(:include, described_class).new(params) }
-  context 'api v2' do
-    before do
-      params[:api_version] = 2
-    end
-
-    it 'sets token when access_token is passed' do
-      params[:access_token] = '123'
-
-      expect(instance.instance_variable_get('@token')).to eq('123')
-    end
-
-    it 'sets token when token is passed' do
-      params[:token] = '123'
-
-      expect(instance.instance_variable_get('@token')).to eq('123')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,62 +0,0 @@
-require 'pry'
-require 'rack/test'
-require 'faker'
-require 'auth0'
-
-require 'simplecov'
-SimpleCov.start
-
-if ENV['CI'] == 'true'
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
-
-require 'dotenv'
-Dotenv.load
-
-require 'webmock/rspec'
-WebMock.allow_net_connect!
-
-require 'vcr'
-VCR.configure do |config|
-  # Uncomment the line below to record new VCR cassettes.
-  # When this is commented out, VCR will reject all outbound HTTP calls.
-  config.allow_http_connections_when_no_cassette = true
-  config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-  config.configure_rspec_metadata!
-  config.hook_into :webmock
-  config.filter_sensitive_data('CLIENT_SECRET') { ENV['CLIENT_SECRET'] }
-  config.filter_sensitive_data('API_TOKEN') { ENV['MASTER_JWT'] }
-
-  ENV['DOMAIN'] = 'auth0-sdk-tests.auth0.com'
-  ENV['CLIENT_ID'] = '2cnWuug6zaFX1j0ge1P99jAUn0F4XSuI'
-end
-
-$LOAD_PATH.unshift File.expand_path('..', __FILE__)
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-Dir['./lib/*.rb'].each { |f| require f }
-Dir['./lib/api/**/*.rb'].each { |f| require f }
-Dir['./spec/support/**/*.rb'].each { |f| require f }
-Dir['./spec/support/*.rb'].each { |f| require f }
-
-require 'rspec'
-RSpec.configure do |config|
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-  config.include Credentials
-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
-
-def entity_suffix
-  'rubytest'
-end
-
-puts "Entity suffix is #{entity_suffix}"

data/spec/support/credentials.rb

@@ -1,30 +0,0 @@
-module Credentials
-  module_function
-
-  def v1_creds
-    {
-      client_id: ENV['CLIENT_ID'],
-      client_secret: ENV['CLIENT_SECRET'],
-      domain: ENV['DOMAIN'],
-      api_version: 1
-    }
-  end
-
-  def v1_global_creds
-    {
-      client_id: ENV['GLOBAL_CLIENT_ID'],
-      client_secret: ENV['GLOBAL_CLIENT_SECRET'],
-      domain: ENV['DOMAIN'],
-      api_version: 1
-    }
-  end
-
-  def v2_creds
-    {
-      domain: ENV.fetch( 'DOMAIN', 'DOMAIN' ),
-      client_id: ENV.fetch( 'CLIENT_ID', 'CLIENT_ID' ),
-      client_secret: ENV.fetch( 'CLIENT_SECRET', 'TEST_CLIENT_SECRET' ),
-      token: ENV.fetch( 'MASTER_JWT', 'TEST_MASTER_JWT' )
-    }
-  end
-end

data/spec/support/dummy_class.rb

@@ -1,18 +0,0 @@
-class DummyClass
-  include Auth0::Mixins::Headers
-
-  attr_reader :domain, :client_id, :client_secret, :audience
-
-  def initialize
-    @domain = 'test.auth0.com'
-    @client_id = '__test_client_id__'
-    @client_secret = '__test_client_secret__'
-    @audience = "https://#{@domain}/api/v2/"
-  end
-
-  %i(get post put patch delete delete_with_body).each do |method|
-    define_method(method) do |_path, _body = {}|
-      true
-    end
-  end
-end

data/spec/support/dummy_class_for_proxy.rb

@@ -1,5 +0,0 @@
-class DummyClassForProxy
-  include Auth0::Mixins::HTTPProxy
-  include Auth0::Mixins::Headers
-  @base_uri = 'http://auth0.com'
-end

data/spec/support/dummy_class_for_restclient.rb

@@ -1,2 +0,0 @@
-class DummyClassForRestClient < RestClient::Exception
-end

data/spec/support/import_users.json

@@ -1,13 +0,0 @@
-[
-  {
-    "email": "john.doe@contoso.com",
-    "email_verified": false,
-    "app_metadata": {
-        "roles": ["admin"],
-        "plan": "premium"
-    },
-    "user_metadata": {
-        "theme": "light"
-    }
-  }
-]

data/spec/support/stub_response.rb

@@ -1 +0,0 @@
-StubResponse = Struct.new(:body, :success?, :code, :headers)