feat: add 7.x source code

pkg/modules/libreoffice/pdfengine/doc.go

@@ -0,0 +1,3 @@
+// Package pdfengine provides a module which abstracts the CLI tool unoconv and
+// implements the gotenberg.PDFEngine interface.
+package pdfengine

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -0,0 +1,76 @@
+package pdfengine
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"go.uber.org/zap"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(UnoconvPDFEngine{})
+}
+
+// UnoconvPDFEngine abstracts the CLI tool unoconv and implements the
+// gotenberg.PDFEngine interface.
+type UnoconvPDFEngine struct {
+	unoconv unoconv.API
+}
+
+// Descriptor returns a UnoconvPDFEngine's module descriptor.
+func (engine UnoconvPDFEngine) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID:  "unoconv-pdfengine",
+		New: func() gotenberg.Module { return new(UnoconvPDFEngine) },
+	}
+}
+
+// Provision sets the module properties.
+func (engine *UnoconvPDFEngine) Provision(ctx *gotenberg.Context) error {
+	provider, err := ctx.Module(new(unoconv.Provider))
+	if err != nil {
+		return fmt.Errorf("get unoconv provider: %w", err)
+	}
+
+	uno, err := provider.(unoconv.Provider).Unoconv()
+	if err != nil {
+		return fmt.Errorf("get unoconv API: %w", err)
+	}
+
+	engine.unoconv = uno
+
+	return nil
+}
+
+// Merge is not available for this PDF engine.
+func (engine UnoconvPDFEngine) Merge(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+	return fmt.Errorf("merge PDFs with unoconv: %w", gotenberg.ErrPDFEngineMethodNotAvailable)
+}
+
+// Convert converts the given PDF to a specific PDF format. Currently, only the
+// PDF/A-1 format is available. If another PDF format is requested, it returns
+// a gotenberg.ErrPDFFormatNotAvailable error.
+func (engine UnoconvPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
+	if format != gotenberg.FormatPDFA1a {
+		return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, gotenberg.ErrPDFFormatNotAvailable)
+	}
+
+	err := engine.unoconv.PDF(ctx, logger, inputPath, outputPath, unoconv.Options{
+		PDFArchive: true,
+	})
+
+	if err == nil {
+		return nil
+	}
+
+	return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, err)
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*UnoconvPDFEngine)(nil)
+	_ gotenberg.Provisioner = (*UnoconvPDFEngine)(nil)
+	_ gotenberg.PDFEngine   = (*UnoconvPDFEngine)(nil)
+)

pkg/modules/libreoffice/pdfengine/pdfengine_test.go

@@ -0,0 +1,197 @@
+package pdfengine
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/zap"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoUnoconvProvider struct {
+	ProtoModule
+	unoconv func() (unoconv.API, error)
+}
+
+func (mod ProtoUnoconvProvider) Unoconv() (unoconv.API, error) {
+	return mod.unoconv()
+}
+
+type ProtoUnoconvAPI struct {
+	pdf func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error
+}
+
+func (mod ProtoUnoconvAPI) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error {
+	return mod.pdf(ctx, logger, inputPath, outputPath, options)
+}
+
+func (mod ProtoUnoconvAPI) Extensions() []string {
+	return nil
+}
+
+func TestUnoconvPDFEngine_Descriptor(t *testing.T) {
+	descriptor := UnoconvPDFEngine{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(UnoconvPDFEngine))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestUnoconvPDFEngine_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       *gotenberg.Context
+		expectErr bool
+	}{
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoModule }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return struct{ ProtoUnoconvAPI }{}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+		},
+	} {
+		mod := new(UnoconvPDFEngine)
+		err := mod.Provision(tc.ctx)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestUnoconvPDFEngine_Merge(t *testing.T) {
+	mod := new(UnoconvPDFEngine)
+	err := mod.Merge(context.TODO(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPDFEngineMethodNotAvailable) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPDFEngineMethodNotAvailable, err)
+	}
+}
+
+func TestUnoconvPDFEngine_Convert(t *testing.T) {
+	for i, tc := range []struct {
+		api       unoconv.API
+		format    string
+		expectErr bool
+	}{
+		{
+			format:    "",
+			expectErr: true,
+		},
+		{
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
+					return errors.New("foo")
+				}
+
+				return unoconvAPI
+			}(),
+			format:    gotenberg.FormatPDFA1a,
+			expectErr: true,
+		},
+		{
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
+					return nil
+				}
+
+				return unoconvAPI
+			}(),
+			format: gotenberg.FormatPDFA1a,
+		},
+	} {
+		mod := new(UnoconvPDFEngine)
+		mod.unoconv = tc.api
+
+		err := mod.Convert(context.TODO(), zap.NewNop(), tc.format, "", "")
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module = (*ProtoModule)(nil)
+	_ unoconv.Provider = (*ProtoUnoconvProvider)(nil)
+	_ gotenberg.Module = (*ProtoUnoconvProvider)(nil)
+	_ unoconv.API      = (*ProtoUnoconvAPI)(nil)
+)