Adding service lifecycle pipeline

Author: bnookala

src/commands/project/init.test.ts

@@ -3,7 +3,11 @@ import os from "os";
 import path from "path";
 import shell from "shelljs";
 import uuid from "uuid/v4";
-import { disableVerboseLogging, enableVerboseLogging } from "../../logger";
+import {
+  disableVerboseLogging,
+  enableVerboseLogging,
+  logger
+} from "../../logger";
 import { initialize } from "./init";
 
 beforeAll(() => {
@@ -15,7 +19,7 @@ afterAll(() => {
 });
 
 describe("Initializing a blank standard repo", () => {
-  test("bedrock.yaml, maintainers.yaml, and azure-pipelines.yaml gets generated in the project root on init for standard repository", async () => {
+  test("all standard files get generated in the project root on init for standard repository", async () => {
     // Create random directory to initialize
     const randomTmpDir = path.join(os.tmpdir(), uuid());
     fs.mkdirSync(randomTmpDir);
@@ -28,17 +32,19 @@ describe("Initializing a blank standard repo", () => {
       "bedrock.yaml",
       "maintainers.yaml",
       "azure-pipelines.yaml",
+      "hld-lifecycle.yaml",
       "Dockerfile"
     ].map(filename => path.join(randomTmpDir, filename));
 
     for (const filepath of filepaths) {
+      logger.info(filepath);
       expect(fs.existsSync(filepath)).toBe(true);
     }
   });
 });
 
 describe("Initializing a blank mono-repo", () => {
-  test("bedrock.yaml and maintainers.yaml get generated in the project root and azure-pipelines.yaml gets generated in all package directories in a mono-repo", async () => {
+  test("all standard files get generated in the project root and azure-pipelines.yaml gets generated in all package directories in a mono-repo", async () => {
     const randomTmpDir = path.join(os.tmpdir(), uuid());
     fs.mkdirSync(randomTmpDir);
 
@@ -61,7 +67,11 @@ describe("Initializing a blank mono-repo", () => {
     });
 
     // root should have bedrock.yaml and maintainers.yaml and should not be in the the package dirs
-    for (const file of ["bedrock.yaml", "maintainers.yaml"]) {
+    for (const file of [
+      "bedrock.yaml",
+      "maintainers.yaml",
+      "hld-lifecycle.yaml"
+    ]) {
       const filepath = path.join(randomTmpDir, file);
       // Should be in package dir
       expect(fs.existsSync(filepath)).toBe(true);

src/commands/project/init.ts

@@ -6,6 +6,7 @@ import * as config from "../../config";
 import {
   generateDockerfile,
   generateGitIgnoreFile,
+  generateHldLifecyclePipelineYaml,
   generateStarterAzurePipelinesYaml
 } from "../../lib/fileutils";
 import { exec } from "../../lib/shell";
@@ -109,6 +110,7 @@ export const initialize = async (
     defaultRing ? [defaultRing] : []
   );
   await generateMaintainersFile(absProjectRoot, absPackagePaths);
+  await generateHldLifecyclePipelineYaml(absProjectRoot);
 
   const gitIgnoreFileContent = "spk.log";
 

src/lib/fileutils.test.ts

@@ -19,6 +19,7 @@ import { disableVerboseLogging, enableVerboseLogging, logger } from "../logger";
 import {
   createTestBedrockYaml,
   createTestHldAzurePipelinesYaml,
+  createTestHldLifecyclePipelineYaml,
   createTestMaintainersYaml
 } from "../test/mockFactory";
 import {
@@ -33,6 +34,7 @@ import {
   generateDockerfile,
   generateGitIgnoreFile,
   generateHldAzurePipelinesYaml,
+  generateHldLifecyclePipelineYaml,
   generateStarterAzurePipelinesYaml,
   starterAzurePipelines
 } from "./fileutils";
@@ -49,6 +51,43 @@ beforeEach(() => {
   jest.clearAllMocks();
 });
 
+describe("generateHldLifecyclePipelineYaml", () => {
+  const targetDirectory = "app-repository";
+  const writeSpy = jest.spyOn(fs, "writeFileSync");
+
+  beforeEach(() => {
+    mockFs({
+      "app-repository": {}
+    });
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  it("should not do anything if hld-lifecycle.yaml exists", async () => {
+    const mockFsOptions = {
+      [`${targetDirectory}/hld-lifecycle.yaml`]: "existing pipeline"
+    };
+    mockFs(mockFsOptions);
+
+    generateHldLifecyclePipelineYaml(targetDirectory);
+    expect(writeSpy).not.toBeCalled();
+  });
+
+  it("should generate the hld-lifecycle.yaml if one does not exist", async () => {
+    const expectedFilePath = `${targetDirectory}/hld-lifecycle.yaml`;
+
+    generateHldLifecyclePipelineYaml(targetDirectory);
+    expect(writeSpy).toBeCalledWith(
+      expectedFilePath,
+      createTestHldLifecyclePipelineYaml(),
+      "utf8"
+    );
+    expect(writeSpy).toBeCalled();
+  });
+});
+
 describe("generateHldAzurePipelinesYaml", () => {
   const targetDirectory = "hld-repository";
   const writeSpy = jest.spyOn(fs, "writeFileSync");

src/lib/fileutils.ts

@@ -11,31 +11,56 @@ import {
   IUser
 } from "../types";
 
+export const generateHldLifecyclePipelineYaml = async (projectRoot: string) => {
+  logger.info(
+    `Generating hld lifecycle pipeline hld-lifecycle.yaml in ${projectRoot}`
+  );
+
+  const azurePipelinesYamlPath = path.join(projectRoot, "hld-lifecycle.yaml");
+
+  if (fs.existsSync(azurePipelinesYamlPath)) {
+    logger.warn(
+      `Existing hld-lifecycle.yaml found at ${azurePipelinesYamlPath}, skipping generation`
+    );
+
+    return;
+  }
+
+  const hldYaml = hldLifecyclePipelineYaml();
+  logger.info(`Writing hld-lifecycle.yaml file to ${azurePipelinesYamlPath}`);
+  fs.writeFileSync(azurePipelinesYamlPath, hldYaml, "utf8");
+};
+
 /**
- * Writes out the starter azure-pipelines.yaml file to `targetPath`
+ * Writes out a starter azure-pipelines.yaml
+ * One pipeline should exist for each service.
  *
- * @param targetPath Path to write the azure-pipelines.yaml file to
+ * @param projectRoot Path to the root of the project (where the bedrock.yaml file exists)
+ * @param packagePath Path to the packages directory
  */
 export const generateStarterAzurePipelinesYaml = async (
   projectRoot: string,
   packagePath: string
 ) => {
   const absProjectRoot = path.resolve(projectRoot);
   const absPackagePath = path.resolve(packagePath);
+  const azurePipelineFileName = `azure-pipelines.yaml`;
 
-  logger.info(`Generating starter azure-pipelines.yaml in ${absPackagePath}`);
+  logger.info(
+    `Generating starter ${azurePipelineFileName} in ${absPackagePath}`
+  );
 
   // Check if azure-pipelines.yaml already exists; if it does, skip generation
   const azurePipelinesYamlPath = path.join(
     absPackagePath,
-    "azure-pipelines.yaml"
+    azurePipelineFileName
   );
   logger.debug(
-    `Writing azure-pipelines.yaml file to ${azurePipelinesYamlPath}`
+    `Writing ${azurePipelineFileName} file to ${azurePipelinesYamlPath}`
   );
   if (fs.existsSync(azurePipelinesYamlPath)) {
     logger.warn(
-      `Existing azure-pipelines.yaml found at ${azurePipelinesYamlPath}, skipping generation`
+      `Existing ${azurePipelineFileName} found at ${azurePipelinesYamlPath}, skipping generation`
     );
   } else {
     const starterYaml = await starterAzurePipelines({
@@ -220,6 +245,39 @@ const manifestGenerationPipelineYaml = () => {
   return yaml.safeDump(pipelineYaml, { lineWidth: Number.MAX_SAFE_INTEGER });
 };
 
+const hldLifecyclePipelineYaml = () => {
+  // based on https://github.com/microsoft/bedrock/blob/master/gitops/azure-devops/ManifestGeneration.md#add-azure-pipelines-build-yaml
+  // tslint:disable: object-literal-sort-keys
+  // tslint:disable: no-empty
+  const pipelineyaml: IAzurePipelinesYaml = {
+    trigger: {
+      branches: {
+        include: ["master"]
+      }
+    },
+    pool: {
+      vmImage: "Ubuntu-16.04"
+    },
+    steps: [
+      {
+        checkout: "self",
+        persistCredentials: true,
+        clean: true
+      },
+      {
+        bash: generateYamlScript([
+          `echo "hello world. this is where lifecycle management will be implemented."`
+        ]),
+        displayName: "hello world"
+      }
+    ]
+  };
+  // tslint:enable: object-literal-sort-keys
+  // tslint:enable: no-empty
+
+  return yaml.safeDump(pipelineyaml, { lineWidth: Number.MAX_SAFE_INTEGER });
+};
+
 /**
  * Update maintainers.yml with new service
  *

src/test/mockFactory.ts

@@ -77,6 +77,38 @@ export const createTestBedrockYaml = (
   return asString ? yaml.dump(data) : data;
 };
 
+export const createTestHldLifecyclePipelineYaml = (
+  asString = true
+): IAzurePipelinesYaml | string => {
+  // tslint:disable: object-literal-sort-keys
+  const data: IAzurePipelinesYaml = {
+    trigger: {
+      branches: {
+        include: ["master"]
+      }
+    },
+    pool: {
+      vmImage: "Ubuntu-16.04"
+    },
+    steps: [
+      {
+        checkout: "self",
+        persistCredentials: true,
+        clean: true
+      },
+      {
+        bash: `echo "hello world. this is where lifecycle management will be implemented."`,
+        displayName: "hello world"
+      }
+    ]
+  };
+  // tslint:enable: object-literal-sort-keys
+
+  return asString
+    ? yaml.safeDump(data, { lineWidth: Number.MAX_SAFE_INTEGER })
+    : data;
+};
+
 export const createTestHldAzurePipelinesYaml = (
   asString = true
 ): IAzurePipelinesYaml | string => {