paquette 0.1.0

data/test/npm_server_test.rb

@@ -0,0 +1,140 @@
+require_relative "test_helper"
+
+class NpmServerTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def setup
+    # Create a temporary directory for test packages
+    @test_packages_dir = Dir.mktmpdir("paquette_npm_test")
+    @app = Paquette::NpmServer.new(@test_packages_dir)
+
+    # Create some test packages
+    create_test_packages
+  end
+
+  def teardown
+    FileUtils.rm_rf(@test_packages_dir) if @test_packages_dir
+  end
+
+  attr_reader :app
+
+  def test_root_endpoint
+    get "/"
+    assert_equal 200, last_response.status
+    assert_equal "Paquette NPM Repository", last_response.body
+  end
+
+  def test_ping_endpoint
+    get "/-/ping"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    response = JSON.parse(last_response.body)
+    assert_equal({}, response)
+  end
+
+  def test_whoami_endpoint
+    get "/-/whoami"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    response = JSON.parse(last_response.body)
+    assert_equal "paquette", response["username"]
+  end
+
+  def test_package_metadata
+    get "/test-package"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    metadata = JSON.parse(last_response.body)
+    assert_equal "test-package", metadata["name"]
+    assert metadata["versions"].is_a?(Hash)
+    assert metadata["versions"].key?("1.0.0")
+    assert metadata["versions"].key?("1.1.0")
+    assert_equal "1.1.0", metadata["dist-tags"]["latest"]
+    assert metadata["time"].is_a?(Hash)
+    assert metadata["time"].key?("1.0.0")
+    assert metadata["time"].key?("1.1.0")
+  end
+
+  def test_package_metadata_nonexistent
+    get "/nonexistent-package"
+    assert_equal 404, last_response.status
+  end
+
+  def test_dist_tags
+    get "/-/package/test-package/dist-tags"
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    dist_tags = JSON.parse(last_response.body)
+    assert_equal "1.1.0", dist_tags["latest"]
+  end
+
+  def test_dist_tags_nonexistent
+    get "/-/package/nonexistent-package/dist-tags"
+    assert_equal 404, last_response.status
+  end
+
+  def test_package_download
+    get "/test-package/test-package-1.0.0.tgz"
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+    assert last_response.body.length > 0
+  end
+
+  def test_package_download_nonexistent
+    get "/test-package/test-package-999.0.0.tgz"
+    assert_equal 404, last_response.status
+  end
+
+  def test_package_download_invalid_filename
+    get "/test-package/invalid-filename.tgz"
+    assert_equal 404, last_response.status
+  end
+
+  def test_multiple_packages
+    get "/another-package"
+    assert_equal 200, last_response.status
+
+    metadata = JSON.parse(last_response.body)
+    assert_equal "another-package", metadata["name"]
+    assert metadata["versions"].key?("2.0.0")
+    assert_equal "2.0.0", metadata["dist-tags"]["latest"]
+  end
+
+  def test_package_versions_structure
+    get "/test-package"
+    metadata = JSON.parse(last_response.body)
+
+    # Check version structure
+    version_1_0_0 = metadata["versions"]["1.0.0"]
+    assert_equal "test-package", version_1_0_0["name"]
+    assert_equal "1.0.0", version_1_0_0["version"]
+    assert version_1_0_0["dist"].is_a?(Hash)
+    assert_equal "test-package/test-package-1.0.0.tgz", version_1_0_0["dist"]["tarball"]
+
+    version_1_1_0 = metadata["versions"]["1.1.0"]
+    assert_equal "test-package", version_1_1_0["name"]
+    assert_equal "1.1.0", version_1_1_0["version"]
+    assert_equal "test-package/test-package-1.1.0.tgz", version_1_1_0["dist"]["tarball"]
+  end
+
+  private
+
+  def create_test_packages
+    # Create test-package with versions 1.0.0 and 1.1.0
+    package_dir = File.join(@test_packages_dir, "test-package")
+    FileUtils.mkdir_p(package_dir)
+
+    # Create dummy .tgz files
+    File.write(File.join(package_dir, "test-package-1.0.0.tgz"), "dummy tarball content 1.0.0")
+    File.write(File.join(package_dir, "test-package-1.1.0.tgz"), "dummy tarball content 1.1.0")
+
+    # Create another-package with version 2.0.0
+    another_package_dir = File.join(@test_packages_dir, "another-package")
+    FileUtils.mkdir_p(another_package_dir)
+    File.write(File.join(another_package_dir, "another-package-2.0.0.tgz"), "dummy tarball content 2.0.0")
+  end
+end

