Merge branch 'quentin/admind' into 'master'

refactor(functional-tests): use new admind API

See merge request Tanker/sdk-js!474

Author: Jérémy Tellaa

config/karma/tanker.test.config.js

@@ -5,6 +5,7 @@ const plugin = new webpack.EnvironmentPlugin([
   'CI',
 
   'TANKER_ID_TOKEN',
+  'TANKER_ADMIND_URL',
   'TANKER_FAKE_AUTH_URL',
   'TANKER_TRUSTCHAIND_URL',
 

packages/functional-tests/src/helpers/AppHelper.js

@@ -7,9 +7,14 @@ import { tcrypto, utils } from '@tanker/crypto';
 import { createIdentity } from '@tanker/identity';
 import { uuid } from '@tanker/test-utils';
 
-import { AuthenticatedRequester } from './AuthenticatedRequester';
+import { requestTrustchaind, requestAdmindWithAuth } from './request';
 import { oidcSettings, storageSettings } from './config';
 
+function toUnpaddedSafeBase64(str: Uint8Array): string {
+  const b64 = utils.toSafeBase64(str);
+  return b64.substring(0, b64.indexOf('='));
+}
+
 function makeRootBlock(appKeyPair: Object) {
   const rootBlock = {
     trustchain_id: new Uint8Array(0),
@@ -25,13 +30,11 @@ function makeRootBlock(appKeyPair: Object) {
 }
 
 export class AppHelper {
-  _requester: AuthenticatedRequester;
   appId: Uint8Array;
   appKeyPair: Object;
   authToken: string;
 
-  constructor(requester: AuthenticatedRequester, appId: Uint8Array, appKeyPair: Object, authToken: string) {
-    this._requester = requester;
+  constructor(appId: Uint8Array, appKeyPair: Object, authToken: string) {
     this.appId = appId;
     this.appKeyPair = appKeyPair;
     this.authToken = authToken;
@@ -40,37 +43,38 @@ export class AppHelper {
   static async newApp(): Promise<AppHelper> {
     const appKeyPair = tcrypto.makeSignKeyPair();
     const rootBlock = makeRootBlock(appKeyPair);
-    const message = {
+    const body = {
       root_block: utils.toBase64(serializeBlock(rootBlock)),
       name: `functest-${uuid.v4()}`,
-      is_test: true,
       private_signature_key: utils.toBase64(appKeyPair.privateKey),
     };
-    const requester = await AuthenticatedRequester.open();
-    const createResponse = await requester.send('create trustchain', message);
-    const authToken = createResponse.auth_token;
+    const createResponse = await requestAdmindWithAuth({ method: 'POST', path: '/apps', body });
+    const authToken = createResponse.app.auth_token;
     const appId = rootBlock.trustchain_id;
-    return new AppHelper(requester, appId, appKeyPair, authToken);
+    return new AppHelper(appId, appKeyPair, authToken);
+  }
+
+  async _update(body: Object): Promise<Object> {
+    await requestAdmindWithAuth({
+      method: 'PATCH',
+      path: `/apps/${toUnpaddedSafeBase64(this.appId)}`,
+      body,
+    });
   }
 
   async setOIDC() {
-    await this._requester.send('update trustchain', {
-      id: utils.toBase64(this.appId),
+    await this._update({
       oidc_provider: 'google',
       oidc_client_id: oidcSettings.googleAuth.clientId,
     });
   }
 
   async unsetOIDC() {
-    await this._requester.send('update trustchain', {
-      id: utils.toBase64(this.appId),
-      oidc_provider: 'none',
-    });
+    await this._update({ oidc_provider: 'none' });
   }
 
   async setS3() {
-    await this._requester.send('update trustchain', {
-      id: utils.toBase64(this.appId),
+    await this._update({
       storage_provider: 's3',
       storage_bucket_name: storageSettings.s3.bucketName,
       storage_bucket_region: storageSettings.s3.bucketRegion,
@@ -80,10 +84,7 @@ export class AppHelper {
   }
 
   async unsetS3() {
-    await this._requester.send('update trustchain', {
-      id: utils.toBase64(this.appId),
-      storage_provider: 'none',
-    });
+    await this._update({ storage_provider: 'none' });
   }
 
   generateIdentity(userId?: string): Promise<b64string> {
@@ -92,11 +93,12 @@ export class AppHelper {
   }
 
   async getVerificationCode(email: string): Promise<string> {
-    const msg = {
-      trustchain_id: utils.toBase64(this.appId),
+    const body = {
+      app_id: utils.toBase64(this.appId),
       email,
+      auth_token: this.authToken,
     };
-    const answer = await this._requester.send('get verification code', msg);
+    const answer = await requestTrustchaind({ method: 'POST', path: '/verification/email/code', body });
     if (!answer.verification_code) {
       throw new Error('Invalid response');
     }
@@ -113,6 +115,9 @@ export class AppHelper {
   }
 
   async cleanup(): Promise<void> {
-    await this._requester.send('delete trustchain', { id: utils.toBase64(this.appId) });
+    await requestAdmindWithAuth({
+      method: 'DELETE',
+      path: `/apps/${toUnpaddedSafeBase64(this.appId)}`
+    });
   }
 }

packages/functional-tests/src/helpers/AuthenticatedRequester.js

@@ -2,6 +2,7 @@
 // Flow trickery, webpack will actually throw for undefined value
 //  https://github.com/webpack/webpack/blob/0740909b901afa69fcc1657a03215d1e011bb5c3/lib/EnvironmentPlugin.js#L41
 const tankerUrl = process.env.TANKER_TRUSTCHAIND_URL || '';
+const admindUrl = process.env.TANKER_ADMIND_URL || '';
 const fakeAuthUrl = process.env.TANKER_FAKE_AUTH_URL || '';
 const idToken = process.env.TANKER_ID_TOKEN || '';
 const oidcSettings = {
@@ -30,4 +31,4 @@ const storageSettings = {
   },
 };
 
-export { tankerUrl, fakeAuthUrl, idToken, oidcSettings, storageSettings };
+export { tankerUrl, admindUrl, fakeAuthUrl, idToken, oidcSettings, storageSettings };

packages/functional-tests/src/helpers/config.js

@@ -1,5 +1,5 @@
 // @flow
-export { tankerUrl, fakeAuthUrl, idToken, oidcSettings } from './config';
+export { admindUrl, tankerUrl, fakeAuthUrl, idToken, oidcSettings } from './config';
 export { expectProgressReport, expectType, expectSameType, expectDeepEqual } from './expectations';
 export { makePrefix } from './makePrefix';
 export { makeRandomUint8Array } from './makeRandomUint8Array';

packages/functional-tests/src/helpers/index.js

@@ -0,0 +1,49 @@
+// @flow
+import fetchPonyfill from 'fetch-ponyfill';
+
+import { admindUrl, tankerUrl, idToken } from './config';
+
+const { fetch } = fetchPonyfill({ Promise });
+
+type stringToAnyMap = { [string]: any, ...};
+
+export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export type Request = {| method: Method, path: string, query?: stringToAnyMap, headers?: stringToAnyMap, body?: stringToAnyMap |};
+
+const stringify = (param: stringToAnyMap | string) => (
+  typeof (param) === 'object'
+    ? JSON.stringify(param)
+    : param
+);
+
+const buildQuery = (params: stringToAnyMap = {}) => (
+  Object.keys(params)
+    .map(key => `${key}=${encodeURIComponent(stringify(params[key]))}`)
+    .join('&')
+);
+
+const request = async (url: string, { method, path, query, headers = {}, body }: Request): Promise<stringToAnyMap> => {
+  const response = await fetch(
+    url + path + (query ? `?${buildQuery(query)}` : ''),
+    {
+      method,
+      headers: { 'Content-Type': 'application/json', ...headers },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    }
+  );
+
+  const parsed = await response.json();
+
+  if (parsed.error)
+    throw new Error(parsed.error.code);
+
+  return parsed;
+};
+
+export const requestTrustchaind = async (req: Request): Promise<stringToAnyMap> => request(tankerUrl, req);
+export const requestAdmind = async (req: Request): Promise<stringToAnyMap> => request(admindUrl, req);
+
+export const requestAdmindWithAuth = async (req: Request): Promise<stringToAnyMap> => requestAdmind({
+  ...req,
+  headers: { ...req.headers, Authorization: `Bearer ${idToken}` },
+});

packages/functional-tests/src/helpers/request.js

@@ -3,7 +3,7 @@ import { utils } from '@tanker/crypto';
 import type { Tanker, b64string } from '@tanker/core';
 import { silencer } from '@tanker/test-utils';
 
-import { AppHelper, tankerUrl, idToken, oidcSettings } from './helpers';
+import { AppHelper, admindUrl, tankerUrl, idToken, oidcSettings } from './helpers';
 import type { TestArgs, TestResources } from './helpers';
 
 import { generateEncryptorStreamTests } from './encryptorStream';
@@ -23,7 +23,7 @@ export function generateFunctionalTests(
   makeTanker: (appId: b64string) => Tanker,
   generateTestResources: () => TestResources,
 ) {
-  if (!tankerUrl || !idToken || !oidcSettings) {
+  if (!admindUrl || !tankerUrl || !idToken || !oidcSettings) {
     // Those functional tests create an app automatically and require a TANKER_CONFIG_NAME
     // and TANKER_CONFIG_FILEPATH to run
     if (process.env.CI) {