react-native-config-ultimate 0.0.1 → 0.0.5

package/src/load-env.spec.ts

@@ -1,163 +0,0 @@
-const mockReadFileSync = jest.fn();
-jest.doMock('fs', () => ({ readFileSync: mockReadFileSync }));
-
-const mockParse = jest.fn();
-jest.doMock('dotenv', () => ({ parse: mockParse }));
-
-const mockExpand = jest.fn();
-jest.doMock('dotenv-expand', () => ({ expand: mockExpand }));
-
-const mockYaml = jest.fn();
-jest.doMock('js-yaml', () => ({ load: mockYaml }));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const load_env: (paths: string | string[]) => Record<string, unknown> =
-  require('./load-env').default;
-
-describe('load-env', () => {
-  beforeEach(() => {
-    mockReadFileSync.mockReset();
-    mockParse.mockReset();
-    mockExpand.mockReset();
-    mockYaml.mockReset();
-    // Default expand: return parsed as-is (no expansion side effects)
-    mockExpand.mockImplementation(
-      (input: { parsed: Record<string, string> }) => input
-    );
-  });
-
-  describe('dotenv format', () => {
-    it('reads a single dotenv file (backward-compatible string arg)', () => {
-      mockReadFileSync.mockReturnValueOnce('hello=world');
-      mockParse.mockReturnValueOnce({ hello: 'world' });
-      const result = load_env('hello');
-      expect(mockReadFileSync).toHaveBeenCalledWith('hello', 'utf8');
-      expect(mockParse).toHaveBeenCalledWith('hello=world');
-      expect(result).toEqual({ hello: 'world' });
-    });
-
-    it('reads a single dotenv file when passed as an array', () => {
-      mockReadFileSync.mockReturnValueOnce('hello=world');
-      mockParse.mockReturnValueOnce({ hello: 'world' });
-      const result = load_env(['hello']);
-      expect(mockReadFileSync).toHaveBeenCalledWith('hello', 'utf8');
-      expect(result).toEqual({ hello: 'world' });
-    });
-
-    it('merges multiple dotenv files, last file wins for conflicts', () => {
-      mockReadFileSync
-        .mockReturnValueOnce('A=base\nB=base')
-        .mockReturnValueOnce('B=override\nC=new');
-      mockParse
-        .mockReturnValueOnce({ A: 'base', B: 'base' })
-        .mockReturnValueOnce({ B: 'override', C: 'new' });
-      const result = load_env(['.env.base', '.env.staging']);
-      expect(mockReadFileSync).toHaveBeenCalledTimes(2);
-      // expand is called once with the merged raw object
-      expect(mockExpand).toHaveBeenCalledWith({
-        parsed: { A: 'base', B: 'override', C: 'new' },
-      });
-      expect(result).toEqual({ A: 'base', B: 'override', C: 'new' });
-    });
-
-    it('expands $VAR references using dotenv-expand', () => {
-      mockReadFileSync.mockReturnValueOnce('BASE=https://api.com\nURL=$BASE/v1');
-      mockParse.mockReturnValueOnce({ BASE: 'https://api.com', URL: '$BASE/v1' });
-      mockExpand.mockReturnValueOnce({
-        parsed: { BASE: 'https://api.com', URL: 'https://api.com/v1' },
-      });
-      const result = load_env('.env');
-      expect(result).toEqual({
-        BASE: 'https://api.com',
-        URL: 'https://api.com/v1',
-      });
-    });
-
-    it('expands cross-file $VAR references when merging multiple files', () => {
-      mockReadFileSync
-        .mockReturnValueOnce('BASE_URL=https://api.com')
-        .mockReturnValueOnce('API_URL=$BASE_URL/v1');
-      mockParse
-        .mockReturnValueOnce({ BASE_URL: 'https://api.com' })
-        .mockReturnValueOnce({ API_URL: '$BASE_URL/v1' });
-      // Expand is called with merged raw — so cross-file reference resolves
-      mockExpand.mockReturnValueOnce({
-        parsed: {
-          BASE_URL: 'https://api.com',
-          API_URL: 'https://api.com/v1',
-        },
-      });
-      const result = load_env(['.env.base', '.env.staging']);
-      expect(mockExpand).toHaveBeenCalledWith({
-        parsed: { BASE_URL: 'https://api.com', API_URL: '$BASE_URL/v1' },
-      });
-      expect(result).toEqual({
-        BASE_URL: 'https://api.com',
-        API_URL: 'https://api.com/v1',
-      });
-    });
-  });
-
-  describe('yaml format', () => {
-    it.each`
-      extension
-      ${'yml'}
-      ${'yaml'}
-    `(
-      "reads yaml when extension is '.$extension'",
-      ({ extension }: { extension: string }) => {
-        mockReadFileSync.mockReturnValueOnce(Buffer.from('data'));
-        mockYaml.mockReturnValueOnce({ hello: 'world' });
-        const result = load_env(`hello.${extension}`);
-        expect(mockReadFileSync).toHaveBeenCalledWith(`hello.${extension}`);
-        expect(mockYaml).toHaveBeenCalledWith('data');
-        expect(result).toEqual({ hello: 'world' });
-      }
-    );
-
-    it('merges multiple yaml files, last file wins for conflicts', () => {
-      mockReadFileSync
-        .mockReturnValueOnce(Buffer.from('A: base\nB: base'))
-        .mockReturnValueOnce(Buffer.from('B: override\nC: new'));
-      mockYaml
-        .mockReturnValueOnce({ A: 'base', B: 'base' })
-        .mockReturnValueOnce({ B: 'override', C: 'new' });
-      const result = load_env(['base.yaml', 'staging.yaml']);
-      expect(mockReadFileSync).toHaveBeenCalledTimes(2);
-      expect(result).toEqual({ A: 'base', B: 'override', C: 'new' });
-    });
-
-    describe.each`
-      extension
-      ${'yml'}
-      ${'yaml'}
-    `(
-      "throws when yaml is not an object with extension '.$extension'",
-      ({ extension }: { extension: string }) => {
-        it.each`
-          content
-          ${'abc:def'}
-          ${false}
-          ${true}
-          ${42}
-          ${null}
-          ${undefined}
-        `("when content is '$content'", ({ content }: { content: unknown }) => {
-          mockReadFileSync.mockReturnValueOnce(Buffer.from('data'));
-          mockYaml.mockReturnValueOnce(content);
-          expect(() => {
-            load_env(`hello.${extension}`);
-          }).toThrow();
-        });
-      }
-    );
-  });
-
-  describe('edge cases', () => {
-    it('throws when no files are provided', () => {
-      expect(() => load_env([])).toThrow(
-        'No env file specified'
-      );
-    });
-  });
-});

