bidi2pdf-rails 0.0.1.pre.alpha → 0.1.0

data/spec/acceptance/user_can_generate_pdf_from_protected_remote_url_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "net/http"
+require "rack/handler/puma"
+require "socket"
+require "base64"
+
+RSpec.feature "As a user, I want to generate a PDF from a protected remote URL", :pdf, type: :request do
+  before(:all) do
+    # Bidi2pdfRails.config.general_options.headless = false
+    Bidi2pdfRails::ChromedriverManagerSingleton.initialize_manager force: true
+  end
+
+  after(:all) do
+    Bidi2pdfRails::ChromedriverManagerSingleton.shutdown
+  end
+
+  scenario "Using basic auth for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure basic auth in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #     config.render_remote_settings.basic_auth_user = ->(_controller) { "admin" }
+    #     config.render_remote_settings.basic_auth_pass = ->(_controller) { "secret" }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #   render pdf: 'convert-remote-url-basic-auth',
+    #          url: basic_auth_endpoint_url(only_path: false),
+    #          auth: { username: "admin", password: "secret" }
+
+    when_ "I request a PDF generated from a basic-auth protected page" do
+      before do
+        with_render_setting :basic_auth_user, ->(_controller) { "admin" }
+        # in prod better to use:
+        # Bidi2pdfRails.config.render_remote_settings.basic_auth_pass = ->(_controller) { Rails.application.credentials.dig('bidi2pdf_rails', 'basic_auth_pass') }
+        with_render_setting :basic_auth_pass, ->(_controller) { "secret" }
+
+        @response = get_pdf_response "/convert-remote-url-basic-auth"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(1)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="convert-remote-url-basic-auth.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("This page is secured with: HTTPBasicAuthentication").at_page(1)
+      end
+    end
+  end
+
+  scenario "Using a session cookie for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure cookies in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #     config.render_remote_settings.cookies = = ->(controller) { { "auth_token" => signed_cookie_value("valid-authentication-token", controller) } }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #     render pdf: 'convert-remote-url-cookie',
+    #            url: cookie_endpoint_url(only_path: false),
+    #            wait_for_page_loaded: false,
+    #            cookies: { "auth_token" => signed_cookie_value("valid-authentication-token", controller) }
+    #
+
+    when_ "I request a PDF from a page that requires a session cookie" do
+      def signed_cookie_value(value, controller)
+        request = controller.request
+        secret = request.key_generator.generate_key(request.signed_cookie_salt)
+        # Sign the value
+        verifier = ActiveSupport::MessageVerifier.new(secret)
+        verifier.generate(value)
+      end
+
+      before do
+        with_render_setting :cookies, ->(controller) { { "auth_token" => signed_cookie_value("valid-authentication-token", controller) } }
+
+        @response = get_pdf_response "/convert-remote-url-cookie"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(1)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="convert-remote-url-cookie.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("Protected Resource This page is secured with: CookieAuthentication").at_page(1)
+      end
+    end
+  end
+
+  scenario "Using custom headers for remote PDF rendering" do
+    # Controller setup:
+    #
+    # You can configure headers in two ways:
+    #
+    # 1. In an initializer (global config):
+    #
+    #   Bidi2pdfRails.configure do |config|
+    #    config.render_remote_settings.headers = ->(controller) { { "X-API-Key" => "your-secret-api-key" } }
+    #   end
+    #
+    # 2. Inline within controller action:
+    #
+    #     render pdf: 'convert-remote-url-cookie',
+    #            url: api_endpoint_url(only_path: false),
+    #            wait_for_page_loaded: false,
+    #            headers: { "X-API-Key" => "your-secret-api-key" }
+    #
+
+    when_ "I request a PDF from a page that requires an auth header" do
+      before do
+        @old_headers = Bidi2pdfRails.config.render_remote_settings.headers
+        with_render_setting :headers, ->(_controller) { { "X-API-Key" => "your-secret-api-key" } }
+
+        @response = get_pdf_response "/convert-remote-url-header"
+      end
+
+      then_ "I receive a successful HTTP response" do
+        expect(@response.code).to eq("200")
+      end
+
+      and_ "I receive a PDF file in response" do
+        expect(@response['Content-Type']).to eq("application/pdf")
+      end
+
+      and_ "the PDF contains the expected number of pages" do
+        expect(@response.body).to have_pdf_page_count(1)
+      end
+
+      and_ "the disposition header is set to attachment" do
+        expect(@response['Content-Disposition']).to start_with('inline; filename="convert-remote-url-cookie.pdf"')
+      end
+
+      and_ "the PDF contains the expected content" do
+        expect(@response.body).to contains_pdf_text("Protected Resource This page is secured with: API KeyAuthentication").at_page(1)
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/reports_controller.rb

