setup-python/__tests__/finder.test.ts

import * as io from '@actions/io';
import os from 'os';
import fs from 'fs';
import path from 'path';

const toolDir = path.join(
  __dirname,
  'runner',
  path.join(Math.random().toString(36).substring(7)),
  'tools'
);
const tempDir = path.join(
  __dirname,
  'runner',
  path.join(Math.random().toString(36).substring(7)),
  'temp'
);

process.env['RUNNER_TOOL_CACHE'] = toolDir;
process.env['RUNNER_TEMP'] = tempDir;

import * as tc from '@actions/tool-cache';
import * as core from '@actions/core';
import * as exec from '@actions/exec';
import * as finder from '../src/find-python';
import * as installer from '../src/install-python';

import manifestData from './data/versions-manifest.json';

describe('Finder tests', () => {
  let writeSpy: jest.SpyInstance;
  let spyCoreAddPath: jest.SpyInstance;
  let spyCoreExportVariable: jest.SpyInstance;
  const env = process.env;

  beforeEach(() => {
    writeSpy = jest.spyOn(process.stdout, 'write');
    writeSpy.mockImplementation(() => {});
    jest.resetModules();
    process.env = {...env};
    spyCoreAddPath = jest.spyOn(core, 'addPath');
    spyCoreExportVariable = jest.spyOn(core, 'exportVariable');
  });

  afterEach(() => {
    jest.resetAllMocks();
    jest.clearAllMocks();
    jest.restoreAllMocks();
    process.env = env;
  });

  it('Finds Python if it is installed', async () => {
    const getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
    getBooleanInputSpy.mockImplementation(input => false);

    const pythonDir: string = path.join(toolDir, 'Python', '3.0.0', 'x64');
    await io.mkdirP(pythonDir);
    fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await finder.useCpythonVersion('3.x', 'x64', true, false, false, false);
    expect(spyCoreAddPath).toHaveBeenCalled();
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'pythonLocation',
      expect.anything()
    );
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'PKG_CONFIG_PATH',
      expect.anything()
    );
  });

  it('Finds Python if it is installed without environment update', async () => {
    const pythonDir: string = path.join(toolDir, 'Python', '3.0.0', 'x64');
    await io.mkdirP(pythonDir);
    fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await finder.useCpythonVersion('3.x', 'x64', false, false, false, false);
    expect(spyCoreAddPath).not.toHaveBeenCalled();
    expect(spyCoreExportVariable).not.toHaveBeenCalled();
  });

  it('Finds stable Python version if it is not installed, but exists in the manifest', async () => {
    const findSpy: jest.SpyInstance = jest.spyOn(tc, 'getManifestFromRepo');
    findSpy.mockImplementation(() => <tc.IToolRelease[]>manifestData);

    const getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
    getBooleanInputSpy.mockImplementation(input => false);

    const installSpy: jest.SpyInstance = jest.spyOn(
      installer,
      'installCpythonFromRelease'
    );
    installSpy.mockImplementation(async () => {
      const pythonDir: string = path.join(toolDir, 'Python', '1.2.3', 'x64');
      await io.mkdirP(pythonDir);
      fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    });
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await expect(
      finder.useCpythonVersion('1.2.3', 'x64', true, false, false, false)
    ).resolves.toEqual({
      impl: 'CPython',
      version: '1.2.3'
    });
    expect(spyCoreAddPath).toHaveBeenCalled();
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'pythonLocation',
      expect.anything()
    );
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'PKG_CONFIG_PATH',
      expect.anything()
    );
  });

  it('Finds pre-release Python version in the manifest', async () => {
    const findSpy: jest.SpyInstance = jest.spyOn(tc, 'getManifestFromRepo');
    findSpy.mockImplementation(() => <tc.IToolRelease[]>manifestData);

    const getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
    getBooleanInputSpy.mockImplementation(input => false);

    const installSpy: jest.SpyInstance = jest.spyOn(
      installer,
      'installCpythonFromRelease'
    );
    installSpy.mockImplementation(async () => {
      const pythonDir: string = path.join(
        toolDir,
        'Python',
        '1.2.4-beta.2',
        'x64'
      );
      await io.mkdirP(pythonDir);
      fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    });
    // This will throw if it doesn't find it in the manifest (because no such version exists)
    await expect(
      finder.useCpythonVersion(
        '1.2.4-beta.2',
        'x64',
        false,
        false,
        false,
        false
      )
    ).resolves.toEqual({
      impl: 'CPython',
      version: '1.2.4-beta.2'
    });
  });

  it('Check-latest true, finds the latest version in the manifest', async () => {
    const findSpy: jest.SpyInstance = jest.spyOn(tc, 'getManifestFromRepo');
    findSpy.mockImplementation(() => <tc.IToolRelease[]>manifestData);

    const getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
    getBooleanInputSpy.mockImplementation(input => true);

    const cnSpy: jest.SpyInstance = jest.spyOn(process.stdout, 'write');
    cnSpy.mockImplementation(line => {
      // uncomment to debug
      // process.stderr.write('write:' + line + '\n');
    });

    const addPathSpy: jest.SpyInstance = jest.spyOn(core, 'addPath');
    addPathSpy.mockImplementation(() => null);

    const infoSpy: jest.SpyInstance = jest.spyOn(core, 'info');
    infoSpy.mockImplementation(() => {});

    const debugSpy: jest.SpyInstance = jest.spyOn(core, 'debug');
    debugSpy.mockImplementation(() => {});

    const pythonDir: string = path.join(toolDir, 'Python', '1.2.2', 'x64');
    const expPath: string = path.join(toolDir, 'Python', '1.2.3', 'x64');

    const installSpy: jest.SpyInstance = jest.spyOn(
      installer,
      'installCpythonFromRelease'
    );
    installSpy.mockImplementation(async () => {
      await io.mkdirP(expPath);
      fs.writeFileSync(`${expPath}.complete`, 'hello');
    });

    const tcFindSpy: jest.SpyInstance = jest.spyOn(tc, 'find');
    tcFindSpy
      .mockImplementationOnce(() => '')
      .mockImplementationOnce(() => expPath);

    await io.mkdirP(pythonDir);
    await io.rmRF(path.join(toolDir, 'Python', '1.2.3'));

    fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await finder.useCpythonVersion('1.2', 'x64', true, true, false, false);

    expect(infoSpy).toHaveBeenCalledWith("Resolved as '1.2.3'");
    expect(infoSpy).toHaveBeenCalledWith(
      'Version 1.2.3 was not found in the local cache'
    );
    expect(infoSpy).toHaveBeenCalledWith(
      'Version 1.2.3 is available for downloading'
    );
    expect(installSpy).toHaveBeenCalled();
    expect(addPathSpy).toHaveBeenCalledWith(expPath);
    await finder.useCpythonVersion(
      '1.2.4-beta.2',
      'x64',
      false,
      true,
      false,
      false
    );
    expect(spyCoreAddPath).toHaveBeenCalled();
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'pythonLocation',
      expect.anything()
    );
    expect(spyCoreExportVariable).toHaveBeenCalledWith(
      'PKG_CONFIG_PATH',
      expect.anything()
    );
  });

  it('Finds stable Python version if it is not installed, but exists in the manifest, skipping newer pre-release', async () => {
    const findSpy: jest.SpyInstance = jest.spyOn(tc, 'getManifestFromRepo');
    findSpy.mockImplementation(() => <tc.IToolRelease[]>manifestData);

    const installSpy: jest.SpyInstance = jest.spyOn(
      installer,
      'installCpythonFromRelease'
    );
    installSpy.mockImplementation(async () => {
      const pythonDir: string = path.join(toolDir, 'Python', '1.2.3', 'x64');
      await io.mkdirP(pythonDir);
      fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    });
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await expect(
      finder.useCpythonVersion('1.2', 'x64', false, false, false, false)
    ).resolves.toEqual({
      impl: 'CPython',
      version: '1.2.3'
    });
  });

  it('Finds Python version if it is not installed, but exists in the manifest, pre-release fallback', async () => {
    const findSpy: jest.SpyInstance = jest.spyOn(tc, 'getManifestFromRepo');
    findSpy.mockImplementation(() => <tc.IToolRelease[]>manifestData);

    const installSpy: jest.SpyInstance = jest.spyOn(
      installer,
      'installCpythonFromRelease'
    );
    installSpy.mockImplementation(async () => {
      const pythonDir: string = path.join(
        toolDir,
        'Python',
        '1.1.0-beta.2',
        'x64'
      );
      await io.mkdirP(pythonDir);
      fs.writeFileSync(`${pythonDir}.complete`, 'hello');
    });
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    await expect(
      finder.useCpythonVersion('1.1', 'x64', false, false, false, false)
    ).rejects.toThrow();
    await expect(
      finder.useCpythonVersion('1.1', 'x64', false, false, true, false)
    ).resolves.toEqual({
      impl: 'CPython',
      version: '1.1.0-beta.2'
    });
    // Check 1.1.0 version specifier does not fallback to '1.1.0-beta.2'
    await expect(
      finder.useCpythonVersion('1.1.0', 'x64', false, false, true, false)
    ).rejects.toThrow();
  });

  it('Errors if Python is not installed', async () => {
    // This will throw if it doesn't find it in the cache and in the manifest (because no such version exists)
    let thrown = false;
    try {
      await finder.useCpythonVersion(
        '3.300000',
        'x64',
        true,
        false,
        false,
        false
      );
    } catch {
      thrown = true;
    }
    expect(thrown).toBeTruthy();
    expect(spyCoreAddPath).not.toHaveBeenCalled();
    expect(spyCoreExportVariable).not.toHaveBeenCalled();
  });

  describe('System Python fallback', () => {
    let execSpy: jest.SpyInstance;
    let manifestSpy: jest.SpyInstance;

    beforeEach(() => {
      // Mock the manifest to return entries only for x64, not riscv64
      manifestSpy = jest.spyOn(installer, 'getManifest');
      manifestSpy.mockImplementation(
        async () => <tc.IToolRelease[]>manifestData
      );
    });

    it('Falls back to system Python on unsupported architecture', async () => {
      execSpy = jest.spyOn(exec, 'getExecOutput');
      execSpy.mockImplementation(async () => ({
        exitCode: 0,
        stdout:
          '/usr/bin/python3\n3.12.0\n/usr\n/usr/bin\n',
        stderr: ''
      }));

      const result = await finder.useCpythonVersion(
        '3.12',
        'riscv64',
        true,
        false,
        false,
        false
      );

      expect(result).toEqual({impl: 'CPython', version: '3.12.0'});
      expect(spyCoreAddPath).toHaveBeenCalledWith('/usr/bin');
      expect(spyCoreExportVariable).toHaveBeenCalledWith(
        'pythonLocation',
        '/usr'
      );
    });

    it('Does not fall back on supported architecture with missing version', async () => {
      // x64 has manifest entries, so fallback should NOT trigger
      let thrown = false;
      try {
        await finder.useCpythonVersion(
          '3.300000',
          'x64',
          true,
          false,
          false,
          false
        );
      } catch {
        thrown = true;
      }
      expect(thrown).toBeTruthy();
    });

    it('Does not fall back when system Python version does not match', async () => {
      execSpy = jest.spyOn(exec, 'getExecOutput');
      execSpy.mockImplementation(async () => ({
        exitCode: 0,
        stdout:
          '/usr/bin/python3\n3.11.5\n/usr\n/usr/bin\n',
        stderr: ''
      }));

      let thrown = false;
      try {
        await finder.useCpythonVersion(
          '3.12',
          'riscv64',
          true,
          false,
          false,
          false
        );
      } catch {
        thrown = true;
      }
      expect(thrown).toBeTruthy();
    });

    it('Does not fall back for freethreaded builds', async () => {
      execSpy = jest.spyOn(exec, 'getExecOutput');
      execSpy.mockImplementation(async () => ({
        exitCode: 0,
        stdout:
          '/usr/bin/python3\n3.13.0\n/usr\n/usr/bin\n',
        stderr: ''
      }));

      let thrown = false;
      try {
        await finder.useCpythonVersion(
          '3.13t',
          'riscv64',
          true,
          false,
          false,
          false
        );
      } catch {
        thrown = true;
      }
      expect(thrown).toBeTruthy();
    });

    it('Handles missing system Python gracefully', async () => {
      execSpy = jest.spyOn(exec, 'getExecOutput');
      execSpy.mockImplementation(async () => {
        throw new Error('python3 not found');
      });

      let thrown = false;
      try {
        await finder.useCpythonVersion(
          '3.12',
          'riscv64',
          true,
          false,
          false,
          false
        );
      } catch {
        thrown = true;
      }
      expect(thrown).toBeTruthy();
    });
  });
});