auth0 4.14.0 → 5.0.0

data/lib/auth0/api/v2.rb

@@ -16,6 +16,7 @@ require 'auth0/api/v2/user_blocks'
 require 'auth0/api/v2/tenants'
 require 'auth0/api/v2/tickets'
 require 'auth0/api/v2/logs'
+require 'auth0/api/v2/log_streams'
 require 'auth0/api/v2/resource_servers'
 require 'auth0/api/v2/guardian'
 
@@ -41,6 +42,7 @@ module Auth0
       include Auth0::Api::V2::Tenants
       include Auth0::Api::V2::Tickets
       include Auth0::Api::V2::Logs
+      include Auth0::Api::V2::LogStreams
       include Auth0::Api::V2::ResourceServers
       include Auth0::Api::V2::Guardian
     end

data/lib/auth0/api/v2/jobs.rb

@@ -78,14 +78,24 @@ module Auth0
         # @see https://auth0.com/docs/api/management/v2#!/Jobs/post_verification_email
         # @param user_id [string] The user_id of the user to whom the email will be sent.
         # @param client_id [string] Client ID to send an Application-specific email.
+        # @param identity [hash] Used to verify secondary, federated, and passwordless-email identities.
+        #   * :user_id [string] user_id of the identity.
+        #   * :provider [string] provider of the identity.
         #
         # @return [json] Returns the job status and properties.
-        def send_verification_email(user_id, client_id = nil)
+        def send_verification_email(user_id, client_id = nil, identity: nil)
           raise Auth0::InvalidParameter, 'Must specify a user id' if user_id.to_s.empty?
 
           request_params = { user_id: user_id }
           request_params[:client_id] = client_id unless client_id.nil?
 
+          if identity
+            unless identity.is_a? Hash
+              raise Auth0::InvalidParameter, 'Identity must be a hash send an email verification'
+            end
+            request_params[:identity] = identity
+          end
+
           path = "#{jobs_path}/verification-email"
           post(path, request_params)
         end

data/lib/auth0/api/v2/log_streams.rb

@@ -0,0 +1,78 @@
+module Auth0
+  module Api
+    module V2
+      # Methods to use the log streams endpoints
+      module LogStreams
+        attr_reader :log_streams_path
+
+        # Retrieves a list of all log streams.
+        # @see https://auth0.com/docs/api/management/v2#!/Log_Streams/get_log_streams
+        # @return [json] Returns the log streams.
+        def log_streams()
+          get(log_streams_path)
+        end
+        alias get_log_streams log_streams
+
+        # Retrieves a log stream by its ID.
+        # @see https://auth0.com/docs/api/management/v2#!/Log_Streams/get_log_streams_by_id
+        # @param id [string] The id of the log stream to retrieve.
+        #
+        # @return [json] Returns the log stream.
+        def log_stream(id)
+          raise Auth0::InvalidParameter, 'Must supply a valid log stream id' if id.to_s.empty?
+          path = "#{log_streams_path}/#{id}"
+          get(path)
+        end
+        alias get_log_stream log_stream
+
+        # Creates a new log stream according to the JSON object received in body.
+        # @see https://auth0.com/docs/api/management/v2#!/Log_Streams/post_log_streams
+        # @param name [string] The name of the log stream.
+        # @param type [string] The type of log stream
+        # @param options [hash] The Hash options used to define the log streams's properties.
+        #
+        # @return [json] Returns the log stream.
+        def create_log_stream(name, type, options)
+          raise Auth0::InvalidParameter, 'Name must contain at least one character' if name.to_s.empty?
+          raise Auth0::InvalidParameter, 'Must specify a valid type' if type.to_s.empty?
+          raise Auth0::InvalidParameter, 'Must supply a valid hash for options' unless options.is_a? Hash
+
+          request_params = {}
+          request_params[:name] = name
+          request_params[:type] = type
+          request_params[:sink] = options
+          post(log_streams_path, request_params)
+        end
+
+        # Deletes a log stream by its ID.
+        # @see https://auth0.com/docs/api/management/v2#!/Log_Streams/delete_log_streams_by_id
+        # @param id [string] The id of the log stream to delete.
+        def delete_log_stream(id)
+          raise Auth0::InvalidParameter, 'Must supply a valid log stream id' if id.to_s.empty?
+          path = "#{log_streams_path}/#{id}"
+          delete(path)
+        end
+
+        # Updates a log stream.
+        # @see https://auth0.com/docs/api/management/v2#!/Log_Streams/patch_log_streams_by_id
+        # @param id [string] The id or audience of the log stream to update.
+        # @param status [string] The Hash options used to define the log streams's properties.
+        def patch_log_stream(id, status)
+          raise Auth0::InvalidParameter, 'Must specify a log stream id' if id.to_s.empty?
+          raise Auth0::InvalidParameter, 'Must specify a valid status' if status.to_s.empty?
+
+          request_params = {}
+          request_params[:status] = status
+          path = "#{log_streams_path}/#{id}"
+          patch(path, request_params)
+        end
+        
+        private
+        # Log Streams API path
+        def log_streams_path
+          @log_streams_path ||= '/api/v2/log-streams'
+        end
+      end
+    end
+  end
+end