@@ -5,4 +5,41 @@ class ReportsController < ApplicationController
       format.pdf { render pdf: 'my-report', layout: 'pdf' }
     end
   end
+
+  def convert_remote_url
+    render pdf: 'convert-remote-url', url: "http://example.com", wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+  end
+
+  def inline_html
+    html = <<~HTML
+      <html>
+      <head>
+      </head>
+      <body>
+        <h1>PDF Rendering Sample</h1>
+        <p style="page-break-after: always;">Page break</p>
+        <p>Content Page 2</p>
+      </body>
+      </html>
+    HTML
+    render pdf: 'inline-html', inline: html, wait_for_page_loaded: false, print_options: { page: { format: :A4 } }
+  end
+
+  def convert_remote_url_basic_auth
+    render pdf: 'convert-remote-url-basic-auth',
+           url: basic_auth_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
+  end
+
+  def convert_remote_url_cookie
+    render pdf: 'convert-remote-url-cookie',
+           url: cookie_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
+  end
+
+  def convert_remote_url_header
+    render pdf: 'convert-remote-url-cookie',
+           url: api_endpoint_url(only_path: false),
+           wait_for_page_loaded: false
+  end
 end

data/spec/dummy/app/controllers/secure_controller.rb

@@ -0,0 +1,52 @@
+# app/controllers/secure_controller.rb
+class SecureController < ApplicationController
+  # Basic Auth protection for the first action
+  http_basic_authenticate_with name: "admin", password: "secret", only: :basic_auth_endpoint
+
+  before_action :authenticate_with_api_key, only: :api_endpoint
+  before_action :authenticate_with_cookie, only: :cookie_endpoint
+
+  def basic_auth_endpoint
+    @auth_method = "HTTP Basic Authentication"
+    @auth_description = "This endpoint requires username and password authentication."
+    @auth_details = "Credentials: username: <code>admin</code>, password: <code>secret</code>"
+
+    render :show, layout: 'simple'
+  end
+
+  def api_endpoint
+    @auth_method = "API Key Authentication"
+    @auth_description = "This endpoint requires an API key in the header."
+    @auth_details = "Required header: <code>X-API-Key: your-secret-api-key</code>"
+
+    render :show, layout: 'simple'
+  end
+
+  def cookie_endpoint
+    @auth_method = "Cookie Authentication"
+    @auth_description = "This endpoint requires an authentication cookie."
+    @auth_details = "Required cookie: <code>auth_token</code> with value <code>valid-authentication-token</code>"
+
+    render :show, layout: 'simple'
+  end
+
+  private
+
+  def authenticate_with_api_key
+    api_key = request.headers["X-API-Key"]
+    valid_key = "your-secret-api-key"
+
+    if api_key.blank? || api_key != valid_key
+      render html: "<h1>Unauthorized</h1><p>Invalid or missing API key</p>".html_safe, status: :unauthorized
+    end
+  end
+
+  def authenticate_with_cookie
+    auth_token = cookies.signed[:auth_token]
+    valid_token = "valid-authentication-token"
+
+    if auth_token.blank? || auth_token != valid_token
+      render html: "<h1>Unauthorized</h1><p>Invalid or missing API key</p>".html_safe, status: :unauthorized
+    end
+  end
+end

data/spec/dummy/app/views/layouts/simple.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title><%= content_for(:title) || "Dummy" %></title>
+  <%= csp_meta_tag %>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+</head>
+
+<body>
+<%= yield %>
+</body>
+</html>

data/spec/dummy/app/views/secure/show.html.erb

