diff --git a/__tests__/lhisp-oauth-client.test.ts b/__tests__/lhisp-oauth-client.test.ts
index 63bb50c..49ee2f3 100644
--- a/__tests__/lhisp-oauth-client.test.ts
+++ b/__tests__/lhisp-oauth-client.test.ts
@@ -1,9 +1,9 @@
-import axios from 'axios';
+import axios from "axios";
 import { LhispOauthClient } from "../src/lhisp-oauth-client";
-import { ContentType, LhispOauthClientConstructorParams } from '../src/lhisp-oauth-client.t';
+import { ContentType, LhispOauthClientConstructorParams } from "../src/lhisp-oauth-client.t";
 
 // Mock jest and set the type
-jest.mock('axios');
+jest.mock("axios");
 const mockedAxios = axios as jest.Mocked<typeof axios>;
 
 const apiUrl = "https://myapi.com";
@@ -11,223 +11,242 @@ const authUrl = "https://auth.myapi.com/oauth/token";
 const clientId = "testClientdId";
 const clientSecret = "testClientSecret";
 const baseClientParams = { apiUrl, authUrl, clientId, clientSecret };
-const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString('base64')}`;
+const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`;
 const contentTypeApplicationJson = "application/json";
 const contentTypeApplicationXFormUrlEncoded = "application/x-www-form-urlencoded";
-const defaultGrantValue='client_credentials';
-const defaultGrantType=`{"grant_type":"${defaultGrantValue}"}`;
+const defaultGrantValue = "client_credentials";
+const defaultGrantType = `{"grant_type":"${defaultGrantValue}"}`;
 