data/lib/auth0/api/v2/tickets.rb

@@ -12,9 +12,12 @@ module Auth0
         # @param ttl_sec [integer] The ticket's lifetime in seconds starting from the moment of creation.
         # After expiration, the ticket cannot be used to verify the user's email. If not specified or if
         # you send 0, the Auth0 default lifetime of five days will be applied
+        # @param identity [hash] Used to verify secondary, federated, and passwordless-email identities.
+        #   * :user_id [string] user_id of the identity.
+        #   * :provider [string] provider of the identity.
         #
         # @return [json] Returns the created ticket url.
-        def post_email_verification(user_id, result_url: nil, ttl_sec: nil)
+        def post_email_verification(user_id, result_url: nil, ttl_sec: nil, identity: nil)
           if user_id.to_s.empty?
             raise Auth0::InvalidParameter, 'Must supply a valid user id to post an email verification'
           end
@@ -24,6 +27,14 @@ module Auth0
             result_url: result_url,
             ttl_sec: ttl_sec.is_a?(Integer) ? ttl_sec : nil
           }
+
+          if identity
+            unless identity.is_a? Hash
+              raise Auth0::InvalidParameter, 'Identity must be a hash to post an email verification'
+            end
+            request_params[:identity] = identity
+          end
+
           post(path, request_params)
         end
 

data/lib/auth0/api/v2/users.rb

@@ -43,13 +43,15 @@ module Auth0
         # The attribute connection is always mandatory but depending on the type of connection you are using there
         # could be others too. For instance, Auth0 DB Connections require email and password.
         # @see https://auth0.com/docs/api/v2#!/Users/post_users
-        # @param name [string] The user name.
-        # @param options [hash]
-        #   * :connection [string] The connection the user belongs to.
+        # @param connection [string]  The connection the user belongs to.
+        # @param options [hash] See https://auth0.com/docs/api/management/v2#!/Users/post_users for available options
         # @return [json] Returns the created user.
-        def create_user(name, options = {})
+        def create_user(connection, options = {})
+          if !connection.is_a?(String) || connection.empty?
+            raise Auth0::MissingParameter, 'Must supply a valid connection'
+          end
           request_params = Hash[options.map { |(k, v)| [k.to_sym, v] }]
-          request_params[:name] = name
+          request_params[:connection] = connection
           post(users_path, request_params)
         end
 
@@ -248,11 +250,22 @@ module Auth0
         # @see https://auth0.com/docs/api/management/v2#!/Users/get_permissions
         #
         # @param user_id [string] The user_id of the permissions to get.
+        # @param options [hash] A hash of options for getting permissions
+        #   * :per_page [integer] The amount of permissions per page. (optional)
+        #   * :page [integer]  The page number. Zero based. (optional)
+        #   * :include_totals [boolean] True if a query summary must be included in the result. (optional)
         #
         # @return [json] Returns permissions for the given user_id.
-        def get_user_permissions(user_id)
+        def get_user_permissions(user_id, options = {})
           raise Auth0::MissingUserId, 'Must supply a valid user_id' if user_id.to_s.empty?
