feat(Geo) Construct: Phase 3 - Integration Testing

.changeset/wild-deer-post.md

@@ -0,0 +1,2 @@
+---
+---

package.json

@@ -64,6 +64,7 @@
     "@aws-sdk/client-cognito-identity-provider": "^3.750.0",
     "@aws-sdk/client-dynamodb": "^3.750.0",
     "@aws-sdk/client-iam": "^3.750.0",
+    "@aws-sdk/client-location": "^3.859.0",
     "@aws-sdk/client-s3": "^3.750.0",
     "@aws-sdk/client-ssm": "^3.750.0",
     "@changesets/cli": "^2.26.1",

packages/integration-tests/package.json

@@ -26,6 +26,7 @@
     "@aws-sdk/client-cognito-identity-provider": "^3.750.0",
     "@aws-sdk/client-iam": "^3.750.0",
     "@aws-sdk/client-lambda": "^3.750.0",
+    "@aws-sdk/client-location": "^3.859.0",
     "@aws-sdk/client-s3": "^3.750.0",
     "@aws-sdk/client-sqs": "^3.750.0",
     "@aws-sdk/client-sts": "^3.750.0",

packages/integration-tests/src/test-e2e/deployment/geo_api_key_support.deployment.test.ts

@@ -0,0 +1,4 @@
+import { defineDeploymentTest } from './deployment.test.template.js';
+import { GeoAPIKeySupportTestProjectCreator } from '../../test-project-setup/geo_api_key_support_testing.js';
+
+defineDeploymentTest(new GeoAPIKeySupportTestProjectCreator());

packages/integration-tests/src/test-e2e/sandbox/geo_api_key_support.sandbox.test.ts

@@ -0,0 +1,4 @@
+import { defineSandboxTest } from './sandbox.test.template.js';
+import { GeoAPIKeySupportTestProjectCreator } from '../../test-project-setup/geo_api_key_support_testing.js';
+
+defineSandboxTest(new GeoAPIKeySupportTestProjectCreator());

packages/integration-tests/src/test-project-setup/cdk/create_empty_cdk_project.ts

@@ -34,5 +34,16 @@ export const createEmptyCdkProject = async (
     force: true,
   });
 
+  // Update tsconfig.json to include types for "node:" imports
+  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+  const tsconfig = JSON.parse(await fsp.readFile(tsconfigPath, 'utf-8'));
+  if (!tsconfig.compilerOptions.types) {
+    tsconfig.compilerOptions.types = [];
+  }
+  if (!tsconfig.compilerOptions.types.includes('node')) {
+    tsconfig.compilerOptions.types.push('node');
+  }
+  await fsp.writeFile(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+
   return { projectName, projectRoot };
 };

packages/integration-tests/src/test-project-setup/geo_api_key_support_testing.ts

