Seed Command using Identifier (#2804)

* seed command accepts identifier

* updated tests

* changeset

* fix tests

---------

Co-authored-by: Vieltojarvi <[email protected]>

Author: ShadowCat567

.changeset/silver-lies-jam.md

@@ -0,0 +1,5 @@
+---
+'@aws-amplify/backend-cli': patch
+---
+
+update seed commands to take identifier

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_command.test.ts

@@ -121,6 +121,23 @@ void describe('sandbox seed command', () => {
       );
       assert.strictEqual(mockHandleProfile.mock.callCount(), 1);
     });
+
+    void it('run seed with identifier if provided', async () => {
+      const output = await commandRunner.runCommand(
+        'sandbox seed --identifier app-name',
+      );
+
+      const outputArr = output.trimEnd().split('\n');
+      const seedMessage = outputArr[1];
+      const successMessage = outputArr[3].trimStart();
+
+      assert.ok(output !== undefined);
+      assert.deepStrictEqual(seedMessage, 'seed has been run');
+      assert.deepStrictEqual(
+        successMessage,
+        '✔ seed has successfully completed',
+      );
+    });
   });
 
   void describe('seed script does not exist', () => {

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_command.ts

@@ -1,4 +1,4 @@
-import { Argv, CommandModule } from 'yargs';
+import { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
 import path from 'path';
 import { existsSync } from 'fs';
 import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
@@ -36,9 +36,11 @@ export class SandboxSeedCommand implements CommandModule<object> {
   /**
    * @inheritDoc
    */
-  handler = async (): Promise<void> => {
+  handler = async (
+    args: ArgumentsCamelCase<SandboxCommandGlobalOptions>,
+  ): Promise<void> => {
     printer.print(`${format.color('seed is running...', 'Blue')}`);
-    const backendID = await this.backendIDResolver.resolve();
+    const backendID = await this.backendIDResolver.resolve(args.identifier);
     const seedPath = path.join('amplify', 'seed', 'seed.ts');
     process.env.AMPLIFY_BACKEND_IDENTIFIER = JSON.stringify(backendID);
     try {

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_policy_command.test.ts

@@ -0,0 +1,103 @@
+import { after, before, describe, it, mock } from 'node:test';
+import fsp from 'fs/promises';
+import * as path from 'path';
+import yargs, { CommandModule } from 'yargs';
+import { TestCommandRunner } from '../../../test-utils/command_runner.js';
+import { printer } from '@aws-amplify/cli-core';
+import { CommandMiddleware } from '../../../command_middleware.js';
+import { SandboxSeedGeneratePolicyCommand } from './sandbox_seed_policy_command.js';
+import assert from 'node:assert';
+import { BackendIdentifier } from '@aws-amplify/plugin-types';
+import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
+import { Effect, PolicyDocument, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { generateSeedPolicyTemplate } from '../../../seed-policy-generation/generate_seed_policy_template.js';
+
+const seedFileContents = 'console.log(`seed has been run`);';
+
+const testBackendNameSpace = 'testSandboxId';
+const testSandboxName = 'testSandboxName';
+
+const testBackendId: BackendIdentifier = {
+  namespace: testBackendNameSpace,
+  name: testSandboxName,
+  type: 'sandbox',
+};
+
+void describe('sandbox policy seed command', () => {
+  let commandRunner: TestCommandRunner;
+
+  const commandMiddleware = new CommandMiddleware(printer);
+  const mockHandleProfile = mock.method(
+    commandMiddleware,
+    'ensureAwsCredentialAndRegion',
+    () => null,
+  );
+
+  let amplifySeedDir: string;
+  let fullPath: string;
+
+  const sandboxIdResolver: SandboxBackendIdResolver = {
+    resolve: () => Promise.resolve(testBackendId),
+  } as SandboxBackendIdResolver;
+
+  const seedPolicyMock = mock.fn(
+    generateSeedPolicyTemplate,
+    (): Promise<PolicyDocument> =>
+      Promise.resolve(
+        new PolicyDocument({
+          statements: [
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: [
+                'cognito-idp:AdminCreateUser',
+                'cognito-idp:AdminAddUserToGroup',
+              ],
+              resources: ['test-arn'],
+            }),
+          ],
+        }),
+      ),
+  );
+
+  before(async () => {
+    const sandboxSeedGeneratePolicyCommand =
+      new SandboxSeedGeneratePolicyCommand(sandboxIdResolver, seedPolicyMock);
+
+    const parser = yargs().command(
+      sandboxSeedGeneratePolicyCommand as unknown as CommandModule,
+    );
+    commandRunner = new TestCommandRunner(parser);
+    mockHandleProfile.mock.resetCalls();
+
+    await fsp.mkdir(path.join(process.cwd(), 'amplify', 'seed'), {
+      recursive: true,
+    });
+
+    amplifySeedDir = path.join(process.cwd(), 'amplify');
+    fullPath = path.join(process.cwd(), 'amplify', 'seed', 'seed.ts');
+    await fsp.writeFile(fullPath, seedFileContents, 'utf8');
+  });
+
+  after(async () => {
+    await fsp.rm(amplifySeedDir, { recursive: true, force: true });
+    if (process.env.AMPLIFY_BACKEND_IDENTIFIER) {
+      delete process.env.AMPLIFY_BACKEND_IDENTIFIER;
+    }
+  });
+
+  void it('runs seed policy command without identifier', async () => {
+    const output = await commandRunner.runCommand(
+      'sandbox seed generate-policy',
+    );
+
+    assert.ok(output !== undefined);
+  });
+
+  void it('runs seed policy command with identifier', async () => {
+    const output = await commandRunner.runCommand(
+      'sandbox seed generate-policy --identifier app-name',
+    );
+
+    assert.ok(output !== undefined);
+  });
+});

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_policy_command.ts

@@ -1,7 +1,8 @@
-import { Argv, CommandModule } from 'yargs';
+import { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
 import { printer } from '@aws-amplify/cli-core';
 import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
 import { generateSeedPolicyTemplate } from '../../../seed-policy-generation/generate_seed_policy_template.js';
+import { SandboxCommandGlobalOptions } from '../option_types.js';
 
 /**
  * Command that generates policy template with permissions to be able to run seed in sandbox environment
@@ -20,17 +21,22 @@ export class SandboxSeedGeneratePolicyCommand implements CommandModule<object> {
   /**
    * Generates policy to run seed, is a subcommand of seed
    */
-  constructor(private readonly backendIdResolver: SandboxBackendIdResolver) {
+  constructor(
+    private readonly backendIdResolver: SandboxBackendIdResolver,
+    private readonly seedPolicyTemplate = generateSeedPolicyTemplate,
+  ) {
     this.command = 'generate-policy';
     this.describe = 'Generates policy for seeding';
   }
 
   /**
    * @inheritDoc
    */
-  handler = async (): Promise<void> => {
-    const backendId = await this.backendIdResolver.resolve();
-    const policyDocument = await generateSeedPolicyTemplate(backendId);
+  handler = async (
+    args: ArgumentsCamelCase<SandboxCommandGlobalOptions>,
+  ): Promise<void> => {
+    const backendId = await this.backendIdResolver.resolve(args.identifier);
+    const policyDocument = await this.seedPolicyTemplate(backendId);
     printer.print(JSON.stringify(policyDocument.toJSON(), null, 2));
   };