Add ring delete command

Added the `spk ring delete <ring-name>` command.

closes microsoft/bedrock#971

Author: evanlouie

src/commands/ring/create.test.ts

@@ -1,10 +1,10 @@
-import { create as createBedrockYaml } from "../../lib/bedrockYaml";
-import { read as loadBedrockFile } from "../../lib/bedrockYaml";
+import {
+  create as createBedrockYaml,
+  read as loadBedrockFile
+} from "../../lib/bedrockYaml";
+import * as fileUtils from "../../lib/fileutils";
 import { createTempDir } from "../../lib/ioUtil";
 import { disableVerboseLogging, enableVerboseLogging } from "../../logger";
-
-import * as fileUtils from "../../lib/fileutils";
-
 import { IBedrockFile } from "../../types";
 import { checkDependencies, execute } from "./create";
 

src/commands/ring/delete.test.ts

@@ -1,9 +1,13 @@
-import { create as createBedrockYaml } from "../../lib/bedrockYaml";
+import * as bedrock from "../../lib/bedrockYaml";
+import * as fileUtils from "../../lib/fileutils";
 import { createTempDir } from "../../lib/ioUtil";
 import { disableVerboseLogging, enableVerboseLogging } from "../../logger";
-
+import { createTestBedrockYaml } from "../../test/mockFactory";
+import { IBedrockFile } from "../../types";
 import { checkDependencies, execute } from "./delete";
 
+jest.mock("../../lib/fileutils");
+
 beforeAll(() => {
   enableVerboseLogging();
 });
@@ -12,15 +16,20 @@ afterAll(() => {
   disableVerboseLogging();
 });
 
