auth0 3.6.1 → 4.0.0

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Tenants do
+  before :all do
+    @instance = DummyClass.new.extend(Auth0::Api::V2::Tenants)
+  end
+
+  context '.get_tenant_settings' do
+    it { expect(@instance).to respond_to(:get_tenant_settings) }
+    it 'expect client to send post to /api/v2/tenants/settings with fields' do
+      expect(@instance).to receive(:get).with('/api/v2/tenants/settings', fields: 'field', include_fields: true)
+      expect { @instance.get_tenant_settings(fields: 'field') }.not_to raise_error
+    end
+  end
+  context '.update_tenant_settings' do
+    it { expect(@instance).to respond_to(:update_tenant_settings) }
+    it 'expect client to send post to /api/v2/tenants/settings with body' do
+      expect(@instance).to receive(:patch).with('/api/v2/tenants/settings', 'test body')
+      expect { @instance.update_tenant_settings('test body') }.not_to raise_error
+    end
+    it 'expect client to rasie error when calling with empty body' do
+      expect { @instance.update_tenant_settings(nil) }.to raise_error(
+        'Must supply a valid body to update tenant settings')
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Tickets do
+  before :all do
+    @instance = DummyClass.new.extend(Auth0::Api::V2::Tickets)
+  end
+
+  context '.post_email_verification' do
+    it { expect(@instance).to respond_to(:post_email_verification) }
+    it 'expect client to send post to /api/v2/tickets/email-verification with body' do
+      expect(@instance).to receive(:post).with('/api/v2/tickets/email-verification', user_id: 'user_id', result_url: nil)
+      expect { @instance.post_email_verification('user_id') }.not_to raise_error
+    end
+    it 'expect client to rasie error when calling with empty body' do
+      expect { @instance.post_email_verification(nil) }.to raise_error(
+        'Must supply a valid user id to post an email verification')
+    end
+  end
+  context '.post_password_change' do
+    it { expect(@instance).to respond_to(:post_password_change) }
+    it 'expect client to send post to /api/v2/tickets/password-change with body' do
+      expect(@instance).to receive(:post).with('/api/v2/tickets/password-change', user_id: nil, result_url: nil,
+                                                                                  new_password: 'new_pass',
+                                                                                  connection_id: nil, email: nil)
+      expect { @instance.post_password_change('new_pass') }.not_to raise_error
+    end
+    it 'expect client to rasie error when calling with empty body' do
+      expect { @instance.post_password_change(nil) }.to raise_error(
+        'Must supply a valid new password to post a password-change')
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 describe Auth0::Api::V2::Users do
   before :all do
     dummy_instance = DummyClass.new
@@ -6,67 +6,129 @@ describe Auth0::Api::V2::Users do
     @instance = dummy_instance
   end
 
-  context ".users" do
-    it {expect(@instance).to respond_to(:users)}
-    it {expect(@instance).to respond_to(:get_users)}
-    it "is expected to call /api/v2/users" do
-      expect(@instance).to receive(:get).with("/api/v2/users",{:per_page=>nil, :page=>nil, :include_totals=>nil, :sort=>nil, :connection=>nil, :fields=>nil, :q=>nil})
-      expect{@instance.users}.not_to raise_error
+  context '.users' do
+    it { expect(@instance).to respond_to(:users) }
+    it { expect(@instance).to respond_to(:get_users) }
+    it 'is expected to call /api/v2/users' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users',
+        per_page: nil,
+        page: nil,
+        include_totals: nil,
+        sort: nil,
+        connection: nil,
+        fields: nil,
+        include_fields: nil,
+        q: nil)
+      expect { @instance.users }.not_to raise_error
     end
   end
 
