2019-08-10 06:38:06 -05:00
|
|
|
import _ from 'lodash';
|
|
|
|
import request from 'supertest';
|
|
|
|
|
2019-06-12 23:58:43 -05:00
|
|
|
import {HEADER_TYPE, HEADERS, HTTP_STATUS, TOKEN_BEARER} from '../../../src/lib/constants';
|
2019-08-10 06:38:06 -05:00
|
|
|
import {buildToken, encodeScopedUri} from '../../../src/lib/utils';
|
2019-07-27 16:47:04 -05:00
|
|
|
import { Package } from '@verdaccio/types';
|
2019-08-10 06:38:06 -05:00
|
|
|
import {getTaggedVersionFromPackage} from "./expects";
|
|
|
|
import {generateRandomHexString} from "../../../src/lib/crypto-utils";
|
2018-08-21 01:05:34 -05:00
|
|
|
|
2019-06-13 11:28:43 -05:00
|
|
|
// API Helpers
|
|
|
|
|
|
|
|
// This file should contain utilities to avoid repeated task over API unit testing,
|
|
|
|
// Please, comply with the following:
|
|
|
|
// - Promisify everything
|
|
|
|
// - Encourage using constants or create new ones if it's needed
|
2019-07-27 16:47:04 -05:00
|
|
|
// - // @ts-ignore or any is fine if there is no other way
|
|
|
|
|
|
|
|
export function putPackage(
|
|
|
|
request: any,
|
|
|
|
pkgName: string,
|
2019-08-10 06:38:06 -05:00
|
|
|
publishMetadata: Package,
|
|
|
|
token?: string,
|
|
|
|
httpStatus: number = HTTP_STATUS.CREATED): Promise<any[]> {
|
2019-07-27 16:47:04 -05:00
|
|
|
return new Promise((resolve) => {
|
2019-08-10 06:38:06 -05:00
|
|
|
let put = request.put(pkgName)
|
2019-07-27 16:47:04 -05:00
|
|
|
.set(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON)
|
2019-08-10 06:38:06 -05:00
|
|
|
.send(JSON.stringify(publishMetadata));
|
|
|
|
|
|
|
|
if (_.isEmpty(token) === false ) {
|
|
|
|
expect(token).toBeDefined();
|
|
|
|
put.set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token as string))
|
|
|
|
}
|
|
|
|
|
|
|
|
put.set('accept', 'gzip')
|
2019-07-27 16:47:04 -05:00
|
|
|
.set('accept-encoding', HEADERS.JSON)
|
|
|
|
.expect(HTTP_STATUS.CREATED)
|
|
|
|
.end(function(err, res) {
|
|
|
|
resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2018-08-21 01:05:34 -05:00
|
|
|
|
2019-08-10 06:38:06 -05:00
|
|
|
export function deletePackage(
|
|
|
|
request: any,
|
|
|
|
pkgName: string,
|
|
|
|
token?: string
|
|
|
|
): Promise<any[]> {
|
|
|
|
return new Promise((resolve) => {
|
|
|
|
let del = request.put(`/${encodeScopedUri(pkgName)}/-rev/${generateRandomHexString(8)}`)
|
|
|
|
.set(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON);
|
|
|
|
|
|
|
|
if (_.isNil(token) === false ) {
|
|
|
|
del.set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token as string))
|
|
|
|
}
|
|
|
|
|
|
|
|
del.set('accept-encoding', HEADERS.JSON)
|
|
|
|
.expect(HTTP_STATUS.CREATED)
|
|
|
|
.end(function(err, res) {
|
|
|
|
resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-08-21 01:05:34 -05:00
|
|
|
export function getPackage(
|
2019-07-16 01:40:01 -05:00
|
|
|
request: any,
|
2019-08-10 06:38:06 -05:00
|
|
|
token: string,
|
|
|
|
pkgName: string,
|
2019-07-16 01:40:01 -05:00
|
|
|
statusCode: number = HTTP_STATUS.OK): Promise<any[]> {
|
2018-08-21 01:05:34 -05:00
|
|
|
return new Promise((resolve) => {
|
2019-08-10 06:38:06 -05:00
|
|
|
let getRequest = request.get(`/${pkgName}`);
|
|
|
|
|
|
|
|
if (_.isNil(token) === false || _.isEmpty(token) === false) {
|
|
|
|
getRequest.set(HEADERS.AUTHORIZATION, buildToken(TOKEN_BEARER, token));
|
|
|
|
}
|
|
|
|
|
|
|
|
getRequest
|
2019-07-16 01:40:01 -05:00
|
|
|
.expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
|
|
|
|
.expect(statusCode)
|
|
|
|
.end(function(err, res) {
|
|
|
|
resolve([err, res]);
|
|
|
|
});
|
2018-08-21 01:05:34 -05:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-06-12 23:58:43 -05:00
|
|
|
export function loginUserToken(request: any,
|
|
|
|
user: string,
|
|
|
|
credentials: any,
|
|
|
|
token: string,
|
2019-07-16 01:40:01 -05:00
|
|
|
statusCode: number = HTTP_STATUS.CREATED): Promise<any[]> {
|
2019-06-12 23:58:43 -05:00
|
|
|
// $FlowFixMe
|
|
|
|
return new Promise((resolve) => {
|
|
|
|
request.put(`/-/user/org.couchdb.user:${user}`)
|
|
|
|
.send(credentials)
|
|
|
|
.set('authorization', buildToken(TOKEN_BEARER, token))
|
|
|
|
.expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
|
|
|
|
.expect(statusCode)
|
|
|
|
.end(function(err, res) {
|
|
|
|
return resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-08-21 01:05:34 -05:00
|
|
|
export function addUser(request: any, user: string, credentials: any,
|
2019-07-16 01:40:01 -05:00
|
|
|
statusCode: number = HTTP_STATUS.CREATED): Promise<any[]> {
|
2018-09-27 09:37:45 -05:00
|
|
|
// $FlowFixMe
|
2018-10-12 04:07:55 -05:00
|
|
|
return new Promise((resolve) => {
|
2019-07-16 01:40:01 -05:00
|
|
|
request.put(`/-/user/org.couchdb.user:${user}`)
|
2018-08-21 01:05:34 -05:00
|
|
|
.send(credentials)
|
|
|
|
.expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
|
|
|
|
.expect(statusCode)
|
|
|
|
.end(function(err, res) {
|
|
|
|
return resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2018-10-12 04:07:55 -05:00
|
|
|
|
2019-07-16 01:40:01 -05:00
|
|
|
export async function getNewToken(request: any, credentials: any): Promise<string> {
|
2018-10-12 04:07:55 -05:00
|
|
|
return new Promise(async (resolve) => {
|
|
|
|
const [err, res] = await
|
|
|
|
addUser(request, credentials.name, credentials);
|
|
|
|
expect(err).toBeNull();
|
|
|
|
const {token, ok} = res.body;
|
|
|
|
expect(ok).toBeDefined();
|
|
|
|
expect(token).toBeDefined();
|
|
|
|
expect(typeof token).toBe('string');
|
|
|
|
resolve(token);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-07-16 01:40:01 -05:00
|
|
|
export function getProfile(request: any, token: string, statusCode: number = HTTP_STATUS.OK): Promise<any[]> {
|
2018-10-12 04:07:55 -05:00
|
|
|
// $FlowFixMe
|
|
|
|
return new Promise((resolve) => {
|
|
|
|
request.get(`/-/npm/v1/user`)
|
2019-06-12 23:58:43 -05:00
|
|
|
.set('authorization', buildToken(TOKEN_BEARER, token))
|
2018-10-12 04:07:55 -05:00
|
|
|
.expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
|
|
|
|
.expect(statusCode)
|
|
|
|
.end(function(err, res) {
|
|
|
|
return resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-07-16 01:40:01 -05:00
|
|
|
export function postProfile(request: any, body: any, token: string, statusCode: number = HTTP_STATUS.OK): Promise<any[]> {
|
2018-10-12 04:07:55 -05:00
|
|
|
// $FlowFixMe
|
|
|
|
return new Promise((resolve) => {
|
|
|
|
request.post(`/-/npm/v1/user`)
|
|
|
|
.send(body)
|
2019-05-19 14:37:43 -05:00
|
|
|
.set(HEADERS.AUTHORIZATION, `Bearer ${token}`)
|
2018-10-12 04:07:55 -05:00
|
|
|
.expect(HEADER_TYPE.CONTENT_TYPE, HEADERS.JSON_CHARSET)
|
|
|
|
.expect(statusCode)
|
|
|
|
.end(function(err, res) {
|
|
|
|
return resolve([err, res]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2019-08-10 06:38:06 -05:00
|
|
|
|
|
|
|
export async function fetchPackageByVersionAndTag(app, encodedPkgName, pkgName, version, tag = 'latest') {
|
|
|
|
// we retrieve the package to verify
|
|
|
|
const [err, resp]= await getPackage(request(app), '', encodedPkgName);
|
|
|
|
|
|
|
|
expect(err).toBeNull();
|
|
|
|
|
|
|
|
// we check whether the latest version match with the previous published one
|
|
|
|
return getTaggedVersionFromPackage(resp.body, pkgName, tag, version);
|
|
|
|
}
|
|
|
|
|
|
|
|
export async function isExistPackage(app, packageName) {
|
|
|
|
const [err]= await getPackage(request(app), '', encodeScopedUri(packageName), HTTP_STATUS.OK);
|
|
|
|
|
|
|
|
return _.isNull(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
export async function verifyPackageVersionDoesExist(app, packageName, version, token?: string) {
|
|
|
|
const [, res]= await getPackage(request(app), token as string, encodeScopedUri(packageName), HTTP_STATUS.OK);
|
|
|
|
|
|
|
|
const { versions } = res.body;
|
|
|
|
const versionsKeys = Object.keys(versions);
|
|
|
|
|
|
|
|
return versionsKeys.includes(version) === false;
|
|
|
|
}
|
|
|
|
|
|
|
|
export function generateUnPublishURI(pkgName) {
|
|
|
|
return `/${encodeScopedUri(pkgName)}/-rev/${generateRandomHexString(8)}`;
|
|
|
|
}
|