now using latest version of unoconv, allowing to specify paper size and orientation + updating go client (#24)

pkg/README.md

@@ -16,19 +16,17 @@ import "github.com/thecodingmachine/gotenberg/pkg"
 func main() {
     // HTML conversion example.
     c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-    req := &gotenberg.HTMLRequest{
-        IndexFilePath: "index.html",
-        AssetFilePaths: []string{
-            "style.css",
-            "img.png",
-        },
-        Options: &gotenberg.HTMLOptions{
-            HeaderFilePath: "header.html",
-            FooterFilePath: "footer.html",
-            PaperSize:      gotenberg.A4,
-            PaperMargins:   gotenberg.NormalMargins,  
-        },
-    }
+    req, _ := gotenberg.NewHTMLRequest("index.html")
+    req.SetHeader("header.html")
+    req.SetFooter("footer.html")
+    req.SetAssets([]string{
+        "font.woff",
+        "img.gif",
+        "style.css",
+    })
+    req.SetPaperSize(A4)
+    req.SetMargins(NormalMargins)
+    req.SetLandscape(false)
     dest := "foo.pdf"
     c.Store(req, dest)
 }

pkg/client.go

@@ -59,18 +59,35 @@ type Client struct {
 // form values and form files to
 // the Gotenberg API.
 type Request interface {
-	validate() error
+	SetWebhookURL(webhookURL string)
 	getPostURL() string
 	getFormValues() map[string]string
 	getFormFiles() map[string]string
 }
 
+// ChromeRequest is a type for sending
+// conversion requests which will be
+// handle by Google Chrome.
+type ChromeRequest interface {
+	SetHeader(fpath string) error
+	SetFooter(fpath string) error
+	SetAssets(fpaths []string) error
+	SetPaperSize(size [2]float64)
+	SetMargins(margins [4]float64)
+	SetLandscape(isLandscape bool)
+}
+
+// UnoconvRequest is a type for sending
+// conversion requests which will be
+// handle by unoconv.
+type UnoconvRequest interface {
+	SetPaperSize(size [2]float64)
+	SetLandscape(landscape bool)
+}
+
 // Post sends a request to the Gotenberg API
 // and returns the response.
 func (c *Client) Post(req Request) (*http.Response, error) {
-	if err := req.validate(); err != nil {
-		return nil, err
-	}
 	body, contentType, err := multipartForm(req)
 	if err != nil {
 		return nil, err

pkg/doc.go

@@ -2,30 +2,7 @@
 Package gotenberg is a Go client for
 interacting with a Gotenberg API.
 
-For instance, if you want to convert HTML:
-
- import "github.com/thecodingmachine/gotenberg/pkg"
-
- func main() {
-     // HTML conversion example.
-     c := &gotenberg.Client{Hostname: "http://localhost:3000"}
-     req := &gotenberg.HTMLRequest{
-         IndexFilePath: "index.html",
-         AssetFilePaths: []string{
-             "style.css",
-             "img.png",
-         },
-         Options: &gotenberg.HTMLOptions{
-             HeaderFilePath: "header.html",
-             FooterFilePath: "footer.html",
-             PaperSize:      gotenberg.A4,
-             PaperMargins:   gotenberg.NormalMargins,
-         },
-     }
-     dest := "foo.pdf"
-     c.Store(req, dest)
- }
-
-For more complete usages, head to the https://thecodingmachine.gotenberg.github.io.
+For more complete usages, head to the documentation:
+https://thecodingmachine.gotenberg.github.io.
 */
 package gotenberg

pkg/html.go

@@ -9,64 +9,89 @@ import (
 // HTMLRequest facilitates HTML conversion
 // with the Gotenberg API.
 type HTMLRequest struct {
-	IndexFilePath  string
-	AssetFilePaths []string
-	Options        *HTMLOptions
+	indexFilePath  string
+	headerFilePath string
+	footerFilePath string
+	assetFilePaths []string
+	values         map[string]string
 }
 
-// HTMLOptions gathers all options
-// for HTML conversion with the Gotenberg API.
-type HTMLOptions struct {
-	WebHookURL     string
-	HeaderFilePath string
-	FooterFilePath string
-	PaperSize      [2]float64
-	PaperMargins   [4]float64
-	Landscape      bool
+// NewHTMLRequest create HTMLRequest.
+func NewHTMLRequest(indexFilePath string) (*HTMLRequest, error) {
+	if !fileExists(indexFilePath) {
+		return nil, fmt.Errorf("%s: index file does not exist", indexFilePath)
+	}
+	return &HTMLRequest{indexFilePath: indexFilePath, values: make(map[string]string)}, nil
 }
 
-func (html *HTMLRequest) validate() error {
-	if !fileExists(html.IndexFilePath) {
-		return fmt.Errorf("%s: index file does not exist", html.IndexFilePath)
-	}
-	if html.Options.HeaderFilePath != "" && !fileExists(html.Options.HeaderFilePath) {
-		return fmt.Errorf("%s: header file does not exist", html.Options.HeaderFilePath)
-	}
-	if html.Options.FooterFilePath != "" && !fileExists(html.Options.FooterFilePath) {
-		return fmt.Errorf("%s: footer file does not exist", html.Options.FooterFilePath)
+// SetWebhookURL sets webhookURL form field.
+func (html *HTMLRequest) SetWebhookURL(webhookURL string) {
+	html.values[webhookURL] = webhookURL
+}
+
+// SetHeader sets header form file.
+func (html *HTMLRequest) SetHeader(fpath string) error {
+	if !fileExists(fpath) {
+		return fmt.Errorf("%s: header file does not exist", fpath)
 	}
+	html.headerFilePath = fpath
 	return nil
 }
 
+// SetFooter sets footer form file.
+func (html *HTMLRequest) SetFooter(fpath string) error {
+	if !fileExists(fpath) {
+		return fmt.Errorf("%s: footer file does not exist", fpath)
+	}
+	html.footerFilePath = fpath
+	return nil
+}
+
+// SetAssets sets assets form files.
+func (html *HTMLRequest) SetAssets(fpaths []string) error {
+	for _, fpath := range fpaths {
+		if !fileExists(fpath) {
+			return fmt.Errorf("%s: file does not exist", fpath)
+		}
+	}
+	html.assetFilePaths = fpaths
+	return nil
+}
+
+// SetPaperSize sets paperWidth and paperHeight form fields.
+func (html *HTMLRequest) SetPaperSize(size [2]float64) {
+	html.values[paperWidth] = fmt.Sprintf("%f", size[0])
+	html.values[paperHeight] = fmt.Sprintf("%f", size[1])
+}
+
+// SetMargins sets marginTop, marginBottom,
+// marginLeft and marginRight form fields.
+func (html *HTMLRequest) SetMargins(margins [4]float64) {
+	html.values[marginTop] = fmt.Sprintf("%f", margins[0])
+	html.values[marginBottom] = fmt.Sprintf("%f", margins[1])
+	html.values[marginLeft] = fmt.Sprintf("%f", margins[2])
+	html.values[marginRight] = fmt.Sprintf("%f", margins[3])
+}
+
+// SetLandscape sets landscape form field.
+func (html *HTMLRequest) SetLandscape(isLandscape bool) {
+	html.values[landscape] = strconv.FormatBool(isLandscape)
+}
+
 func (html *HTMLRequest) getPostURL() string {
 	return "/convert/html"
 }
 
 func (html *HTMLRequest) getFormValues() map[string]string {
-	if html.Options == nil {
-		html.Options = &HTMLOptions{}
-	}
-	values := make(map[string]string)
-	values[webhookURL] = html.Options.WebHookURL
-	values[paperWidth] = fmt.Sprintf("%f", html.Options.PaperSize[0])
-	values[paperHeight] = fmt.Sprintf("%f", html.Options.PaperSize[1])
-	values[marginTop] = fmt.Sprintf("%f", html.Options.PaperMargins[0])
-	values[marginBottom] = fmt.Sprintf("%f", html.Options.PaperMargins[1])
-	values[marginLeft] = fmt.Sprintf("%f", html.Options.PaperMargins[2])
-	values[marginRight] = fmt.Sprintf("%f", html.Options.PaperMargins[3])
-	values[landscape] = strconv.FormatBool(html.Options.Landscape)
-	return values
+	return html.values
 }
 
 func (html *HTMLRequest) getFormFiles() map[string]string {
-	if html.Options == nil {
-		html.Options = &HTMLOptions{}
-	}
 	files := make(map[string]string)
-	files["index.html"] = html.IndexFilePath
-	files["header.html"] = html.Options.HeaderFilePath
-	files["footer.html"] = html.Options.FooterFilePath
-	for _, fpath := range html.AssetFilePaths {
+	files["index.html"] = html.indexFilePath
+	files["header.html"] = html.headerFilePath
+	files["footer.html"] = html.footerFilePath
+	for _, fpath := range html.assetFilePaths {
 		files[filepath.Base(fpath)] = fpath
 	}
 	return files
@@ -75,4 +100,5 @@ func (html *HTMLRequest) getFormFiles() map[string]string {
 // Compile-time checks to ensure type implements desired interfaces.
 var (
 	_ = Request(new(HTMLRequest))
+	_ = ChromeRequest(new(HTMLRequest))
 )

pkg/html_test.go

@@ -13,20 +13,21 @@ import (
 
 func TestHTML(t *testing.T) {
 	c := &Client{Hostname: "http://localhost:3000"}
-	req := &HTMLRequest{
-		IndexFilePath: test.HTMLTestFilePath(t, "index.html"),
-		AssetFilePaths: []string{
-			test.HTMLTestFilePath(t, "font.woff"),
-			test.HTMLTestFilePath(t, "img.gif"),
-			test.HTMLTestFilePath(t, "style.css"),
-		},
-		Options: &HTMLOptions{
-			HeaderFilePath: test.HTMLTestFilePath(t, "header.html"),
-			FooterFilePath: test.HTMLTestFilePath(t, "footer.html"),
-			PaperSize:      A4,
-			PaperMargins:   NormalMargins,
-		},
-	}
+	req, err := NewHTMLRequest(test.HTMLTestFilePath(t, "index.html"))
+	require.Nil(t, err)
+	err = req.SetHeader(test.HTMLTestFilePath(t, "header.html"))
+	require.Nil(t, err)
+	err = req.SetFooter(test.HTMLTestFilePath(t, "footer.html"))
+	require.Nil(t, err)
+	err = req.SetAssets([]string{
+		test.HTMLTestFilePath(t, "font.woff"),
+		test.HTMLTestFilePath(t, "img.gif"),
+		test.HTMLTestFilePath(t, "style.css"),
+	})
+	require.Nil(t, err)
+	req.SetPaperSize(A4)
+	req.SetMargins(NormalMargins)
+	req.SetLandscape(false)
 	dirPath, err := rand.Get()
 	require.Nil(t, err)
 	dest := fmt.Sprintf("%s/foo.pdf", dirPath)

pkg/markdown.go

@@ -9,73 +9,102 @@ import (
 // MarkdownRequest facilitates Markdown conversion
 // with the Gotenberg API.
 type MarkdownRequest struct {
-	IndexFilePath     string
-	MarkdownFilePaths []string
-	AssetFilePaths    []string
-	Options           *MarkdownOptions
+	indexFilePath     string
+	markdownFilePaths []string
+	headerFilePath    string
+	footerFilePath    string
+	assetFilePaths    []string
+	values            map[string]string
 }
 
-// MarkdownOptions gathers all options
-// for Markdown conversion with the Gotenberg API.
-type MarkdownOptions struct {
-	WebHookURL     string
-	HeaderFilePath string
-	FooterFilePath string
-	PaperSize      [2]float64
-	PaperMargins   [4]float64
-	Landscape      bool
-}
-
-func (markdown *MarkdownRequest) validate() error {
-	if !fileExists(markdown.IndexFilePath) {
-		return fmt.Errorf("%s: index file does not exist", markdown.IndexFilePath)
+// NewMarkdownRequest create MarkdownRequest.
+func NewMarkdownRequest(indexFilePath string, markdownFilePaths []string) (*MarkdownRequest, error) {
+	if !fileExists(indexFilePath) {
+		return nil, fmt.Errorf("%s: index file does not exist", indexFilePath)
 	}
-	if markdown.Options.HeaderFilePath != "" && !fileExists(markdown.Options.HeaderFilePath) {
-		return fmt.Errorf("%s: header file does not exist", markdown.Options.HeaderFilePath)
-	}
-	if markdown.Options.FooterFilePath != "" && !fileExists(markdown.Options.FooterFilePath) {
-		return fmt.Errorf("%s: footer file does not exist", markdown.Options.FooterFilePath)
-	}
-	for _, fpath := range markdown.MarkdownFilePaths {
+	for _, fpath := range markdownFilePaths {
 		if !fileExists(fpath) {
-			return fmt.Errorf("%s: markdown file does not exist", fpath)
+			return nil, fmt.Errorf("%s: markdown file does not exist", fpath)
 		}
 	}
+	return &MarkdownRequest{
+		indexFilePath:     indexFilePath,
+		markdownFilePaths: markdownFilePaths,
+		values:            make(map[string]string),
+	}, nil
+}
+
+// SetWebhookURL sets webhookURL form field.
+func (markdown *MarkdownRequest) SetWebhookURL(webhookURL string) {
+	markdown.values[webhookURL] = webhookURL
+}
+
+// SetHeader sets header form file.
+func (markdown *MarkdownRequest) SetHeader(fpath string) error {
+	if !fileExists(fpath) {
+		return fmt.Errorf("%s: header file does not exist", fpath)
+	}
+	markdown.headerFilePath = fpath
 	return nil
 }
 
+// SetFooter sets footer form file.
+func (markdown *MarkdownRequest) SetFooter(fpath string) error {
+	if !fileExists(fpath) {
+		return fmt.Errorf("%s: footer file does not exist", fpath)
+	}
+	markdown.footerFilePath = fpath
+	return nil
+}
+
+// SetAssets sets assets form files.
+func (markdown *MarkdownRequest) SetAssets(fpaths []string) error {
+	for _, fpath := range fpaths {
+		if !fileExists(fpath) {
+			return fmt.Errorf("%s: file does not exist", fpath)
+		}
+	}
+	markdown.assetFilePaths = fpaths
+	return nil
+}
+
+// SetPaperSize sets paperWidth and paperHeight form fields.
+func (markdown *MarkdownRequest) SetPaperSize(size [2]float64) {
+	markdown.values[paperWidth] = fmt.Sprintf("%f", size[0])
+	markdown.values[paperHeight] = fmt.Sprintf("%f", size[1])
+}
+
+// SetMargins sets marginTop, marginBottom,
+// marginLeft and marginRight form fields.
+func (markdown *MarkdownRequest) SetMargins(margins [4]float64) {
+	markdown.values[marginTop] = fmt.Sprintf("%f", margins[0])
+	markdown.values[marginBottom] = fmt.Sprintf("%f", margins[1])
+	markdown.values[marginLeft] = fmt.Sprintf("%f", margins[2])
+	markdown.values[marginRight] = fmt.Sprintf("%f", margins[3])
+}
+
+// SetLandscape sets landscape form field.
+func (markdown *MarkdownRequest) SetLandscape(isLandscape bool) {
+	markdown.values[landscape] = strconv.FormatBool(isLandscape)
+}
+
 func (markdown *MarkdownRequest) getPostURL() string {
 	return "/convert/markdown"
 }
 
 func (markdown *MarkdownRequest) getFormValues() map[string]string {
-	if markdown.Options == nil {
-		markdown.Options = &MarkdownOptions{}
-	}
-	values := make(map[string]string)
-	values[webhookURL] = markdown.Options.WebHookURL
-	values[paperWidth] = fmt.Sprintf("%f", markdown.Options.PaperSize[0])
-	values[paperHeight] = fmt.Sprintf("%f", markdown.Options.PaperSize[1])
-	values[marginTop] = fmt.Sprintf("%f", markdown.Options.PaperMargins[0])
-	values[marginBottom] = fmt.Sprintf("%f", markdown.Options.PaperMargins[1])
-	values[marginLeft] = fmt.Sprintf("%f", markdown.Options.PaperMargins[2])
-	values[marginRight] = fmt.Sprintf("%f", markdown.Options.PaperMargins[3])
-	values[landscape] = strconv.FormatBool(markdown.Options.Landscape)
-	return values
+	return markdown.values
 }
 
 func (markdown *MarkdownRequest) getFormFiles() map[string]string {
-	if markdown.Options == nil {
-		markdown.Options = &MarkdownOptions{}
-	}
 	files := make(map[string]string)
-	files["index.html"] = markdown.IndexFilePath
-	files["header.html"] = markdown.Options.HeaderFilePath
-	files["footer.html"] = markdown.Options.FooterFilePath
-	for _, fpath := range markdown.MarkdownFilePaths {
+	files["index.html"] = markdown.indexFilePath
+	files["header.html"] = markdown.headerFilePath
+	files["footer.html"] = markdown.footerFilePath
+	for _, fpath := range markdown.markdownFilePaths {
 		files[filepath.Base(fpath)] = fpath
 	}
-	for _, fpath := range markdown.AssetFilePaths {
+	for _, fpath := range markdown.assetFilePaths {
 		files[filepath.Base(fpath)] = fpath
 	}
 	return files
@@ -84,4 +113,5 @@ func (markdown *MarkdownRequest) getFormFiles() map[string]string {
 // Compile-time checks to ensure type implements desired interfaces.
 var (
 	_ = Request(new(MarkdownRequest))
+	_ = ChromeRequest(new(MarkdownRequest))
 )

pkg/markdown_test.go

@@ -13,25 +13,28 @@ import (
 
 func TestMarkdown(t *testing.T) {
 	c := &Client{Hostname: "http://localhost:3000"}
-	req := &MarkdownRequest{
-		IndexFilePath: test.MarkdownTestFilePath(t, "index.html"),
-		MarkdownFilePaths: []string{
+	req, err := NewMarkdownRequest(
+		test.MarkdownTestFilePath(t, "index.html"),
+		[]string{
 			test.MarkdownTestFilePath(t, "paragraph1.md"),
 			test.MarkdownTestFilePath(t, "paragraph2.md"),
 			test.MarkdownTestFilePath(t, "paragraph3.md"),
 		},
-		AssetFilePaths: []string{
-			test.HTMLTestFilePath(t, "font.woff"),
-			test.HTMLTestFilePath(t, "img.gif"),
-			test.HTMLTestFilePath(t, "style.css"),
-		},
-		Options: &MarkdownOptions{
-			HeaderFilePath: test.MarkdownTestFilePath(t, "header.html"),
-			FooterFilePath: test.MarkdownTestFilePath(t, "footer.html"),
-			PaperSize:      A4,
-			PaperMargins:   NormalMargins,
-		},
-	}
+	)
+	require.Nil(t, err)
+	err = req.SetHeader(test.MarkdownTestFilePath(t, "header.html"))
+	require.Nil(t, err)
+	err = req.SetFooter(test.MarkdownTestFilePath(t, "footer.html"))
+	require.Nil(t, err)
+	err = req.SetAssets([]string{
+		test.MarkdownTestFilePath(t, "font.woff"),
+		test.MarkdownTestFilePath(t, "img.gif"),
+		test.MarkdownTestFilePath(t, "style.css"),
+	})
+	require.Nil(t, err)
+	req.SetPaperSize(A4)
+	req.SetMargins(NormalMargins)
+	req.SetLandscape(false)
 	dirPath, err := rand.Get()
 	require.Nil(t, err)
 	dest := fmt.Sprintf("%s/foo.pdf", dirPath)

pkg/merge.go

@@ -8,24 +8,23 @@ import (
 // MergeRequest facilitates merging PDF
 // with the Gotenberg API.
 type MergeRequest struct {
-	FilePaths []string
-	Options   *MergeOptions
+	filePaths []string
+	values    map[string]string
 }
 
-// MergeOptions gathers all options
-// for merging PDF
-// with the Gotenberg API.
-type MergeOptions struct {
-	WebHookURL string
-}
-
-func (merge *MergeRequest) validate() error {
-	for _, fpath := range merge.FilePaths {
+// NewMergeRequest create MergeRequest.
+func NewMergeRequest(fpaths []string) (*MergeRequest, error) {
+	for _, fpath := range fpaths {
 		if !fileExists(fpath) {
-			return fmt.Errorf("%s: PDF file does not exist", fpath)
+			return nil, fmt.Errorf("%s: file does not exist", fpath)
 		}
 	}
-	return nil
+	return &MergeRequest{filePaths: fpaths, values: make(map[string]string)}, nil
+}
+
+// SetWebhookURL sets webhookURL form field.
+func (merge *MergeRequest) SetWebhookURL(webhookURL string) {
+	merge.values[webhookURL] = webhookURL
 }
 
 func (merge *MergeRequest) getPostURL() string {
@@ -33,17 +32,12 @@ func (merge *MergeRequest) getPostURL() string {
 }
 
 func (merge *MergeRequest) getFormValues() map[string]string {
-	if merge.Options == nil {
-		merge.Options = &MergeOptions{}
-	}
-	values := make(map[string]string)
-	values[webhookURL] = merge.Options.WebHookURL
-	return values
+	return merge.values
 }
 
 func (merge *MergeRequest) getFormFiles() map[string]string {
 	files := make(map[string]string)
-	for _, fpath := range merge.FilePaths {
+	for _, fpath := range merge.filePaths {
 		files[filepath.Base(fpath)] = fpath
 	}
 	return files

pkg/merge_test.go

@@ -13,12 +13,11 @@ import (
 
 func TestMerge(t *testing.T) {
 	c := &Client{Hostname: "http://localhost:3000"}
-	req := &MergeRequest{
-		FilePaths: []string{
-			test.PDFTestFilePath(t, "gotenberg.pdf"),
-			test.PDFTestFilePath(t, "gotenberg.pdf"),
-		},
-	}
+	req, err := NewMergeRequest([]string{
+		test.PDFTestFilePath(t, "gotenberg.pdf"),
+		test.PDFTestFilePath(t, "gotenberg.pdf"),
+	})
+	require.Nil(t, err)
 	dirPath, err := rand.Get()
 	require.Nil(t, err)
 	dest := fmt.Sprintf("%s/foo.pdf", dirPath)

pkg/office.go

@@ -3,29 +3,40 @@ package gotenberg
 import (
 	"fmt"
 	"path/filepath"
+	"strconv"
 )
 
 // OfficeRequest facilitates Office documents
 // conversion with the Gotenberg API.
 type OfficeRequest struct {
-	FilePaths []string
-	Options   *OfficeOptions
+	filePaths []string
+	values    map[string]string
 }
 
-// OfficeOptions gathers all options
-// for Office documents conversion
-// with the Gotenberg API.
-type OfficeOptions struct {
-	WebHookURL string
-}
-
-func (office *OfficeRequest) validate() error {
-	for _, fpath := range office.FilePaths {
+// NewOfficeRequest create OfficeRequest.
+func NewOfficeRequest(fpaths []string) (*OfficeRequest, error) {
+	for _, fpath := range fpaths {
 		if !fileExists(fpath) {
-			return fmt.Errorf("%s: office file does not exist", fpath)
+			return nil, fmt.Errorf("%s: file does not exist", fpath)
 		}
 	}
-	return nil
+	return &OfficeRequest{filePaths: fpaths, values: make(map[string]string)}, nil
+}
+
+// SetWebhookURL sets webhookURL form field.
+func (office *OfficeRequest) SetWebhookURL(webhookURL string) {
+	office.values[webhookURL] = webhookURL
+}
+
+// SetPaperSize sets paperWidth and paperHeight form fields.
+func (office *OfficeRequest) SetPaperSize(size [2]float64) {
+	office.values[paperWidth] = fmt.Sprintf("%f", size[0])
+	office.values[paperHeight] = fmt.Sprintf("%f", size[1])
+}
+
+// SetLandscape sets landscape form field.
+func (office *OfficeRequest) SetLandscape(isLandscape bool) {
+	office.values[landscape] = strconv.FormatBool(isLandscape)
 }
 
 func (office *OfficeRequest) getPostURL() string {
@@ -33,17 +44,12 @@ func (office *OfficeRequest) getPostURL() string {
 }
 
 func (office *OfficeRequest) getFormValues() map[string]string {
-	if office.Options == nil {
-		office.Options = &OfficeOptions{}
-	}
-	values := make(map[string]string)
-	values[webhookURL] = office.Options.WebHookURL
-	return values
+	return office.values
 }
 
 func (office *OfficeRequest) getFormFiles() map[string]string {
 	files := make(map[string]string)
-	for _, fpath := range office.FilePaths {
+	for _, fpath := range office.filePaths {
 		files[filepath.Base(fpath)] = fpath
 	}
 	return files
@@ -52,4 +58,5 @@ func (office *OfficeRequest) getFormFiles() map[string]string {
 // Compile-time checks to ensure type implements desired interfaces.
 var (
 	_ = Request(new(OfficeRequest))
+	_ = UnoconvRequest(new(OfficeRequest))
 )

pkg/office_test.go

@@ -13,11 +13,12 @@ import (
 
 func TestOffice(t *testing.T) {
 	c := &Client{Hostname: "http://localhost:3000"}
-	req := &OfficeRequest{
-		FilePaths: []string{
-			test.OfficeTestFilePath(t, "document.docx"),
-		},
-	}
+	req, err := NewOfficeRequest([]string{
+		test.OfficeTestFilePath(t, "document.docx"),
+	})
+	require.Nil(t, err)
+	req.SetPaperSize(A4)
+	req.SetLandscape(false)
 	dirPath, err := rand.Get()
 	require.Nil(t, err)
 	dest := fmt.Sprintf("%s/foo.pdf", dirPath)