package/src/main.spec.ts

@@ -1,171 +0,0 @@
-const mock_load_env = jest.fn();
-jest.doMock('./load-env', () => ({ __esModule: true, default: mock_load_env }));
-const mock_render_env = jest.fn();
-jest.doMock('./render-env', () => ({ __esModule: true, default: mock_render_env }));
-const mock_write_env = jest.fn();
-jest.doMock('./write-env', () => ({ __esModule: true, default: mock_write_env }));
-const mock_flatten = jest.fn();
-jest.doMock('./flatten', () => ({ __esModule: true, default: mock_flatten }));
-const mock_validate_env = jest.fn();
-jest.doMock('./validate-env', () => ({ validate_env: mock_validate_env }));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const main: (...args: unknown[]) => Promise<void> = require('./main').default;
-
-
-export const files_to_assert = [
-  'ios/rncu.xcconfig',
-  'node_modules/react-native-config-ultimate/ios/ConfigValues.h',
-  'node_modules/react-native-config-ultimate/android/rncu.yaml',
-  'node_modules/react-native-config-ultimate/index.d.ts',
-  'node_modules/react-native-config-ultimate/index.web.js',
-  'node_modules/react-native-config-ultimate/override.js',
-];
-
-describe('main', () => {
-  beforeEach(() => {
-    mock_load_env.mockReset();
-    mock_render_env.mockReset();
-    mock_write_env.mockReset();
-    mock_flatten.mockReset();
-    mock_validate_env.mockReset();
-  });
-
-  it('execute render with paths (string arg — backward-compatible)', async () => {
-    mock_load_env.mockReturnValueOnce({ data: true });
-    mock_flatten.mockReturnValueOnce({ data: true, ios: true });
-    mock_flatten.mockReturnValueOnce({ data: true, android: true });
-    mock_flatten.mockReturnValueOnce({ data: true, web: true });
-    mock_render_env.mockReturnValueOnce({ hello: 'world' });
-    await main(
-      'project',
-      'project/node_modules/react-native-config-ultimate',
-      'file'
-    );
-    expect(mock_load_env).toHaveBeenCalledWith('file');
-    expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'ios');
-    expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'android');
-    expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'web');
-    expect(mock_render_env).toHaveBeenCalledWith(
-      'project',
-      'project/node_modules/react-native-config-ultimate',
-      {
-        ios: { data: true, ios: true },
-        android: { data: true, android: true },
-        web: { data: true, web: true },
-      },
-      undefined
-    );
-    expect(mock_write_env).toHaveBeenCalledWith({ hello: 'world' });
-  });
-
-  it('passes array of env files to load_env (multi-file merge)', async () => {
-    mock_load_env.mockReturnValueOnce({ data: true });
-    mock_flatten.mockReturnValue({});
-    mock_render_env.mockReturnValueOnce({});
-    await main(
-      'project',
-      'project/node_modules/react-native-config-ultimate',
-      ['.env.base', '.env.staging']
-    );
-    expect(mock_load_env).toHaveBeenCalledWith(['.env.base', '.env.staging']);
-  });
-  describe('rc.on_env', () => {
-    it('invoke rc hook with config before flattening', async () => {
-      const on_env = jest.fn();
-      mock_load_env.mockReturnValueOnce({ data: true });
-      await main(
-        'project',
-        'project/node_modules/react-native-config-ultimate',
-        'file',
-        { on_env }
-      );
-      expect(on_env).toHaveBeenCalledWith({ data: true });
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'ios');
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'android');
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true }, 'web');
-    });
-    it('hook can add or remove values', async () => {
-      const on_env = jest.fn();
-      on_env.mockImplementation((env: Record<string, unknown>) => {
-        const { key1, ...rest } = env;
-        void key1;
-        return { ...rest, key2: 'hello' };
-      });
-      mock_load_env.mockReturnValueOnce({ data: true, key1: 'bye' });
-      await main(
-        'project',
-        'project/node_modules/react-native-config-ultimate',
-        'file',
-        { on_env }
-      );
-      expect(on_env).toHaveBeenCalledWith({ data: true, key1: 'bye' });
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true, key2: 'hello' }, 'ios');
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true, key2: 'hello' }, 'android');
-      expect(mock_flatten).toHaveBeenCalledWith({ data: true, key2: 'hello' }, 'web');
-    });
-  });
-
-  describe('rc.schema', () => {
-    it('calls validate_env when schema is provided', async () => {
-      const schema = { API_KEY: { type: 'string' as const, required: true } };
-      mock_load_env.mockReturnValueOnce({ API_KEY: 'secret' });
-      mock_flatten.mockReturnValue({});
-      mock_render_env.mockReturnValueOnce({});
-      await main(
-        'project',
-        'project/node_modules/react-native-config-ultimate',
-        'file',
-        { schema }
-      );
-      expect(mock_validate_env).toHaveBeenCalledWith({ API_KEY: 'secret' }, schema);
-    });
-
-    it('does not call validate_env when no schema is provided', async () => {
-      mock_load_env.mockReturnValueOnce({ data: true });
-      mock_flatten.mockReturnValue({});
-      mock_render_env.mockReturnValueOnce({});
-      await main(
-        'project',
-        'project/node_modules/react-native-config-ultimate',
-        'file'
-      );
-      expect(mock_validate_env).not.toHaveBeenCalled();
-    });
-
-    it('validates env AFTER on_env hook runs (hook output is validated)', async () => {
-      const schema = { INJECTED_KEY: { type: 'string' as const, required: true } };
-      const on_env = jest.fn().mockReturnValue({ INJECTED_KEY: 'from-hook' });
-      mock_load_env.mockReturnValueOnce({});
-      mock_flatten.mockReturnValue({});
-      mock_render_env.mockReturnValueOnce({});
-      await main(
-        'project',
-        'project/node_modules/react-native-config-ultimate',
-        'file',
-        { on_env, schema }
-      );
-      // validate_env receives the HOOK output, not the raw env
-      expect(mock_validate_env).toHaveBeenCalledWith(
-        { INJECTED_KEY: 'from-hook' },
-        schema
-      );
-    });
-
-    it('propagates validation error thrown by validate_env', async () => {
-      const schema = { API_KEY: { type: 'string' as const, required: true } };
-      mock_load_env.mockReturnValueOnce({});
-      mock_validate_env.mockImplementation(() => {
-        throw new Error('❌ validation failed: Missing required env var: API_KEY');
-      });
-      await expect(
-        main(
-          'project',
-          'project/node_modules/react-native-config-ultimate',
-          'file',
-          { schema }
-        )
-      ).rejects.toThrow('Missing required env var: API_KEY');
-    });
-  });
-});

