paquette 0.1.0

data/test/gem_server/repository_stack_test.rb

@@ -0,0 +1,71 @@
+require_relative "../test_helper"
+
+class RepositoryStackTest < Minitest::Test
+  def setup
+    @gems_dir = FIXTURE_GEMS_DIR
+    @dir_repository = Paquette::GemServer::DirectoryGemRepository.new(@gems_dir)
+  end
+
+  def test_repository_stack_setup
+    # Test the exact stack setup as used in GemServer
+    personalized_repository = Paquette::GemServer::Personalizer.new(@dir_repository,
+      license_key: "TEST-LICENSE-123",
+      magic_comment_replacements: {"# paquette_license_info" => "TEST-LICENSE-123"})
+    gated_repository = Paquette::GemServer::ReadGatedRepository.new(personalized_repository) { |name:, version: nil| true }
+
+    # Verify the stack works end-to-end
+    assert gated_repository.gem_names.include?("minuscule_test")
+    assert gated_repository.versions_for_gem("minuscule_test").include?("0.1.0")
+    assert gated_repository.gem_exists?("minuscule_test", "0.1.0")
+
+    # Test that personalization happens through the stack
+    skip "Test gem not found" unless gated_repository.gem_exists?("minuscule_test", "0.1.0")
+
+    gem_path = gated_repository.gem_file_path("minuscule_test", "0.1.0")
+    assert File.exist?(gem_path)
+
+    # Should be a personalized gem (different from original)
+    original_path = @dir_repository.gem_file_path("minuscule_test", "0.1.0")
+    refute_equal original_path, gem_path
+
+    # Should have different checksums
+    require "digest"
+    original_checksum = Digest::SHA256.file(original_path).hexdigest
+    personalized_checksum = Digest::SHA256.file(gem_path).hexdigest
+    refute_equal original_checksum, personalized_checksum
+  end
+
+  def test_stack_delegation
+    # Test that all methods are properly delegated through the stack
+    personalized_repository = Paquette::GemServer::Personalizer.new(@dir_repository,
+      license_key: "TEST-LICENSE-123",
+      magic_comment_replacements: {"# paquette_license_info" => "TEST-LICENSE-123"})
+    gated_repository = Paquette::GemServer::ReadGatedRepository.new(personalized_repository) { |name:, version: nil| true }
+
+    # Test that methods are delegated correctly
+    assert_equal @dir_repository.gem_names, gated_repository.gem_names
+    assert_equal @dir_repository.gem_versions, gated_repository.gem_versions
+
+    # Test that personalization is applied
+    skip "Test gem not found" unless gated_repository.gem_exists?("minuscule_test", "0.1.0")
+
+    # compact_info should use personalized checksums
+    personalized_info = gated_repository.compact_info("minuscule_test")
+    original_info = @dir_repository.compact_info("minuscule_test")
+
+    assert_equal original_info.length, personalized_info.length
+
+    # But checksums should be different
+    original_checksum = extract_checksum(original_info.first)
+    personalized_checksum = extract_checksum(personalized_info.first)
+    refute_equal original_checksum, personalized_checksum
+  end
+
+  private
+
+  def extract_checksum(info_line)
+    if (match = info_line.match(/checksum:([a-f0-9]+)/))
+      match[1]
+    end
+  end
+end

data/test/gem_server_test.rb