-describe("test valid function", () => {
-  it("negative test", async () => {
-    try {
-      const tmpDir = createBedrockYaml();
-      checkDependencies(tmpDir);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).not.toBeNull();
-    }
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("checkDependencies", () => {
+  it("throws when project not initialized", () => {
+    const tmpDir = createTempDir();
+    expect(() => checkDependencies(tmpDir)).toThrow();
+  });
+
+  it("does not throw when project initialized", () => {
+    const tmpDir = createTempDir();
+    bedrock.create(tmpDir, createTestBedrockYaml(false) as IBedrockFile);
+    expect(() => checkDependencies(tmpDir)).not.toThrow();
   });
 });
 
@@ -31,22 +40,34 @@ describe("test execute function and logic", () => {
     expect(exitFn).toBeCalledTimes(1);
     expect(exitFn.mock.calls).toEqual([[1]]);
   });
+
   it("test execute function: working path with bedrock.yaml", async () => {
     const exitFn = jest.fn();
-
     const tmpDir = createTempDir();
-    createBedrockYaml(tmpDir, {
-      rings: {
-        master: {
-          isDefault: true
-        }
-      },
-      services: {},
-      variableGroups: ["testvg"]
-    });
-    await execute("ring", tmpDir, exitFn);
+    const bedrockConfig = createTestBedrockYaml(false) as IBedrockFile;
+    bedrock.create(tmpDir, bedrockConfig);
 
-    expect(exitFn).toBeCalledTimes(1);
+    // delete the first ring and write out the update
+    jest.spyOn(bedrock, "create");
+    const ringToDelete = Object.keys(bedrockConfig.rings).pop() as string;
+    expect(ringToDelete).toBeDefined();
+    await execute(ringToDelete, tmpDir, exitFn);
+    expect(bedrock.create).toBeCalledTimes(1);
+
+    // updateTriggerBranchesForServiceBuildAndUpdatePipeline should be called
+    // once per service
+    const numberOfServices = Object.keys(bedrockConfig.services).length;
+    const updatedRingList = Object.keys(
+      bedrock.removeRing(bedrockConfig, ringToDelete).rings
+    );
+    expect(
+      fileUtils.updateTriggerBranchesForServiceBuildAndUpdatePipeline
+    ).toBeCalledTimes(numberOfServices);
+    for (const serviceName of Object.keys(bedrockConfig.services)) {
+      expect(
+        fileUtils.updateTriggerBranchesForServiceBuildAndUpdatePipeline
+      ).toBeCalledWith(updatedRingList, serviceName);
+    }
     expect(exitFn.mock.calls).toEqual([[0]]);
   });
 });

src/commands/ring/delete.ts

@@ -1,11 +1,11 @@
 import commander from "commander";
-import { fileInfo as bedrockFileInfo } from "../../lib/bedrockYaml";
+import * as bedrock from "../../lib/bedrockYaml";
 import { build as buildCmd, exit as exitCmd } from "../../lib/commandBuilder";
 import { PROJECT_INIT_DEPENDENCY_ERROR_MESSAGE } from "../../lib/constants";
+import { updateTriggerBranchesForServiceBuildAndUpdatePipeline } from "../../lib/fileutils";
 import { hasValue } from "../../lib/validator";
 import { logger } from "../../logger";
 import { IBedrockFileInfo } from "../../types";
-
 import decorator from "./delete.decorator.json";
 
 /**
@@ -27,12 +27,24 @@ export const execute = async (
   try {
     logger.info(`Project path: ${projectPath}`);
 
+    // Check if bedrock config exists, if not, warn and exit
     checkDependencies(projectPath);
 
-    // Check if ring exists, if not, warn and exit
-    // Check if ring is default, if so, warn "Cannot delete default ring, set a new default via `spk ring set-default` first." and exit
-    // Delete ring from bedrock.yaml
+    // Remove the ring
+    const bedrockConfig = bedrock.read(projectPath);
+    const bedrockWithoutRing = bedrock.removeRing(bedrockConfig, ringName);
+
+    // Write out the updated bedrock.yaml
+    bedrock.create(projectPath, bedrockWithoutRing);
+
     // Delete ring from all linked service build pipelines' branch triggers
+    const ringBranches = Object.keys(bedrockWithoutRing.rings);
+    for (const servicePath of Object.keys(bedrockConfig.services)) {
+      updateTriggerBranchesForServiceBuildAndUpdatePipeline(
+        ringBranches,
+        servicePath
+      );
+    }
 
     logger.info(`Successfully deleted ring: ${ringName} from this project!`);
     await exitFn(0);
@@ -52,12 +64,12 @@ export const commandDecorator = (command: commander.Command): void => {
 };
 
 /**
- * Check for bedrock.yaml
+ * Check the bedrock.yaml and the target ring exists
  * @param projectPath
  */
 export const checkDependencies = (projectPath: string) => {
-  const fileInfo: IBedrockFileInfo = bedrockFileInfo(projectPath);
+  const fileInfo: IBedrockFileInfo = bedrock.fileInfo(projectPath);
   if (fileInfo.exist === false) {
-    throw new Error(PROJECT_INIT_DEPENDENCY_ERROR_MESSAGE);
+    throw Error(PROJECT_INIT_DEPENDENCY_ERROR_MESSAGE);
   }
 };

src/lib/bedrockYaml.test.ts

@@ -1,4 +1,4 @@
-import uuid from "uuid/v4";
+import uuid = require("uuid/v4");
 import { createTempDir } from "../lib/ioUtil";
 import { createTestBedrockYaml } from "../test/mockFactory";
 import { IBedrockFile, IHelmConfig } from "../types";
@@ -10,7 +10,8 @@ import {
   fileInfo,
   isExists,
   read,
-  setDefaultRing
+  removeRing,
+  setDefaultRing,
 } from "./bedrockYaml";
 
 describe("Creation and Existence test on bedrock.yaml", () => {
@@ -76,11 +77,7 @@ describe("Adding a new service to a Bedrock file", () => {
     );
 
     const expected: IBedrockFile = {
-      rings: {
-        master: {
-          isDefault: true
-        }
-      },
+      ...defaultBedrockFileObject,
       services: {
         ...(defaultBedrockFileObject as IBedrockFile).services,
         ["./" + servicePath]: {
@@ -192,3 +189,34 @@ describe("Set default ring", () => {
     expect(result.rings.prod.isDefault).toBe(undefined);
   });
 });
+
+describe("removeRing", () => {
+  it("removes a valid matching ring", () => {
+    const original = createTestBedrockYaml(false) as IBedrockFile;
+    const ringToRemove = Object.keys(original.rings).pop() as string;
+    expect(ringToRemove).toBeDefined();
+    const updated = removeRing(original, ringToRemove);
+    const originalWithoutRing = (() => {
+      const copy: IBedrockFile = JSON.parse(JSON.stringify(original));
+      delete copy.rings[ringToRemove];
+      return copy;
+    })();
+    expect(Object.keys(updated.rings)).not.toContain(ringToRemove);
+    expect(updated).toStrictEqual(originalWithoutRing);
+  });
+
+  it("throws when the ring doesn't exist", () => {
+    const original = createTestBedrockYaml(false) as IBedrockFile;
+    expect(() => removeRing(original, uuid())).toThrow();
+  });
+
+  it("throws when the ring is found but isDefault === true", () => {
+    const original = createTestBedrockYaml(false) as IBedrockFile;
+    const defaultRing = Object.entries(original.rings)
+      .map(([name, config]) => ({ name, config }))
+      .find(({ config }) => config.isDefault);
+    const ringToRemove = defaultRing?.name;
+    expect(ringToRemove).toBeDefined();
+    expect(() => removeRing(original, ringToRemove as string)).toThrow();
+  });
+});

src/lib/bedrockYaml.ts

@@ -3,7 +3,7 @@ import yaml from "js-yaml";
 import path from "path";
 import { createTempDir } from "../lib/ioUtil";
 import { logger } from "../logger";
-import { IBedrockFile, IBedrockFileInfo, IHelmConfig } from "../types";
+import { IBedrockFile, IBedrockFileInfo, IHelmConfig, IRings } from "../types";
 
 export const YAML_NAME = "bedrock.yaml";
 
@@ -183,3 +183,50 @@ export const fileInfo = (rootProjectPath?: string): IBedrockFileInfo => {
     };
   }
 };
+
+/**
+ * Deletes the target ring with name `ringToDelete` from the provided `bedrock`
+ * config.
+ *
+ * @throws {Error} if ring is not found in `bedrock`
+ * @throws {Error} if the matching ring is `isDefault === true`
+ *
+ * @param bedrock the bedrock file to remove the ring from
+ * @param ringToDelete the name of the ring to remove
+ */
+export const removeRing = (
+  bedrock: IBedrockFile,
+  ringToDelete: string
+): IBedrockFile => {
+  // Check if ring exists, if not, warn and exit
+  const rings = Object.entries(bedrock.rings).map(([name, config]) => ({
+    config,
+    name
+  }));
+  const matchingRing = rings.find(({ name }) => name === ringToDelete);
+  if (matchingRing === undefined) {
+    throw Error(`Ring ${ringToDelete} not found in bedrock.yaml`);
+  }
+
+  // Check if ring is default, if so, warn "Cannot delete default ring
+  // set a new default via `spk ring set-default` first." and exit
+  if (matchingRing.config.isDefault) {
+    throw Error(
+      `Ring ${matchingRing.name} is currently set to isDefault -- set another default ring with 'spk ring set-default' first before attempting to delete`
+    );
+  }
+
+  // Remove the ring
+  const updatedRings: IRings = rings.reduce((updated, ring) => {
+    if (ring.name === ringToDelete) {
+      return updated;
+    }
+    return { ...updated, [ring.name]: ring.config };
+  }, {});
+  const bedrockWithoutRing: IBedrockFile = {
+    ...bedrock,
+    rings: updatedRings
+  };
+
+  return bedrockWithoutRing;
+};

src/test/mockFactory.ts

@@ -258,9 +258,12 @@ export const createTestBedrockYaml = (
 
   const data: IBedrockFile = {
     rings: {
+      develop: {},
       master: {
         isDefault: true
-      }
+      },
+      qa: {},
+      testing: {}
     },
     services: {
       "./": {

src/types.d.ts

@@ -39,16 +39,20 @@ export interface IHelmConfig {
       ));
 }
 
+export interface IRings {
+  [branchName: string]: IRingConfig;
+}
+
+export interface IRingConfig {
+  isDefault?: boolean; // indicates the branch is a default branch to PR against when creating a service revision
+}
+
 /**
  * Bedrock config file
  * Used to capture service meta-information regarding how to deploy
  */
 export interface IBedrockFile {
-  rings: {
-    [branchName: string]: {
-      isDefault?: boolean; // indicates the branch is a default branch to PR against when creating a service revision
-    };
-  };
+  rings: IRings;
   services: {
     [relativeDirectory: string]: IBedrockServiceConfig;
   };