shakapacker 8.4.0 → 9.7.0

data/test/package/rspack/index.test.js

@@ -0,0 +1,293 @@
+/* eslint-disable func-names, jest/no-conditional-in-test */
+
+const { chdirTestApp } = require("../../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+// Mock config to ensure assets_bundler is set to rspack
+jest.mock("../../../package/config", () => {
+  const actual = jest.requireActual("../../../package/config")
+  return {
+    ...actual,
+    assets_bundler: "rspack"
+  }
+})
+
+// Mock helpers before requiring the rspack module
+jest.mock("../../../package/utils/helpers", () => {
+  const original = jest.requireActual("../../../package/utils/helpers")
+  const moduleExists = jest.fn(() => true)
+  return {
+    ...original,
+    moduleExists
+  }
+})
+
+// Mock validateDependencies to prevent actual validation
+jest.mock("../../../package/utils/validateDependencies", () => ({
+  validateRspackDependencies: jest.fn()
+}))
+
+// Mock requireOrError to provide a fake @rspack/core (v2 is pure ESM, can't be require()'d by Jest)
+jest.mock("../../../package/utils/requireOrError", () => ({
+  requireOrError: (moduleName) => {
+    if (moduleName === "@rspack/core") {
+      const CssExtractRspackPlugin = jest.fn(function (options) {
+        this.options = options
+      })
+      CssExtractRspackPlugin.loader = "css-extract-rspack-loader"
+
+      return {
+        DefinePlugin: jest.fn(function (definitions) {
+          this.definitions = definitions
+        }),
+        EnvironmentPlugin: jest.fn(function (env) {
+          this.env = env
+        }),
+        ProvidePlugin: jest.fn(function (definitions) {
+          this.definitions = definitions
+        }),
+        HotModuleReplacementPlugin: jest.fn(),
+        ProgressPlugin: jest.fn(),
+        CssExtractRspackPlugin,
+        SubresourceIntegrityPlugin: jest.fn(function (options) {
+          this.options = options
+        }),
+        SwcJsMinimizerRspackPlugin: jest.fn(),
+        LightningCssMinimizerRspackPlugin: jest.fn()
+      }
+    }
+    if (moduleName === "rspack-manifest-plugin") {
+      return {
+        RspackManifestPlugin: jest.fn(function (options) {
+          this.options = options
+        })
+      }
+    }
+    return jest
+      .requireActual("../../../package/utils/requireOrError")
+      .requireOrError(moduleName)
+  }
+}))
+
+describe("rspack/index", () => {
+  let rspackIndex
+  let validateRspackDependencies
+
+  beforeEach(() => {
+    jest.resetModules()
+    rspackIndex = require("../../../package/rspack/index")
+    ;({
+      validateRspackDependencies
+    } = require("../../../package/utils/validateDependencies"))
+  })
+
+  afterAll(() => process.chdir(rootPath))
+
+  describe("exports", () => {
+    test("exports webpack-merge v5 functions", () => {
+      expect(rspackIndex.merge).toBeInstanceOf(Function)
+      expect(rspackIndex.mergeWithRules).toBeInstanceOf(Function)
+      expect(rspackIndex.mergeWithCustomize).toBeInstanceOf(Function)
+      expect(rspackIndex.unique).toBeInstanceOf(Function)
+    })
+
+    test("exports config object", () => {
+      expect(rspackIndex.config).toHaveProperty("source_path")
+      expect(rspackIndex.config).toHaveProperty("public_output_path")
+    })
+
+    test("exports devServer object", () => {
+      expect(rspackIndex.devServer).toBeDefined()
+    })
+
+    test("exports generateRspackConfig function", () => {
+      expect(rspackIndex.generateRspackConfig).toBeInstanceOf(Function)
+    })
+
+    test("exports baseConfig object", () => {
+      expect(rspackIndex.baseConfig).toBeDefined()
+      expect(rspackIndex.baseConfig).toHaveProperty("mode")
+    })
+
+    test("exports env object", () => {
+      expect(rspackIndex.env).toHaveProperty("railsEnv")
+      expect(rspackIndex.env).toHaveProperty("nodeEnv")
+    })
+
+    test("exports rules array", () => {
+      expect(Array.isArray(rspackIndex.rules)).toBe(true)
+      expect(rspackIndex.rules.length).toBeGreaterThan(0)
+    })
+
+    test("exports moduleExists function", () => {
+      expect(typeof rspackIndex.moduleExists).toBe("function")
+    })
+
+    test("exports canProcess function", () => {
+      expect(rspackIndex.canProcess).toBeInstanceOf(Function)
+    })
+
+    test("exports inliningCss value", () => {
+      expect(typeof rspackIndex.inliningCss).toBe("boolean")
+    })
+  })
+
+  describe("generateRspackConfig", () => {
+    test("returns a valid rspack config object", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config).toBeDefined()
+      expect(config).toHaveProperty("mode")
+      expect(config).toHaveProperty("module")
+      expect(config).toHaveProperty("plugins")
+      expect(config).toHaveProperty("optimization")
+    })
+
+    test("returns a new top-level config object on each call", () => {
+      const config1 = rspackIndex.generateRspackConfig()
+      const config2 = rspackIndex.generateRspackConfig()
+
+      expect(config1).not.toBe(config2)
+      config1.newKey = "new value"
+
+      expect(config2).not.toHaveProperty("newKey")
+    })
+
+    test("merges extra config", () => {
+      const config = rspackIndex.generateRspackConfig({
+        newKey: "new value",
+        output: {
+          path: "new path"
+        }
+      })
+
+      expect(config).toHaveProperty("newKey", "new value")
+      expect(config).toHaveProperty("output.path", "new path")
+    })
+
+    test("includes module rules in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.module).toBeDefined()
+      expect(config.module.rules).toBeDefined()
+      expect(Array.isArray(config.module.rules)).toBe(true)
+      // The exact number of rules depends on which optional loaders are installed,
+      // so we only verify that at least some rules exist
+      expect(config.module.rules.length).toBeGreaterThan(0)
+    })
+
+    test("includes plugins in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.plugins).toBeDefined()
+      expect(Array.isArray(config.plugins)).toBe(true)
+    })
+
+    test("includes optimization in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.optimization).toBeDefined()
+      expect(config.optimization).toHaveProperty("minimize")
+    })
+
+    test("errors if multiple configs are provided", () => {
+      expect(() => rspackIndex.generateRspackConfig({}, {})).toThrow(
+        "use webpack-merge to merge configs before passing them to Shakapacker"
+      )
+    })
+
+    test("validates rspack dependencies on generation", () => {
+      rspackIndex.generateRspackConfig()
+      expect(validateRspackDependencies).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe("rules", () => {
+    test("includes JavaScript/JSX rule with builtin:swc-loader", () => {
+      const jsRule = rspackIndex.rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule).toBeDefined()
+      expect(jsRule.type).toBe("javascript/auto")
+      expect(jsRule.use).toBeDefined()
+      expect(Array.isArray(jsRule.use)).toBe(true)
+      expect(jsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("includes TypeScript rule with builtin:swc-loader", () => {
+      const tsRule = rspackIndex.rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule).toBeDefined()
+      expect(tsRule.type).toBe("javascript/auto")
+      expect(tsRule.use).toBeDefined()
+      expect(Array.isArray(tsRule.use)).toBe(true)
+      expect(tsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("includes file/asset handling rule", () => {
+      const fileRule = rspackIndex.rules.find(
+        (rule) =>
+          rule.test &&
+          (rule.test.toString().includes("png") ||
+            rule.test.toString().includes("jpg") ||
+            rule.test.toString().includes("svg"))
+      )
+
+      expect(fileRule).toBeDefined()
+    })
+
+    test("includes raw file loading rule", () => {
+      const rawRule = rspackIndex.rules.find(
+        (rule) => rule.type === "asset/source"
+      )
+
+      expect(rawRule).toBeDefined()
+    })
+  })
+
+  describe("helper functions", () => {
+    test("moduleExists returns boolean", () => {
+      const result = rspackIndex.moduleExists("some-module")
+      expect(typeof result).toBe("boolean")
+    })
+
+    test("canProcess invokes callback when module resolves", () => {
+      const callback = jest.fn((modulePath) => ({
+        processed: true,
+        path: modulePath
+      }))
+      const result = rspackIndex.canProcess("path", callback)
+
+      expect(callback).toHaveBeenCalledWith(expect.any(String))
+      expect(result).toHaveProperty("processed", true)
+      expect(result).toHaveProperty("path")
+    })
+
+    test("canProcess returns null and does not invoke callback when module is missing", () => {
+      const callback = jest.fn()
+      const result = rspackIndex.canProcess(
+        "__definitely_not_a_real_package_name__",
+        callback
+      )
+
+      expect(result).toBeNull()
+      expect(callback).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("environment integration", () => {
+    test("uses correct environment config based on NODE_ENV", () => {
+      const config = rspackIndex.generateRspackConfig()
+      const { nodeEnv } = rspackIndex.env
+
+      const expectedMode =
+        nodeEnv === "production" ? "production" : "development"
+      expect(config.mode).toBe(expectedMode)
+    })
+  })
+})

data/test/package/rspack/optimization.test.js

@@ -0,0 +1,86 @@
+/* eslint-disable func-names */
+
+// Mock requireOrError to prevent actual module loading
+jest.mock("../../../package/utils/requireOrError", () => ({
+  requireOrError: (moduleName) => {
+    if (moduleName === "@rspack/core") {
+      return {
+        SwcJsMinimizerRspackPlugin: jest.fn(function () {
+          this.name = "SwcJsMinimizerRspackPlugin"
+        }),
+        LightningCssMinimizerRspackPlugin: jest.fn(function () {
+          this.name = "LightningCssMinimizerRspackPlugin"
+        })
+      }
+    }
+    throw new Error(`Module ${moduleName} not found`)
+  }
+}))
+
+// Mock debug logger
+jest.mock("../../../package/utils/debug", () => ({
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn()
+}))
+
+describe("rspack/optimization", () => {
+  let getOptimization
+
+  beforeEach(() => {
+    jest.resetModules()
+    const optimizationModule = require("../../../package/optimization/rspack")
+    getOptimization = optimizationModule.getOptimization
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("getOptimization", () => {
+    test("returns an optimization config object", () => {
+      const optimization = getOptimization()
+
+      expect(optimization).toBeDefined()
+      expect(optimization).toHaveProperty("minimize")
+      expect(optimization).toHaveProperty("minimizer")
+    })
+
+    test("sets minimize to true", () => {
+      const optimization = getOptimization()
+
+      expect(optimization.minimize).toBe(true)
+    })
+
+    test("includes SwcJsMinimizerRspackPlugin", () => {
+      const optimization = getOptimization()
+
+      expect(Array.isArray(optimization.minimizer)).toBe(true)
+      const jsMinimizer = optimization.minimizer.find(
+        (m) => m.name === "SwcJsMinimizerRspackPlugin"
+      )
+      expect(jsMinimizer).toBeDefined()
+    })
+
+    test("includes LightningCssMinimizerRspackPlugin", () => {
+      const optimization = getOptimization()
+
+      expect(Array.isArray(optimization.minimizer)).toBe(true)
+      const cssMinimizer = optimization.minimizer.find(
+        (m) => m.name === "LightningCssMinimizerRspackPlugin"
+      )
+      expect(cssMinimizer).toBeDefined()
+    })
+
+    test("includes both minimizers in correct order", () => {
+      const optimization = getOptimization()
+
+      expect(optimization.minimizer).toHaveLength(2)
+      expect(optimization.minimizer[0].name).toBe("SwcJsMinimizerRspackPlugin")
+      expect(optimization.minimizer[1].name).toBe(
+        "LightningCssMinimizerRspackPlugin"
+      )
+    })
+  })
+})

data/test/package/rspack/plugins.test.js

@@ -0,0 +1,185 @@
+/* eslint-disable func-names, jest/prefer-strict-equal */
+
+// Mock helpers before requiring the plugins module
+jest.mock("../../../package/utils/helpers", () => {
+  const original = jest.requireActual("../../../package/utils/helpers")
+  return {
+    ...original,
+    moduleExists: jest.fn(() => true)
+  }
+})
+
+// Mock requireOrError to prevent actual module loading
+jest.mock("../../../package/utils/requireOrError", () => ({
+  requireOrError: (moduleName) => {
+    if (moduleName === "rspack-manifest-plugin") {
+      return {
+        RspackManifestPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "RspackManifestPlugin"
+        })
+      }
+    }
+    if (moduleName === "@rspack/core") {
+      return {
+        EnvironmentPlugin: jest.fn(function (env) {
+          this.env = env
+          this.name = "EnvironmentPlugin"
+        }),
+        CssExtractRspackPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "CssExtractRspackPlugin"
+        }),
+        SubresourceIntegrityPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "SubresourceIntegrityPlugin"
+        })
+      }
+    }
+    throw new Error(`Module ${moduleName} not found`)
+  }
+}))
+
+describe("rspack/plugins", () => {
+  let getPlugins
+  let moduleExists
+  let config
+
+  beforeEach(() => {
+    jest.resetModules()
+    config = require("../../../package/config")
+    moduleExists = require("../../../package/utils/helpers").moduleExists
+    const pluginsModule = require("../../../package/plugins/rspack")
+    getPlugins = pluginsModule.getPlugins
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("getPlugins", () => {
+    test("returns an array", () => {
+      const plugins = getPlugins()
+      expect(Array.isArray(plugins)).toBe(true)
+    })
+
+    test("includes EnvironmentPlugin with filtered env", () => {
+      const plugins = getPlugins()
+      const envPlugin = plugins.find((p) => p.name === "EnvironmentPlugin")
+      expect(envPlugin).toBeDefined()
+      // EnvironmentPlugin receives getFilteredEnv() - a security-filtered version of process.env
+      // that only includes allowlisted environment variables
+      expect(envPlugin.env).toBeDefined()
+      expect(typeof envPlugin.env).toBe("object")
+    })
+
+    test("includes RspackManifestPlugin", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      expect(manifestPlugin).toBeDefined()
+      expect(manifestPlugin.options).toBeDefined()
+      expect(manifestPlugin.options.writeToFileEmit).toBe(true)
+    })
+
+    test("rspackManifestPlugin has generate function", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      expect(manifestPlugin.options.generate).toBeInstanceOf(Function)
+    })
+
+    test("rspackManifestPlugin generate creates proper manifest structure", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      const { publicPath } = manifestPlugin.options
+
+      const files = [
+        { name: "app.js", path: `${publicPath}app-123.js` },
+        { name: "app.css", path: `${publicPath}app-456.css` }
+      ]
+
+      const entrypoints = {
+        app: ["app-123.js", "app-456.css"]
+      }
+
+      const manifest = manifestPlugin.options.generate(null, files, entrypoints)
+
+      expect(manifest["app.js"]).toBe(`${publicPath}app-123.js`)
+      expect(manifest["app.css"]).toBe(`${publicPath}app-456.css`)
+      expect(manifest).toHaveProperty("entrypoints")
+      expect(manifest.entrypoints).toHaveProperty("app")
+      expect(manifest.entrypoints.app).toHaveProperty("assets")
+    })
+
+    test("rspackManifestPlugin filters hot-update files", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      const { publicPath } = manifestPlugin.options
+
+      const files = []
+      const entrypoints = {
+        app: [
+          "app-123.js",
+          "app.hot-update.js",
+          "app-456.css",
+          "app.hot-update.css"
+        ]
+      }
+
+      const manifest = manifestPlugin.options.generate(null, files, entrypoints)
+
+      expect(manifest.entrypoints.app.assets.js).toEqual([
+        `${publicPath}app-123.js`
+      ])
+      expect(manifest.entrypoints.app.assets.css).toEqual([
+        `${publicPath}app-456.css`
+      ])
+    })
+
+    test("includes CssExtractRspackPlugin when css-loader exists", () => {
+      moduleExists.mockReturnValue(true)
+
+      const plugins = getPlugins()
+      const cssPlugin = plugins.find((p) => p.name === "CssExtractRspackPlugin")
+      expect(cssPlugin).toBeDefined()
+      expect(cssPlugin.options.filename).toMatch(/^css\//)
+      expect(cssPlugin.options.emit).toBe(true)
+    })
+
+    test("does not include CssExtractRspackPlugin when css-loader is missing", () => {
+      moduleExists.mockReturnValue(false)
+
+      const plugins = getPlugins()
+      const cssPlugin = plugins.find((p) => p.name === "CssExtractRspackPlugin")
+      expect(cssPlugin).toBeUndefined()
+    })
+
+    test("includes SubresourceIntegrityPlugin when integrity is enabled", () => {
+      const originalIntegrity = config.integrity
+      config.integrity = {
+        ...originalIntegrity,
+        enabled: true,
+        hash_functions: ["sha256"]
+      }
+
+      try {
+        const plugins = getPlugins()
+        const sriPlugin = plugins.find(
+          (p) => p.name === "SubresourceIntegrityPlugin"
+        )
+
+        expect(sriPlugin).toBeDefined()
+        expect(sriPlugin.options.hashFuncNames).toEqual(["sha256"])
+      } finally {
+        config.integrity = originalIntegrity
+      }
+    })
+  })
+})