react-native 0.71.4 → 0.72.0-rc.0

package/scripts/codegen/__tests__/generate-artifacts-executor-test.js

@@ -0,0 +1,500 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+const underTest = require('../generate-artifacts-executor');
+const fixtures = require('../__test_fixtures__/fixtures');
+const path = require('path');
+const fs = require('fs');
+const child_process = require('child_process');
+
+const codegenConfigKey = 'codegenConfig';
+const reactNativeDependencyName = 'react-native';
+const rootPath = path.join(__dirname, '../../..');
+
+describe('generateCode', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.resetAllMocks();
+  });
+
+  it('executeNodes with the right arguments', () => {
+    // Define variables and expected values
+    const iosOutputDir = 'app/ios/build/generated/ios';
+    const library = {config: {name: 'library', type: 'all'}};
+    const tmpDir = 'tmp';
+    const node = 'usr/bin/node';
+    const pathToSchema = 'app/build/schema.json';
+    const rnRoot = path.join(__dirname, '../..');
+    const libraryType = 'all';
+
+    const tmpOutDir = path.join(tmpDir, 'out');
+
+    // mock used functions
+    jest.spyOn(fs, 'mkdirSync').mockImplementation();
+    jest.spyOn(child_process, 'execSync').mockImplementation();
+
+    underTest._generateCode(iosOutputDir, library, tmpDir, node, pathToSchema);
+
+    const expectedCommand = `${node} ${path.join(
+      rnRoot,
+      'generate-specs-cli.js',
+    )}         --platform ios         --schemaPath ${pathToSchema}         --outputDir ${tmpOutDir}         --libraryName ${
+      library.config.name
+    }         --libraryType ${libraryType}`;
+
+    expect(child_process.execSync).toHaveBeenCalledTimes(2);
+    expect(child_process.execSync).toHaveBeenNthCalledWith(1, expectedCommand);
+    expect(child_process.execSync).toHaveBeenNthCalledWith(
+      2,
+      `cp -R ${tmpOutDir}/* ${iosOutputDir}`,
+    );
+
+    expect(fs.mkdirSync).toHaveBeenCalledTimes(2);
+    expect(fs.mkdirSync).toHaveBeenNthCalledWith(1, tmpOutDir, {
+      recursive: true,
+    });
+    expect(fs.mkdirSync).toHaveBeenNthCalledWith(2, iosOutputDir, {
+      recursive: true,
+    });
+  });
+});
+
+describe('extractLibrariesFromJSON', () => {
+  it('throws if in react-native and no dependencies found', () => {
+    let libraries = [];
+    let configFile = {};
+    expect(() => {
+      underTest._extractLibrariesFromJSON(
+        configFile,
+        libraries,
+        codegenConfigKey,
+      );
+    }).toThrow();
+  });
+
+  it('it skips if not into react-native and no dependencies found', () => {
+    let libraries = [];
+    let configFile = {};
+
+    underTest._extractLibrariesFromJSON(
+      configFile,
+      libraries,
+      codegenConfigKey,
+      'some-node-module',
+      'node_modules/some',
+    );
+    expect(libraries.length).toBe(0);
+  });
+
+  it('extracts a single dependency when config has no libraries', () => {
+    let libraries = [];
+    let configFile = fixtures.noLibrariesConfigFile;
+    underTest._extractLibrariesFromJSON(
+      configFile,
+      libraries,
+      codegenConfigKey,
+      'my-app',
+      '.',
+    );
+    expect(libraries.length).toBe(1);
+    expect(libraries[0]).toEqual({
+      library: 'my-app',
+      config: {
+        name: 'AppModules',
+        type: 'all',
+        jsSrcsDir: '.',
+      },
+      libraryPath: '.',
+    });
+  });
+
+  it("extract codegenConfig when it's empty", () => {
+    const configFile = {codegenConfig: {libraries: []}};
+    let libraries = [];
+    underTest._extractLibrariesFromJSON(
+      configFile,
+      codegenConfigKey,
+      libraries,
+      reactNativeDependencyName,
+      rootPath,
+    );
+    expect(libraries.length).toBe(0);
+  });
+
+  it('extract codegenConfig when dependency is one', () => {
+    const configFile = fixtures.singleLibraryCodegenConfig;
+    let libraries = [];
+    underTest._extractLibrariesFromJSON(
+      configFile,
+      libraries,
+      codegenConfigKey,
+      reactNativeDependencyName,
+      rootPath,
+    );
+    expect(libraries.length).toBe(1);
+    expect(libraries[0]).toEqual({
+      library: reactNativeDependencyName,
+      config: {
+        name: 'react-native',
+        type: 'all',
+        jsSrcsDir: '.',
+      },
+      libraryPath: rootPath,
+    });
+  });
+
+  it('extract codegenConfig with multiple dependencies', () => {
+    const configFile = fixtures.multipleLibrariesCodegenConfig;
+    const myDependency = 'my-dependency';
+    const myDependencyPath = path.join(__dirname, myDependency);
+    let libraries = [];
+    underTest._extractLibrariesFromJSON(
+      configFile,
+      libraries,
+      codegenConfigKey,
+      myDependency,
+      myDependencyPath,
+    );
+    expect(libraries.length).toBe(3);
+    expect(libraries[0]).toEqual({
+      library: myDependency,
+      config: {
+        name: 'react-native',
+        type: 'all',
+        jsSrcsDir: '.',
+      },
+      libraryPath: myDependencyPath,
+    });
+    expect(libraries[1]).toEqual({
+      library: myDependency,
+      config: {
+        name: 'my-component',
+        type: 'components',
+        jsSrcsDir: 'component/js',
+      },
+      libraryPath: myDependencyPath,
+    });
+    expect(libraries[2]).toEqual({
+      library: myDependency,
+      config: {
+        name: 'my-module',
+        type: 'module',
+        jsSrcsDir: 'module/js',
+      },
+      libraryPath: myDependencyPath,
+    });
+  });
+});
+
+describe('findCodegenEnabledLibraries', () => {
+  const mock = require('mock-fs');
+  const {
+    _findCodegenEnabledLibraries: findCodegenEnabledLibraries,
+  } = require('../generate-artifacts-executor');
+
+  afterEach(() => {
+    mock.restore();
+  });
+
+  it('returns libraries defined in react-native.config.js', () => {
+    const projectDir = path.join(__dirname, '../../../../test-project');
+    const baseCodegenConfigFileDir = path.join(__dirname, '../../..');
+    const baseCodegenConfigFilePath = path.join(
+      baseCodegenConfigFileDir,
+      'package.json',
+    );
+
+    mock({
+      [baseCodegenConfigFilePath]: `
+      {
+        "codegenConfig": {}
+      }
+      `,
+      [projectDir]: {
+        app: {
+          'package.json': `{
+            "name": "my-app"
+          }`,
+          'react-native.config.js': '',
+        },
+        'library-foo': {
+          'package.json': `{
+            "name": "react-native-foo",
+            "codegenConfig": {
+              "name": "RNFooSpec",
+              "type": "modules",
+              "jsSrcsDir": "src"
+            }
+          }`,
+        },
+      },
+    });
+
+    jest.mock(path.join(projectDir, 'app', 'react-native.config.js'), () => ({
+      dependencies: {
+        'react-native-foo': {
+          root: path.join(projectDir, 'library-foo'),
+        },
+        'react-native-bar': {
+          root: path.join(projectDir, 'library-bar'),
+        },
+      },
+    }));
+
+    const libraries = findCodegenEnabledLibraries(
+      `${projectDir}/app`,
+      baseCodegenConfigFileDir,
+      `package.json`,
+      'codegenConfig',
+    );
+
+    expect(libraries).toEqual([
+      {
+        library: 'react-native',
+        config: {},
+        libraryPath: baseCodegenConfigFileDir,
+      },
+      {
+        library: 'react-native-foo',
+        config: {name: 'RNFooSpec', type: 'modules', jsSrcsDir: 'src'},
+        libraryPath: path.join(projectDir, 'library-foo'),
+      },
+    ]);
+  });
+});
+
+describe('delete empty files and folders', () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  it('when path is empty file, deletes it', () => {
+    const targetFilepath = 'my-file.txt';
+    let statSyncInvocationCount = 0;
+    let rmSyncInvocationCount = 0;
+    let rmdirSyncInvocationCount = 0;
+    jest.mock('fs', () => ({
+      statSync: filepath => {
+        statSyncInvocationCount += 1;
+        expect(filepath).toBe(targetFilepath);
+        return {
+          isFile: () => {
+            return true;
+          },
+          size: 0,
+        };
+      },
+      rmSync: filepath => {
+        rmSyncInvocationCount += 1;
+        expect(filepath).toBe(targetFilepath);
+      },
+      rmdirSync: filepath => {
+        rmdirSyncInvocationCount += 1;
+      },
+    }));
+
+    underTest._cleanupEmptyFilesAndFolders(targetFilepath);
+    expect(statSyncInvocationCount).toBe(1);
+    expect(rmSyncInvocationCount).toBe(1);
+    expect(rmdirSyncInvocationCount).toBe(0);
+  });
+
+  it('when path is not an empty file, does nothing', () => {
+    const targetFilepath = 'my-file.txt';
+    const size = 128;
+
+    let statSyncInvocationCount = 0;
+    let rmSyncInvocationCount = 0;
+    let rmdirSyncInvocationCount = 0;
+
+    jest.mock('fs', () => ({
+      statSync: filepath => {
+        statSyncInvocationCount += 1;
+        expect(filepath).toBe(targetFilepath);
+        return {
+          isFile: () => {
+            return true;
+          },
+          size: size,
+        };
+      },
+      rmSync: filepath => {
+        rmSyncInvocationCount += 1;
+      },
+      rmdirSync: filepath => {
+        rmdirSyncInvocationCount += 1;
+      },
+    }));
+
+    underTest._cleanupEmptyFilesAndFolders(targetFilepath);
+    expect(statSyncInvocationCount).toBe(1);
+    expect(rmSyncInvocationCount).toBe(0);
+    expect(rmdirSyncInvocationCount).toBe(0);
+  });
+
+  it("when path is folder and it's empty, removes it", () => {
+    const targetFolder = 'build';
+    const content = [];
+
+    let statSyncInvocationCount = 0;
+    let readdirInvocationCount = 0;
+    let rmSyncInvocationCount = 0;
+    let rmdirSyncInvocationCount = 0;
+
+    jest.mock('fs', () => ({
+      statSync: filepath => {
+        statSyncInvocationCount += 1;
+        expect(filepath).toBe(targetFolder);
+        return {
+          isFile: () => {
+            return false;
+          },
+        };
+      },
+      rmSync: filepath => {
+        rmSyncInvocationCount += 1;
+      },
+      rmdirSync: filepath => {
+        rmdirSyncInvocationCount += 1;
+        expect(filepath).toBe(targetFolder);
+      },
+      readdirSync: filepath => {
+        readdirInvocationCount += 1;
+        return content;
+      },
+    }));
+
+    underTest._cleanupEmptyFilesAndFolders(targetFolder);
+    expect(statSyncInvocationCount).toBe(1);
+    expect(readdirInvocationCount).toBe(2);
+    expect(rmSyncInvocationCount).toBe(0);
+    expect(rmdirSyncInvocationCount).toBe(1);
+  });
+
+  it("when path is folder and it's not empty, removes only empty folders and files", () => {
+    const targetFolder = 'build';
+    const content = ['emptyFolder', 'emptyFile', 'notEmptyFile'];
+
+    const files = [
+      path.normalize('build/emptyFile'),
+      path.normalize('build/notEmptyFile'),
+    ];
+
+    const emptyContent = [];
+    let fileSizes = {};
+    fileSizes[path.normalize('build/emptyFile')] = 0;
+    fileSizes[path.normalize('build/notEmptyFile')] = 32;
+
+    let statSyncInvocation = [];
+    let rmSyncInvocation = [];
+    let rmdirSyncInvocation = [];
+    let readdirInvocation = [];
+
+    jest.mock('fs', () => ({
+      statSync: filepath => {
+        statSyncInvocation.push(filepath);
+
+        return {
+          isFile: () => {
+            return files.includes(filepath);
+          },
+          size: fileSizes[filepath],
+        };
+      },
+      rmSync: filepath => {
+        rmSyncInvocation.push(filepath);
+      },
+      rmdirSync: filepath => {
+        rmdirSyncInvocation.push(filepath);
+      },
+      readdirSync: filepath => {
+        readdirInvocation.push(filepath);
+        return filepath === targetFolder ? content : emptyContent;
+      },
+    }));
+
+    underTest._cleanupEmptyFilesAndFolders(targetFolder);
+    expect(statSyncInvocation).toEqual([
+      path.normalize('build'),
+      path.normalize('build/emptyFolder'),
+      path.normalize('build/emptyFile'),
+      path.normalize('build/notEmptyFile'),
+    ]);
+    expect(readdirInvocation).toEqual([
+      path.normalize('build'),
+      path.normalize('build/emptyFolder'),
+      path.normalize('build/emptyFolder'),
+      path.normalize('build'),
+    ]);
+    expect(rmSyncInvocation).toEqual([path.normalize('build/emptyFile')]);
+    expect(rmdirSyncInvocation).toEqual([path.normalize('build/emptyFolder')]);
+  });
+
+  it('when path is folder and it contains only empty folders, removes everything', () => {
+    const targetFolder = 'build';
+    const content = ['emptyFolder1', 'emptyFolder2'];
+    const emptyContent = [];
+
+    let statSyncInvocation = [];
+    let rmSyncInvocation = [];
+    let rmdirSyncInvocation = [];
+    let readdirInvocation = [];
+
+    jest.mock('fs', () => ({
+      statSync: filepath => {
+        statSyncInvocation.push(filepath);
+
+        return {
+          isFile: () => {
+            return false;
+          },
+        };
+      },
+      rmSync: filepath => {
+        rmSyncInvocation.push(filepath);
+      },
+      rmdirSync: filepath => {
+        rmdirSyncInvocation.push(filepath);
+      },
+      readdirSync: filepath => {
+        readdirInvocation.push(filepath);
+        return filepath === targetFolder
+          ? content.filter(
+              element =>
+                !rmdirSyncInvocation.includes(path.join(targetFolder, element)),
+            )
+          : emptyContent;
+      },
+    }));
+
+    underTest._cleanupEmptyFilesAndFolders(targetFolder);
+    expect(statSyncInvocation).toEqual([
+      path.normalize('build'),
+      path.normalize('build/emptyFolder1'),
+      path.normalize('build/emptyFolder2'),
+    ]);
+    expect(readdirInvocation).toEqual([
+      path.normalize('build'),
+      path.normalize('build/emptyFolder1'),
+      path.normalize('build/emptyFolder1'),
+      path.normalize('build/emptyFolder2'),
+      path.normalize('build/emptyFolder2'),
+      path.normalize('build'),
+    ]);
+    expect(rmSyncInvocation).toEqual([]);
+    expect(rmdirSyncInvocation).toEqual([
+      path.normalize('build/emptyFolder1'),
+      path.normalize('build/emptyFolder2'),
+      path.normalize('build'),
+    ]);
+  });
+});