-          get "#{users_path}/#{user_id}/permissions"
+
+          request_params = {
+            per_page: options.fetch(:per_page, nil),
+            page: options.fetch(:page, nil),
+            include_totals: options.fetch(:include_totals, nil)
+          }
+
+          get "#{users_path}/#{user_id}/permissions", request_params
         end
 
         # Remove one or more permissions from a specific user.

data/lib/auth0/exception.rb

@@ -44,17 +44,12 @@ module Auth0
   class AccessDenied < Auth0::HTTPError; end
   # Invalid parameter passed, e.g. empty where ID is required
   class InvalidParameter < Auth0::Exception; end
-  # Invalid Auth0 credentials either client_id/secret for API v1
-  # or JWT for API v2/
+  # Invalid JWT
   class InvalidCredentials < Auth0::Exception; end
   # Invalid Auth0 API namespace
   class InvalidApiNamespace < Auth0::Exception; end
   # Auth0 API rate-limiting encountered
-  # TODO: When making API-breaking changes, make this a subclass
-  # of Auth0::HTTPError directly rather than Auth0::Unsupported.
-  # It's currently under Unsupported to avoid breaking compatibility
-  # with prior gem versions that treated 429 errors as unknown errors.
-  class RateLimitEncountered < Auth0::Unsupported
+  class RateLimitEncountered < Auth0::HTTPError
     def reset
       Time.at(headers['X-RateLimit-Reset']).utc
     end

data/lib/auth0/mixins.rb

@@ -11,7 +11,6 @@ require 'auth0/mixins/permission_struct'
 require 'auth0/mixins/validation'
 
 require 'auth0/api/authentication_endpoints'
-require 'auth0/api/v1'
 require 'auth0/api/v2'
 
 module Auth0

data/lib/auth0/mixins/access_token_struct.rb

