mirror of
https://github.com/gotenberg/gotenberg.git
synced 2026-08-14 19:32:15 +01:00
454 lines
9.6 KiB
Go
454 lines
9.6 KiB
Go
package unoconv
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type ProtoModule struct {
|
|
descriptor func() gotenberg.ModuleDescriptor
|
|
}
|
|
|
|
func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
|
|
return mod.descriptor()
|
|
}
|
|
|
|
type ProtoValidator struct {
|
|
ProtoModule
|
|
validate func() error
|
|
}
|
|
|
|
func (mod ProtoValidator) Validate() error {
|
|
return mod.validate()
|
|
}
|
|
|
|
type ProtoLoggerProvider struct {
|
|
ProtoModule
|
|
logger func(mod gotenberg.Module) (*zap.Logger, error)
|
|
}
|
|
|
|
func (factory ProtoLoggerProvider) Logger(mod gotenberg.Module) (*zap.Logger, error) {
|
|
return factory.logger(mod)
|
|
}
|
|
|
|
func TestUnoconv_Descriptor(t *testing.T) {
|
|
descriptor := Unoconv{}.Descriptor()
|
|
|
|
actual := reflect.TypeOf(descriptor.New())
|
|
expect := reflect.TypeOf(new(Unoconv))
|
|
|
|
if actual != expect {
|
|
t.Errorf("expected '%'s' but got '%s'", expect, actual)
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_Provision(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
ctx *gotenberg.Context
|
|
expectErr bool
|
|
}{
|
|
{
|
|
ctx: gotenberg.NewContext(
|
|
gotenberg.ParsedFlags{FlagSet: new(Unoconv).Descriptor().FlagSet},
|
|
make([]gotenberg.ModuleDescriptor, 0),
|
|
),
|
|
expectErr: true,
|
|
},
|
|
{
|
|
ctx: func() *gotenberg.Context {
|
|
mod := struct {
|
|
ProtoLoggerProvider
|
|
}{}
|
|
mod.descriptor = func() gotenberg.ModuleDescriptor {
|
|
return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
|
|
}
|
|
mod.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return nil, errors.New("foo") }
|
|
|
|
return gotenberg.NewContext(
|
|
gotenberg.ParsedFlags{
|
|
FlagSet: new(Unoconv).Descriptor().FlagSet,
|
|
},
|
|
[]gotenberg.ModuleDescriptor{
|
|
mod.Descriptor(),
|
|
},
|
|
)
|
|
}(),
|
|
expectErr: true,
|
|
},
|
|
{
|
|
ctx: func() *gotenberg.Context {
|
|
mod := struct {
|
|
ProtoLoggerProvider
|
|
}{}
|
|
mod.descriptor = func() gotenberg.ModuleDescriptor {
|
|
return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
|
|
}
|
|
mod.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return zap.NewNop(), nil }
|
|
|
|
return gotenberg.NewContext(
|
|
gotenberg.ParsedFlags{
|
|
FlagSet: new(Unoconv).Descriptor().FlagSet,
|
|
},
|
|
[]gotenberg.ModuleDescriptor{
|
|
mod.Descriptor(),
|
|
},
|
|
)
|
|
}(),
|
|
},
|
|
} {
|
|
mod := new(Unoconv)
|
|
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 TestUnoconv_Validate(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
binPath string
|
|
expectErr bool
|
|
}{
|
|
{
|
|
expectErr: true,
|
|
},
|
|
{
|
|
binPath: "/foo",
|
|
expectErr: true,
|
|
},
|
|
{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
},
|
|
} {
|
|
mod := Unoconv{
|
|
binPath: tc.binPath,
|
|
}
|
|
|
|
err := mod.Validate()
|
|
|
|
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 TestUnoconv_Start(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
mod *Unoconv
|
|
expectErr bool
|
|
}{
|
|
{
|
|
mod: &Unoconv{
|
|
disableListener: true,
|
|
logger: zap.NewNop(),
|
|
},
|
|
},
|
|
{
|
|
mod: &Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: false,
|
|
logger: zap.NewExample(),
|
|
},
|
|
},
|
|
} {
|
|
func() {
|
|
err := tc.mod.Start()
|
|
|
|
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)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(1)*time.Nanosecond)
|
|
defer cancel()
|
|
|
|
err = tc.mod.Stop(ctx)
|
|
if err != nil {
|
|
t.Errorf("test %d: expected not error but got: %v", i, err)
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_StartupMessage(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
disableListener bool
|
|
expectMessage string
|
|
}{
|
|
{
|
|
disableListener: true,
|
|
expectMessage: "listener disabled",
|
|
},
|
|
{
|
|
expectMessage: "listener started on port 0",
|
|
},
|
|
} {
|
|
mod := Unoconv{
|
|
disableListener: tc.disableListener,
|
|
}
|
|
|
|
actual := mod.StartupMessage()
|
|
if actual != tc.expectMessage {
|
|
t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectMessage, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_Stop(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
start bool
|
|
disableListener bool
|
|
timeout time.Duration
|
|
expectErr bool
|
|
}{
|
|
{
|
|
disableListener: true,
|
|
},
|
|
{
|
|
expectErr: true,
|
|
},
|
|
{
|
|
start: true,
|
|
timeout: time.Duration(1) * time.Nanosecond,
|
|
},
|
|
} {
|
|
func() {
|
|
mod := &Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: tc.disableListener,
|
|
logger: zap.NewNop(),
|
|
}
|
|
|
|
if tc.start {
|
|
err := mod.Start()
|
|
if err != nil {
|
|
t.Fatalf("test %d: expected no error but got: %v", i, err)
|
|
}
|
|
}
|
|
|
|
var err error
|
|
|
|
if tc.timeout == 0 {
|
|
err = mod.Stop(context.TODO())
|
|
} else {
|
|
ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
|
|
defer cancel()
|
|
|
|
err = mod.Stop(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 TestUnoconv_Metrics(t *testing.T) {
|
|
metrics, err := new(Unoconv).Metrics()
|
|
if err != nil {
|
|
t.Fatalf("expected no error but got: %v", err)
|
|
}
|
|
|
|
if len(metrics) != 3 {
|
|
t.Fatalf("expected %d metrics, but got %d", 1, len(metrics))
|
|
}
|
|
|
|
actual := metrics[0].Read()
|
|
if actual != 0 {
|
|
t.Errorf("expected %d unoconv instances, but got %f", 0, actual)
|
|
}
|
|
|
|
actual = metrics[1].Read()
|
|
if actual != 0 {
|
|
t.Errorf("expected %d unoconv listener instances, but got %f", 0, actual)
|
|
}
|
|
|
|
actual = metrics[2].Read()
|
|
if actual != 0 {
|
|
t.Errorf("expected %d processes in the queue, but got %f", 0, actual)
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_Unoconv(t *testing.T) {
|
|
mod := new(Unoconv)
|
|
|
|
_, err := mod.Unoconv()
|
|
if err != nil {
|
|
t.Errorf("expected no error but got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_PDF(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
ctx context.Context
|
|
mod Unoconv
|
|
logger *zap.Logger
|
|
inputPath string
|
|
options Options
|
|
expectErr bool
|
|
}{
|
|
{
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: true,
|
|
},
|
|
logger: zap.NewNop(),
|
|
expectErr: true,
|
|
},
|
|
{
|
|
ctx: context.Background(),
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: true,
|
|
},
|
|
logger: zap.NewExample(),
|
|
inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
|
|
options: Options{
|
|
Landscape: true,
|
|
PageRanges: "1-2",
|
|
PDFArchive: true,
|
|
},
|
|
},
|
|
{
|
|
ctx: context.Background(),
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: true,
|
|
},
|
|
logger: zap.NewNop(),
|
|
inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
|
|
options: Options{
|
|
PageRanges: "foo",
|
|
},
|
|
expectErr: true,
|
|
},
|
|
{
|
|
ctx: func() context.Context {
|
|
ctx, cancel := context.WithCancel(context.TODO())
|
|
defer cancel()
|
|
|
|
return ctx
|
|
}(),
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
disableListener: true,
|
|
},
|
|
logger: zap.NewNop(),
|
|
inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
|
|
expectErr: true,
|
|
},
|
|
{
|
|
ctx: context.Background(),
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
logger: zap.NewNop(),
|
|
},
|
|
logger: zap.NewNop(),
|
|
inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
|
|
},
|
|
{
|
|
ctx: func() context.Context {
|
|
ctx, cancel := context.WithCancel(context.TODO())
|
|
defer cancel()
|
|
|
|
return ctx
|
|
}(),
|
|
mod: Unoconv{
|
|
binPath: os.Getenv("UNOCONV_BIN_PATH"),
|
|
logger: zap.NewNop(),
|
|
},
|
|
logger: zap.NewNop(),
|
|
inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
|
|
expectErr: true,
|
|
},
|
|
} {
|
|
func() {
|
|
outputDir, err := gotenberg.MkdirAll()
|
|
if err != nil {
|
|
t.Fatalf("test %d: expected error but got: %v", i, err)
|
|
}
|
|
|
|
defer func() {
|
|
err := os.RemoveAll(outputDir)
|
|
if err != nil {
|
|
t.Fatalf("test %d: expected no error but got: %v", i, err)
|
|
}
|
|
}()
|
|
|
|
if !tc.mod.disableListener {
|
|
err = tc.mod.Start()
|
|
if err != nil {
|
|
t.Fatalf("test %d: expected no error but got: %v", i, err)
|
|
}
|
|
|
|
// Let's give it some room to start.
|
|
time.Sleep(time.Duration(1) * time.Second)
|
|
}
|
|
|
|
err = tc.mod.PDF(tc.ctx, tc.logger, tc.inputPath, outputDir+"/foo.pdf", tc.options)
|
|
|
|
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)
|
|
}
|
|
|
|
if !tc.mod.disableListener {
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(1)*time.Nanosecond)
|
|
defer cancel()
|
|
|
|
err = tc.mod.Stop(ctx)
|
|
if err != nil {
|
|
t.Fatalf("test %d: expected no error but got: %v", i, err)
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
func TestUnoconv_Extensions(t *testing.T) {
|
|
mod := new(Unoconv)
|
|
extensions := mod.Extensions()
|
|
|
|
actual := len(extensions)
|
|
expect := 76
|
|
|
|
if actual != expect {
|
|
t.Errorf("expected %d extensions but got %d", expect, actual)
|
|
}
|
|
}
|
|
|
|
// Interface guards.
|
|
var (
|
|
_ gotenberg.Module = (*ProtoModule)(nil)
|
|
_ gotenberg.Validator = (*ProtoValidator)(nil)
|
|
_ gotenberg.LoggerProvider = (*ProtoLoggerProvider)(nil)
|
|
_ gotenberg.Module = (*ProtoLoggerProvider)(nil)
|
|
)
|