Test Lab Functions (#229)

* Firebase Test Lab Provider

* Minor code cleanups

* Update event type and provider namespace to new format

* Rename testlab to testLab

* Add testMatrix handler function to HandlerBuilder

* Resolve PR comments

* Resolve PR comments

* Add changelog message for new Test Lab trigger

* Resolve minor pr comments

* Promisify makeRequest and reuse in existing http request helpers

* Fix testLab import in handler-builder.ts

* Necessary fixes after merging master

Author: michaelzoech

changelog.txt

@@ -1 +1,2 @@
-feature - Adds region support for us-east4.
+feature - Adds support for Test Lab triggered functions with `functions.testLab`.
+feature - Adds region support for us-east4.

integration_test/functions/src/index.ts

@@ -14,36 +14,29 @@ export * from './firestore-tests';
 export * from './https-tests';
 export * from './remoteConfig-tests';
 export * from './storage-tests';
+export * from './testLab-tests';
 const numTests = Object.keys(exports).length; // Assumption: every exported function is its own test.
 
+import * as utils from './test-utils';
+import * as testLab from './testLab-utils';
+
 import 'firebase-functions'; // temporary shim until process.env.FIREBASE_CONFIG available natively in GCF(BUG 63586213)
 const firebaseConfig = JSON.parse(process.env.FIREBASE_CONFIG);
 admin.initializeApp();
 
 // TODO(klimt): Get rid of this once the JS client SDK supports callable triggers.
 function callHttpsTrigger(name: string, data: any, baseUrl) {
-  return new Promise((resolve, reject) => {
-    const request = https.request(
-      {
-        method: 'POST',
-        host: 'us-central1-' + firebaseConfig.projectId + '.' + baseUrl,
-        path: '/' + name,
-        headers: {
-          'Content-Type': 'application/json',
-        },
+  return utils.makeRequest(
+    {
+      method: 'POST',
+      host: 'us-central1-' + firebaseConfig.projectId + '.' + baseUrl,
+      path: '/' + name,
+      headers: {
+        'Content-Type': 'application/json',
       },
-      (response) => {
-        let body = '';
-        response.on('data', (chunk) => {
-          body += chunk;
-        });
-        response.on('end', () => resolve(body));
-      }
-    );
-    request.on('error', reject);
-    request.write(JSON.stringify({ data }));
-    request.end();
-  });
+    },
+    JSON.stringify({ data })
+  );
 }
 
 function callScheduleTrigger(functionName: string, region: string) {
@@ -149,6 +142,7 @@ export const integrationTests: any = functions
         .storage()
         .bucket()
         .upload('/tmp/' + testId + '.txt'),
+      testLab.startTestRun(firebaseConfig.projectId, testId),
       // Invoke the schedule for our scheduled function to fire
       callScheduleTrigger('schedule', 'us-central1'),
     ])

integration_test/functions/src/test-utils.ts

@@ -0,0 +1,38 @@
+import * as https from 'https';
+
+/**
+ * Makes an http request asynchronously and returns the response data.
+ *
+ * This function wraps the callback-based `http.request()` function with a
+ * Promise. The returned Promise will be rejected in case the request fails with an
+ * error, or the response code is not in the 200-299 range.
+ *
+ * @param options Request options for the request.
+ * @param body Optional body to send as part of the request.
+ * @returns Promise returning the response data as string.
+ */
+export function makeRequest(
+  options: https.RequestOptions,
+  body?: string
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const request = https.request(options, (response) => {
+      let body = '';
+      response.on('data', (chunk) => {
+        body += chunk;
+      });
+      response.on('end', () => {
+        if (response.statusCode < 200 || response.statusCode > 299) {
+          reject(body);
+          return;
+        }
+        resolve(body);
+      });
+    });
+    if (body) {
+      request.write(body);
+    }
+    request.on('error', reject);
+    request.end();
+  });
+}

integration_test/functions/src/testLab-tests.ts

@@ -0,0 +1,26 @@
+import * as functions from 'firebase-functions';
+import * as _ from 'lodash';
+import { TestSuite, expectEq } from './testing';
+import TestMatrix = functions.testLab.TestMatrix;
+
+export const testLabTests: any = functions
+  .runWith({
+    timeoutSeconds: 540,
+  })
+  .testLab.testMatrix()
+  .onComplete((matrix, context) => {
+    return new TestSuite<TestMatrix>('test matrix complete')
+      .it('should have eventId', (snap, context) => context.eventId)
+
+      .it('should have timestamp', (snap, context) => context.timestamp)
+
+      .it('should have right eventType', (_, context) =>
+        expectEq(context.eventType, 'google.testing.testMatrix.complete')
+      )
+
+      .it("should be in state 'INVALID'", (matrix, _) =>
+        expectEq(matrix.state, 'INVALID')
+      )
+
+      .run(_.get(matrix, 'clientInfo.details.testId'), matrix, context);
+  });

integration_test/functions/src/testLab-utils.ts