-describe("Get Access Token", ()=>{
-    beforeEach(() => {
-        mockedAxios.request.mockReset();
-        mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
+describe("Get Access Token", () => {
+  beforeEach(() => {
+    mockedAxios.request.mockReset();
+    mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
+  });
+
+  it("Shoud Get with Standard Config", async () => {
+    const cli = getOauthClient();
+    await accessTokenValidator(cli);
+    validateDefaultGetAccessToken();
+  });
+
+  it("Shoud Get with Custom Auth Header", async () => {
+    const cli = getOauthClient({
+      ...baseClientParams,
+      authHeaderName: "CustomAuthorizationHeader",
     });
-
-    it("Shoud Get with Standard Config", async ()=>{
-        const cli = getOauthClient();
-        await accessTokenValidator(cli);
-        validateDefaultGetAccessToken();
-    });
-
-    it("Shoud Get with Custom Auth Header", async ()=>{
-        const cli = getOauthClient({
-            ...baseClientParams,
-            authHeaderName: 'CustomAuthorizationHeader',
-        });
-        await accessTokenValidator(cli);
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: authUrl,
-            method: "POST",
-            headers: {
-                CustomAuthorizationHeader: basicAuth,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: defaultGrantType,
-        }));
-    });
-
-    it("Shoud Get with Custom Grant Type", async ()=>{
-        const cli = getOauthClient({
-            ...baseClientParams,
-            grantType: 'PermissaoCustom',
-        });
-        await accessTokenValidator(cli);
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: authUrl,
-            method: "POST",
-            headers: {
-                Authorization: basicAuth,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: '{"grant_type":"PermissaoCustom"}',
-        }));
-    });
-
-    it("Shoud Get with Custom Auth Scope", async ()=>{
-        const cli = getOauthClient({
-            ...baseClientParams,
-            authScope: 'EscopoCustom',
-        });
-        await accessTokenValidator(cli);
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: authUrl,
-            method: "POST",
-            headers: {
-                Authorization: basicAuth,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: `{"grant_type":"${defaultGrantValue}","scope":"EscopoCustom"}`,
-        }));
-    });
-
-    it("Shoud Get with Credentials on Request body", async ()=>{
-        const cli = getOauthClient({
-            ...baseClientParams,
-            sendAuthCredentialsOnRequestBody: true,
-        });
-        await accessTokenValidator(cli);
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: authUrl,
-            method: "POST",
-            headers: {
-                Authorization: basicAuth,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: `{"grant_type":"${defaultGrantValue}","client_id":"${clientId}","client_secret":"${clientSecret}"}`,
-        }));
-    });
-});
-
-describe("Request", ()=>{
-    beforeEach(() => {
-        mockedAxios.request.mockReset();
-        mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
-        mockedAxios.request.mockResolvedValueOnce({ data: {"status": "ok"} });
-    });
-
-    it("Get without Params", async ()=>{
-        const cli = getOauthClient();
-        const resp = await cli.get({ path: '/my-test-url' });
-        validateDefaultGetAccessToken();
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: `${apiUrl}/my-test-url`,
-            method: "GET",
-            headers: {
-                Authorization: `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: undefined
-        }));
-        expect(resp).toStrictEqual({"status": "ok"});
-    });
-
-    it("Get with Params", async ()=>{
-        const cli = getOauthClient();
-        const resp = await cli.get({ path: '/my-test-url', params: { id: 1 } });
-        validateDefaultGetAccessToken();
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: `${apiUrl}/my-test-url`,
-            method: "GET",
-            headers: {
-                Authorization: `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            params: { id: 1 },
-            data: undefined
-        }));
-        expect(resp).toStrictEqual({"status": "ok"});
-    });
-
-    it("Post", async ()=>{
-        const cli = getOauthClient();
-        const resp = await cli.post({ path: '/my-test-url-post', data: { id: 1, user: 'test' } });
-        validateDefaultGetAccessToken();
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: `${apiUrl}/my-test-url-post`,
-            method: "POST",
-            headers: {
-                Authorization: `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationJson,
-            },
-            data: { id: 1, user: 'test' }
-        }));
-        expect(resp).toStrictEqual({"status": "ok"});
-    });
-
-    it("Post with different contentType", async ()=>{
-        const cli = getOauthClient();
-        const resp = await cli.post({ 
-            path: '/my-test-url-post', 
-            data: { id: 1, user: 'test' },
-            contentType: ContentType.APPLICATION_X_WWW_FORM_URLENCODED
-        });
-        validateDefaultGetAccessToken();
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: `${apiUrl}/my-test-url-post`,
-            method: "POST",
-            headers: {
-                Authorization: `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationXFormUrlEncoded,
-            },
-            data: { id: 1, user: 'test' }
-        }));
-        expect(resp).toStrictEqual({"status": "ok"});
-    });
-
-    it("Post with Different Token Header Name", async ()=>{
-        const cli = getOauthClient({
-            ...baseClientParams,
-            tokenHeaderName: "x-token",
-        });
-        const resp = await cli.post({ 
-            path: '/my-test-url-post', 
-            data: { id: 1, user: 'test' },
-            contentType: ContentType.APPLICATION_X_WWW_FORM_URLENCODED
-        });
-        validateDefaultGetAccessToken();
-        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
-            url: `${apiUrl}/my-test-url-post`,
-            method: "POST",
-            headers: {
-                'x-token': `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationXFormUrlEncoded,
-            },
-            data: { id: 1, user: 'test' }
-        }));
-        expect(resp).toStrictEqual({"status": "ok"});
-    });
-});
-
-function validateDefaultGetAccessToken(){
-    expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+    await accessTokenValidator(cli);
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
         url: authUrl,
         method: "POST",
         headers: {
-            Authorization: basicAuth,
-            'Content-Type': contentTypeApplicationJson,
+          CustomAuthorizationHeader: basicAuth,
+          "Content-Type": contentTypeApplicationJson,
         },
         data: defaultGrantType,
-    }));
+      })
+    );
+  });
+
+  it("Shoud Get with Custom Grant Type", async () => {
+    const cli = getOauthClient({
+      ...baseClientParams,
+      grantType: "PermissaoCustom",
+    });
+    await accessTokenValidator(cli);
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: authUrl,
+        method: "POST",
+        headers: {
+          Authorization: basicAuth,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        data: '{"grant_type":"PermissaoCustom"}',
+      })
+    );
+  });
+
+  it("Shoud Get with Custom Auth Scope", async () => {
+    const cli = getOauthClient({
+      ...baseClientParams,
+      authScope: "EscopoCustom",
+    });
+    await accessTokenValidator(cli);
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: authUrl,
+        method: "POST",
+        headers: {
+          Authorization: basicAuth,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        data: `{"grant_type":"${defaultGrantValue}","scope":"EscopoCustom"}`,
+      })
+    );
+  });
+
+  it("Shoud Get with Credentials on Request body", async () => {
+    const cli = getOauthClient({
+      ...baseClientParams,
+      sendAuthCredentialsOnRequestBody: true,
+    });
+    await accessTokenValidator(cli);
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: authUrl,
+        method: "POST",
+        headers: {
+          Authorization: basicAuth,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        data: `{"grant_type":"${defaultGrantValue}","client_id":"${clientId}","client_secret":"${clientSecret}"}`,
+      })
+    );
+  });
+});
+
+describe("Request", () => {
+  beforeEach(() => {
+    mockedAxios.request.mockReset();
+    mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
+    mockedAxios.request.mockResolvedValueOnce({ data: { status: "ok" } });
+  });
+
+  it("Get without Params", async () => {
+    const cli = getOauthClient();
+    const resp = await cli.get({ path: "/my-test-url" });
+    validateDefaultGetAccessToken();
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: `${apiUrl}/my-test-url`,
+        method: "GET",
+        headers: {
+          Authorization: `Bearer SomeAccessToken`,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        data: undefined,
+      })
+    );
+    expect(resp).toStrictEqual({ status: "ok" });
+  });
+
+  it("Get with Params", async () => {
+    const cli = getOauthClient();
+    const resp = await cli.get({ path: "/my-test-url", params: { id: 1 } });
+    validateDefaultGetAccessToken();
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: `${apiUrl}/my-test-url`,
+        method: "GET",
+        headers: {
+          Authorization: `Bearer SomeAccessToken`,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        params: { id: 1 },
+        data: undefined,
+      })
+    );
+    expect(resp).toStrictEqual({ status: "ok" });
+  });
+
+  it("Post", async () => {
+    const cli = getOauthClient();
+    const resp = await cli.post({ path: "/my-test-url-post", data: { id: 1, user: "test" } });
+    validateDefaultGetAccessToken();
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: `${apiUrl}/my-test-url-post`,
+        method: "POST",
+        headers: {
+          Authorization: `Bearer SomeAccessToken`,
+          "Content-Type": contentTypeApplicationJson,
+        },
+        data: { id: 1, user: "test" },
+      })
+    );
+    expect(resp).toStrictEqual({ status: "ok" });
+  });
+
+  it("Post with different contentType", async () => {
+    const cli = getOauthClient();
+    const resp = await cli.post({
+      path: "/my-test-url-post",
+      data: { id: 1, user: "test" },
+      contentType: ContentType.APPLICATION_X_WWW_FORM_URLENCODED,
+    });
+    validateDefaultGetAccessToken();
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: `${apiUrl}/my-test-url-post`,
+        method: "POST",
+        headers: {
+          Authorization: `Bearer SomeAccessToken`,
+          "Content-Type": contentTypeApplicationXFormUrlEncoded,
+        },
+        data: { id: 1, user: "test" },
+      })
+    );
+    expect(resp).toStrictEqual({ status: "ok" });
+  });
+
+  it("Post with Different Token Header Name", async () => {
+    const cli = getOauthClient({
+      ...baseClientParams,
+      tokenHeaderName: "x-token",
+    });
+    const resp = await cli.post({
+      path: "/my-test-url-post",
+      data: { id: 1, user: "test" },
+      contentType: ContentType.APPLICATION_X_WWW_FORM_URLENCODED,
+    });
+    validateDefaultGetAccessToken();
+    expect(mockedAxios.request).toBeCalledWith(
+      expect.objectContaining({
+        url: `${apiUrl}/my-test-url-post`,
+        method: "POST",
+        headers: {
+          "x-token": `Bearer SomeAccessToken`,
+          "Content-Type": contentTypeApplicationXFormUrlEncoded,
+        },
+        data: { id: 1, user: "test" },
+      })
+    );
+    expect(resp).toStrictEqual({ status: "ok" });
+  });
+});
+
+function validateDefaultGetAccessToken() {
+  expect(mockedAxios.request).toBeCalledWith(
+    expect.objectContaining({
+      url: authUrl,
+      method: "POST",
+      headers: {
+        Authorization: basicAuth,
+        "Content-Type": contentTypeApplicationJson,
+      },
+      data: defaultGrantType,
+    })
+  );
 }
 
-async function accessTokenValidator(cli: LhispOauthClient){
-    const now = Date.now();
-    const accessToken = await cli.getAccessToken();
-    expect(accessToken).toBeDefined();
-    expect(accessToken.token_type).toBe(mockedAccessToken.token_type);
-    expect(accessToken.access_token).toBe(mockedAccessToken.access_token);
-    expect(accessToken.expires_in).toBe(mockedAccessToken.expires_in);
-    expect(accessToken.scope).toBe(mockedAccessToken.scope);
-    expect(accessToken.created_at).toBeGreaterThanOrEqual(now);
+async function accessTokenValidator(cli: LhispOauthClient) {
+  const now = Date.now();
+  const accessToken = await cli.getAccessToken();
+  expect(accessToken).toBeDefined();
+  expect(accessToken.token_type).toBe(mockedAccessToken.token_type);
+  expect(accessToken.access_token).toBe(mockedAccessToken.access_token);
+  expect(accessToken.expires_in).toBe(mockedAccessToken.expires_in);
+  expect(accessToken.scope).toBe(mockedAccessToken.scope);
 }
 
-function getOauthClient(opt:LhispOauthClientConstructorParams=baseClientParams){
-    return new LhispOauthClient(opt);
+function getOauthClient(opt: LhispOauthClientConstructorParams = baseClientParams) {
+  return new LhispOauthClient(opt);
 }
 
 const mockedAccessToken = {
-    token_type: "Bearer",
-    access_token: "SomeAccessToken",
-    expires_in: 600,
-    scope: "cobrancas.boletos-requisicao cobrancas.boletos-info",
-}
\ No newline at end of file
+  token_type: "Bearer",
+  access_token: "SomeAccessToken",
+  expires_in: 600,
+  scope: "cobrancas.boletos-requisicao cobrancas.boletos-info",
+};