-  context ".user" do
-    it {expect(@instance).to respond_to(:user)}
-    it "is expected to call get request to /api/v2/users/USER_ID" do
-      expect(@instance).to receive(:get).with("/api/v2/users/USER_ID", {fields: nil})
-      expect{@instance.user("USER_ID")}.not_to raise_error
+  context '.user' do
+    it { expect(@instance).to respond_to(:user) }
+    it 'is expected to call get request to /api/v2/users/USER_ID' do
+      expect(@instance).to receive(:get).with('/api/v2/users/USER_ID', fields: nil, include_fields: true)
+      expect { @instance.user('USER_ID') }.not_to raise_error
     end
+    it { expect { @instance.user('') }.to raise_error 'Must supply a valid user_id' }
   end
 
-
-  context ".create_user" do
-    it {expect(@instance).to respond_to(:create_user)}
-    it "is expected to call post to /api/v2/users" do
-      expect(@instance).to receive(:post).with("/api/v2/users", {email: "test@test.com", password: "password", connection: "conn", name:"name"})
-      @instance.create_user("name", {email:"test@test.com",password: "password", connection: "conn"})
+  context '.create_user' do
+    it { expect(@instance).to respond_to(:create_user) }
+    it 'is expected to call post to /api/v2/users' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/users',
+        email: 'test@test.com',
+        password: 'password',
+        connection: 'conn',
+        name: 'name')
+      @instance.create_user(
+        'name',
+        email: 'test@test.com',
+        password: 'password',
+        connection: 'conn')
     end
   end
 
-  context ".delete_users" do
-    it {expect(@instance).to respond_to :delete_users}
-    it "is expected to call delete to /api/v2/users" do
-      expect(@instance).to receive(:delete).with("/api/v2/users")
+  context '.delete_users' do
+    it { expect(@instance).to respond_to :delete_users }
+    it 'is expected to call delete to /api/v2/users' do
+      expect(@instance).to receive(:delete).with('/api/v2/users')
       @instance.delete_users
     end
   end
 
-  context ".delete_user" do
-    it {expect(@instance).to respond_to(:delete_user)}
-    it "is expected to call delete to /api/v2/users/userId" do
-      expect(@instance).to receive(:delete).with("/api/v2/users/userId")
-      @instance.delete_user("userId")
+  context '.delete_user' do
+    it { expect(@instance).to respond_to(:delete_user) }
+    it 'is expected to call delete to /api/v2/users/userId' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/userId')
+      @instance.delete_user('userId')
     end
 