@@ -0,0 +1,117 @@
+import * as http from 'http';
+import * as https from 'https';
+import * as admin from 'firebase-admin';
+import * as _ from 'lodash';
+import * as utils from './test-utils';
+
+interface AndroidDevice {
+  androidModelId: string;
+  androidVersionId: string;
+  locale: string;
+  orientation: string;
+}
+
+const TESTING_API_SERVICE_NAME = 'testing.googleapis.com';
+
+/**
+ * Creates a new TestMatrix in Test Lab which is expected to be rejected as
+ * invalid.
+ *
+ * @param projectId Project for which the test run will be created
+ * @param testId Test id which will be encoded in client info details
+ */
+export async function startTestRun(projectId: string, testId: string) {
+  const accessToken = await admin.credential
+    .applicationDefault()
+    .getAccessToken();
+  const device = await fetchDefaultDevice(accessToken);
+  return await createTestMatrix(accessToken, projectId, testId, device);
+}
+
+async function fetchDefaultDevice(
+  accessToken: admin.GoogleOAuthAccessToken
+): Promise<AndroidDevice> {
+  const response = await utils.makeRequest(
+    requestOptions(accessToken, 'GET', '/v1/testEnvironmentCatalog/ANDROID')
+  );
+  const data = JSON.parse(response);
+  const models = _.get(data, 'androidDeviceCatalog.models', []);
+  const defaultModels = models.filter(
+    (m) =>
+      m.tags !== undefined &&
+      m.tags.indexOf('default') > -1 &&
+      m.supportedVersionIds !== undefined &&
+      m.supportedVersionIds.length > 0
+  );
+
+  if (defaultModels.length === 0) {
+    throw new Error('No default device found');
+  }
+
+  const model = defaultModels[0];
+  const versions = model.supportedVersionIds;
+
+  return <AndroidDevice>{
+    androidModelId: model.id,
+    androidVersionId: versions[versions.length - 1],
+    locale: 'en',
+    orientation: 'portrait',
+  };
+}
+
+function createTestMatrix(
+  accessToken: admin.GoogleOAuthAccessToken,
+  projectId: string,
+  testId: string,
+  device: AndroidDevice
+): Promise<string> {
+  const options = requestOptions(
+    accessToken,
+    'POST',
+    '/v1/projects/' + projectId + '/testMatrices'
+  );
+  const body = {
+    projectId: projectId,
+    testSpecification: {
+      androidRoboTest: {
+        appApk: {
+          gcsPath: 'gs://path/to/non-existing-app.apk',
+        },
+      },
+    },
+    environmentMatrix: {
+      androidDeviceList: {
+        androidDevices: [device],
+      },
+    },
+    resultStorage: {
+      googleCloudStorage: {
+        gcsPath: 'gs://' + admin.storage().bucket().name,
+      },
+    },
+    clientInfo: {
+      name: 'CloudFunctionsSDKIntegrationTest',
+      clientInfoDetails: {
+        key: 'testId',
+        value: testId,
+      },
+    },
+  };
+  return utils.makeRequest(options, JSON.stringify(body));
+}
+
+function requestOptions(
+  accessToken: admin.GoogleOAuthAccessToken,
+  method: string,
+  path: string
+): https.RequestOptions {
+  return {
+    method: method,
+    hostname: TESTING_API_SERVICE_NAME,
+    path: path,
+    headers: {
+      Authorization: 'Bearer ' + accessToken.access_token,
+      'Content-Type': 'application/json',
+    },
+  };
+}

integration_test/run_tests.sh

@@ -60,9 +60,9 @@ function delete_all_functions {
   # Try to delete, if there are errors it is because the project is already empty,
   # in that case do nothing.
   if [[ "${TOKEN}" == "" ]]; then
-    firebase functions:delete callableTests createUserTests databaseTests deleteUserTests firestoreTests integrationTests pubsubTests remoteConfigTests --force --project=$PROJECT_ID || : &
+    firebase functions:delete callableTests createUserTests databaseTests deleteUserTests firestoreTests integrationTests pubsubTests remoteConfigTests testLabTests --force --project=$PROJECT_ID || : &
   else
-    firebase functions:delete callableTests createUserTests databaseTests deleteUserTests firestoreTests integrationTests pubsubTests remoteConfigTests --force --project=$PROJECT_ID --token=$TOKEN || : &
+    firebase functions:delete callableTests createUserTests databaseTests deleteUserTests firestoreTests integrationTests pubsubTests remoteConfigTests testLabTests --force --project=$PROJECT_ID --token=$TOKEN || : &
   fi
   wait
   announce "Project emptied."

spec/index.spec.ts

@@ -42,6 +42,7 @@ import './providers/https.spec';
 import './providers/pubsub.spec';
 import './providers/remoteConfig.spec';
 import './providers/storage.spec';
+import './providers/testLab.spec';
 import './setup.spec';
 import './testing.spec';
 import './utils.spec';