package/scripts/codegen/__tests__/generate-specs-cli-executor-test.js

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+const sut = require('../generate-specs-cli-executor');
+const fixtures = require('../__test_fixtures__/fixtures');
+const {normalize} = require('path');
+
+describe('generateSpec', () => {
+  it('invokes RNCodegen with the right params', () => {
+    const platform = 'ios';
+    const libraryType = 'all';
+    const schemaPath = './';
+    const componentsOutputDir = normalize(
+      'app/ios/build/generated/ios/react/renderer/components/library',
+    );
+    const modulesOutputDir = normalize('app/ios/build/generated/ios/library');
+    const outputDirectory = normalize('app/ios/build/generated/ios');
+    const libraryName = 'library';
+    const packageName = 'com.library';
+    const generators = ['componentsIOS', 'modulesIOS', 'modulesCxx'];
+
+    jest.mock('fs', () => ({
+      readFileSync: (path, encoding) => {
+        expect(path).toBe(schemaPath);
+        expect(encoding).toBe('utf-8');
+        return fixtures.schemaText;
+      },
+    }));
+
+    let mkdirpSyncInvoked = 0;
+    jest.mock('mkdirp', () => ({
+      sync: folder => {
+        if (mkdirpSyncInvoked === 0) {
+          expect(folder).toBe(outputDirectory);
+        }
+
+        if (mkdirpSyncInvoked === 1) {
+          expect(folder).toBe(componentsOutputDir);
+        }
+
+        if (mkdirpSyncInvoked === 2) {
+          expect(folder).toBe(modulesOutputDir);
+        }
+
+        mkdirpSyncInvoked += 1;
+      },
+    }));
+
+    // We cannot mock directly the `RNCodegen` object because the
+    // code access the `lib` folder directly and request a file explicitly.
+    // This makes testing harder than usually. To overcome this, we created a utility
+    // to retrieve the `Codegen`. By doing that, we can mock the wrapper so that it returns
+    // an object with the same interface of the `RNCodegen` object.
+    jest.mock('../codegen-utils', () => ({
+      getCodegen: () => ({
+        generate: (libraryConfig, generatorConfigs) => {
+          expect(libraryConfig.libraryName).toBe(libraryName);
+          expect(libraryConfig.schema).toStrictEqual(fixtures.schema);
+          expect(libraryConfig.outputDirectory).toBe(outputDirectory);
+          expect(libraryConfig.packageName).toBe(packageName);
+
+          expect(generatorConfigs.generators).toStrictEqual(generators);
+          expect(generatorConfigs.test).toBeUndefined();
+        },
+      }),
+    }));
+
+    sut.execute(
+      platform,
+      schemaPath,
+      outputDirectory,
+      libraryName,
+      packageName,
+      libraryType,
+    );
+
+    expect(mkdirpSyncInvoked).toBe(3);
+  });
+});

package/scripts/codegen/codegen-utils.js

@@ -12,7 +12,7 @@
 /**
  * Wrapper required to abstract away from the actual codegen.
  * This is needed because, when running tests in Sandcastle, not everything is setup as usually.
- * For example, the `react-native-codegen` lib is not present.
+ * For example, the `@react-native/codegen` lib is not present.
  *
  * Thanks to this wrapper, we are able to mock the getter for the codegen in a way that allow us to return
  * a custom object which mimics the Codegen interface.
@@ -24,7 +24,7 @@ function getCodegen() {
   try {
     RNCodegen = require('../../packages/react-native-codegen/lib/generators/RNCodegen.js');
   } catch (e) {
-    RNCodegen = require('react-native-codegen/lib/generators/RNCodegen.js');
+    RNCodegen = require('@react-native/codegen/lib/generators/RNCodegen.js');
   }
   if (!RNCodegen) {
     throw 'RNCodegen not found.';