-    it "is expected not to call delete to /api/v2/users if user_id is blank" 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)
+      expect { @instance.delete_user('') }.to raise_exception(
+        Auth0::MissingUserId)
+    end
+  end
+
+  context '.delete_user_provider' do
+    it { expect(@instance).to respond_to(:delete_user_provider) }
+    it 'is expected to call delete to /api/v2/users/userId/multifactor/provider' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/userId/multifactor/provider')
+      @instance.delete_user_provider('userId', 'provider')
+    end
+  end
+
+  context '.patch_user' do
+    it { expect(@instance).to respond_to(:patch_user) }
+    it 'is expected to call patch to /api/v2/users/userID' do
+      expect(@instance).to receive(:patch).with(
+        '/api/v2/users/UserID',
+        email: 'test@test.com',
+        password: 'password',
+        connection: 'conn',
+        name: 'name')
+      @instance.patch_user(
+        'UserID',
+        email: 'test@test.com',
+        password: 'password',
+        connection: 'conn',
+        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' }
   end
 
-  context ".delete_user_provider" do
-    it {expect(@instance).to respond_to(:delete_user_provider)}
-    it "is expected to call delete to /api/v2/users/userId/multifactor/provider" do
-      expect(@instance).to receive(:delete).with("/api/v2/users/userId/multifactor/provider")
-      @instance.delete_user_provider("userId", "provider")
+  context '.link_user_account' do
+    it { expect(@instance).to respond_to(:link_user_account) }
+    it 'is expected to call post to /api/v2/users/UserId/identities' do
+      expect(@instance).to receive(:post).with('/api/v2/users/UserID/identities', body: 'json body')
+      @instance.link_user_account('UserID', body: 'json body')
     end
+    it { expect { @instance.link_user_account('', 'body') }.to raise_error 'Must supply a valid user_id' }
+    it { expect { @instance.link_user_account('UserId', '') }.to raise_error 'Must supply a valid body' }
   end
 
-  context ".patch_user" do
-    it {expect(@instance).to respond_to(:patch_user)}
-    it "is expected to call patch to /api/v2/users/userID" do
-      expect(@instance).to receive(:patch).with("/api/v2/users/UserID", {email: "test@test.com", password: "password", connection: "conn", name:"name"})
-      @instance.patch_user("UserID", {email:"test@test.com",password: "password", connection: "conn", name:"name"})
+  context '.unlink_users_account' do
+    it { expect(@instance).to respond_to(:unlink_users_account) }
+    it 'is expected to call delete to /api/v2/users/UserId/identities' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/UserID/identities/provider_name/Secondary_User_ID')
+      @instance.unlink_users_account('UserID', 'provider_name', 'Secondary_User_ID')
+    end
+    it { expect { @instance.unlink_users_account('', 'pro', 'SUserID') }.to raise_error 'Must supply a valid user_id' }
+    it { expect { @instance.unlink_users_account('UID', nil, 'SUID') }.to raise_error 'Must supply a valid provider' }
+    it do
+      expect { @instance.unlink_users_account('UID', 'pro', nil) }.to raise_error 'Must supply a valid secondary user_id'
     end
   end
 
+  context '.delete_user_provider' do
+    it { expect(@instance).to respond_to(:delete_user_provider) }
+    it 'is expected to call delete to /api/v2/users/User_ID/multifactor/provider_name' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/User_ID/multifactor/provider_name')
+      @instance.delete_user_provider('User_ID', 'provider_name')
+    end
+    it { expect { @instance.delete_user_provider(nil, 'test') }.to raise_error 'Must supply a valid user_id' }
+  end
 end

data/spec/lib/auth0/client_spec.rb

@@ -1,8 +1,7 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Auth0::Client do
-
-  shared_examples_for "v1 API client" do
+  shared_examples_for 'v1 API client' do
     it { should be_a Auth0::Api::V1 }
     it { should be_a Auth0::Api::V1::Users }
     it { should be_a Auth0::Api::V1::Connections }
@@ -17,7 +16,7 @@ describe Auth0::Client do
     it { should_not be_a Auth0::Api::V2::Blacklists }
   end
 
-  shared_examples_for "v2 API client" do
+  shared_examples_for 'v2 API client' do
     it { should be_a Auth0::Api::V2 }
     it { should be_a Auth0::Api::V2::Clients }
     it { should be_a Auth0::Api::V2::Users }
@@ -32,84 +31,73 @@ describe Auth0::Client do
     it { should_not be_a Auth0::Api::V1::Logs }
   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(:jwt) { "Header.Payload.Signature" }
-  let(:access_token) { "token" }
-
-  describe "V1 client" do
+  let(:domain) { 'samples.auth0.com' }
+  let(:client_id) { 'client_id' }
+  let(:client_secret) { 'client_secret' }
+  let(:jwt) { 'Header.Payload.Signature' }
+  let(:access_token) { 'token' }
 
+  describe 'V1 client' do
     before :each do
-      allow_any_instance_of(Auth0::Api::AuthenticationEndpoints).to receive(:obtain_access_token).and_return "token"
+      allow_any_instance_of(Auth0::Api::AuthenticationEndpoints).to receive(:obtain_access_token).and_return 'token'
     end
 
-    context "with namespace" do
-
-      let(:subject) { Auth0::Client.new(client_id: "client_id", client_secret: "client_secret", namespace: "samples.auth0.com") }
-
-      it_should_behave_like "v1 API client"
-      it_should_behave_like "authentication API client"
+    context 'with namespace' do
+      let(:subject) do
+        Auth0::Client.new(client_id: 'client_id', client_secret: 'client_secret', namespace: 'samples.auth0.com')
+      end
 
+      it_should_behave_like 'v1 API client'
+      it_should_behave_like 'authentication API client'
     end
 
-    context "with domain" do
-
-      let(:subject) { Auth0::Client.new(client_id: "client_id", client_secret: "client_secret", domain: "samples.auth0.com") }
-
-      it_should_behave_like "v1 API client"
-      it_should_behave_like "authentication API client"
+    context 'with domain' do
+      let(:subject) do
+        Auth0::Client.new(client_id: 'client_id', client_secret: 'client_secret', domain: 'samples.auth0.com')
+      end
 
+      it_should_behave_like 'v1 API client'
+      it_should_behave_like 'authentication API client'
     end
 
-    context "with version" do
-
-      let(:subject) { Auth0::Client.new(client_id: "client_id", client_secret: "client_secret", domain: "samples.auth0.com", api_version: 1) }
-
-      it_should_behave_like "v1 API client"
-      it_should_behave_like "authentication API client"
-
+    context 'with version' do
+      let(:subject) do
+        Auth0::Client.new(
+          client_id: 'client_id',
+          client_secret: 'client_secret',
+          domain: 'samples.auth0.com',
+          api_version: 1)
+      end
+      it_should_behave_like 'v1 API client'
+      it_should_behave_like 'authentication API client'
     end
-
   end
 
-  describe "V2 client" do
-
+  describe 'V2 client' do
     before :each do
       expect_any_instance_of(Auth0::Api::AuthenticationEndpoints).not_to receive(:obtain_access_token)
     end
 
-    context "with namespace" do
-
-      let(:subject) { Auth0::Client.new(protocols: "v2", access_token: "access_token", namespace: "samples.auth0.com") }
-
-      it_should_behave_like "v2 API client"
-      it_should_behave_like "authentication API client"
-
+    context 'with namespace' do
+      let(:subject) { Auth0::Client.new(protocols: 'v2', 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") }
-
-      it_should_behave_like "v2 API client"
-      it_should_behave_like "authentication API client"
-
+    context 'with domain' do
+      let(:subject) { Auth0::Client.new(protocols: 'v2', access_token: 'access_token', domain: 'samples.auth0.com') }
+      it_should_behave_like 'v2 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") }
-
-      it_should_behave_like "v2 API client"
-      it_should_behave_like "authentication API client"
-
+    context 'with version' do
+      let(:subject) { Auth0::Client.new(api_version: 2, access_token: 'access_token', domain: 'samples.auth0.com') }
+      it_should_behave_like 'v2 API client'
+      it_should_behave_like 'authentication API client'
     end
-
   end
-
 end

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

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 describe Auth0::Mixins::HTTPartyProxy do
   before :all do
     dummy_instance = DummyClassForProxy.new
@@ -8,111 +8,140 @@ describe Auth0::Mixins::HTTPartyProxy do
 
   %i(get).each do |http_method|
     context ".#{http_method}" do
-      it {expect(@instance).to respond_to(http_method.to_sym)}
+      it { expect(@instance).to respond_to(http_method.to_sym) }
       it "should call send http #{http_method} method to path defined through HTTParty" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, true, 200))
-        expect{@instance.send(http_method,"/test")}.not_to raise_error
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .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(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).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"
+      it 'should not raise exception if data returned not in json format (should be fixed in v2)' do
+        allow(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .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 HTTParty when 401 status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 401))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::Unauthorized)
+      it "should raise Auth0::Unauthorized on send http #{http_method}
+        method to path defined through HTTParty when 401 status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .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 HTTParty when 404 status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 404))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::NotFound)
+      it "should raise Auth0::NotFound on send http #{http_method} method
+        to path defined through HTTParty when 404 status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .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 HTTParty when 418 or other unknown status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 418))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::Unsupported)
+      it "should raise Auth0::Unsupported on send http #{http_method} method
+        to path defined through HTTParty when 418 or other unknown status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .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 HTTParty when 400 or other unknown status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 400))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::BadRequest)
+      it "should raise Auth0::BadRequest on send http #{http_method} method
+        to path defined through HTTParty when 400 or other unknown status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .and_return(StubResponse.new({}, false, 400))
+        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 HTTParty when 403" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 403))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::AccessDenied)
+      it "should raise Auth0::AccessDenied on send http #{http_method} method
+        to path defined through HTTParty when 403" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .and_return(StubResponse.new({}, false, 403))
+        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 HTTParty when 500 received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :query => {}).and_return(StubResponse.new({}, false, 500))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::ServerError)
+      it "should raise Auth0::ServerError on send http #{http_method} method
+        to path defined through HTTParty when 500 received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/test', query: {})
+          .and_return(StubResponse.new({}, false, 500))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it "should escape path with URI.escape" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/te%20st", :query => {})
-        expect(DummyClassForProxy).to receive(http_method).with("/te%20st", :query => {}).and_return(StubResponse.new({}, true, 200))
-        expect{@instance.send(http_method,"/te st")}.not_to raise_error
+      it 'should escape path with URI.escape' do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/te%20st', query: {})
+        expect(DummyClassForProxy).to receive(http_method).with('/te%20st', query: {})
+          .and_return(StubResponse.new({}, true, 200))
+        expect { @instance.send(http_method, '/te st') }.not_to raise_error
       end
     end
   end
 
   %i(post put patch delete).each do |http_method|
     context ".#{http_method}" do