@@ -0,0 +1,339 @@
+require_relative "test_helper"
+
+class GemServerTest < Minitest::Test
+  include Rack::Test::Methods
+
+  MINUSCULE_FIXTURE = File.join(FIXTURE_GEMS_DIR, "minuscule_test", "minuscule_test-0.1.0.gem")
+
+  def setup
+    repo = Paquette::GemServer::DirectoryGemRepository.new(FIXTURE_GEMS_DIR)
+    @app = Paquette::GemServer.new(repo)
+  end
+
+  attr_reader :app
+
+  def test_root_endpoint
+    get "/"
+    assert_equal 200, last_response.status
+    assert_equal "Paquette RubyGems Repository", last_response.body
+  end
+
+  def test_names_endpoint
+    get "/api/v1/names"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    names = JSON.parse(last_response.body)
+    assert_equal ["minuscule_test", "zip_kit"], names.sort
+  end
+
+  def test_versions_endpoint
+    get "/api/v1/versions"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    versions = JSON.parse(last_response.body)
+    assert_equal 3, versions.length
+
+    zip_kit_versions = versions.select { |v| v["name"] == "zip_kit" }
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions.map { |v| v["number"] }, "6.2.0"
+    assert_includes zip_kit_versions.map { |v| v["number"] }, "6.2.1"
+
+    minuscule_versions = versions.select { |v| v["name"] == "minuscule_test" }
+    assert_equal 1, minuscule_versions.length
+    assert_includes minuscule_versions.map { |v| v["number"] }, "0.1.0"
+  end
+
+  def test_specs_endpoint
+    get "/specs.4.8"
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+
+    specs = Marshal.load(last_response.body)
+    assert specs.is_a?(Array)
+    assert_equal 3, specs.length
+
+    gem_names = specs.map { |spec| spec[0] }.sort.uniq
+    assert_equal ["minuscule_test", "zip_kit"], gem_names
+  end
+
+  def test_latest_specs_endpoint
+    get "/latest_specs.4.8"
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+
+    specs = Marshal.load(last_response.body)
+    assert specs.is_a?(Array)
+    assert_equal 2, specs.length
+
+    gem_names = specs.map { |spec| spec[0] }.sort
+    assert_equal ["minuscule_test", "zip_kit"], gem_names
+  end
+
+  def test_gem_download
+    get "/gems/zip_kit-6.2.0.gem"
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+    assert last_response.body.length > 0
+  end
+
+  def test_search_endpoint
+    get "/api/v1/search.json", query: "zip"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    results = JSON.parse(last_response.body)
+    assert results.is_a?(Array)
+    assert results.any? { |r| r["name"] == "zip_kit" }
+  end
+
+  # Test compact index endpoints
+  def test_compact_index_names
+    get "/names"
+    assert_equal 200, last_response.status
+    assert_equal "text/plain", last_response.content_type
+
+    names = last_response.body.split("\n")
+    assert_equal ["minuscule_test", "zip_kit"], names.sort
+  end
+
+  def test_compact_index_versions
+    get "/versions"
+    assert_equal 200, last_response.status
+    assert_equal "text/plain", last_response.content_type
+
+    # Check for checksum header
+    assert last_response.headers["X-Checksum-Sha256"]
+    refute_nil last_response.headers["X-Checksum-Sha256"]
+
+    lines = last_response.body.split("\n")
+
+    # Check for timestamp header
+    assert lines[0].start_with?("created_at:")
+    assert lines[1] == "---"
+
+    # Check gem lines (skip timestamp and separator)
+    gem_lines = lines[2..]
+    assert_equal 2, gem_lines.length
+
+    # Check that each gem line has the format "gem_name versions checksum"
+    gem_lines.each do |line|
+      parts = line.split(" ")
+      assert parts.length >= 3, "Each gem line should have at least 3 parts: #{line}"
+      assert_match(/^[a-f0-9]{32}$/, parts[-1], "Checksum should be 32 hex characters: #{line}")
+    end
+
+    gem_names = gem_lines.map { |line| line.split(" ")[0] }
+    assert_equal ["minuscule_test", "zip_kit"], gem_names.sort
+  end
+
+  def test_compact_index_info
+    get "/info/zip_kit"
+    assert_equal 200, last_response.status
+    assert_equal "text/plain", last_response.content_type
+
+    info_lines = last_response.body.split("\n")
+    assert_equal 2, info_lines.length
+
+    # Check that each line has the format "version |checksum:sha256_checksum,ruby:required_ruby_version"
+    info_lines.each do |line|
+      assert_match(/^\S+\s+\|checksum:[a-f0-9]{64},ruby:.+$/, line, "Line should match compact index format: #{line}")
+
+      version, rest = line.split(" ", 2)
+      assert version.match?(/^\d+\.\d+\.\d+/), "Version should be in semver format: #{version}"
+
+      assert rest.start_with?("|checksum:"), "Should have checksum prefix: #{rest}"
+      checksum_part, ruby_part = rest[1..].split(",", 2)
+      assert checksum_part.start_with?("checksum:"), "Should have checksum: #{checksum_part}"
+      checksum = checksum_part.split(":", 2)[1]
+      assert_match(/^[a-f0-9]{64}$/, checksum, "Checksum should be 64 hex characters (SHA256): #{checksum}")
+
+      assert ruby_part.start_with?("ruby:"), "Should have ruby version requirement: #{ruby_part}"
+    end
+
+    version_lines = info_lines.map { |line| line.split(" ")[0] }
+    assert_includes version_lines, "6.2.0"
+    assert_includes version_lines, "6.2.1"
+  end
+
+  def test_compact_index_info_nonexistent
+    get "/info/nonexistent"
+    assert_equal 404, last_response.status
+  end
+
+  def test_specs_gz_endpoint
+    get "/specs.4.8.gz"
+    assert_equal 200, last_response.status
+    assert_equal "application/x-gzip", last_response.content_type
+
+    decompressed = Zlib::GzipReader.new(StringIO.new(last_response.body)).read
+    specs = Marshal.load(decompressed)
+    assert specs.is_a?(Array)
+    assert_equal 3, specs.length
+
+    gem_names = specs.map { |spec| spec[0] }.sort.uniq
+    assert_equal ["minuscule_test", "zip_kit"], gem_names
+  end
+
+  def test_latest_specs_gz_endpoint
+    get "/latest_specs.4.8.gz"
+    assert_equal 200, last_response.status
+    assert_equal "application/x-gzip", last_response.content_type
+
+    decompressed = Zlib::GzipReader.new(StringIO.new(last_response.body)).read
+    specs = Marshal.load(decompressed)
+    assert specs.is_a?(Array)
+    assert_equal 2, specs.length
+
+    gem_names = specs.map { |spec| spec[0] }.sort
+    assert_equal ["minuscule_test", "zip_kit"], gem_names
+  end
+
+  def test_quick_gemspec_endpoint
+    get "/quick/Marshal.4.8/zip_kit-6.2.0.gemspec.rz"
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+
+    decompressed = Zlib::Inflate.inflate(last_response.body)
+    spec = Marshal.load(decompressed)
+    assert_equal "zip_kit", spec.name
+    assert_equal "6.2.0", spec.version.to_s
+  end
+
+  def test_quick_gemspec_nonexistent
+    get "/quick/Marshal.4.8/nonexistent-1.0.0.gemspec.rz"
+    assert_equal 404, last_response.status
+  end
+
+  def test_push_publishes_gem
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      binary = File.binread(MINUSCULE_FIXTURE)
+
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+
+      assert_equal 200, session.last_response.status
+      assert_equal "text/plain", session.last_response.content_type
+      assert_equal "Successfully registered gem: minuscule_test-0.1.0", session.last_response.body
+
+      persisted = File.join(dir, "minuscule_test", "minuscule_test-0.1.0.gem")
+      assert File.exist?(persisted)
+      assert_equal binary, File.binread(persisted)
+    end
+  end
+
+  def test_push_rejects_duplicate
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      binary = File.binread(MINUSCULE_FIXTURE)
+
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+      assert_equal 200, session.last_response.status
+
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+      assert_equal 409, session.last_response.status
+      assert_match(/already exists/, session.last_response.body)
+    end
+  end
+
+  def test_push_rejects_invalid_payload
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      session.post "/api/v1/gems", "not a real gem", "CONTENT_TYPE" => "application/octet-stream"
+      assert_equal 400, session.last_response.status
+    end
+  end
+
+  def test_yank_removes_gem_from_listings
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      binary = File.binread(MINUSCULE_FIXTURE)
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+
+      session.delete "/api/v1/gems/yank", {gem_name: "minuscule_test", version: "0.1.0"}
+      assert_equal 200, session.last_response.status
+      assert_equal "Successfully yanked gem: minuscule_test-0.1.0", session.last_response.body
+
+      tomb = File.join(dir, "minuscule_test", "minuscule_test-0.1.0.gem.tomb")
+      assert File.exist?(tomb)
+      refute File.exist?(File.join(dir, "minuscule_test", "minuscule_test-0.1.0.gem"))
+
+      # The gem disappears from version listings and compact info
+      session.get "/api/v1/versions"
+      versions = JSON.parse(session.last_response.body)
+      assert_empty versions.select { |v| v["name"] == "minuscule_test" }
+
+      session.get "/info/minuscule_test"
+      assert_equal 404, session.last_response.status
+    end
+  end
+
+  def test_yank_nonexistent_returns_404
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      session.delete "/api/v1/gems/yank", {gem_name: "nope", version: "1.0.0"}
+      assert_equal 404, session.last_response.status
+    end
+  end
+
+  def test_yank_missing_params_returns_400
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      session.delete "/api/v1/gems/yank", {gem_name: "foo"}
+      assert_equal 400, session.last_response.status
+    end
+  end
+
+  def test_push_refuses_tombed_gem
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      app_with_writable_dir = Paquette::GemServer.new(repo)
+      session = Rack::Test::Session.new(Rack::MockSession.new(app_with_writable_dir))
+
+      binary = File.binread(MINUSCULE_FIXTURE)
+
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+      session.delete "/api/v1/gems/yank", {gem_name: "minuscule_test", version: "0.1.0"}
+
+      session.post "/api/v1/gems", binary, "CONTENT_TYPE" => "application/octet-stream"
+      assert_equal 403, session.last_response.status
+      assert_match(/yanked/, session.last_response.body)
+    end
+  end
+
+  def test_push_and_yank_return_403_through_read_gated_repository
+    Dir.mktmpdir do |dir|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(dir)
+      gated = Paquette::GemServer::ReadGatedRepository.new(repo) { |**| true }
+      read_only_app = Paquette::GemServer.new(gated)
+      session = Rack::Test::Session.new(Rack::MockSession.new(read_only_app))
+
+      session.post "/api/v1/gems", "anything", "CONTENT_TYPE" => "application/octet-stream"
+      assert_equal 403, session.last_response.status
+      assert_match(/not allowed/, session.last_response.body)
+
+      session.delete "/api/v1/gems/yank", {gem_name: "foo", version: "1.0.0"}
+      assert_equal 403, session.last_response.status
+      assert_match(/not allowed/, session.last_response.body)
+    end
+  end
+end

