Skip to content
Snippets Groups Projects
Select Git revision
  • dca3418bbdbf1024ac6807e591562b4042bc846d
  • main default protected
  • next
  • renovate/main-ghcr.io-renovatebot-base-image-10.x
  • renovate/main-ghcr.io-containerbase-devcontainer-13.x
  • revert-31645-feat/rename-gradle-wrapper-validation-action
  • renovate/main-redis-5.x
  • fix/36615b-branch-reuse-no-cache
  • chore/punycode
  • fix/36615-branch-reuse-bug
  • refactor/pin-new-value
  • feat/36219--git-x509-signing
  • feat/structured-logger
  • hotfix/39.264.1
  • feat/skip-dangling
  • gh-readonly-queue/next/pr-36034-7a061c4ca1024a19e2c295d773d9642625d1c2be
  • hotfix/39.238.3
  • refactor/gitlab-auto-approve
  • feat/template-strings
  • gh-readonly-queue/next/pr-35654-137d934242c784e0c45d4b957362214f0eade1d7
  • fix/32307-global-extends-merging
  • 41.32.1
  • 41.32.0
  • 41.31.1
  • 41.31.0
  • 41.30.5
  • 41.30.4
  • 41.30.3
  • 41.30.2
  • 41.30.1
  • 41.30.0
  • 41.29.1
  • 41.29.0
  • 41.28.2
  • 41.28.1
  • 41.28.0
  • 41.27.1
  • 41.27.0
  • 41.26.2
  • 41.26.1
  • 41.26.0
41 results

http.ts

Blame
  • artifacts.spec.ts 5.08 KiB
    import { exec as _exec } from 'child_process';
    import _fs from 'fs-extra';
    import { join } from 'upath';
    import { envMock, mockExecAll } from '../../../test/execUtil';
    import { git, mocked } from '../../../test/util';
    import { setUtilConfig } from '../../util';
    import { BinarySource } from '../../util/exec/common';
    import * as docker from '../../util/exec/docker';
    import * as _env from '../../util/exec/env';
    import { StatusResult } from '../../util/git';
    import * as pipenv from './artifacts';
    
    jest.mock('fs-extra');
    jest.mock('child_process');
    jest.mock('../../util/exec/env');
    jest.mock('../../util/git');
    jest.mock('../../util/host-rules');
    jest.mock('../../util/http');
    
    const fs: jest.Mocked<typeof _fs> = _fs as any;
    const exec: jest.Mock<typeof _exec> = _exec as any;
    const env = mocked(_env);
    
    const config = {
      // `join` fixes Windows CI
      localDir: join('/tmp/github/some/repo'),
      cacheDir: join('/tmp/renovate/cache'),
      dockerUser: 'foobar',
    };
    
    const dockerConfig = { ...config, binarySource: BinarySource.Docker };
    const lockMaintenceConfig = { ...config, isLockFileMaintenance: true };
    
    describe('.updateArtifacts()', () => {
      let pipFileLock;
      beforeEach(async () => {
        jest.resetAllMocks();
        env.getChildProcessEnv.mockReturnValue({
          ...envMock.basic,
          LANG: 'en_US.UTF-8',
          LC_ALL: 'en_US',
        });
    
        await setUtilConfig(config);
        docker.resetPrefetchedImages();
        pipFileLock = { _meta: { requires: {} } };
      });
    
      it('returns if no Pipfile.lock found', async () => {
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: '',
            config,
          })
        ).toBeNull();
      });
      it('returns null if unchanged', async () => {
        pipFileLock._meta.requires.python_full_version = '3.7.6';
        fs.readFile.mockResolvedValueOnce(JSON.stringify(pipFileLock) as any);
        const execSnapshots = mockExecAll(exec);
        fs.readFile.mockReturnValueOnce(JSON.stringify(pipFileLock) as any);
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: 'some new content',
            config,
          })
        ).toBeNull();
        expect(execSnapshots).toMatchSnapshot();
      });
      it('handles no constraint', async () => {
        fs.readFile.mockResolvedValueOnce('unparseable pipfile lock' as any);
        const execSnapshots = mockExecAll(exec);
        fs.readFile.mockReturnValueOnce('unparseable pipfile lock' as any);
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: 'some new content',
            config,
          })
        ).toBeNull();
        expect(execSnapshots).toMatchSnapshot();
      });
      it('returns updated Pipfile.lock', async () => {
        fs.readFile.mockResolvedValueOnce('current pipfile.lock' as any);
        const execSnapshots = mockExecAll(exec);
        git.getRepoStatus.mockResolvedValue({
          modified: ['Pipfile.lock'],
        } as StatusResult);
        fs.readFile.mockReturnValueOnce('New Pipfile.lock' as any);
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: 'some new content',
            config: { ...config, constraints: { python: '3.7' } },
          })
        ).not.toBeNull();
        expect(execSnapshots).toMatchSnapshot();
      });
      it('supports docker mode', async () => {
        jest.spyOn(docker, 'removeDanglingContainers').mockResolvedValueOnce();
        await setUtilConfig(dockerConfig);
        pipFileLock._meta.requires.python_version = '3.7';
        fs.readFile.mockResolvedValueOnce(JSON.stringify(pipFileLock) as any);
        const execSnapshots = mockExecAll(exec);
        git.getRepoStatus.mockResolvedValue({
          modified: ['Pipfile.lock'],
        } as StatusResult);
        fs.readFile.mockReturnValueOnce('new lock' as any);
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: 'some new content',
            config: dockerConfig,
          })
        ).not.toBeNull();
        expect(execSnapshots).toMatchSnapshot();
      });
      it('catches errors', async () => {
        fs.readFile.mockResolvedValueOnce('Current Pipfile.lock' as any);
        fs.outputFile.mockImplementationOnce(() => {
          throw new Error('not found');
        });
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: '{}',
            config,
          })
        ).toMatchSnapshot();
      });
      it('returns updated Pipenv.lock when doing lockfile maintenance', async () => {
        fs.readFile.mockResolvedValueOnce('Current Pipfile.lock' as any);
        const execSnapshots = mockExecAll(exec);
        git.getRepoStatus.mockResolvedValue({
          modified: ['Pipfile.lock'],
        } as StatusResult);
        fs.readFile.mockReturnValueOnce('New Pipfile.lock' as any);
        expect(
          await pipenv.updateArtifacts({
            packageFileName: 'Pipfile',
            updatedDeps: [],
            newPackageFileContent: '{}',
            config: lockMaintenceConfig,
          })
        ).not.toBeNull();
        expect(execSnapshots).toMatchSnapshot();
      });
    });