@@ -0,0 +1,177 @@
+import { TestProjectBase } from './test_project_base.js';
+import fs from 'fs/promises';
+import { createEmptyAmplifyProject } from './create_empty_amplify_project.js';
+import { CloudFormationClient } from '@aws-sdk/client-cloudformation';
+import { TestProjectCreator } from './test_project_creator.js';
+import { AmplifyClient } from '@aws-sdk/client-amplify';
+import { e2eToolingClientConfig } from '../e2e_tooling_client_config.js';
+import { BackendIdentifier } from '@aws-amplify/plugin-types';
+import {
+  ListGeofenceCollectionsCommand,
+  ListKeysCommand,
+  Location,
+  LocationClient,
+} from '@aws-sdk/client-location';
+import { DeployedResourcesFinder } from '../find_deployed_resource.js';
+import assert from 'node:assert';
+
+/**
+ * Creates test project for testing new Geo backend functionality with API key support.
+ */
+export class GeoAPIKeySupportTestProjectCreator implements TestProjectCreator {
+  readonly name = 'geo-api-key-support';
+
+  /**
+   * Initializes project creator object
+   */
+  constructor(
+    private readonly cfnClient: CloudFormationClient = new CloudFormationClient(
+      e2eToolingClientConfig,
+    ),
+    private readonly amplifyClient: AmplifyClient = new AmplifyClient(
+      e2eToolingClientConfig,
+    ),
+    private readonly locationClient: LocationClient = new Location(
+      e2eToolingClientConfig,
+    ),
+    private readonly resourceFinder: DeployedResourcesFinder = new DeployedResourcesFinder(),
+  ) {}
+
+  createProject = async (e2eProjectDir: string): Promise<TestProjectBase> => {
+    const { projectName, projectRoot, projectAmplifyDir } =
+      await createEmptyAmplifyProject(this.name, e2eProjectDir);
+
+    const project = new GeoAPIKeySupportTestProject(
+      projectName,
+      projectRoot,
+      projectAmplifyDir,
+      this.cfnClient,
+      this.amplifyClient,
+      this.locationClient,
+      this.resourceFinder,
+    );
+
+    await fs.cp(
+      project.sourceProjectAmplifyDirURL,
+      project.projectAmplifyDirPath,
+      { recursive: true },
+    );
+
+    return project;
+  };
+}
+
+/**
+ * Creates project with geo and auth resources initialized
+ */
+export class GeoAPIKeySupportTestProject extends TestProjectBase {
+  readonly sourceProjectDirPath = '../../src/test-projects/geo-api-key-support';
+  readonly sourceProjectAmplifyDirURL = new URL(
+    `${this.sourceProjectDirPath}/amplify`,
+    import.meta.url,
+  );
+
+  /**
+   * Creates an instance of a test project with Geofence Collections and API keys provisioned
+   */
+  constructor(
+    name: string,
+    projectDirPath: string,
+    projectAmplifyDirPath: string,
+    cfnClient: CloudFormationClient,
+    amplifyClient: AmplifyClient,
+    private readonly locationClient: LocationClient,
+    private readonly resourceFinder: DeployedResourcesFinder,
+  ) {
+    super(
+      name,
+      projectDirPath,
+      projectAmplifyDirPath,
+      cfnClient,
+      amplifyClient,
+    );
+  }
+
+  /**
+   * Override implementation of post deployment assertions specific to Amplify Geo tests
+   */
+  override async assertPostDeployment(
+    backendId: BackendIdentifier,
+  ): Promise<void> {
+    await super.assertPostDeployment(backendId); // perform regular post-deployment tests
+
+    const testCollection = await this.resourceFinder.findByBackendIdentifier(
+      backendId,
+      'AWS::Location::GeofenceCollection',
+      (name) => name.includes('amplifyTestCollection'),
+    );
+
+    const testAPIKey = await this.resourceFinder.findByBackendIdentifier(
+      backendId,
+      'AWS::Location::APIKey',
+      (name) => name.includes('amplifyTestIndexKey'),
+    );
+
+    assert.equal(testCollection.length, 1);
+    assert.equal(testAPIKey.length, 1);
+
+    const expectedCollectionResponse = {
+      Entries: [
+        {
+          CollectionName: 'amplifyTestCollection',
+          Description:
+            'This is a geofence collection setup for integration testing purposes.',
+          CreateTime: new Date(),
+          UpdateTime: new Date(),
+        },
+      ],
+    };
+
+    const collectionResponse = await this.locationClient.send(
+      new ListGeofenceCollectionsCommand(),
+    );
+
+    const hasCollection = collectionResponse.Entries?.some(
+      (entry) =>
+        entry.CollectionName ===
+          expectedCollectionResponse.Entries[0].CollectionName &&
+        entry.Description === expectedCollectionResponse.Entries[0].Description,
+    );
+
+    assert.ok(
+      hasCollection,
+      'Expected collection not found in client response.',
+    );
+
+    const expectedKeysResponse = {
+      Entries: {
+        KeyName: 'amplifyTestIndexKey',
+        CreateTime: new Date(),
+        UpdateTime: new Date(),
+        Restrictions: {
+          AllowActions: ['geo-places:Autocomplete'],
+        },
+      },
+    };
+
+    const keyResponse = await this.locationClient.send(new ListKeysCommand());
+
+    const hasKey = keyResponse.Entries?.some(
+      (entry) =>
+        entry.KeyName === expectedKeysResponse.Entries.KeyName &&
+        JSON.stringify(entry.Restrictions?.AllowActions) ===
+          JSON.stringify(
+            expectedKeysResponse.Entries.Restrictions.AllowActions,
+          ),
+    );
+
+    assert.ok(hasKey, 'Expected key not found in client response.');
+  }
+
+  private verifyCollectionResponse = async (expectedResponse: unknown) => {
+    const locationResponse = await this.locationClient.send(
+      new ListGeofenceCollectionsCommand(),
+    );
+    assert.equal(locationResponse, expectedResponse);
+  };
+}

packages/integration-tests/src/test-projects/geo-api-key-support/amplify/auth/resource.ts

@@ -0,0 +1,7 @@
+import { defineAuth } from '@aws-amplify/backend';
+
+export const auth = defineAuth({
+  loginWith: {
+    email: true,
+  },
+});

packages/integration-tests/src/test-projects/geo-api-key-support/amplify/backend.ts

@@ -0,0 +1,10 @@
+import { defineBackend } from '@aws-amplify/backend';
+import { map, place, collection } from './geo/resource.js';
+import { auth } from './auth/resource.js';
+
+defineBackend({
+  auth,
+  map,
+  place,
+  collection,
+});

packages/integration-tests/src/test-projects/geo-api-key-support/amplify/geo/resource.ts

@@ -0,0 +1,32 @@
+import {
+  defineMap,
+  defineCollection,
+  definePlace,
+} from '@aws-amplify/backend-geo';
+
+export const map = defineMap({
+  name: 'amplifyTestMap',
+  access: (allow) => [allow.authenticated.to(['get'])],
+});
+
+export const place = definePlace({
+  name: 'amplifyTestPlaceIndex',
+  access: (allow) => [
+    allow.authenticated.to(['search']),
+    allow.guest.to(['geocode']),
+    allow.apiKey.to(['autocomplete']),
+  ],
+  apiKeyProps: {
+    apiKeyName: 'amplifyTestIndexKey',
+  },
+});
+
+export const collection = defineCollection({
+  name: 'amplifyTestCollection',
+  description:
+    'This is a geofence collection setup for integration testing purposes.',
+  access: (allow) => [
+    allow.authenticated.to(['create', 'read', 'update', 'delete']),
+    allow.guest.to(['read', 'list']),
+  ],
+});

packages/integration-tests/tsconfig.json

@@ -1,6 +1,11 @@
 {
   "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "rootDir": "src", "outDir": "lib", "allowJs": true },
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib",
+    "allowJs": true,
+    "types": ["node"]
+  },
   "references": [
     { "path": "../ai-constructs" },
     { "path": "../auth-construct" },