data/test/npm_repacker_sourcemap_test.rb

@@ -0,0 +1,108 @@
+require_relative "test_helper"
+
+class NpmRepackerSourcemapTest < Minitest::Test
+  def setup
+    @temp_dir = Dir.mktmpdir("npm_repacker_sourcemap_test")
+    @package_dir = File.join(@temp_dir, "package")
+    FileUtils.mkdir_p(@package_dir)
+
+    # Create a test package with JS file and sourcemap
+    create_test_package
+  end
+
+  def teardown
+    FileUtils.rm_rf(@temp_dir)
+  end
+
+  def test_repack_with_sourcemap_updates
+    # Create a temporary NPM package
+    package_path = create_npm_package
+
+    # Repack the package with text replacement
+    new_package_path = Paquette::NpmRepacker.repack(package_path) do |input_file, output_file, file_path|
+      unless File.extname(file_path).match?(/\.(ts|js|mjs|jsx|tsx)$/)
+        IO.copy_stream(input_file, output_file)
+        next
+      end
+
+      content = input_file.read
+      # Add some text to change the file length (simulating a real transformation)
+      content = content.gsub("function test()", 'function test() { console.log("modified");')
+      output_file.write(content)
+    end
+
+    assert File.exist?(new_package_path)
+
+    # Unpack and verify the sourcemap was updated
+    verify_sourcemap_update(new_package_path)
+
+    # Clean up
+    File.delete(package_path) if File.exist?(package_path)
+    File.delete(new_package_path) if File.exist?(new_package_path)
+  end
+
+  private
+
+  def create_test_package
+    # Create a simple JS file
+    js_content = <<~JS
+      function test() {
+        return "hello world";
+      }
+      //# sourceMappingURL=test.js.map
+    JS
+
+    # Create a simple sourcemap
+    sourcemap_content = {
+      version: 3,
+      sources: ["test.js"],
+      names: ["test"],
+      mappings: "AAAA,SAAS,SAAS,SAAS,CAAC",
+      file: "test.js"
+    }.to_json
+
+    File.write(File.join(@package_dir, "test.js"), js_content)
+    File.write(File.join(@package_dir, "test.js.map"), sourcemap_content)
+  end
+
+  def create_npm_package
+    package_path = File.join(@temp_dir, "test-package.tgz")
+    result = system("cd #{@temp_dir} && tar -czf #{package_path} package/")
+    raise "Failed to create test package" unless result
+    package_path
+  end
+
+  def verify_sourcemap_update(package_path)
+    # Unpack the repacked package
+    temp_unpack_dir = Dir.mktmpdir("verify_sourcemap")
+    begin
+      result = system("tar -xzf #{package_path} -C #{temp_unpack_dir}")
+      assert result, "Failed to unpack the repacked package"
+
+      # Find the unpacked package directory
+      package_dir = Dir.glob(File.join(temp_unpack_dir, "*")).find { |path| File.directory?(path) }
+      assert package_dir, "Could not find unpacked package directory"
+
+      # Check that the JS file was modified
+      js_file = File.join(package_dir, "test.js")
+      assert File.exist?(js_file), "JS file not found"
+
+      js_content = File.read(js_file)
+      assert js_content.include?('console.log("modified")'), "JS file was not modified"
+
+      # Check that the sourcemap was updated
+      sourcemap_file = File.join(package_dir, "test.js.map")
+      if File.exist?(sourcemap_file)
+        sourcemap_content = File.read(sourcemap_file)
+        sourcemap = JSON.parse(sourcemap_content)
+
+        # The sourcemap should have been updated (we can't easily verify the exact mapping changes
+        # without a more complex test, but we can verify it's still valid JSON)
+        assert sourcemap.is_a?(Hash), "Sourcemap is not valid JSON"
+        assert sourcemap["version"], "Sourcemap missing version"
+      end
+    ensure
+      FileUtils.rm_rf(temp_unpack_dir)
+    end
+  end
+end