@@ -1,4 +1,4 @@
-AccessToken = Struct.new(
+Auth0::AccessToken = Struct.new(
   :access_token,
   :expires_in,
   :refresh_token,
@@ -17,4 +17,4 @@ AccessToken = Struct.new(
   def token
     access_token
   end
-end
+end

data/lib/auth0/mixins/api_token_struct.rb

@@ -1,4 +1,4 @@
-ApiToken = Struct.new :access_token, :scope, :expires_in do
+Auth0::ApiToken = Struct.new :access_token, :scope, :expires_in do
 
   def token
     access_token
@@ -7,4 +7,4 @@ ApiToken = Struct.new :access_token, :scope, :expires_in do
   def scopes
     scope.split
   end
-end
+end

data/lib/auth0/mixins/httpproxy.rb

@@ -1,3 +1,5 @@
+require "addressable/uri"
+
 module Auth0
   module Mixins
     # here's the proxy for Rest calls based on rest-client, we're building all request on that gem
@@ -8,7 +10,7 @@ module Auth0
       # proxying requests from instance methods to HTTP class methods
       %i(get post post_file put patch delete delete_with_body).each do |method|
         define_method(method) do |path, body = {}, extra_headers = {}|
-          safe_path = URI.escape(path)
+          safe_path = Addressable::URI.escape(path)
           body = body.delete_if { |_, v| v.nil? }
           result = if method == :get
                      # Mutate the headers property to add parameters.

data/lib/auth0/mixins/initializer.rb

@@ -40,7 +40,7 @@ module Auth0
       private
 
       def initialize_api(options)
-        api_v2?(options) ? initialize_v2(options) : initialize_v1
+        initialize_v2(options)
         raise InvalidCredentials, 'Must supply a valid API token' if @token.nil?
         if options.fetch(:authorization, nil) == 'Basic'
           authorization_header_basic(options)
@@ -61,12 +61,6 @@ module Auth0
         @token = api_token.token if @token.nil? && @client_id && @client_secret
       end
 
-      def initialize_v1
-        extend Auth0::Api::V1
-        raise InvalidCredentials, 'Invalid API v1 client_id and client_secret' if @client_id.nil? || @client_secret.nil?
-        @token = obtain_access_token
-      end
-
       def api_v2?(options)
         version = options[:api_version] || 2
         protocol = options[:protocols].to_s

data/lib/auth0/mixins/permission_struct.rb

@@ -1,3 +1,3 @@
-Permission = Struct.new :permission_name, :resource_server_identifier do
+Auth0::Permission = Struct.new :permission_name, :resource_server_identifier do
 
-end
+end

data/lib/auth0/mixins/validation.rb

@@ -23,7 +23,7 @@ module Auth0
         raise Auth0::InvalidParameter, 'Must supply an array of Permissions' unless permissions.kind_of?(Array)
         raise Auth0::MissingParameter, 'Must supply an array of Permissions' if permissions.empty?
         raise Auth0::InvalidParameter, 'All array elements must be Permissions' unless permissions.all? do |permission|
-          permission.kind_of? Permission
+          permission.kind_of? ::Auth0::Permission
         end
         permissions.map { |permission| permission.to_h }
       end

data/lib/auth0/version.rb

@@ -1,4 +1,4 @@
 # current version of gem
 module Auth0
-  VERSION = '4.14.0'.freeze
+  VERSION = '5.0.0'.freeze
 end

data/spec/integration/lib/auth0/api/api_authentication_spec.rb

@@ -60,7 +60,7 @@ describe Auth0::Api::AuthenticationEndpoints do
     end
 
     it 'should return the userinfo' do
-      tokens = @client.login(test_user_email, test_user_pwd, nil, nil)
+      tokens = @client.login_with_resource_owner(test_user_email, test_user_pwd)
       expect(@client.userinfo(tokens['access_token'])).to(
         include( 'email' => test_user_email )
       )

data/spec/integration/lib/auth0/api/v2/api_jobs_spec.rb

@@ -100,6 +100,18 @@ describe Auth0::Api::V2::Jobs do
         client.send_verification_email(user['user_id'], Random.new(32).to_s)
       end.to raise_error Auth0::BadRequest
     end
+
+    it 'should raise an error if the user id is empty' do
+      expect do
+        client.send_verification_email( '' )
+      end.to raise_error Auth0::InvalidParameter, 'Must specify a user id'
+    end
+
+    it 'should raise an error if the identity supplied is not a Hash' do
+      expect do
+        client.send_verification_email( 'user_id', identity: 'not a hash')
+      end.to raise_error Auth0::InvalidParameter, 'Identity must be a hash send an email verification'
+    end
   end
 
   after(:all) do

data/spec/integration/lib/auth0/api/v2/api_roles_spec.rb

@@ -14,7 +14,7 @@ describe Auth0::Api::V2::Roles do
     @test_role_name = "#{entity_suffix}-test-role"
 
     @test_permission_name = "#{entity_suffix}-test-permission"
-    @test_permission = Permission.new(@test_permission_name, @test_api_name)
+    @test_permission = ::Auth0::Permission.new(@test_permission_name , @test_api_name)
 
     VCR.use_cassette('Auth0_Api_V2_Roles/create_test_user') do
       @test_user ||= client.create_user(

data/spec/integration/lib/auth0/api/v2/api_tickets_spec.rb

@@ -35,7 +35,13 @@ describe Auth0::Api::V2::Tickets do
     it 'should raise an error if the user id is empty' do
       expect do
         client.post_email_verification( '' )
-      end.to raise_error Auth0::InvalidParameter
+      end.to raise_error Auth0::InvalidParameter, 'Must supply a valid user id to post an email verification'
+    end
+
+    it 'should raise an error if the identity supplied is not a Hash' do
+      expect do
+        client.post_email_verification( '', identity: 'not a hash')
+      end.to raise_error Auth0::InvalidParameter, 'Must supply a valid user id to post an email verification'
     end
   end
 

data/spec/integration/lib/auth0/api/v2/api_users_spec.rb

@@ -14,7 +14,7 @@ describe Auth0::Api::V2::Users do
     @test_api_scope = 'test:scope'
 
     @test_permission_name = "#{entity_suffix}-test-permission-for-users"
-    @test_permission = Permission.new("#{entity_suffix}-test-permission-for-users", @test_api_name)
+    @test_permission = ::Auth0::Permission.new("#{entity_suffix}-test-permission-for-users", @test_api_name)
 
     VCR.use_cassette('Auth0_Api_V2_Users/create_test_user') do
       @test_user ||= client.create_user(

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

@@ -102,6 +102,23 @@ describe Auth0::Api::V2::Jobs do
       end.not_to raise_error
     end
 
+    it 'expect client to accept hash identity' do
+      expect(@instance).to receive(:post).with('/api/v2/jobs/verification-email', user_id: 'user_id',
+                                                                                  identity: {
+                                                                                    provider: "auth0",
+                                                                                    user_id: "user_id"
+                                                                                  })
+      expect {
+        @instance.send_verification_email('user_id', identity: { provider: "auth0", user_id: "user_id"}) 
+      }.not_to raise_error
+    end
+
+    it 'expect client to return nil when calling with a non-hash identity' do
+      expect { @instance.send_verification_email('user_id', identity: "nonhash") }.to raise_error(
+        'Identity must be a hash send an email verification'
+      )
+    end
+
     it 'should raise an error if the user_id is empty' do
       expect do
         @instance.send_verification_email('')

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+describe Auth0::Api::V2::LogStreams do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::LogStreams)
+    dummy_instance.extend(Auth0::Mixins::Initializer)
+    @instance = dummy_instance
+  end
+
+  context '.log_streams' do
+    it { expect(@instance).to respond_to(:log_streams) }
+    it { expect(@instance).to respond_to(:get_log_streams) }
+    it 'is expected to call get /api/v2/log-streams' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/log-streams'
+      )
+      expect { @instance.log_streams }.not_to raise_error
+    end
+  end
+
+  context '.log_stream' do
+    it { expect(@instance).to respond_to(:log_stream) }
+    it 'is expected to call get /api/v2/log-streams/test' do
+      expect(@instance).to receive(:get).with('/api/v2/log-streams/test')
+      expect { @instance.log_stream('test') }.not_to raise_error
+    end
+    it 'expect to raise an error when calling with empty log stream id' do
+      expect { @instance.log_stream(nil) }.to raise_error 'Must supply a valid log stream id'
+    end
+  end
+
+  context '.create_log_stream' do
+    it { expect(@instance).to respond_to(:create_log_stream) }
+    it 'is expected to call post /api/v2/log-streams' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/log-streams',
+        name: 'test',
+        type: 'https',
+        sink: {
+          httpEndpoint: "https://mycompany.com",
+          httpContentType: "string",
+          httpContentFormat: "JSONLINES",
+          httpAuthorization: "string"
+        }
+      )
+
+      @instance.create_log_stream('test', 'https',
+        httpEndpoint: "https://mycompany.com",
+        httpContentType: "string",
+        httpContentFormat: "JSONLINES",
+        httpAuthorization: "string")
+    end
+    it 'expect to raise an error when calling with empty name' do
+      expect { @instance.create_log_stream('', '', '') }.to raise_error 'Name must contain at least one character'
+    end
+    it 'expect to raise an error when calling with empty type' do
+      expect { @instance.create_log_stream('name', '', '') }.to raise_error 'Must specify a valid type'
+    end
+    it 'expect to raise an error when calling without options' do
+      expect { @instance.create_log_stream('name', 'https', nil) }.to raise_error 'Must supply a valid hash for options'
+    end
+  end
+
+  context '.delete_log_stream' do
+    it { expect(@instance).to respond_to(:delete_log_stream) }
+    it 'is expected to call delete /api/v2/log-streams/test' do
+      expect(@instance).to receive(:delete).with('/api/v2/log-streams/test')
+      expect { @instance.delete_log_stream('test') }.not_to raise_error
+    end
+    it 'expect to raise an error when calling with empty log stream id' do
+      expect { @instance.delete_log_stream(nil) }.to raise_error 'Must supply a valid log stream id'
+    end
+  end
+
+  context '.patch_log_stream' do
+    it { expect(@instance).to respond_to(:patch_log_stream) }
+    it 'is expected to send patch to /api/v2/log_streams/test' do
+      expect(@instance).to receive(:patch).with('/api/v2/log-streams/test', status: 'paused')
+      expect { @instance.patch_log_stream('test', 'paused') }.not_to raise_error
+    end
+    it { expect { @instance.patch_log_stream('', nil) }.to raise_error 'Must specify a log stream id' }
+    it { expect { @instance.patch_log_stream('test', nil) }.to raise_error 'Must specify a valid status' }
+  end
+end