data/test/routes_test.rb

@@ -0,0 +1,142 @@
+require_relative "test_helper"
+
+class RoutesTest < Minitest::Test
+  include Rack::Test::Methods
+
+  class TestApp
+    attr_reader :last_params, :last_action
+
+    def initialize
+      @last_params = nil
+      @last_action = nil
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if (route = @routes.match(request))
+        @last_params = route.params(request)
+        @last_action = @routes.perform_action(route, self, request)
+      else
+        [404, {}, ["Not Found"]]
+      end
+    end
+
+    def setup_routes
+      @routes = Paquette::Routes.draw do |r|
+        r.get "/" do
+          [200, {}, ["Root"]]
+        end
+
+        r.get "/hello/:name" do |name:|
+          [200, {}, ["Hello #{name}"]]
+        end
+
+        r.get "/gem/stuff/:some_param.gz" do |some_param:|
+          [200, {}, ["Gem stuff with param: #{some_param}"]]
+        end
+
+        r.post "/api/data" do
+          [201, {}, ["Data created"]]
+        end
+
+        r.get "/api/version/:version" do |version:|
+          [200, {}, ["Version: #{version}"]]
+        end
+      end
+    end
+  end
+
+  def setup
+    @app = TestApp.new
+    @app.setup_routes
+  end
+
+  attr_reader :app
+
+  def test_root_route
+    get "/"
+    assert_equal 200, last_response.status
+    assert_equal "Root", last_response.body
+  end
+
+  def test_hello_route_with_params
+    get "/hello/world"
+    assert_equal 200, last_response.status
+    assert_equal "Hello world", last_response.body
+    assert_equal "world", app.last_params["name"]
+  end
+
+  def test_gem_stuff_route_with_params
+    get "/gem/stuff/test-param.gz"
+    assert_equal 200, last_response.status
+    assert_equal "Gem stuff with param: test-param", last_response.body
+    assert_equal "test-param", app.last_params["some_param"]
+  end
+
+  def test_post_route
+    post "/api/data"
+    assert_equal 201, last_response.status
+    assert_equal "Data created", last_response.body
+  end
+
+  def test_version_route_with_params
+    get "/api/version/1.2.3"
+    assert_equal 200, last_response.status
+    assert_equal "Version: 1.2.3", last_response.body
+    assert_equal "1.2.3", app.last_params["version"]
+  end
+
+  def test_nonexistent_route
+    get "/nonexistent"
+    assert_equal 404, last_response.status
+    assert_equal "Not Found", last_response.body
+  end
+
+  def test_wrong_method
+    post "/hello/world"
+    assert_equal 404, last_response.status
+    assert_equal "Not Found", last_response.body
+  end
+
+  def test_routes_class_draw_method
+    routes = Paquette::Routes.draw do |r|
+      r.get "/test" do
+        [200, {}, ["Test"]]
+      end
+    end
+
+    assert_instance_of Paquette::Routes, routes
+    assert_equal 1, routes.instance_variable_get(:@routes).length
+  end
+
+  def test_route_builder_methods
+    routes = Paquette::Routes.draw do |r|
+      r.get("/get") { [200, {}, ["GET"]] }
+      r.post("/post") { [200, {}, ["POST"]] }
+      r.put("/put") { [200, {}, ["PUT"]] }
+      r.delete("/delete") { [200, {}, ["DELETE"]] }
+      r.patch("/patch") { [200, {}, ["PATCH"]] }
+    end
+
+    assert_equal 5, routes.instance_variable_get(:@routes).length
+  end
+
+  def test_instance_exec_in_route_blocks
+    test_instance = self
+
+    routes = Paquette::Routes.draw do |r|
+      r.get "/self-test" do
+        [200, {}, ["Instance: #{self.class}"]]
+      end
+    end
+
+    # Create a mock request
+    request = Rack::Request.new(Rack::MockRequest.env_for("/self-test"))
+    route = routes.match(request)
+
+    assert route
+    result = routes.perform_action(route, test_instance, request)
+    assert_equal [200, {}, ["Instance: RoutesTest"]], result
+  end
+end

