@verdaccio/api 8.1.0-next-8.12 → 8.1.0-next-8.13

package/test/integration/search.spec.ts

@@ -1,139 +0,0 @@
-import MockDate from 'mockdate';
-import supertest from 'supertest';
-import { beforeEach, describe, expect, test } from 'vitest';
-
-import { HEADERS, HEADER_TYPE, HTTP_STATUS } from '@verdaccio/core';
-
-import { createUser, initializeServer, publishVersionWithToken } from './_helper';
-
-describe('search', () => {
-  let app;
-  beforeEach(async () => {
-    app = await initializeServer('search.yaml');
-  });
-
-  describe('search authenticated', () => {
-    test.each([['foo']])('should return a foo private package', async (pkg) => {
-      const mockDate = '2018-01-14T11:17:40.712Z';
-      MockDate.set(mockDate);
-      const res = await createUser(app, 'test', 'test');
-      await publishVersionWithToken(app, pkg, '1.0.0', res.body.token);
-      // this should not be displayed as part of the search
-      await publishVersionWithToken(app, 'private-auth', '1.0.0', res.body.token);
-      const response = await supertest(app)
-        .get(
-          `/-/v1/search?text=${encodeURIComponent(
-            pkg
-          )}&size=2000&from=0&quality=1&popularity=0.1&maintenance=0.1`
-        )
-        .set(HEADERS.ACCEPT, HEADERS.JSON)
-        .set(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON)
-        .expect(HEADERS.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      expect(response.body).toEqual({
-        objects: [
-          {
-            package: {
-              author: {
-                email: 'user@domain.com',
-                name: 'User NPM',
-              },
-              date: mockDate,
-              description: 'package generated',
-              keywords: [],
-              links: {
-                npm: '',
-              },
-              maintainers: [
-                {
-                  email: '',
-                  name: 'test',
-                },
-              ],
-              name: pkg,
-              publisher: {},
-              scope: '',
-              version: '1.0.0',
-            },
-            score: {
-              detail: {
-                maintenance: 0,
-                popularity: 1,
-                quality: 1,
-              },
-              final: 1,
-            },
-            searchScore: 1,
-            verdaccioPkgCached: false,
-            verdaccioPrivate: true,
-          },
-        ],
-        time: 'Sun, 14 Jan 2018 11:17:40 GMT',
-        total: 1,
-      });
-    });
-
-    test.each([['@scope/foo']])('should return a scoped foo private package', async (pkg) => {
-      const mockDate = '2018-01-14T11:17:40.712Z';
-      MockDate.set(mockDate);
-      const res = await createUser(app, 'test', 'test');
-      await publishVersionWithToken(app, pkg, '1.0.0', res.body.token);
-      // this should not be displayed as part of the search
-      await publishVersionWithToken(app, '@private/auth', '1.0.0', res.body.token);
-      const response = await supertest(app)
-        .get(
-          `/-/v1/search?text=${encodeURIComponent(
-            pkg
-          )}&size=2000&from=0&quality=1&popularity=0.1&maintenance=0.1`
-        )
-        .set(HEADERS.ACCEPT, HEADERS.JSON)
-        .set(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON)
-        .expect(HEADERS.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      expect(response.body).toEqual({
-        objects: [
-          {
-            package: {
-              author: {
-                email: 'user@domain.com',
-                name: 'User NPM',
-              },
-              date: mockDate,
-              description: 'package generated',
-              keywords: [],
-              links: {
-                npm: '',
-              },
-              maintainers: [
-                {
-                  email: '',
-                  name: 'test',
-                },
-              ],
-              name: pkg,
-              publisher: {},
-              scope: '@scope',
-              version: '1.0.0',
-            },
-            score: {
-              detail: {
-                maintenance: 0,
-                popularity: 1,
-                quality: 1,
-              },
-              final: 1,
-            },
-            searchScore: 1,
-            verdaccioPkgCached: false,
-            verdaccioPrivate: true,
-          },
-        ],
-        time: 'Sun, 14 Jan 2018 11:17:40 GMT',
-        total: 1,
-      });
-    });
-  });
-  describe('error handling', () => {
-    test.todo('should able to abort the request');
-  });
-});

package/test/integration/star.spec.ts

@@ -1,74 +0,0 @@
-import nock from 'nock';
-import supertest from 'supertest';
-import { describe, expect, test } from 'vitest';
-
-import { HTTP_STATUS } from '@verdaccio/core';
-import { HEADERS, HEADER_TYPE } from '@verdaccio/core';
-
-import { getNewToken, getPackage, initializeServer, publishVersion, starPackage } from './_helper';
-
-describe('star', () => {
-  test.each([['foo', '@scope%2Ffoo']])(
-    'should list stared packages for an user',
-    async (pkgName) => {
-      const userLogged = 'jota_token';
-      nock('https://registry.npmjs.org').get(`/${pkgName}`).reply(404);
-      const app = await initializeServer('star.yaml');
-      const token = await getNewToken(app, { name: userLogged, password: 'secretPass' });
-      await publishVersion(app, pkgName, '1.0.0', undefined, token).expect(HTTP_STATUS.CREATED);
-      await publishVersion(app, 'pkg-1', '1.0.0', undefined, token).expect(HTTP_STATUS.CREATED);
-      await publishVersion(app, 'pkg-2', '1.0.0', undefined, token).expect(HTTP_STATUS.CREATED);
-      const manifest = await getPackage(app, '', decodeURIComponent(pkgName));
-      await starPackage(
-        app,
-        {
-          _rev: manifest.body._rev,
-          _id: manifest.body.id,
-          name: pkgName,
-          users: { [userLogged]: true },
-        },
-        token
-      ).expect(HTTP_STATUS.CREATED);
-      await starPackage(
-        app,
-        {
-          _rev: manifest.body._rev,
-          _id: manifest.body.id,
-          name: 'pkg-1',
-          users: { [userLogged]: true },
-        },
-        token
-      ).expect(HTTP_STATUS.CREATED);
-      await starPackage(
-        app,
-        {
-          _rev: manifest.body._rev,
-          _id: manifest.body.id,
-          name: 'pkg-2',
-          users: { [userLogged]: true },
-        },
-        token
-      ).expect(HTTP_STATUS.CREATED);
-      const resp = await supertest(app)
-        .get(`/-/_view/starredByUser?key=%22jota_token%22`)
-        .set('Accept', HEADERS.JSON)
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      expect(resp.body.rows).toHaveLength(3);
-      expect(resp.body.rows).toEqual([{ value: 'foo' }, { value: 'pkg-1' }, { value: 'pkg-2' }]);
-    }
-  );
-
-  test.each([['foo']])('should requires parameters', async (pkgName) => {
-    const userLogged = 'jota_token';
-    nock('https://registry.npmjs.org').get(`/${pkgName}`).reply(404);
-    const app = await initializeServer('star.yaml');
-    const token = await getNewToken(app, { name: userLogged, password: 'secretPass' });
-    await publishVersion(app, pkgName, '1.0.0', undefined, token).expect(HTTP_STATUS.CREATED);
-    await supertest(app)
-      .get(`/-/_view/starredByUser?key_xxxxx=other`)
-      .set('Accept', HEADERS.JSON)
-      .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-      .expect(HTTP_STATUS.BAD_REQUEST);
-  });
-});

package/test/integration/token.spec.ts

@@ -1,125 +0,0 @@
-import _ from 'lodash';
-import supertest from 'supertest';
-import { describe, expect, test } from 'vitest';
-
-import {
-  API_ERROR,
-  HEADERS,
-  HEADER_TYPE,
-  HTTP_STATUS,
-  SUPPORT_ERRORS,
-  TOKEN_BEARER,
-} from '@verdaccio/core';
-import { buildToken } from '@verdaccio/utils';
-
-import { deleteTokenCLI, generateTokenCLI, getNewToken, initializeServer } from './_helper';
-
-describe('token', () => {
-  describe('basics', () => {
-    test.each([['token.yaml'], ['token.jwt.yaml']])('should list empty tokens', async (conf) => {
-      const app = await initializeServer(conf);
-      const token = await getNewToken(app, { name: 'jota_token', password: 'secretPass' });
-      const response = await supertest(app)
-        .get('/-/npm/v1/tokens')
-        .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token))
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      expect(response.body.objects).toHaveLength(0);
-    });
-
-    test.each([['token.yaml'], ['token.jwt.yaml']])('should generate one token', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'jota_token', password: 'secretPass' };
-      const token = await getNewToken(app, credentials);
-      await generateTokenCLI(app, token, {
-        password: credentials.password,
-        readonly: false,
-        cidr_whitelist: [],
-      });
-      const response = await supertest(app)
-        .get('/-/npm/v1/tokens')
-        .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token))
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      const { objects, urls } = response.body;
-
-      expect(objects).toHaveLength(1);
-      const [tokenGenerated] = objects;
-      expect(tokenGenerated.user).toEqual(credentials.name);
-      expect(tokenGenerated.readonly).toBeFalsy();
-      expect(tokenGenerated.token).toMatch(/.../);
-      expect(_.isString(tokenGenerated.created)).toBeTruthy();
-
-      // we don't support pagination yet
-      expect(urls.next).toEqual('');
-    });
-
-    test.each([['token.yaml'], ['token.jwt.yaml']])('should delete a token', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'jota_token', password: 'secretPass' };
-      const token = await getNewToken(app, credentials);
-      const response = await generateTokenCLI(app, token, {
-        password: credentials.password,
-        readonly: false,
-        cidr_whitelist: [],
-      });
-
-      const key = response.body.key;
-      await deleteTokenCLI(app, token, key);
-      const response2 = await supertest(app)
-        .get('/-/npm/v1/tokens')
-        .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token))
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      const { objects } = response2.body;
-      expect(objects).toHaveLength(0);
-    });
-  });
-
-  describe('handle errors', () => {
-    test.each([['token.yaml'], ['token.jwt.yaml']])('should delete a token', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'jota_token', password: 'secretPass' };
-      const token = await getNewToken(app, credentials);
-      const resp = await generateTokenCLI(app, token, {
-        password: 'wrongPassword',
-        readonly: false,
-        cidr_whitelist: [],
-      });
-      expect(resp.body.error).toEqual(API_ERROR.BAD_USERNAME_PASSWORD);
-    });
-
-    test.each([['token.yaml'], ['token.jwt.yaml']])(
-      'should fail if readonly is missing',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'jota_token', password: 'secretPass' };
-        const token = await getNewToken(app, credentials);
-        const resp = await generateTokenCLI(app, token, {
-          password: credentials.password,
-          cidr_whitelist: [],
-        });
-        expect(resp.body.error).toEqual(SUPPORT_ERRORS.PARAMETERS_NOT_VALID);
-      }
-    );
-  });
-
-  test.each([['token.yaml'], ['token.jwt.yaml']])(
-    'should fail if cidr_whitelist is missing',
-    async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'jota_token', password: 'secretPass' };
-      const token = await getNewToken(app, credentials);
-      const resp = await generateTokenCLI(app, token, {
-        password: credentials.password,
-        readonly: false,
-      });
-      expect(resp.body.error).toEqual(SUPPORT_ERRORS.PARAMETERS_NOT_VALID);
-    }
-  );
-
-  test.todo('handle failure if delete token');
-  test.todo('handle failure if getApiToken fails');
-  test.todo('handle failure if token creating fails');
-  test.todo('handle failure if token list fails');
-});