package/src/resolve-env.spec.ts

@@ -1,25 +0,0 @@
-import resolve_env from './resolve-env';
-import type { EnvData } from './resolve-env';
-
-describe('resolve_env', () => {
-  const original: EnvData = { original: 'data' };
-  it.each`
-    on_env_result | expected
-    ${1}          | ${1}
-    ${''}         | ${''}
-    ${'hello'}    | ${'hello'}
-    ${0}          | ${0}
-    ${1}          | ${1}
-    ${false}      | ${false}
-    ${true}       | ${true}
-    ${null}       | ${null}
-    ${undefined}  | ${original}
-  `(
-    "when hook returns '$on_env_result' env is resolved to '$expected'",
-    async ({ on_env_result, expected }: { on_env_result: unknown; expected: unknown }) => {
-      const on_env = jest.fn();
-      on_env.mockReturnValueOnce(on_env_result);
-      expect(await resolve_env(original, { on_env })).toEqual(expected);
-    }
-  );
-});

package/src/validate-env.spec.ts

@@ -1,164 +0,0 @@
-import { validate_env } from './validate-env';
-import type { Schema } from './resolve-env';
-
-describe('validate-env', () => {
-  describe('required fields', () => {
-    it('throws when a required var is missing', () => {
-      const schema: Schema = { API_KEY: { type: 'string', required: true } };
-      expect(() => validate_env({}, schema)).toThrow('Missing required env var: API_KEY');
-    });
-
-    it('throws when a required var is an empty string', () => {
-      const schema: Schema = { API_KEY: { type: 'string', required: true } };
-      expect(() => validate_env({ API_KEY: '' }, schema)).toThrow(
-        'Missing required env var: API_KEY'
-      );
-    });
-
-    it('throws when a required var is null', () => {
-      const schema: Schema = { API_KEY: { type: 'string', required: true } };
-      expect(() => validate_env({ API_KEY: null }, schema)).toThrow(
-        'Missing required env var: API_KEY'
-      );
-    });
-
-    it('does not throw when a required var is present', () => {
-      const schema: Schema = { API_KEY: { type: 'string', required: true } };
-      expect(() => validate_env({ API_KEY: 'my-key' }, schema)).not.toThrow();
-    });
-
-    it('does not throw when an optional var is missing', () => {
-      const schema: Schema = { DEBUG: { type: 'boolean', required: false } };
-      expect(() => validate_env({}, schema)).not.toThrow();
-    });
-
-    it('does not throw when required is not specified and var is missing', () => {
-      const schema: Schema = { DEBUG: { type: 'boolean' } };
-      expect(() => validate_env({}, schema)).not.toThrow();
-    });
-  });
-
-  describe('type validation', () => {
-    describe('number', () => {
-      it('accepts valid number strings', () => {
-        const schema: Schema = { TIMEOUT: { type: 'number' } };
-        expect(() => validate_env({ TIMEOUT: '3000' }, schema)).not.toThrow();
-        expect(() => validate_env({ TIMEOUT: '0' }, schema)).not.toThrow();
-        expect(() => validate_env({ TIMEOUT: '-1' }, schema)).not.toThrow();
-        expect(() => validate_env({ TIMEOUT: '3.14' }, schema)).not.toThrow();
-      });
-
-      it('throws for non-numeric strings', () => {
-        const schema: Schema = { TIMEOUT: { type: 'number' } };
-        expect(() => validate_env({ TIMEOUT: 'fast' }, schema)).toThrow(
-          'TIMEOUT must be a number, got "fast"'
-        );
-        expect(() => validate_env({ TIMEOUT: 'abc' }, schema)).toThrow(
-          'TIMEOUT must be a number'
-        );
-      });
-
-      it('accepts actual number values', () => {
-        const schema: Schema = { TIMEOUT: { type: 'number' } };
-        expect(() => validate_env({ TIMEOUT: 3000 }, schema)).not.toThrow();
-      });
-    });
-
-    describe('boolean', () => {
-      it('accepts valid boolean strings', () => {
-        const schema: Schema = { DEBUG: { type: 'boolean' } };
-        for (const v of ['true', 'false', '1', '0', 'TRUE', 'FALSE']) {
-          expect(() => validate_env({ DEBUG: v }, schema)).not.toThrow();
-        }
-      });
-
-      it('throws for invalid boolean strings', () => {
-        const schema: Schema = { DEBUG: { type: 'boolean' } };
-        expect(() => validate_env({ DEBUG: 'yes' }, schema)).toThrow(
-          'DEBUG must be a boolean (true/false/1/0), got "yes"'
-        );
-        expect(() => validate_env({ DEBUG: 'enabled' }, schema)).toThrow(
-          'DEBUG must be a boolean'
-        );
-      });
-    });
-
-    describe('string', () => {
-      it('accepts any non-empty value as string', () => {
-        const schema: Schema = { NAME: { type: 'string' } };
-        expect(() => validate_env({ NAME: 'hello' }, schema)).not.toThrow();
-        expect(() => validate_env({ NAME: '123' }, schema)).not.toThrow();
-        expect(() => validate_env({ NAME: 'true' }, schema)).not.toThrow();
-      });
-    });
-  });
-
-  describe('pattern validation', () => {
-    it('accepts values matching the pattern', () => {
-      const schema: Schema = {
-        ENV: { type: 'string', pattern: '^(dev|staging|prod)$' },
-      };
-      expect(() => validate_env({ ENV: 'dev' }, schema)).not.toThrow();
-      expect(() => validate_env({ ENV: 'staging' }, schema)).not.toThrow();
-      expect(() => validate_env({ ENV: 'prod' }, schema)).not.toThrow();
-    });
-
-    it('throws for values not matching the pattern', () => {
-      const schema: Schema = {
-        ENV: { type: 'string', pattern: '^(dev|staging|prod)$' },
-      };
-      expect(() => validate_env({ ENV: 'production' }, schema)).toThrow(
-        'ENV does not match pattern /^(dev|staging|prod)$/, got "production"'
-      );
-    });
-
-    it('pattern validation is skipped for missing optional vars', () => {
-      const schema: Schema = {
-        ENV: { type: 'string', pattern: '^(dev|staging|prod)$' },
-      };
-      expect(() => validate_env({}, schema)).not.toThrow();
-    });
-  });
-
-  describe('multiple errors', () => {
-    it('reports all validation errors at once, not just the first', () => {
-      const schema: Schema = {
-        API_KEY: { type: 'string', required: true },
-        TIMEOUT: { type: 'number', required: true },
-        ENV: { type: 'string', pattern: '^(dev|staging|prod)$' },
-      };
-      let error: Error | undefined;
-      try {
-        validate_env({ TIMEOUT: 'fast', ENV: 'production' }, schema);
-      } catch (e) {
-        error = e as Error;
-      }
-      expect(error).toBeDefined();
-      expect(error?.message).toContain('Missing required env var: API_KEY');
-      expect(error?.message).toContain('TIMEOUT must be a number');
-      expect(error?.message).toContain('ENV does not match pattern');
-    });
-  });
-
-  describe('does not throw for valid env', () => {
-    it('passes a complete valid env without error', () => {
-      const schema: Schema = {
-        API_KEY: { type: 'string', required: true },
-        TIMEOUT_MS: { type: 'number', required: true },
-        DEBUG: { type: 'boolean', required: false },
-        ENV_NAME: { type: 'string', required: true, pattern: '^(dev|staging|prod)$' },
-      };
-      expect(() =>
-        validate_env(
-          {
-            API_KEY: 'secret-key',
-            TIMEOUT_MS: '5000',
-            ENV_NAME: 'staging',
-            // DEBUG intentionally omitted (optional)
-          },
-          schema
-        )
-      ).not.toThrow();
-    });
-  });
-});

