adding modified files to use getCurrentPewPewLatestVersion

controller/integration/testmanager.spec.ts

@@ -1882,7 +1882,7 @@ describe("TestManager Integration", () => {
       });
     });
 
-    it("postTest with version latest should respond 200 OK", (done: Mocha.Done) => {
+    it("postTest with version latest should respond 400 Bad Request, because latest is Legacy", (done: Mocha.Done) => {
       const parsedForm: ParsedForm = {
         files: scriptingFiles,
         fields: {
@@ -1893,14 +1893,14 @@ describe("TestManager Integration", () => {
       log("postTest parsedForm latest", LogLevel.DEBUG, { parsedForm });
       TestManager.postTest(parsedForm, authAdmin, UNIT_TEST_FOLDER).then((res: ErrorResponse | TestDataResponse) => {
         log("postTest res", LogLevel.DEBUG, res);
-        expect(res.status, JSON.stringify(res.json)).to.equal(200);
-        const body: TestData = res.json as TestData;
-        log("body: " + JSON.stringify(res.json), LogLevel.DEBUG, body);
+        expect(res.status, JSON.stringify(res.json)).to.equal(400);
+        log("body: " + JSON.stringify(res.json), LogLevel.DEBUG, res.json);
+        const body: TestManagerError = res.json as TestManagerError;
         expect(body).to.not.equal(undefined);
-        expect(body.testId).to.not.equal(undefined);
-        expect(body.s3Folder).to.not.equal(undefined);
-        expect(body.status).to.equal(TestStatus.Created);
-        expect(body.userId).to.equal(authAdmin.userId);
+        expect(body.message).to.not.equal(undefined);
+        expect(body.message).to.include("failed to parse");
+        expect(body.error).to.not.equal(undefined);
+        expect(body.error).to.include("UnrecognizedKey");
         done();
       }).catch((error) => {
         log("postTest error", LogLevel.ERROR, error);

controller/pages/api/util/testmanager.ts

@@ -53,6 +53,7 @@ import { formatError, isYamlFile, latestPewPewVersion } from "./clientutil";
 import { createS3Filename as createS3MessageFilename } from "@fs/ppaas-common/dist/src/ppaass3message";
 import { createS3Filename as createS3StatusFilename } from "@fs/ppaas-common/dist/src/ppaasteststatus";
 import fs from "fs/promises";
+import { getCurrentPewPewLatestVersion } from "./pewpew";
 import semver from "semver";
 
 logger.config.LogFileName = "ppaas-controller";
@@ -431,10 +432,13 @@ export async function downloadPriorTestId (
 }
 
 // Export for testing
-export function getValidateLegacyOnly (version: string | undefined): boolean | undefined {
+export async function getValidateLegacyOnly (version: string | undefined): Promise<boolean | undefined> {
   // undefined or "latest" parse as anything (reutrn undefined)
   if (!version || version === latestPewPewVersion) {
-    return undefined;
+    version = await getCurrentPewPewLatestVersion();
+    if (!version) { // If it's still undefined, we don't know what version latest is, parse as either
+      return undefined;
+    }
   }
   // This needs to create the validateLegacyOnly, so anything less than 0.6.0
   return semver.satisfies(version, LEGACY_PEWPEW_VERSION, { includePrerelease: true });
@@ -1217,7 +1221,7 @@ export abstract class TestManager {
         log("environmentVariables", LogLevel.TRACE, environmentVariablesFile);
 
         // Pass pewpew version legacy/scripting
-        const validateLegacyOnly = getValidateLegacyOnly(version);
+        const validateLegacyOnly = await getValidateLegacyOnly(version);
         const validateResult: ErrorResponse | ValidateYamlfileResult = await validateYamlfile(yamlFile, PpaasEncryptEnvironmentFile.getEnvironmentVariables(environmentVariablesFile), additionalFileNames, bypassParser, authPermissions, validateLegacyOnly);
         // eslint-disable-next-line no-prototype-builtins
         if (validateResult.hasOwnProperty("json")) {

controller/test/testmanager.spec.ts

@@ -34,9 +34,11 @@ import {
   logger
 } from "@fs/ppaas-common";
 import type { File, FileJSON } from "formidable";
+import { mockGetObjectTagging, mockS3, resetMockS3 } from "./mock";
 import { Test as MochaTest } from "mocha";
 import { PpaasEncryptS3File } from "../pages/api/util/ppaasencrypts3file";
 import { TestSchedulerIntegration } from "./testscheduler.spec";
+import { VERSION_TAG_NAME } from "../pages/api/util/pewpew";
 import { expect } from "chai";
 import { latestPewPewVersion } from "../pages/api/util/clientutil";
 import path from "path";
@@ -318,6 +320,8 @@ describe("TestManager", () => {
 
   const validateLegacyOnlySuite: Mocha.Suite = describe("getValidateLegacyOnly", () => {
     before (() => {
+      mockS3();
+      mockGetObjectTagging(new Map([["pewpew", "true"]]));
       const validateLegacyOnlyArray: [string, boolean][] = [
         ["0.4.0", true],
         ["0.5.0", true],
@@ -335,41 +339,66 @@ describe("TestManager", () => {
         ["1.0.0", false]
       ];
       for (const [version, expected] of validateLegacyOnlyArray) {
-        validateLegacyOnlySuite.addTest(new MochaTest(version + " should return " + expected, (done: Mocha.Done) => {
+        validateLegacyOnlySuite.addTest(new MochaTest(version + " should return " + expected, async () => {
           try {
-            expect(getValidateLegacyOnly(version)).to.equal(expected);
-            done();
+            expect(await getValidateLegacyOnly(version)).to.equal(expected);
           } catch (error) {
-            done(error);
+            throw error;
+          }
+        }));
+        validateLegacyOnlySuite.addTest(new MochaTest(`latest should return ${expected} for pewpew tagged with version ${version}` , async () => {
+          try {
+            mockGetObjectTagging(new Map([[VERSION_TAG_NAME, version]]));
+            await getValidateLegacyOnly(latestPewPewVersion).then((result: boolean | undefined) => {
+              log("getValidateLegacyOnly()", LogLevel.INFO, result);
+              expect(result).to.equal(expected);
+            });
+          } catch (error) {
+            throw error;
           }
         }));
       }
     });
 
-    it("should return undefined for undefined", (done: Mocha.Done) => {
+    beforeEach(() => {
+      mockGetObjectTagging(new Map([["pewpew", "true"]]));
+      global.currentLatestVersion = undefined;
+    });
+
+    after(() => {
+      resetMockS3();
+      global.currentLatestVersion = undefined;
+    });
+    it("should return undefined for undefined", async () => {
       try {
-        expect(getValidateLegacyOnly(undefined)).to.equal(undefined);
-        done();
+        await getValidateLegacyOnly(undefined).then((result: boolean | undefined) => {
+          log("getValidateLegacyOnly()", LogLevel.INFO, result);
+          expect(result).to.equal(undefined);
+        });
       } catch (error) {
-        done(error);
+        throw error;
       }
     });
 
-    it("should return undefined for empty string", (done: Mocha.Done) => {
+    it("should return undefined for empty string", async () => {
       try {
-        expect(getValidateLegacyOnly("")).to.equal(undefined);
-        done();
+        await getValidateLegacyOnly("").then((result: boolean | undefined) => {
+          log("getValidateLegacyOnly()", LogLevel.INFO, result);
+          expect(result).to.equal(undefined);
+        });
       } catch (error) {
-        done(error);
+        throw error;
       }
     });
 
-    it("should return undefined for latest", (done: Mocha.Done) => {
+    it("should return undefined for latest when no version tagged", async () => {
       try {
-        expect(getValidateLegacyOnly(latestPewPewVersion)).to.equal(undefined);
-        done();
+        await getValidateLegacyOnly(latestPewPewVersion).then((result: boolean | undefined) => {
+          log("getValidateLegacyOnly()", LogLevel.INFO, result);
+          expect(result).to.equal(undefined);
+        });
       } catch (error) {
-        done(error);
+        throw error;
       }
     });
   });