-      it {expect(@instance).to respond_to(http_method.to_sym)}
+      it { expect(@instance).to respond_to(http_method.to_sym) }
       it "should call send http #{http_method} method to path defined through HTTParty" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", true, 200))
-        expect{@instance.send(http_method,"/test")}.not_to raise_error
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .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(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").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"
+      it 'should not raise exception if data returned not in json format (should be fixed in v2)' do
+        allow(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .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 HTTParty when 401 status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", false, 401))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::Unauthorized)
+      it "should raise Auth0::Unauthorized on send http #{http_method} method
+        to path defined through HTTParty when 401 status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .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 HTTParty when 404 status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", false, 404))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::NotFound)
+      it "should raise Auth0::NotFound on send http #{http_method} method
+        to path defined through HTTParty when 404 status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .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 HTTParty when 418 or other unknown status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", false, 418))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::Unsupported)
+      it "should raise Auth0::Unsupported on send http #{http_method} method
+        to path defined through HTTParty when 418 or other unknown status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .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 HTTParty when 400 or other unknown status received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", false, 400))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::BadRequest)
+      it "should raise Auth0::BadRequest on send http #{http_method} method
+        to path defined through HTTParty when 400 or other unknown status received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .and_return(StubResponse.new('{}', false, 400))
+        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 HTTParty when 500 received" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/test", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/test", :body => "{}").and_return(StubResponse.new("{}", false, 500))
-        expect{@instance.send(http_method,"/test")}.to raise_error(Auth0::ServerError)
+      it "should raise Auth0::ServerError on send http #{http_method} method
+        to path defined through HTTParty when 500 received" do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/test', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/test', body: '{}')
+          .and_return(StubResponse.new('{}', false, 500))
+        expect { @instance.send(http_method, '/test') }.to raise_error(Auth0::ServerError)
       end
 
-      it "should escape path with URI.escape" do
-        allow(DummyClassForProxy).to receive(http_method).with("http://login.auth0.com/te%20st", :body => "{}")
-        expect(DummyClassForProxy).to receive(http_method).with("/te%20st", :body => "{}").and_return(StubResponse.new("{}", true, 200))
-        expect{@instance.send(http_method,"/te st")}.not_to raise_error
+      it 'should escape path with URI.escape' do
+        allow(DummyClassForProxy).to receive(http_method).with('http://login.auth0.com/te%20st', body: '{}')
+        expect(DummyClassForProxy).to receive(http_method).with('/te%20st', body: '{}')
+          .and_return(StubResponse.new('{}', true, 200))
+        expect { @instance.send(http_method, '/te st') }.not_to raise_error
       end
     end
   end