data/test/npm_repacker_test.rb

@@ -0,0 +1,117 @@
+require_relative "test_helper"
+
+class NpmRepackerTest < Minitest::Test
+  def setup
+    @test_package_path = File.join(FIXTURE_NPM_DIR, "react-dropzone", "react-dropzone-14.3.8.tgz")
+  end
+
+  def test_repack_with_text_replacement
+    skip "Test package not found" unless File.exist?(@test_package_path)
+
+    # Replace the first occurrence of 'Dropzone' with 'Liftzone' in JS/TS files
+    new_package_path = Paquette::NpmRepacker.repack(@test_package_path) do |input_file, output_file, file_path|
+      unless File.extname(file_path).match?(/\.(ts|js|mjs|jsx|tsx)$/)
+        IO.copy_stream(input_file, output_file)
+        next
+      end
+
+      # Read the entire content
+      content = input_file.read
+
+      # Replace ALL occurrences of 'Dropzone' with 'Liftzone'
+      if content.include?("Dropzone")
+        content = content.gsub("Dropzone", "Liftzone")
+      end
+
+      # Write the processed content
+      output_file.write(content)
+    end
+
+    assert File.exist?(new_package_path)
+    assert new_package_path.end_with?("-repacked.tgz")
+
+    # Unpack the produced package and verify the replacement
+    verify_repacking(new_package_path)
+
+    # Clean up
+    File.delete(new_package_path) if File.exist?(new_package_path)
+  end
+
+  def test_repack_requires_block
+    skip "Test package not found" unless File.exist?(@test_package_path)
+
+    assert_raises(ArgumentError) do
+      Paquette::NpmRepacker.repack(@test_package_path)
+    end
+  end
+
+  def test_repack_with_nonexistent_package
+    nonexistent_path = "/nonexistent/path.tgz"
+
+    assert_raises(ArgumentError) do
+      Paquette::NpmRepacker.repack(nonexistent_path) { |input_file, output_file, file_path| }
+    end
+  end
+
+  def test_repack_creates_new_package_with_different_checksum
+    skip "Test package not found" unless File.exist?(@test_package_path)
+
+    original_checksum = Digest::SHA256.file(@test_package_path).hexdigest
+
+    new_package_path = Paquette::NpmRepacker.repack(@test_package_path) do |input_file, output_file, file_path|
+      unless File.extname(file_path).match?(/\.(ts|js|mjs|jsx|tsx)$/)
+        IO.copy_stream(input_file, output_file)
+        next
+      end
+
+      content = input_file.read
+      content = content.gsub("Dropzone", "Liftzone") if content.include?("Dropzone")
+      output_file.write(content)
+    end
+
+    new_checksum = Digest::SHA256.file(new_package_path).hexdigest
+
+    assert File.exist?(new_package_path)
+    refute_equal original_checksum, new_checksum
+
+    # Clean up
+    File.delete(new_package_path) if File.exist?(new_package_path)
+  end
+
+  private
+
+  def verify_repacking(package_path)
+    # Create a temporary directory to unpack the new package
+    temp_dir = Dir.mktmpdir("verify_npm_repacking")
+    unpacked_dir = File.join(temp_dir, "unpacked")
+    FileUtils.mkdir_p(unpacked_dir)
+
+    begin
+      # Unpack the new package
+      result = system("tar -xzf #{package_path} -C #{unpacked_dir}")
+      assert result, "Failed to unpack the repacked package"
+
+      # Find the unpacked package directory
+      package_dir = Dir.glob(File.join(unpacked_dir, "*")).find { |path| File.directory?(path) }
+      assert package_dir, "Could not find unpacked package directory"
+
+      # Check JS/TS files for the replacement
+      found_replacement = false
+      extensions = %w[.ts .js .mjs .jsx .tsx]
+      extensions.each do |ext|
+        Dir.glob(File.join(package_dir, "**", "*#{ext}")).each do |js_file|
+          content = File.read(js_file)
+          if content.include?("Liftzone")
+            found_replacement = true
+          end
+          # Ensure the original word is gone (all occurrences)
+          refute content.include?("Dropzone"), "Original word 'Dropzone' still present in #{js_file}"
+        end
+      end
+
+      assert found_replacement, "Replacement word 'Liftzone' not found in any JS/TS file"
+    ensure
+      FileUtils.rm_rf(temp_dir)
+    end
+  end
+end