package/test/integration/user.spec.ts

@@ -1,222 +0,0 @@
-import supertest from 'supertest';
-import { describe, expect, test, vi } from 'vitest';
-
-import { API_ERROR, HEADERS, HEADER_TYPE, HTTP_STATUS, TOKEN_BEARER } from '@verdaccio/core';
-import { buildToken } from '@verdaccio/utils';
-
-import { createUser, getPackage, initializeServer } from './_helper';
-
-const FORBIDDEN_VUE = 'authorization required to access package vue';
-
-vi.setConfig({ testTimeout: 20000 });
-
-describe('token', () => {
-  describe('basics', () => {
-    const FAKE_TOKEN: string = buildToken(TOKEN_BEARER, 'fake');
-    test.each([['user.yaml'], ['user.jwt.yaml']])('should test add a new user', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'JotaJWT', password: 'secretPass' };
-      const response = await createUser(app, credentials.name, credentials.password);
-      expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-
-      const vueResponse = await getPackage(app, response.body.token, 'vue');
-      expect(vueResponse.body).toBeDefined();
-      expect(vueResponse.body.name).toMatch('vue');
-
-      const vueFailResp = await getPackage(app, FAKE_TOKEN, 'vue', HTTP_STATUS.UNAUTHORIZED);
-      expect(vueFailResp.body.error).toMatch(FORBIDDEN_VUE);
-    });
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])('should login an user', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'test', password: 'test' };
-      const response = await createUser(app, credentials.name, credentials.password);
-      expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-
-      await supertest(app)
-        .put(`/-/user/org.couchdb.user:${credentials.name}`)
-        .send({
-          name: credentials.name,
-          password: credentials.password,
-        })
-        .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.CREATED);
-    });
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should fails login a valid user',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'test', password: 'test' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-
-        await supertest(app)
-          .put(`/-/user/org.couchdb.user:${credentials.name}`)
-          .send({
-            name: credentials.name,
-            password: 'failPassword',
-          })
-          .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.UNAUTHORIZED);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should test conflict create new user',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'JotaJWT', password: 'secretPass' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-        const response2 = await supertest(app)
-          .put(`/-/user/org.couchdb.user:${credentials.name}`)
-          .send({
-            name: credentials.name,
-            password: credentials.password,
-          })
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.CONFLICT);
-        expect(response2.body.error).toBe(API_ERROR.USERNAME_ALREADY_REGISTERED);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should fails on login if user credentials are invalid',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'newFailsUser', password: 'secretPass' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-        const response2 = await supertest(app)
-          .put(`/-/user/org.couchdb.user:${credentials.name}`)
-          .send({
-            name: credentials.name,
-            password: 'BAD_PASSWORD',
-          })
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.UNAUTHORIZED);
-        expect(response2.body.error).toBe(API_ERROR.UNAUTHORIZED_ACCESS);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should fails password validation',
-      async (conf) => {
-        const credentials = { name: 'test', password: '12' };
-        const app = await initializeServer(conf);
-        const response = await supertest(app)
-          .put(`/-/user/org.couchdb.user:${credentials.name}`)
-          .send({
-            name: credentials.name,
-            password: credentials.password,
-          })
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.BAD_REQUEST);
-        expect(response.body.error).toBe(API_ERROR.PASSWORD_SHORT);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should fails missing password validation',
-      async (conf) => {
-        const credentials = { name: 'test' };
-        const app = await initializeServer(conf);
-        const response = await supertest(app)
-          .put(`/-/user/org.couchdb.user:${credentials.name}`)
-          .send({
-            name: credentials.name,
-            password: undefined,
-          })
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.BAD_REQUEST);
-        expect(response.body.error).toBe(API_ERROR.PASSWORD_SHORT);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should verify if user is logged',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'jota', password: 'secretPass' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-        const response2 = await supertest(app)
-          .get(`/-/user/org.couchdb.user:${credentials.name}`)
-          .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.OK);
-        expect(response2.body.ok).toBe(`you are authenticated as '${credentials.name}'`);
-        expect(response2.body.name).toBe(credentials.name);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should return name of requested user',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const username = 'yeti';
-        const credentials = { name: 'jota', password: 'secretPass' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-        const response3 = await supertest(app)
-          .get(`/-/user/org.couchdb.user:${username}`)
-          .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.OK);
-        expect(response3.body.ok).toBe(`you are authenticated as '${credentials.name}'`);
-        expect(response3.body.name).toBe(username);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])('should logout user', async (conf) => {
-      const app = await initializeServer(conf);
-      const credentials = { name: 'jota', password: 'secretPass' };
-      const response = await createUser(app, credentials.name, credentials.password);
-      await supertest(app)
-        .get(`/-/user/org.couchdb.user:${credentials.name}`)
-        .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-      await supertest(app)
-        .delete(`/-/user/token/someSecretToken:${response.body.token}`)
-        .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-        .expect(HTTP_STATUS.OK);
-    });
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should return "false" if user is not logged in',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'jota', password: '' };
-        const response = await supertest(app)
-          .get(`/-/user/org.couchdb.user:${credentials.name}`)
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.OK);
-        expect(response.body.ok).toBe(false);
-      }
-    );
-
-    test.each([['user.yaml'], ['user.jwt.yaml']])(
-      'should fail if URL does not match user in request body',
-      async (conf) => {
-        const app = await initializeServer(conf);
-        const credentials = { name: 'jota', password: 'secretPass' };
-        const response = await createUser(app, credentials.name, credentials.password);
-        expect(response.body.ok).toMatch(`user '${credentials.name}' created`);
-        const response2 = await supertest(app)
-          .put('/-/user/org.couchdb.user:yeti') // different user
-          .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, response.body.token))
-          .send({
-            name: credentials.name,
-            password: credentials.password,
-          })
-          .expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
-          .expect(HTTP_STATUS.BAD_REQUEST);
-        expect(response2.body.error).toBe(API_ERROR.USERNAME_MISMATCH);
-      }
-    );
-  });
-});

