Update release info (#57)

Author: davidbuzinski

.github/workflows/bat.yml

@@ -47,6 +47,11 @@ jobs:
             products: Simulink
             check-matlab: matlabVer = ver('matlab'); assert(~isempty(matlabVer));
             check-simulink: simulinkVer = ver('simulink'); assert(~isempty(simulinkVer));
+          - os: macos-latest
+            release: latest
+            products: Simulink
+            check-matlab: matlabVer = ver('matlab'); assert(~isempty(matlabVer));
+            check-simulink: simulinkVer = ver('simulink'); assert(~isempty(simulinkVer));
     steps:
       - uses: actions/download-artifact@v3
         with:

README.md

@@ -22,8 +22,8 @@ jobs:
         uses: actions/checkout@v3
       - name: Set up MATLAB
         uses: matlab-actions/setup-matlab@v2-beta
-	with:
-	  products: Simulink Simulink_Test
+        with:
+          products: Simulink Simulink_Test
       - name: Run build
         uses: matlab-actions/run-build@v1
         with:

src/install.ts

@@ -30,7 +30,10 @@ export async function install(platform: string, architecture: string, release: s
 
     await core.group("Setting up MATLAB", async () => {
         const mpmPath: string = await mpm.setup(platform, architecture);
-        const [destination, alreadyExists]: [string, boolean] = await matlab.makeToolcacheDir(releaseInfo);
+        let [destination, alreadyExists]: [string, boolean] = await matlab.makeToolcacheDir(releaseInfo, platform);
+        if (platform === "darwin") {
+            destination = destination + "/MATLAB.app";
+        }
         if (!alreadyExists) {
             await mpm.install(mpmPath, releaseInfo, products, destination);
         }

src/install.unit.test.ts

@@ -66,6 +66,11 @@ describe("install procedure", () => {
         expect(setOutputMock).toHaveBeenCalledTimes(1);
     });
 
+    it("installs to MATLAB.app on mac", async () => {
+        await expect(install.install("darwin", arch, release, products)).resolves.toBeUndefined();
+        expect(mpmInstallMock.mock.calls[0][3]).toMatch("MATLAB.app");
+    });
+
     ["darwin", "win32"].forEach((os) => {
         it(`does not run deps script on ${os}`, async () => { 
             await expect(install.install(os, arch, release, products)).resolves.toBeUndefined();

src/matlab.ts

@@ -14,14 +14,7 @@ export interface Release {
     update: string;
 }
 
-interface MATLABReleaseInfo {
-    latest: string;
-    version: {
-        [release: string]: string | undefined
-    }
-}
-
-export async function makeToolcacheDir(release: Release): Promise<[string, boolean]> {
+export async function makeToolcacheDir(release: Release, platform: string): Promise<[string, boolean]> {
     let toolpath: string = tc.find("MATLAB", release.version);
     let alreadyExists = false;
     if (toolpath) {
@@ -46,27 +39,45 @@ export async function setupBatch(platform: string) {
 }
 
 export async function getReleaseInfo(release: string): Promise<Release> {
-    const client: http.HttpClient = new http.HttpClient();
-    const releaseInfo = await client.getJson<MATLABReleaseInfo>(properties.matlabReleaseInfoUrl);
-
-    if (!releaseInfo.result) {
-        return Promise.reject(Error(`Unable to retrieve the MATLAB release information. Contact MathWorks at continuous-integration@mathworks.com if the problem persists.`));
+    // Get release name from input parameter
+    let name: string;
+    let trimmedRelease = release.toLowerCase().trim()
+    if (trimmedRelease === "latest") {
+        try {
+            const client: http.HttpClient = new http.HttpClient();
+            const latestResp = await client.get(properties.matlabLatestReleaseUrl);
+            name = await latestResp.readBody();    
+        }
+        catch {
+            return Promise.reject(Error(`Unable to retrieve the MATLAB release information. Contact MathWorks at continuous-integration@mathworks.com if the problem persists.`));
+        }
+    } else {
+        let nameMatch = trimmedRelease.match(/r[0-9]{4}[a-b]/);
+        if (!nameMatch) {
+            return Promise.reject(Error(`${release} is invalid or unsupported. Specify the value as R2020a or a later release.`));
+        }
+        name = nameMatch[0];
     }
 
-    let name: string = release.toLowerCase().trim().substring(0,6);
-    if (name === "latest") {
-        name = releaseInfo.result.latest;
+    // create semantic version of format year.semiannual.update from release
+    let year = name.slice(1,5);
+    let semiannual = name[5] === "a"? "1": "2";
+    let updateMatch = release.toLowerCase().match(/u[0-9]+/);
+    let version = `${year}.${semiannual}`;
+    let update: string;
+    if (updateMatch) {
+        update = updateMatch[0]
+        version += `.${update[1]}`;
+    } else {
+        // Notify user if Update version format is invalid
+        if (trimmedRelease !== name && trimmedRelease !== "latest") {
+            const invalidUpdate = trimmedRelease.replace(name, "");
+            return Promise.reject(Error(`${invalidUpdate} is not a valid update release name.`));
+        }
+        update = "";
+        version += ".999"
     }
 
-    // Remove update version
-    let version = releaseInfo.result.version[name];
-    let update = release.toLowerCase().trim().substring(6,release.length);
-    if (!update) {
-        update = "latest"
-    }
-    if (!version) {
-        return Promise.reject(Error(`${release} is invalid or unsupported. Specify the value as R2020a or a later release.`));
-    }
     return {
         name: name,
         version: version,

src/matlab.unit.test.ts

@@ -2,11 +2,15 @@
 
 import * as core from "@actions/core";
 import * as http from "@actions/http-client";
+import * as httpjs from "http";
+import * as net from 'net';
 import * as tc from "@actions/tool-cache";
 import * as matlab from "./matlab";
 import * as script from "./script";
 
-jest.mock("./script")
+jest.mock("./script");
+jest.mock("http");
+jest.mock("net");
 jest.mock("@actions/core");
 jest.mock("@actions/http-client");
 jest.mock("@actions/tool-cache");
@@ -18,9 +22,10 @@ afterEach(() => {
 describe("matlab tests", () => {
     const release = {
         name: "r2022b",
-        version: "9.13.0",
-        update: "latest",
+        version: "2022.2.999",
+        update: "",
     }
+    const platform = "linux";
     describe("toolcacheLocation", () => {
         let findMock: jest.Mock<any, any>;
         let cacheFileMock: jest.Mock<any, any>; 
@@ -34,14 +39,14 @@ describe("matlab tests", () => {
 
         it("returns toolpath if in toolcache", async () => {
             findMock.mockReturnValue("/opt/hostedtoolcache/matlab/r2022b");
-            await expect(matlab.makeToolcacheDir(release)).resolves.toMatchObject(["/opt/hostedtoolcache/matlab/r2022b", true]);
+            await expect(matlab.makeToolcacheDir(release, platform)).resolves.toMatchObject(["/opt/hostedtoolcache/matlab/r2022b", true]);
             expect(infoMock).toHaveBeenCalledTimes(1);
         });
 
         it("creates cache and returns new path if not in toolcache", async () => {
             findMock.mockReturnValue("");
             cacheFileMock.mockReturnValue("/opt/hostedtoolcache/matlab/r2022b");
-            await expect(matlab.makeToolcacheDir(release)).resolves.toMatchObject(["/opt/hostedtoolcache/matlab/r2022b", false]);
+            await expect(matlab.makeToolcacheDir(release, platform)).resolves.toMatchObject(["/opt/hostedtoolcache/matlab/r2022b", false]);
         })    
     });
 
@@ -78,18 +83,14 @@ describe("matlab tests", () => {
     });
 
     describe("getReleaseInfo", () => {
+        let infoMock: jest.Mock<any, any>;
         beforeEach(() => {
+            infoMock = core.info as jest.Mock;
             // Mock MATLABReleaseInfo response from http client
-            jest.spyOn(http.HttpClient.prototype, 'getJson').mockImplementation(async () => {
+            jest.spyOn(http.HttpClient.prototype, 'get').mockImplementation(async () => {
                 return {
-                    statusCode: 200,
-                    result: {
-                      latest: 'r2022b',
-                      version: {
-                        r2022b: '9.13.0',
-                      }
-                    },
-                    headers: {}
+                    message: new httpjs.IncomingMessage(new net.Socket()),
+                    readBody: () => {return Promise.resolve("r2022b")}
                 };
             })            
         });
@@ -102,28 +103,47 @@ describe("matlab tests", () => {
             expect(matlab.getReleaseInfo("R2022b")).resolves.toMatchObject(release);
         });
 
+        it("Sets minor version according to a or b release", () => {
+            const R2022aRelease = {
+                name: "r2022a",
+                update: "",
+                version: "2022.1.999",
+            }
+            expect(matlab.getReleaseInfo("R2022a")).resolves.toMatchObject(R2022aRelease);
+
+            const R2022bRelease = {
+                name: "r2022b",
+                update: "",
+                version: "2022.2.999",
+            }
+            expect(matlab.getReleaseInfo("R2022b")).resolves.toMatchObject(R2022bRelease);
+        });
+
         it("allows specifying update number", () => {
             const releaseWithUpdate = {
                 name: "r2022b",
                 update: "u2",
-                version: "9.13.0",
+                version: "2022.2.2",
             }
             expect(matlab.getReleaseInfo("R2022bU2")).resolves.toMatchObject(releaseWithUpdate);
         });
 
+        it("displays message for invalid update level input format and uses latest", () => {
+            expect(matlab.getReleaseInfo("r2022bUpdate1")).rejects.toBeDefined();
+        });
+
         it("rejects for unsupported release", () => {
             expect(matlab.getReleaseInfo("R2022c")).rejects.toBeDefined();
         });
 
         it("rejects if for bad http response", () => {
-            jest.spyOn(http.HttpClient.prototype, 'getJson').mockImplementation(async () => {
+            jest.spyOn(http.HttpClient.prototype, 'get').mockImplementation(async () => {
                 return {
-                    statusCode: 400,
-                    result: undefined,
-                    headers: {}
+                    message: new httpjs.IncomingMessage(new net.Socket()),
+                    readBody: () => {return Promise.reject("Bam!")}
                 };
             })            
-            expect(matlab.getReleaseInfo("R2022b")).rejects.toBeDefined();
+            expect(matlab.getReleaseInfo("latest")).rejects.toBeDefined();
         });
     });
 });

src/mpm.ts

@@ -18,6 +18,9 @@ export async function setup(platform: string, architecture: string): Promise<str
         case "linux":
             mpmUrl = properties.mpmRootUrl + "glnxa64/mpm";
             break;
+        case "darwin":
+            mpmUrl = properties.mpmRootUrl + "maci64/mpm";
+            break;
         default:
             return Promise.reject(Error(`This action is not supported on ${platform} runners using the ${architecture} architecture.`));
     }
@@ -26,7 +29,10 @@ export async function setup(platform: string, architecture: string): Promise<str
     if (platform === "win32") {
        let mpmExtractedPath: string = await tc.extractZip(mpm);
        mpm = path.join(mpmExtractedPath, "bin", "win64",  "mpm.exe");
-    }
+    } else if (platform === "darwin") {
+        let mpmExtractedPath: string = await tc.extractZip(mpm);
+        mpm = path.join(mpmExtractedPath, "bin", "maci64",  "mpm");
+     }
 
     const exitCode = await exec.exec(`chmod +x ${mpm}`);
     if (exitCode !== 0) {

src/mpm.unit.test.ts

@@ -51,6 +51,16 @@ describe("setup mpm", () => {
             expect(tcExtractZipMock).toHaveBeenCalledTimes(1);
             expect(tcDownloadToolMock.mock.calls[0][0]).toContain("win64");
         });
+
+        it(`works on mac`, async () => {
+            const platform = "darwin";
+            tcDownloadToolMock.mockResolvedValue(zipMockPath);
+            tcExtractZipMock.mockResolvedValue(mpmMockPath);
+            execMock.mockResolvedValue(0);
+            await expect(mpm.setup(platform, arch)).resolves.toBe(path.join(mpmMockPath, "bin", "maci64", "mpm"));
+            expect(tcExtractZipMock).toHaveBeenCalledTimes(1);
+            expect(tcDownloadToolMock.mock.calls[0][0]).toContain("maci64");
+        });
     });
 
     it("errors on unsupported platform", async () => {
@@ -89,11 +99,9 @@ describe("setup mpm", () => {
 
 describe("mpm install", () => {
     let execMock: jest.Mock<any, any>;
-    let addPathMock: jest.Mock<any, any>;
-    let setOutputMock: jest.Mock<any, any>;
     const mpmPath = "mpm";
-    const releaseInfo = {name: "r2022b", version: "9.13.0", update: "latest"};
-    const mpmRelease = "r2022blatest"
+    const releaseInfo = {name: "r2022b", version: "9.13.0", update: ""};
+    const mpmRelease = "r2022b"
     beforeEach(() => {
         execMock = exec.exec as jest.Mock;
     });

src/properties.json

@@ -1,6 +1,6 @@
 {
     "matlabBatchUrl": "https://ssd.mathworks.com/supportfiles/ci/matlab-batch/v0/install.sh",
     "matlabDepsUrl": "https://ssd.mathworks.com/supportfiles/ci/matlab-deps/v0/install.sh",
-    "matlabReleaseInfoUrl": "https://mw-ci-static-dev.s3.amazonaws.com/matlab-deps/v0/versions.json",
+    "matlabLatestReleaseUrl": "https://ssd.mathworks.com/supportfiles/ci/matlab-release/v0/latest",
     "mpmRootUrl": "https://www.mathworks.com/mpm/"
 }