fix: Add override OS and linux default

src/buildExec.ts

@@ -27,6 +27,7 @@ const buildExec = () => {
   const flags = core.getInput('flags');
   const functionalities = core.getInput('functionalities');
   const name = core.getInput('name');
+  const os = core.getInput('os');
   const overrideBranch = core.getInput('override_branch');
   const overrideBuild = core.getInput('override_build');
   const overrideCommit = core.getInput('override_commit');
@@ -146,7 +147,7 @@ const buildExec = () => {
     options.cwd = workingDir;
   }
 
-  return {execArgs, options, failCi};
+  return {execArgs, options, failCi, os};
 };
 
 export default buildExec;

src/helpers.test.ts

@@ -0,0 +1,61 @@
+import {
+  getBaseUrl,
+  getPlatform,
+  isValidPlatform,
+  isWindows,
+  PLATFORMS,
+} from './helpers';
+
+let OLDOS = process.env.RUNNER_OS;
+
+beforeEach(() => {
+  jest.resetModules();
+  OLDOS = process.env.RUNNER_OS;
+});
+
+afterAll(() => {
+  process.env.RUNNER_OS = OLDOS;
+});
+
+test('getPlatform', () => {
+  expect(getPlatform('linux')).toBe('linux');
+  expect(getPlatform('windows')).toBe('windows');
+
+  const defaultPlatform =
+      process.env.RUNNER_OS ? process.env.RUNNER_OS.toLowerCase() : 'linux';
+  expect(getPlatform('fakeos')).toBe(defaultPlatform);
+  expect(getPlatform()).toBe(defaultPlatform);
+
+  process.env.RUNNER_OS = 'macos';
+  expect(getPlatform('fakeos')).toBe('macos');
+  expect(getPlatform()).toBe('macos');
+
+  process.env.RUNNER_OS = 'alsofakeos';
+  expect(getPlatform()).toBe('linux');
+  expect(getPlatform('fakeos')).toBe('linux');
+});
+
+test('getBaseUrl', () => {
+  expect(PLATFORMS.map((platform) => {
+    return getBaseUrl(platform);
+  })).toEqual([
+    'https://uploader.codecov.io/latest/alpine/codecov',
+    'https://uploader.codecov.io/latest/linux/codecov',
+    'https://uploader.codecov.io/latest/macos/codecov',
+    'https://uploader.codecov.io/latest/windows/codecov.exe',
+  ]);
+});
+
+test('isWindows', () => {
+  expect(PLATFORMS.map((platform) => {
+    return isWindows(platform);
+  })).toEqual([false, false, false, true]);
+});
+
+test('isValidPlatform', () => {
+  expect(PLATFORMS.map((platform) => {
+    return isValidPlatform(platform);
+  })).toEqual([true, true, true, true]);
+
+  expect(isValidPlatform('fakeos')).toBeFalsy();
+});

src/helpers.ts

@@ -9,30 +9,47 @@ const setFailure = (message: string, failCi: boolean): void => {
     }
 };
 
-const getUploaderName = (): string => {
-  if (isWindows()) {
+const getUploaderName = (platform: string): string => {
+  if (isWindows(platform)) {
     return 'codecov.exe';
   } else {
     return 'codecov';
   }
 };
 
-const isValidPlatform = (): boolean => {
-  return PLATFORMS.includes(getPlatform());
+const isValidPlatform = (platform: string): boolean => {
+  return PLATFORMS.includes(platform);
 };
 
-const isWindows = (): boolean => {
-  return getPlatform() === 'windows';
+const isWindows = (platform: string): boolean => {
+  return platform === 'windows';
 };
 
-const getPlatform = (): string => {
-  return process.env.RUNNER_OS.toLowerCase();
+const getPlatform = (os?: string): string => {
+  if (isValidPlatform(os)) {
+    core.info(`==> ${os} OS provided`);
+    return os;
+  }
+
+  const platform = process.env.RUNNER_OS?.toLowerCase();
+  if (isValidPlatform(platform)) {
+    core.info(`==> ${platform} OS detected`);
+    return platform;
+  }
+
+  core.info(
+      '==> Could not detect OS or provided OS is invalid. Defaulting to linux',
+  );
+  return 'linux';
 };
 
-const BASEURL = `https://uploader.codecov.io/latest/${getPlatform()}/${getUploaderName()}`;
+const getBaseUrl = (platform: string): string => {
+  return `https://uploader.codecov.io/latest/${platform}/${getUploaderName(platform)}`;
+};
 
 export {
-  BASEURL,
+  PLATFORMS,
+  getBaseUrl,
   getPlatform,
   getUploaderName,
   isValidPlatform,

src/index.ts

@@ -2,15 +2,13 @@ import * as fs from 'fs';
 import * as https from 'https';
 import * as path from 'path';
 
-import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 
 import buildExec from './buildExec';
 import {
-  BASEURL,
+  getBaseUrl,
   getPlatform,
   getUploaderName,
-  isValidPlatform,
   setFailure,
 } from './helpers';
 
@@ -19,18 +17,11 @@ import verify from './validate';
 let failCi;
 
 try {
-  const {execArgs, options, failCi} = buildExec();
-  const platform = getPlatform();
-  core.info(`==> ${platform} OS detected`);
+  const {execArgs, options, failCi, os} = buildExec();
+  const platform = getPlatform(os);
 
-  if (!isValidPlatform()) {
-    setFailure(
-        `Codecov: Encountered an unexpected platform: ${platform}`,
-        failCi,
-    );
-  }
-  const filename = path.join( __dirname, getUploaderName());
-  https.get(BASEURL, (res) => {
+  const filename = path.join( __dirname, getUploaderName(platform));
+  https.get(getBaseUrl(platform), (res) => {
     // Image will be stored at this path
     const filePath = fs.createWriteStream(filename);
     res.pipe(filePath);
@@ -43,7 +34,7 @@ try {
         }).on('finish', async () => {
           filePath.close();
 
-          await verify(filename);
+          await verify(filename, platform);
           await fs.chmodSync(filename, '777');
 
           const unlink = () => {

src/validate.ts

@@ -7,14 +7,14 @@ import * as openpgp from 'openpgp';
 import * as fetch from 'node-fetch';
 
 import {
-  BASEURL,
+  getBaseUrl,
   getUploaderName,
   setFailure,
 } from './helpers';
 
-const verify = async (filename: string) => {
+const verify = async (filename: string, platform: string) => {
   try {
-    const uploaderName = getUploaderName();
+    const uploaderName = getUploaderName(platform);
 
     // Read in public key
     const publicKeyArmored = await fs.readFileSync(
@@ -23,10 +23,10 @@ const verify = async (filename: string) => {
     );
 
     // Get SHASUM and SHASUM signature files
-    const shasumRes = await fetch( `${BASEURL}.SHA256SUM`);
+    const shasumRes = await fetch( `${getBaseUrl(platform)}.SHA256SUM`);
     const shasum = await shasumRes.text();
 
-    const shaSigRes = await fetch( `${BASEURL}.SHA256SUM.sig`);
+    const shaSigRes = await fetch( `${getBaseUrl(platform)}.SHA256SUM.sig`);
     const shaSig = await shaSigRes.text();
 
     // Verify shasum