package/test/integration/whoami.spec.ts

@@ -1,36 +0,0 @@
-import supertest from 'supertest';
-import { describe, expect, test } from 'vitest';
-
-import { HEADERS, HTTP_STATUS, TOKEN_BEARER } from '@verdaccio/core';
-import { buildToken } from '@verdaccio/utils';
-
-import { createUser, initializeServer } from './_helper';
-
-describe('whoami', () => {
-  test('should return the logged username', async () => {
-    const app = await initializeServer('whoami.yaml');
-    // @ts-expect-error internal property
-    const { _body } = await createUser(app, 'test', 'test');
-    return supertest(app)
-      .get('/-/whoami')
-      .set('Accept', HEADERS.JSON)
-      .set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, _body.token))
-      .expect('Content-Type', HEADERS.JSON_CHARSET)
-      .expect(HTTP_STATUS.OK)
-      .then((response) => {
-        expect(response.body.username).toEqual('test');
-      });
-  });
-
-  test('should fails with 401 if is not logged in', async () => {
-    const app = await initializeServer('whoami.yaml');
-    // @ts-expect-error internal property
-    const { _body } = await createUser(app, 'test', 'test');
-    return supertest(app)
-      .get('/-/whoami')
-      .set('Accept', HEADERS.JSON)
-      .set(HEADERS.AUTHORIZATION, buildToken('invalid-token', _body.token))
-      .expect('Content-Type', HEADERS.JSON_CHARSET)
-      .expect(HTTP_STATUS.UNAUTHORIZED);
-  });
-});