fix: chromium memory leaks (#705)

pkg/modules/chromium/chromium_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"os"
 	"reflect"
-	"regexp"
 	"testing"
 	"time"
 
@@ -15,14 +14,6 @@ import (
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 )
 
-type ProtoAPI struct {
-	pdf func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error
-}
-
-func (mod ProtoAPI) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error {
-	return mod.pdf(ctx, logger, URL, outputPath, options)
-}
-
 func TestDefaultOptions(t *testing.T) {
 	actual := DefaultOptions()
 	notExpect := Options{}
@@ -33,7 +24,7 @@ func TestDefaultOptions(t *testing.T) {
 }
 
 func TestChromium_Descriptor(t *testing.T) {
-	descriptor := Chromium{}.Descriptor()
+	descriptor := new(Chromium).Descriptor()
 
 	actual := reflect.TypeOf(descriptor.New())
 	expect := reflect.TypeOf(new(Chromium))
@@ -45,9 +36,9 @@ func TestChromium_Descriptor(t *testing.T) {
 
 func TestChromium_Provision(t *testing.T) {
 	for _, tc := range []struct {
-		scenario  string
-		ctx       *gotenberg.Context
-		expectErr bool
+		scenario    string
+		ctx         *gotenberg.Context
+		expectError bool
 	}{
 		{
 			scenario: "no logger provider",
@@ -59,12 +50,12 @@ func TestChromium_Provision(t *testing.T) {
 					[]gotenberg.ModuleDescriptor{},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
 			scenario: "no logger from logger provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct {
+				mod := &struct {
 					gotenberg.ModuleMock
 					gotenberg.LoggerProviderMock
 				}{}
@@ -84,12 +75,12 @@ func TestChromium_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
 			scenario: "no PDF engine provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct {
+				mod := &struct {
 					gotenberg.ModuleMock
 					gotenberg.LoggerProviderMock
 				}{}
@@ -109,12 +100,12 @@ func TestChromium_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
 			scenario: "no PDF engine from PDF engine provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct {
+				mod := &struct {
 					gotenberg.ModuleMock
 					gotenberg.LoggerProviderMock
 					gotenberg.PDFEngineProviderMock
@@ -138,12 +129,12 @@ func TestChromium_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
 			scenario: "provision success",
 			ctx: func() *gotenberg.Context {
-				mod := struct {
+				mod := &struct {
 					gotenberg.ModuleMock
 					gotenberg.LoggerProviderMock
 					gotenberg.PDFEngineProviderMock
@@ -155,7 +146,7 @@ func TestChromium_Provision(t *testing.T) {
 					return zap.NewNop(), nil
 				}
 				mod.PDFEngineMock = func() (gotenberg.PDFEngine, error) {
-					return gotenberg.PDFEngineMock{}, nil
+					return new(gotenberg.PDFEngineMock), nil
 				}
 
 				return gotenberg.NewContext(
@@ -169,123 +160,233 @@ func TestChromium_Provision(t *testing.T) {
 			}(),
 		},
 	} {
-		mod := new(Chromium)
-		err := mod.Provision(tc.ctx)
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			err := mod.Provision(tc.ctx)
 
-		if tc.expectErr && err == nil {
-			t.Errorf("test %s: expected error but got: %v", tc.scenario, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
 
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %s: expected no error but got: %v", tc.scenario, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }
 
 func TestChromium_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		binPath   string
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
 	}{
 		{
-			expectErr: true,
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
 		},
 		{
-			binPath:   "/foo",
-			expectErr: true,
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
 		},
 		{
-			binPath: os.Getenv("CHROMIUM_BIN_PATH"),
+			scenario:    "valid bin path",
+			binPath:     os.Getenv("CHROMIUM_BIN_PATH"),
+			expectError: false,
 		},
 	} {
-		mod := new(Chromium)
-		mod.binPath = tc.binPath
-		err := mod.Validate()
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.args = browserArguments{
+				binPath: tc.binPath,
+			}
+			err := mod.Validate()
 
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
 
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestChromium_Start(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		autoStart   bool
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario:    "no auto-start",
+			autoStart:   false,
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start success",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start failed",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.autoStart = tc.autoStart
+			mod.supervisor = tc.supervisor
+
+			err := mod.Start()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestChromium_StartupMessage(t *testing.T) {
+	mod := new(Chromium)
+
+	mod.autoStart = true
+	autoStartMsg := mod.StartupMessage()
+
+	mod.autoStart = false
+	noAutoStartMsg := mod.StartupMessage()
+
+	if autoStartMsg == noAutoStartMsg {
+		t.Errorf("expected differrent startup messages based on auto start, but got '%s'", autoStartMsg)
+	}
+}
+
+func TestChromium_Stop(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario: "stop success",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario: "stop failed",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.logger = zap.NewNop()
+			mod.supervisor = tc.supervisor
+
+			ctx, cancel := context.WithTimeout(context.Background(), 0*time.Second)
+			cancel()
+
+			err := mod.Stop(ctx)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }
 
 func TestChromium_Metrics(t *testing.T) {
-	metrics, err := new(Chromium).Metrics()
+	mod := new(Chromium)
+	mod.supervisor = &gotenberg.ProcessSupervisorMock{
+		ReqQueueSizeMock: func() int64 {
+			return 10
+		},
+		RestartsCountMock: func() int64 {
+			return 0
+		},
+	}
+
+	metrics, err := mod.Metrics()
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}
 
-	if len(metrics) != 2 {
-		t.Fatalf("expected %d metrics, but got %d", 2, len(metrics))
+	if len(metrics) != 4 {
+		t.Fatalf("expected %d metrics, but got %d", 4, len(metrics))
 	}
 
 	actual := metrics[0].Read()
-	if actual != 0 {
-		t.Errorf("expected %d Chromium instances, but got %f", 0, actual)
+	if actual != float64(1) {
+		t.Errorf("expected %f for chromium_active_instances_count, but got %f", float64(1), actual)
 	}
 
 	actual = metrics[1].Read()
-	if actual != 0 {
-		t.Errorf("expected %d Chromium failed starts, but got %f", 0, actual)
+	if actual != float64(0) {
+		t.Errorf("expected %f for chromium_failed_starts_count, but got %f", float64(0), actual)
+	}
+
+	actual = metrics[2].Read()
+	if actual != float64(10) {
+		t.Errorf("expected %f for chromium_requests_queue_size, but got %f", float64(10), actual)
+	}
+
+	actual = metrics[3].Read()
+	if actual != float64(0) {
+		t.Errorf("expected %f for chromium_restarts_count, but got %f", float64(0), actual)
 	}
 }
 
 func TestChromium_Checks(t *testing.T) {
-	tests := []struct {
-		name                     string
-		mod                      Chromium
-		tearUp                   func()
-		tearDown                 func()
+	for _, tc := range []struct {
+		scenario                 string
+		supervisor               gotenberg.ProcessSupervisor
 		expectAvailabilityStatus health.AvailabilityStatus
 	}{
 		{
-			name: "ignore Chromium failed starts",
-			mod: Chromium{
-				failedStartsThreshold: 0,
-			},
-		},
-		{
-			name: "with Chromium failed starts threshold not reached",
-			mod: Chromium{
-				failedStartsThreshold: 1,
-			},
+			scenario: "healthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return true
+			}},
 			expectAvailabilityStatus: health.StatusUp,
 		},
 		{
-			name: "with Chromium failed starts threshold reached",
-			mod: Chromium{
-				failedStartsThreshold: 1,
-			},
-			tearUp: func() {
-				failedStartsCount = 1
-			},
-			tearDown: func() {
-				failedStartsCount = 0
-			},
+			scenario: "unhealthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return false
+			}},
 			expectAvailabilityStatus: health.StatusDown,
 		},
-	}
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.supervisor = tc.supervisor
 
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if tc.tearUp != nil {
-				tc.tearUp()
-			}
-
-			checks, err := tc.mod.Checks()
+			checks, err := mod.Checks()
 			if err != nil {
-				t.Fatalf("expected no error from mod.Checks(), but got: %v", err)
-			}
-
-			if len(checks) == 0 {
-				return
-			}
-
-			if len(checks) != 1 {
-				t.Fatalf("expected 1 check from mod.Checks(), but got %d", len(checks))
+				t.Fatalf("expected no error but got: %v", err)
 			}
 
 			checker := health.NewChecker(checks...)
@@ -294,10 +395,6 @@ func TestChromium_Checks(t *testing.T) {
 			if result.Status != tc.expectAvailabilityStatus {
 				t.Errorf("expected '%s' as availability status, but got '%s'", tc.expectAvailabilityStatus, result.Status)
 			}
-
-			if tc.tearDown != nil {
-				tc.tearDown()
-			}
 		})
 	}
 }
@@ -312,412 +409,76 @@ func TestChromium_Chromium(t *testing.T) {
 }
 
 func TestChromium_Routes(t *testing.T) {
-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario      string
 		expectRoutes  int
 		disableRoutes bool
 	}{
 		{
-			expectRoutes: 3,
+			scenario:      "routes not disabled",
+			expectRoutes:  3,
+			disableRoutes: false,
 		},
 		{
+			scenario:      "routes disabled",
+			expectRoutes:  0,
 			disableRoutes: true,
 		},
 	} {
-		mod := new(Chromium)
-		mod.disableRoutes = tc.disableRoutes
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.disableRoutes = tc.disableRoutes
 
-		routes, err := mod.Routes()
-		if err != nil {
-			t.Fatalf("test %d: expected no error but got: %v", i, err)
-		}
+			routes, err := mod.Routes()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
 
-		if tc.expectRoutes != len(routes) {
-			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
-		}
+			if tc.expectRoutes != len(routes) {
+				t.Errorf("expected %d routes but got %d", tc.expectRoutes, len(routes))
+			}
+		})
 	}
 }
 
-func TestChromium_PDF(t *testing.T) {
+func TestChromium_Pdf(t *testing.T) {
 	for _, tc := range []struct {
-		name                     string
-		timeout                  time.Duration
-		cancel                   context.CancelFunc
-		URL                      string
-		options                  Options
-		userAgent                string
-		incognito                bool
-		allowInsecureLocalhost   bool
-		ignoreCertificateErrors  bool
-		disableWebSecurity       bool
-		allowFileAccessFromFiles bool
-		hostResolverRules        string
-		proxyServer              string
-		allowList                *regexp.Regexp
-		denyList                 *regexp.Regexp
-		disableJavaScript        bool
-		expectErr                bool
+		scenario    string
+		supervisor  gotenberg.ProcessSupervisor
+		browser     browser
+		expectError bool
 	}{
 		{
-			name:      "context has no deadline",
-			URL:       "file:///tests/test/testdata/chromium/html/sample1/index.html",
-			expectErr: true,
+			scenario: "PDF task success",
+			browser: &browserMock{pdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options Options) error {
+				return nil
+			}},
+			expectError: false,
 		},
 		{
-			name:      "URL does not match the expression from the allowed list",
-			timeout:   time.Duration(60) * time.Second,
-			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			allowList: regexp.MustCompile("file:///tmp/*"),
-			expectErr: true,
-		},
-		{
-			name:      "URL does not match the expression from the denied list",
-			timeout:   time.Duration(60) * time.Second,
-			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			denyList:  regexp.MustCompile("file:///tests/*"),
-			expectErr: true,
-		},
-		{
-			name:    "with user agent",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				UserAgent: "foo",
-			},
-		},
-		{
-			name:    "fail on console exceptions",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample10/index.html",
-			options: Options{
-				FailOnConsoleExceptions: true,
-			},
-			expectErr: true,
-		},
-		{
-			name:              "disable JavaScript",
-			timeout:           time.Duration(60) * time.Second,
-			URL:               "file:///tests/test/testdata/chromium/html/sample9/index.html",
-			disableJavaScript: true,
-		},
-		{
-			name:    "with extra HTTP headers",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				ExtraHTTPHeaders: map[string]string{
-					"foo": "bar",
-				},
-			},
-		},
-		{
-			name:    "with extra link tags",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample11/index.html",
-			options: Options{
-				ExtraLinkTags: []LinkTag{
-					{
-						Href: "font.woff",
-					},
-					{
-						Href: "style.css",
-					},
-				},
-			},
-		},
-		{
-			name:    "with invalid emulated media type",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample8/index.html",
-			options: Options{
-				EmulatedMediaType: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with screen emulated media type",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample8/index.html",
-			options: Options{
-				EmulatedMediaType: "screen",
-			},
-		},
-		{
-			name:    "with print emulated media type",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample8/index.html",
-			options: Options{
-				EmulatedMediaType: "print",
-			},
-		},
-		{
-			name:    "with omit background but not print background",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				OmitBackground: true,
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with omit background and print background",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				OmitBackground:  true,
-				PrintBackground: true,
-			},
-		},
-		{
-			name:    "with extra script tags",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample11/index.html",
-			options: Options{
-				ExtraScriptTags: []ScriptTag{
-					{
-						Src: "script.js",
-					},
-				},
-			},
-		},
-		{
-			name:    "with wait delay",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				WaitDelay: time.Duration(1) * time.Nanosecond,
-			},
-		},
-		{
-			name:    "with invalid wait window status",
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitWindowStatus: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with wait window status",
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitWindowStatus: "ready",
-			},
-		},
-		{
-			name:    "with wait for expression that should not happen",
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitForExpression: "window.status === 'foo'",
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with valid wait for expression",
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitForExpression: "window.status === 'ready'",
-			},
-		},
-		{
-			name:    "with invalid wait for expression",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				WaitForExpression: "return undefined",
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with too big margin bottom",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				MarginBottom: 100,
-			},
-			expectErr: true,
-		},
-		{
-			name:    "with invalid page ranges",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				PageRanges: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			name:                     "with a lot of properties",
-			timeout:                  time.Duration(60) * time.Second,
-			URL:                      "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			userAgent:                "foo",
-			incognito:                true,
-			ignoreCertificateErrors:  true,
-			allowInsecureLocalhost:   true,
-			disableWebSecurity:       true,
-			allowFileAccessFromFiles: true,
-			hostResolverRules:        "foo",
-			proxyServer:              "foo",
-		},
-		{
-			name:    "with file using local and remote assets",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample1/index.html",
-		},
-		{
-			name:      "URL does match the expression from the allowed list",
-			timeout:   time.Duration(60) * time.Second,
-			URL:       "file:///tests/test/testdata/chromium/html/sample3/index.html",
-			allowList: regexp.MustCompile("file:///tests/*"),
-		},
-		{
-			name:     "URL does match the expression from the denied list",
-			timeout:  time.Duration(60) * time.Second,
-			URL:      "file:///tests/test/testdata/chromium/html/sample3/index.html",
-			denyList: regexp.MustCompile("file:///etc/*"),
-		},
-		{
-			name:    "with custom header and footer templates",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				HeaderTemplate: func() string {
-					b, err := os.ReadFile("/tests/test/testdata/chromium/url/sample2/header.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-				FooterTemplate: func() string {
-					b, err := os.ReadFile("/tests/test/testdata/chromium/url/sample2/footer.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-			},
-		},
-		{
-			name:    "with custom header template only",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				HeaderTemplate: func() string {
-					b, err := os.ReadFile("/tests/test/testdata/chromium/url/sample2/header.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-				FooterTemplate: DefaultOptions().FooterTemplate,
-			},
-		},
-		{
-			name:    "with custom footer template only",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				HeaderTemplate: DefaultOptions().HeaderTemplate,
-				FooterTemplate: func() string {
-					b, err := os.ReadFile("/tests/test/testdata/chromium/url/sample2/footer.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-			},
-		},
-		{
-			name:    "without custom header and footer templates",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				HeaderTemplate: DefaultOptions().HeaderTemplate,
-				FooterTemplate: DefaultOptions().FooterTemplate,
-			},
-		},
-		{
-			name:    "with file using a .gif",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample5/index.html",
-		},
-		{
-			name:                     "with allow file access from files",
-			timeout:                  time.Duration(60) * time.Second,
-			URL:                      "file:///tests/test/testdata/chromium/html/sample6/index.html",
-			allowFileAccessFromFiles: true,
-		},
-		{
-			name:    "with file using a style attribute",
-			timeout: time.Duration(60) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample7/index.html",
+			scenario: "PDF task error",
+			browser: &browserMock{pdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options Options) error {
+				return errors.New("PDF task error")
+			}},
+			expectError: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			mod := new(Chromium)
-			mod.binPath = os.Getenv("CHROMIUM_BIN_PATH")
-			mod.userAgent = tc.userAgent
-			mod.incognito = tc.incognito
-			mod.allowInsecureLocalhost = tc.allowInsecureLocalhost
-			mod.ignoreCertificateErrors = tc.ignoreCertificateErrors
-			mod.disableWebSecurity = tc.disableWebSecurity
-			mod.allowFileAccessFromFiles = tc.allowFileAccessFromFiles
-			mod.hostResolverRules = tc.hostResolverRules
-			mod.proxyServer = tc.proxyServer
+			mod.supervisor = &gotenberg.ProcessSupervisorMock{RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+				return task()
+			}}
+			mod.browser = tc.browser
 
-			if tc.allowList == nil {
-				tc.allowList = regexp.MustCompile("")
+			err := mod.Pdf(context.Background(), zap.NewNop(), "", "", Options{})
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
 			}
 
-			if tc.denyList == nil {
-				tc.denyList = regexp.MustCompile("")
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
 			}
-
-			mod.allowList = tc.allowList
-			mod.denyList = tc.denyList
-			mod.disableJavaScript = tc.disableJavaScript
-			mod.fs = gotenberg.NewFileSystem()
-
-			ctxFs := gotenberg.NewFileSystem()
-			outputDir, err := ctxFs.MkdirAll()
-			if err != nil {
-				t.Fatalf("test %s: expected error but got: %v", tc.name, err)
-			}
-
-			defer func() {
-				err := os.RemoveAll(ctxFs.WorkingDirPath())
-				if err != nil {
-					t.Fatalf("test %s: expected no error while cleaning up but got: %v", tc.name, err)
-				}
-			}()
-
-			if tc.timeout == 0 {
-				err = mod.PDF(context.Background(), zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
-			} else {
-				ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
-				defer cancel()
-
-				err = mod.PDF(ctx, zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
-			}
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %s: expected error but got: %v", tc.name, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %s: expected no error but got: %v", tc.name, err)
-			}
-		}()
+		})
 	}
 }
-
-// Interface guards.
-var (
-	_ API = (*ProtoAPI)(nil)
-)