v2-beta bugfix (#52)

* adding tests to catch bugs

* updating unit tests and source code

* updating workflow to use 2nd release

* fixing update level logic

* update level deps script workaround

* testing no-op on existing install

* add output

* Update bat.yml

* Update bat.yml

* Update bat.yml

* Update src/matlab.ts

Co-authored-by: Mark Cafaro <34887852+mcafaro@users.noreply.github.com>

* Update matlab.Release and removed usExisting from destination

* updated release info to fix inconsistency

* changed output name to matlabroot

* fixng pipeline syntax

* missing colon in yml

* updating naming and fixing missing simulink in bat workflow

* changing some variable names for clarity

Co-authored-by: Mark Cafaro <34887852+mcafaro@users.noreply.github.com>

Author: davidbuzinski

.github/workflows/bat.yml

@@ -31,29 +31,42 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            release: latest
+            release: latest 
+            products: Simulink Simulink_Test
             check-matlab: matlabVer = ver('matlab'); assert(~isempty(matlabVer));
             check-simulink: simulinkVer = ver('simulink'); assert(~isempty(simulinkVer));
           - os: ubuntu-20.04
-            release: R2022a
-            check-matlab: matlabVer = ver('matlab'); assert(strcmp(matlabVer.Release,'(R2022a)'));
-            check-simulink: simulinkVer = ver('simulink'); assert(strcmp(simulinkVer.Release,'(R2022a)'));
+            release: R2021bU2
+            products: |
+              MATLAB
+              Simulink
+            check-matlab: matlabVer = ver('matlab'); assert(strcmp(matlabVer.Release,'(R2021b)'));
+            check-simulink: simulinkVer = ver('simulink'); assert(strcmp(simulinkVer.Release,'(R2021b)'));
           - os: windows-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:
           name: built-action
-      - name: Install MATLAB & Simulink (and PCT)
+      - name: Install selected products
+        id: setup_matlab
         uses: ./
         with:
-          release: ${{ matrix.release}}
-          products: |
-            MATLAB
-            Simulink
+          release: ${{ matrix.release }}
+          products: ${{ matrix.products }}
+      - name: Check matlabroot output is set
+        run:  'if [[ "${{ steps.setup_matlab.outputs.matlabroot }}" != *"MATLAB"* ]]; then exit 1; fi'
+        shell: bash
       - name: Check MATLAB version
         run: matlab-batch "${{ matrix.check-matlab }}"
       - name: Check Simulink version
         run: matlab-batch "${{ matrix.check-simulink }}"
+      - name: Check NoOp on 2nd install
+        uses: ./
+        with:
+          release: ${{ matrix.release }}
+          products: ${{ matrix.products }}
+  

action.yml

@@ -1,4 +1,4 @@
-# Copyright 2020 The MathWorks, Inc.
+# Copyright 2020-2022 The MathWorks, Inc.
 
 name: Setup MATLAB
 description: >-
@@ -16,6 +16,10 @@ inputs:
     default: |
       MATLAB
       Parallel_Computing_Toolbox
+outputs:
+  matlabroot:
+    description: >-
+      A full path to the folder where MATLAB is installed.
 runs:
   using: node16
   main: dist/index.js

src/install.ts

@@ -5,6 +5,7 @@ import * as matlab from "./matlab";
 import * as mpm from "./mpm";
 import properties from "./properties.json";
 import * as script from "./script";
+import * as path from "path";
 
 /**
  * Set up an instance of MATLAB on the runner.
@@ -18,20 +19,24 @@ import * as script from "./script";
  * @param products A list of products to install (e.g. ["MATLAB", "Simulink"]).
  */
 export async function install(platform: string, architecture: string, release: string, products: string[]) {
-    const version = await matlab.getVersion(release);
+    const releaseInfo = await matlab.getReleaseInfo(release);
 
     // Install runtime system dependencies for MATLAB on Linux
     if (platform === "linux") {
         await core.group("Preparing system for MATLAB", () =>
-            script.downloadAndRunScript(platform, properties.matlabDepsUrl, [version.release])
+            script.downloadAndRunScript(platform, properties.matlabDepsUrl, [releaseInfo.name])
         );
     }
 
     await core.group("Setting up MATLAB", async () => {
         const mpmPath: string = await mpm.setup(platform, architecture);
-        const destination: string = await matlab.toolcacheLocation(version);
+        const [destination, alreadyExists]: [string, boolean] = await matlab.makeToolcacheDir(releaseInfo);
+        if (!alreadyExists) {
+            await mpm.install(mpmPath, releaseInfo, products, destination);
+        }
+        core.addPath(path.join(destination, "bin"));
+        core.setOutput('matlabroot', destination);
 
-        await mpm.install(mpmPath, version.release, products, destination);
         await matlab.setupBatch(platform);
     });
 

src/install.unit.test.ts

@@ -17,35 +17,43 @@ afterEach(() => {
 
 describe("install procedure", () => {
     let downloadAndRunScriptMock: jest.Mock<any, any>;
-    let matlabGetVersionMock: jest.Mock<any, any>;    
+    let matlabGetReleaseInfoMock: jest.Mock<any, any>;
+    let matlabMakeToolcacheDirMock: jest.Mock<any, any>;
     let matlabSetupBatchMock: jest.Mock<any, any>;
     let mpmSetupMock: jest.Mock<any, any>;
     let mpmInstallMock: jest.Mock<any, any>;
+    let addPathMock: jest.Mock<any, any>;
+    let setOutputMock: jest.Mock<any, any>;
 
     const platform = "linux";
     const arch = "x64";
     const release = "latest";
-    const version = {
-        semantic: "9.13.0",
-        release: "r2022b"
+    const releaseInfo = {
+        name: "r2022b",
+        version: "9.13.0",
+        updateNumber: "latest"
     };
     const products = ["MATLAB", "Parallel_Computing_Toolbox"];
 
     const doInstall = () => install.install(platform, arch, release, products);
 
     beforeEach(() => {
         downloadAndRunScriptMock = script.downloadAndRunScript as jest.Mock;
-        matlabGetVersionMock = matlab.getVersion as jest.Mock;
+        matlabGetReleaseInfoMock = matlab.getReleaseInfo as jest.Mock;
+        matlabMakeToolcacheDirMock = matlab.makeToolcacheDir as jest.Mock;
         matlabSetupBatchMock = matlab.setupBatch as jest.Mock;
         mpmSetupMock = mpm.setup as jest.Mock;
         mpmInstallMock = mpm.install as jest.Mock;
+        addPathMock = core.addPath as jest.Mock;
+        setOutputMock = core.setOutput as jest.Mock;
 
         // Mock core.group to simply return the output of the func it gets from
         // the caller
         (core.group as jest.Mock).mockImplementation(async (_, func) => {
             return func();
         });
-        matlabGetVersionMock.mockResolvedValue(version);
+        matlabGetReleaseInfoMock.mockResolvedValue(releaseInfo);
+        matlabMakeToolcacheDirMock.mockResolvedValue(["/opt/hostedtoolcache/MATLAB/9.13.0/x64", false]);
     });
 
     it("ideally works", async () => {
@@ -54,6 +62,8 @@ describe("install procedure", () => {
         expect(matlabSetupBatchMock).toHaveBeenCalledTimes(1);
         expect(mpmSetupMock).toHaveBeenCalledTimes(1);
         expect(mpmInstallMock).toHaveBeenCalledTimes(1);
+        expect(addPathMock).toHaveBeenCalledTimes(1);
+        expect(setOutputMock).toHaveBeenCalledTimes(1);
     });
 
     ["darwin", "win32"].forEach((os) => {
@@ -64,11 +74,21 @@ describe("install procedure", () => {
             expect(matlabSetupBatchMock).toHaveBeenCalledTimes(1);
             expect(mpmSetupMock).toHaveBeenCalledTimes(1);
             expect(mpmInstallMock).toHaveBeenCalledTimes(1);
+            expect(addPathMock).toHaveBeenCalledTimes(1);
+            expect(setOutputMock).toHaveBeenCalledTimes(1);
         });
     });
 
+    it("NoOp on existing install", async () => {
+        matlabMakeToolcacheDirMock.mockResolvedValue(["/opt/hostedtoolcache/MATLAB/9.13.0/x64", true]);
+        await expect(doInstall()).resolves.toBeUndefined();
+        expect(mpmInstallMock).toHaveBeenCalledTimes(0);
+        expect(addPathMock).toHaveBeenCalledTimes(1);
+        expect(setOutputMock).toHaveBeenCalledTimes(1);
+    });
+
     it("rejects for invalid MATLAB version", async () => {
-        matlabGetVersionMock.mockRejectedValue(Error("oof"));
+        matlabGetReleaseInfoMock.mockRejectedValue(Error("oof"));
         await expect(doInstall()).rejects.toBeDefined();
     });
 

src/matlab.ts

@@ -8,28 +8,31 @@ import * as fs from "fs";
 import properties from "./properties.json";
 import * as script from "./script";
 
-export interface Version {
-    release: string;
-    semantic: string;
+export interface Release {
+    name: string;
+    version: string;
+    update: string;
 }
 
 interface MATLABReleaseInfo {
     latest: string;
-    semantic: {
+    version: {
         [release: string]: string | undefined
     }
 }
 
-export async function toolcacheLocation(version: Version): Promise<string> {
-    let toolpath: string = tc.find("MATLAB", version.semantic);
+export async function makeToolcacheDir(release: Release): Promise<[string, boolean]> {
+    let toolpath: string = tc.find("MATLAB", release.version);
+    let alreadyExists = false;
     if (toolpath) {
-        core.info(`Found MATLAB ${version.release} in cache at ${toolpath}.`);
+        core.info(`Found MATLAB ${release.name} in cache at ${toolpath}.`);
+        alreadyExists = true;
     } else {
         fs.writeFileSync(".keep", "");
-        toolpath = await tc.cacheFile(".keep", ".keep", "MATLAB", version.semantic);
+        toolpath = await tc.cacheFile(".keep", ".keep", "MATLAB", release.version);
         io.rmRF(".keep");
     }
-    return toolpath
+    return [toolpath, alreadyExists]
 }
 
 export async function setupBatch(platform: string) {
@@ -42,25 +45,31 @@ export async function setupBatch(platform: string) {
     return
 }
 
-export async function getVersion(release: string): Promise<Version> {
+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.`));
     }
 
-    let parsedRelease: string = release.toLowerCase();
-    if (parsedRelease === "latest") {
-        parsedRelease = releaseInfo.result.latest;
+    let name: string = release.toLowerCase().trim().substring(0,6);
+    if (name === "latest") {
+        name = releaseInfo.result.latest;
     }
 
-    let parsedSemantic = releaseInfo.result.semantic[parsedRelease];
-    if (!parsedSemantic) {
+    // 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 {
-        semantic: parsedSemantic,
-        release: parsedRelease,
+        name: name,
+        version: version,
+        update: update,
     }
 }

src/matlab.unit.test.ts

@@ -1,10 +1,10 @@
 // Copyright 2022 The MathWorks, Inc.
 
-import * as matlab from "./matlab";
-import * as script from "./script";
 import * as core from "@actions/core";
+import * as http from "@actions/http-client";
 import * as tc from "@actions/tool-cache";
-import * as http from "@actions/http-client"
+import * as matlab from "./matlab";
+import * as script from "./script";
 
 jest.mock("./script")
 jest.mock("@actions/core");
@@ -16,9 +16,10 @@ afterEach(() => {
 });
 
 describe("matlab tests", () => {
-    const version = {
-        semantic: "9.13.0",
-        release: "r2022b"
+    const release = {
+        name: "r2022b",
+        version: "9.13.0",
+        update: "latest",
     }
     describe("toolcacheLocation", () => {
         let findMock: jest.Mock<any, any>;
@@ -33,14 +34,14 @@ describe("matlab tests", () => {
 
         it("returns toolpath if in toolcache", async () => {
             findMock.mockReturnValue("/opt/hostedtoolcache/matlab/r2022b");
-            await expect(matlab.toolcacheLocation(version)).resolves.toBe("/opt/hostedtoolcache/matlab/r2022b");
+            await expect(matlab.makeToolcacheDir(release)).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.toolcacheLocation(version)).resolves.toBe("/opt/hostedtoolcache/matlab/r2022b");
+            await expect(matlab.makeToolcacheDir(release)).resolves.toMatchObject(["/opt/hostedtoolcache/matlab/r2022b", false]);
         })    
     });
 
@@ -74,18 +75,17 @@ describe("matlab tests", () => {
             expect(addPathMock).toHaveBeenCalledTimes(0);
             expect(tcCacheDirMock).toHaveBeenCalledTimes(0);
         });
-
     });
 
-    describe("getVersion", () => {
+    describe("getReleaseInfo", () => {
         beforeEach(() => {
-            // Mock versionInfo response from http client
+            // Mock MATLABReleaseInfo response from http client
             jest.spyOn(http.HttpClient.prototype, 'getJson').mockImplementation(async () => {
                 return {
                     statusCode: 200,
                     result: {
                       latest: 'r2022b',
-                      semantic: {
+                      version: {
                         r2022b: '9.13.0',
                       }
                     },
@@ -95,15 +95,24 @@ describe("matlab tests", () => {
         });
 
         it("latest resolves", () => {
-            expect(matlab.getVersion("latest")).resolves.toMatchObject(version);
+            expect(matlab.getReleaseInfo("latest")).resolves.toMatchObject(release);
         });
 
         it("case insensitive", () => {
-            expect(matlab.getVersion("R2022b")).resolves.toMatchObject(version);
+            expect(matlab.getReleaseInfo("R2022b")).resolves.toMatchObject(release);
+        });
+
+        it("allows specifying update number", () => {
+            const releaseWithUpdate = {
+                name: "r2022b",
+                update: "u2",
+                version: "9.13.0",
+            }
+            expect(matlab.getReleaseInfo("R2022bU2")).resolves.toMatchObject(releaseWithUpdate);
         });
 
         it("rejects for unsupported release", () => {
-            expect(matlab.getVersion("R2022c")).rejects.toBeDefined();
+            expect(matlab.getReleaseInfo("R2022c")).rejects.toBeDefined();
         });
 
         it("rejects if for bad http response", () => {
@@ -114,7 +123,7 @@ describe("matlab tests", () => {
                     headers: {}
                 };
             })            
-            expect(matlab.getVersion("R2022b")).rejects.toBeDefined();
+            expect(matlab.getReleaseInfo("R2022b")).rejects.toBeDefined();
         });
     });
-});
+});