@@ -0,0 +1,10 @@
+# app/views/secure/show.html.erb
+<h1>Protected Resource</h1>
+<p>This page is secured with: <strong><%= @auth_method %></strong></p>
+<p><%= @auth_description %></p>
+
+<div class="auth-details">
+  <%= @auth_details %>
+</div>
+
+<p>When authenticated, you can access this content.</p>

data/spec/dummy/config/environments/production.rb

@@ -46,7 +46,7 @@ Rails.application.configure do
     .then { |logger| ActiveSupport::TaggedLogging.new(logger) }
 
   # Prepend all log lines with the following tags.
-  config.log_tags = [ :request_id ]
+  config.log_tags = [:request_id]
 
   # "info" includes generic and useful information about system operation, but avoids logging too much
   # information to avoid inadvertent exposure of personally identifiable information (PII). If you

data/spec/dummy/config/initializers/bidi2pdf_rails.rb

@@ -3,62 +3,76 @@
 Bidi2pdfRails.configure do |config|
   overrides = Rails.application.config.x.bidi2pdf_rails
 
-  config.notification_service = ActiveSupport::Notifications
-
-  config.logger = Rails.logger
-  config.verbosity = overrides.verbosity.nil? ? :none : overrides.verbosity
-  config.default_timeout = 10
-
-  # Logging options
-  config.log_network_events = false
-  config.log_browser_console = false
-
-  # Chrome & BiDi
-  # config.remote_browser_url = nil
-  config.headless = overrides.headless.nil? ? false : overrides.headless
-  # config.chromedriver_port = 0
-  # config.chrome_session_args = [
-  #   "--disable-gpu",
-  #   "--no-sandbox"
-  # ]
-
-
-  # config.proxy_addr = nil
-  # config.proxy_port = nil
-  # config.proxy_user = nil
-  # config.proxy_pass = nil
-
-
-
-  # Viewport settings
-  # config.viewport_width = 1920
-  # config.viewport_height = 1080
-
-
-
-  # PDF settings
-  # config.pdf_orientation = "portrait"
-  # config.pdf_margin_top = 10
-  # config.pdf_margin_bottom = 10
-  # config.pdf_margin_left = 10
-  # config.pdf_margin_right = 10
-  # config.pdf_print_background = true
-  # config.pdf_scale = 1.0
-
+  #
+  # General Options
+  #
+
+  # config.general_options.logger = Rails.logger # The logger
+
+  # Allowed values: "none", "low", "medium", "high"
+  config.general_options.verbosity = "medium" # How verbose to be
+  # config.general_options.headless = !Rails.env.development? # Run Chrome in headless mode
+  # config.general_options.wait_for_network_idle = true # Wait for network idle
+  config.general_options.wait_for_page_loaded = true # Wait for page loaded
+  # config.general_options.wait_for_page_check_script = nil # Wait for page check script
+  # config.general_options.notification_service = -> { ActiveSupport::Notifications } # Notification service
+  # config.general_options.default_timeout = 10 # Default timeout for various Bidi commands
+  # config.general_options.chrome_session_args = ["--disable-gpu", "--disable-popup-blocking", "--disable-hang-monitor"] # Chrome session arguments
+
+  #
+  # Chromedriver Settings (when chromedriver run within your app)
+  #
+
+  # config.chromedriver_settings.install_dir = nil # Chromedriver install directory
+  # config.chromedriver_settings.port = 0 # Chromedriver port
+
+  #
+  # Proxy Settings
+  #
+
+  # config.proxy_settings.addr = nil # Proxy address (e.g., 127.0.0.1)
+  # config.proxy_settings.port = nil # Proxy port (e.g., 8080)
+  # config.proxy_settings.user = nil # Proxy user
+  # config.proxy_settings.pass = -> { Rails.application.credentials.dig('bidi2pdf_rails', 'proxy_pass') } # Proxy password
+
+  #
+  # PDF Settings
+  #
+
+  # Allowed values: "portrait", "landscape"
+  # config.pdf_settings.orientation = "portrait" # PDF orientation (portrait/landscape)
+  # config.pdf_settings.margins = false # Configure PDF margins?
+  # config.pdf_settings.margin_top = 2.5 # PDF margin top (cm)
+  # config.pdf_settings.margin_bottom = 2 # PDF margin bottom (cm)
+  # config.pdf_settings.margin_left = 2 # PDF margin left (cm)
+  # config.pdf_settings.margin_right = 2 # PDF margin right (cm)
+
+  # Allowed values: "letter", "legal", "tabloid", "ledger", "a0", "a1", "a2", "a3", "a4", "a5", "a6"
+  # config.pdf_settings.page_format = nil # PDF page format (e.g., A4)
+  # config.pdf_settings.page_width = 21.0 # PDF page width (cm, not needed when format is specified)
+  # config.pdf_settings.page_height = 29.7 # PDF page height (cm, not needed when format is specified)
+  # config.pdf_settings.print_background = true # Print background graphics?
+  # config.pdf_settings.scale = 1.0 # PDF scale (e.g., 1.0)
+  # config.pdf_settings.shrink_to_fit = false # Shrink to fit?
+
+  #
+  # Remote URL Settings
+  #
+
+  # config.render_remote_settings.browser_url = nil # Remote browser URL (e.g. http://localhost:3001/sesion)
+  # config.render_remote_settings.basic_auth_user = nil # Basic auth user
+  # config.render_remote_settings.basic_auth_pass = -> { Rails.application.credentials.dig('bidi2pdf_rails', 'basic_auth_pass') } # Basic auth password
+  # config.render_remote_settings.headers = {"X-API-INFO" => "my info"} # Headers to be send when allong an url
+  # config.render_remote_settings.cookies = {"session_id" => "my session"} # Cookies to be send when alling an url
+end
 