package/src/write-env.spec.ts

@@ -1,105 +0,0 @@
-// Mocks must be declared before the module is required.
-const mockWriteFileSync = jest.fn();
-const mockRenameSync = jest.fn();
-const mockUnlinkSync = jest.fn();
-const mockCopyFileSync = jest.fn();
-const mockMkdirSync = jest.fn(); // needed since write-env creates dest dirs
-
-jest.mock('fs', () => ({
-  writeFileSync: (...args: unknown[]) => mockWriteFileSync(...args),
-  renameSync: (...args: unknown[]) => mockRenameSync(...args),
-  unlinkSync: (...args: unknown[]) => mockUnlinkSync(...args),
-  copyFileSync: (...args: unknown[]) => mockCopyFileSync(...args),
-  mkdirSync: (...args: unknown[]) => mockMkdirSync(...args),
-}));
-
-jest.mock('os', () => ({ tmpdir: () => '/tmp' }));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const write_env: (env: Record<string, string>) => void = require('./write-env').default;
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-/** Returns the temp file path used for a given destination. */
-function tmp_for(dest: string): string {
-  const rename_call = mockRenameSync.mock.calls.find(
-    ([, d]: [string, string]) => d === dest
-  );
-  return rename_call?.[0] as string;
-}
-
-// ─── tests ───────────────────────────────────────────────────────────────────
-
-describe('write-env', () => {
-  beforeEach(() => {
-    mockWriteFileSync.mockReset();
-    mockRenameSync.mockReset();
-    mockUnlinkSync.mockReset();
-    mockCopyFileSync.mockReset();
-    mockMkdirSync.mockReset();
-  });
-
-  it('writes content to a temp file then renames to destination (atomic write)', () => {
-    write_env({ hello: 'world' });
-
-    // Phase 1: content written to a temp path under /tmp
-    expect(mockWriteFileSync).toHaveBeenCalledTimes(1);
-    const [tmp_path, content, encoding] = mockWriteFileSync.mock.calls[0] as [string, string, string];
-    expect(tmp_path).toMatch(/^\/tmp\/rncu_/);
-    expect(content).toBe('world');
-    expect(encoding).toBe('utf8');
-
-    // Phase 2: temp renamed to final destination (atomic)
-    expect(mockRenameSync).toHaveBeenCalledWith(tmp_path, 'hello');
-  });
-
-  it('writes multiple files atomically', () => {
-    write_env({ hello: 'world', hey: 'you' });
-
-    expect(mockWriteFileSync).toHaveBeenCalledTimes(2);
-    expect(mockRenameSync).toHaveBeenCalledTimes(2);
-
-    // Each dest should have been renamed from a unique temp path
-    const tmp_hello = tmp_for('hello');
-    const tmp_hey = tmp_for('hey');
-    expect(tmp_hello).toBeDefined();
-    expect(tmp_hey).toBeDefined();
-    expect(tmp_hello).not.toBe(tmp_hey);
-  });
-
-  it('falls back to copyFileSync + unlinkSync when renameSync fails (cross-device)', () => {
-    // Simulate cross-device rename error (e.g. /tmp on different device)
-    mockRenameSync.mockImplementation(() => { throw new Error('EXDEV'); });
-
-    write_env({ hello: 'world' });
-
-    expect(mockCopyFileSync).toHaveBeenCalledWith(expect.stringMatching(/^\/tmp\/rncu_/), 'hello');
-    expect(mockUnlinkSync).toHaveBeenCalled();
-  });
-
-  it('throws a descriptive error if copyFileSync also fails', () => {
-    mockRenameSync.mockImplementation(() => { throw new Error('EXDEV'); });
-    mockCopyFileSync.mockImplementation(() => { throw new Error('EACCES: permission denied'); });
-
-    expect(() => write_env({ hello: 'world' })).toThrow(
-      /Failed to write output files/
-    );
-    expect(() => write_env({ hello: 'world' })).toThrow('hello');
-  });
-
-  it('cleans up temp files when Phase 1 write fails', () => {
-    // First write succeeds, second fails mid-write
-    mockWriteFileSync
-      .mockImplementationOnce(() => { /* success */ })
-      .mockImplementationOnce(() => { throw new Error('ENOSPC: no space left'); });
-
-    expect(() => write_env({ hello: 'world', hey: 'you' })).toThrow(
-      /Failed to prepare output files/
-    );
-
-    // The first temp file should have been cleaned up
-    expect(mockUnlinkSync).toHaveBeenCalledTimes(1);
-    // No renames should have happened (no real files touched)
-    expect(mockRenameSync).not.toHaveBeenCalled();
-  });
-});