data/test/subdomain_router_integration_test.rb

@@ -0,0 +1,126 @@
+require_relative "test_helper"
+
+class SubdomainRouterIntegrationTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def setup
+    # No need to set environment variables since we use the packages directory structure
+  end
+
+  def app
+    # Load config.ru with the test fixtures dir so we don't depend on
+    # whatever a dev push may have left in packages/.
+    ENV["PAQUETTE_PACKAGES_DIR"] = File.expand_path("fixtures", __dir__)
+    Rack::Builder.parse_file(File.expand_path("../config.ru", __dir__))
+  end
+
+  def test_gem_subdomain_routing
+    get "/", {}, {"HTTP_HOST" => "gem.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "Paquette RubyGems Repository", last_response.body
+  end
+
+  def test_gem_subdomain_api_endpoints
+    get "/api/v1/names", {}, {"HTTP_HOST" => "gem.example.com"}
+    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_gem_subdomain_specs_endpoint
+    get "/specs.4.8", {}, {"HTTP_HOST" => "gem.example.com"}
+    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_npm_subdomain_routing
+    # Test that requests to npm.example.com are routed to NpmServer
+    get "/", {}, {"HTTP_HOST" => "npm.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "Paquette NPM Repository", last_response.body
+  end
+
+  def test_npm_subdomain_ping_endpoint
+    # Test that npm ping endpoint works with npm subdomain
+    get "/-/ping", {}, {"HTTP_HOST" => "npm.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    response = JSON.parse(last_response.body)
+    assert_equal({}, response)
+  end
+
+  def test_npm_subdomain_package_metadata
+    # Test that package metadata works with npm subdomain
+    get "/react-dropzone", {}, {"HTTP_HOST" => "npm.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "application/json", last_response.content_type
+
+    metadata = JSON.parse(last_response.body)
+    assert_equal "react-dropzone", metadata["name"]
+    assert metadata["versions"].is_a?(Hash)
+    assert metadata["versions"].key?("14.3.8")
+  end
+
+  def test_npm_subdomain_package_download
+    # Test that package download works with npm subdomain
+    get "/react-dropzone/react-dropzone-14.3.8.tgz", {}, {"HTTP_HOST" => "npm.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+    assert last_response.body.length > 0
+  end
+
+  def test_unknown_subdomain_fallback
+    # Test that unknown subdomains get the fallback response
+    get "/", {}, {"HTTP_HOST" => "api.example.com"}
+    assert_equal 404, last_response.status
+    assert_equal "Need subdomain gem/npm", last_response.body
+  end
+
+  def test_no_subdomain_fallback
+    # Test that requests without subdomain get the fallback response
+    get "/", {}, {"HTTP_HOST" => "example.com"}
+    assert_equal 404, last_response.status
+    assert_equal "Need subdomain gem/npm", last_response.body
+  end
+
+  def test_localhost_with_port_gem_subdomain
+    # Test that localhost with port works for gem subdomain
+    get "/", {}, {"HTTP_HOST" => "gem.localhost:9292"}
+    assert_equal 200, last_response.status
+    assert_equal "Paquette RubyGems Repository", last_response.body
+  end
+
+  def test_localhost_with_port_npm_subdomain
+    # Test that localhost with port works for npm subdomain
+    get "/", {}, {"HTTP_HOST" => "npm.localhost:9292"}
+    assert_equal 200, last_response.status
+    assert_equal "Paquette NPM Repository", last_response.body
+  end
+
+  def test_gem_subdomain_gem_download
+    get "/gems/zip_kit-6.2.0.gem", {}, {"HTTP_HOST" => "gem.example.com"}
+    assert_equal 200, last_response.status
+    assert_equal "application/octet-stream", last_response.content_type
+    assert last_response.body.length > 0
+  end
+
+  def test_cross_subdomain_isolation
+    # Test that npm endpoints don't work on gem subdomain
+    get "/-/ping", {}, {"HTTP_HOST" => "gem.example.com"}
+    assert_equal 404, last_response.status
+
+    # Test that gem endpoints don't work on npm subdomain
+    get "/api/v1/names", {}, {"HTTP_HOST" => "npm.example.com"}
+    assert_equal 404, last_response.status
+  end
+end

data/test/subdomain_router_test.rb

@@ -0,0 +1,125 @@
+require_relative "test_helper"
+
+class SubdomainRouterTest < Minitest::Test
+  def setup
+    @mock_app = MockApp.new
+    @gem_server = Paquette::GemServer.new(Paquette::GemServer::DirectoryGemRepository.new(FIXTURE_GEMS_DIR))
+    @npm_server = Paquette::NpmServer.new(FIXTURE_NPM_DIR)
+    @router = Paquette::SubdomainRouter.new do |router|
+      router.map "gems", to: @gem_server
+      router.map "npm", to: @npm_server
+      router.fallback to: @mock_app
+    end
+  end
+
+  def test_extract_subdomain_with_gems_subdomain
+    test_cases = [
+      ["gems.example.com", "gems"],
+      ["gems.localhost", "gems"],
+      ["gems.localhost:9292", "gems"]
+    ]
+
+    test_cases.each do |host, expected|
+      result = @router.send(:extract_subdomain, host)
+      assert_equal expected, result, "Expected '#{expected}' for host '#{host}', got '#{result}'"
+    end
+  end
+
+  def test_extract_subdomain_with_npm_subdomain
+    test_cases = [
+      ["npm.example.com", "npm"],
+      ["npm.localhost", "npm"],
+      ["npm.localhost:9292", "npm"]
+    ]
+
+    test_cases.each do |host, expected|
+      result = @router.send(:extract_subdomain, host)
+      assert_equal expected, result, "Expected '#{expected}' for host '#{host}', got '#{result}'"
+    end
+  end
+
+  def test_extract_subdomain_with_no_subdomain
+    test_cases = [
+      ["localhost", nil],
+      ["localhost:9292", nil],
+      ["example.com", nil],
+      ["api.example.com", nil] # unknown subdomain
+    ]
+
+    test_cases.each do |host, expected|
+      result = @router.send(:extract_subdomain, host)
+      if expected.nil?
+        assert_nil result, "Expected nil for host '#{host}', got '#{result}'"
+      else
+        assert_equal expected, result, "Expected '#{expected}' for host '#{host}', got '#{result}'"
+      end
+    end
+  end
+
+  def test_routing_to_gems_server
+    env = create_env("gems.example.com", "/")
+
+    # Mock the GemServer instance to verify it's called
+    gem_server_mock = Minitest::Mock.new
+    gem_server_mock.expect :call, [200, {}, ["GemServer response"]], [env]
+
+    # Stub the instance method
+    @gem_server.stub :call, ->(env) { gem_server_mock.call(env) } do
+      response = @router.call(env)
+      assert_equal [200, {}, ["GemServer response"]], response
+    end
+
+    gem_server_mock.verify
+  end
+
+  def test_routing_to_npm_server
+    env = create_env("npm.example.com", "/")
+
+    # Mock the NpmServer instance to verify it's called
+    npm_server_mock = Minitest::Mock.new
+    npm_server_mock.expect :call, [200, {}, ["NpmServer response"]], [env]
+
+    # Stub the instance method
+    @npm_server.stub :call, ->(env) { npm_server_mock.call(env) } do
+      response = @router.call(env)
+      assert_equal [200, {}, ["NpmServer response"]], response
+    end
+
+    npm_server_mock.verify
+  end
+
+  def test_routing_to_default_app
+    env = create_env("example.com", "/")
+
+    # The router should call the default app
+    response = @router.call(env)
+    assert_equal [200, {}, ["Default app response"]], response
+  end
+
+  def test_fallback_behavior
+    env = create_env("unknown.example.com", "/")
+
+    # The router should call the fallback app
+    response = @router.call(env)
+    assert_equal [200, {}, ["Default app response"]], response
+  end
+
+  private
+
+  def create_env(host, path)
+    {
+      "HTTP_HOST" => host,
+      "REQUEST_METHOD" => "GET",
+      "PATH_INFO" => path,
+      "QUERY_STRING" => "",
+      "rack.input" => StringIO.new
+    }
+  end
+
+  # Mock app for testing
+  class MockApp
+    def call(env)
+      [200, {}, ["Default app response"]]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require "minitest/autorun"
+require "rack/test"
+require "rack"
+require "fileutils"
+require "json"
+require "stringio"
+require "net/http"
+require "tempfile"
+require_relative "../lib/paquette"
+
+FIXTURE_GEMS_DIR = File.expand_path("fixtures/gems", __dir__)
+FIXTURE_NPM_DIR = File.expand_path("fixtures/npm", __dir__)

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: paquette
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Julik Tarkhanov
+bindir: bin
+cert_chain: []
+date: 2026-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sourcemap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/paquette.rb
+- lib/paquette/gem_server.rb
+- lib/paquette/gem_server/directory_gem_repository.rb
+- lib/paquette/gem_server/gem_repacker.rb
+- lib/paquette/gem_server/gem_repository.rb
+- lib/paquette/gem_server/personalizer.rb
+- lib/paquette/gem_server/read_gated_repository.rb
+- lib/paquette/npm_repacker.rb
+- lib/paquette/npm_server.rb
+- lib/paquette/npm_server/directory_npm_repository.rb
+- lib/paquette/npm_server/gated_npm_repository.rb
+- lib/paquette/npm_server/npm_repository.rb
+- lib/paquette/routes.rb
+- lib/paquette/subdomain_router.rb
+- lib/paquette/version.rb
+- test/fixtures/gems/minuscule_test/minuscule_test-0.1.0.gem
+- test/fixtures/gems/zip_kit/zip_kit-6.2.0.gem
+- test/fixtures/gems/zip_kit/zip_kit-6.2.1.gem
+- test/fixtures/npm/react-dropzone/react-dropzone-14.3.8.tgz
+- test/gem_server/bundler_install_test.rb
+- test/gem_server/directory_gem_repository_test.rb
+- test/gem_server/gem_repacker_test.rb
+- test/gem_server/personalizer_metadata_test.rb
+- test/gem_server/personalizer_test.rb
+- test/gem_server/read_gated_repository_test.rb
+- test/gem_server/repository_stack_test.rb
+- test/gem_server_test.rb
+- test/npm_repacker_sourcemap_test.rb
+- test/npm_repacker_test.rb
+- test/npm_server_test.rb
+- test/routes_test.rb
+- test/subdomain_router_integration_test.rb
+- test/subdomain_router_test.rb
+- test/test_helper.rb
+homepage: https://github.com/julik/paquette
+licenses:
+- Osassy
+metadata:
+  homepage_uri: https://github.com/julik/paquette
+  source_code_uri: https://github.com/julik/paquette
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Rack-based server for gated gem and NPM package repositories
+test_files: []