-  # config.cookies = [
-  #   { name: "session", value: "abc123", domain: "example.com" }
-  # ]
+Rails.application.config.after_initialize do
+  Bidi2pdfRails::MainLogSubscriber.attach_to "bidi2pdf", inherit_all: true # needed for imported methods
+  Bidi2pdfRails::MainLogSubscriber.attach_to "bidi2pdf_rails", inherit_all: true # needed for imported methods
 
-  # config.headers = {
-  #   "X-API-KEY" => "topsecret"
-  # }
+  Bidi2pdfRails::BrowserConsoleLogSubscriber.attach_to "bidi2pdf"
 
-  # config.auth = {
-  #   username: "admin",
-  #   password: "secret"
-  # }
+  Bidi2pdfRails::MainLogSubscriber.silence /network_event_.*\.bidi2pdf/
 
-  # chromedriver install dir
-  # config.install_dir = Rails.root.join("tmp", "bidi2pdf").to_s
+  Bidi2pdfRails::NetworkLogSubscriber.attach_to "bidi2pdf"
 end

data/spec/dummy/config/initializers/cors.rb

@@ -4,6 +4,6 @@ gem 'rack-cors'
 Rails.application.config.middleware.insert_before 0, Rack::Cors do
   allow do
     origins '*'
-    resource '/assets/*', headers: :any, methods: [ :get, :options ]
+    resource '/assets/*', headers: :any, methods: [:get, :options]
   end
 end

data/spec/dummy/config/routes.rb

@@ -1,6 +1,16 @@
 Rails.application.routes.draw do
   get "reports/:id" => "reports#show", as: :report
 
+  get "convert-remote-url" => "reports#convert_remote_url", as: :print_remote
+  get "inline-html" => "reports#inline_html", as: :print_inline
+  get "convert-remote-url-basic-auth" => "reports#convert_remote_url_basic_auth", as: :print_remote_basic_auth
+  get "convert-remote-url-cookie" => "reports#convert_remote_url_cookie", as: :print_remote_url_cookie
+  get "convert-remote-url-header" => "reports#convert_remote_url_header", as: :print_remote_url_header
+
+  get 'basic-auth', to: 'secure#basic_auth_endpoint', as: :basic_auth_endpoint
+  get 'header-auth', to: 'secure#api_endpoint', as: :api_endpoint
+  get 'cookie-auth', to: 'secure#cookie_endpoint', as: :cookie_endpoint
+
   # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
 
   # Reveal health status on /up that returns 200 if the app boots with no exceptions, otherwise 500.