Skip to content
Snippets Groups Projects
Select Git revision
  • 150370563fcce53e834194ce154f4035ee52d7bf
  • master default protected
  • dwmcallister-patch-1
  • 520-fix-wsl
  • tune-worker-processes
  • alpine-nginxorg
  • 1.29.0
  • 1.28.0
  • 1.27.5
  • 1.27.3
  • 1.27.2
  • 1.27.0
  • 1.26.1
  • 1.26.0
  • 1.25.5
  • 1.25.4
  • 1.25.3
  • 1.25.2
  • 1.25.1
  • 1.25.0
  • 1.24.0
  • 1.23.3
  • 1.23.4
  • 1.23.2
  • 1.22.1
  • 1.23.1
26 results

Dockerfile-debian-otel.template

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();
      });
    });