more tests + small refactoring (no more App struct)

app/converter/file/file.go

@@ -0,0 +1,152 @@
+// Package file implements a solution for handling files coming from a request.
+package file
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	ghttp "github.com/gulien/gotenberg/app/http"
+
+	"github.com/satori/go.uuid"
+)
+
+// File represents a file which has been created
+// from a request.
+type File struct {
+	// Type is the kind of file.
+	Type Type
+	// Path is the file path.
+	Path string
+}
+
+// Type represents what kind of file we're dealing with.
+type Type uint32
+
+const (
+	// PDFType represents a... PDF file.
+	PDFType Type = iota
+	// HTMLType represents an... HTML file.
+	HTMLType
+	// OfficeType represents an... Office document.
+	OfficeType
+)
+
+// NewFile creates a file in the considered directory.
+// Returns a *File instance or an error if something bad happened.
+func NewFile(workingDir string, r io.Reader) (*File, error) {
+	f := &File{
+		Path: MakeFilePath(workingDir),
+	}
+
+	file, err := os.Create(f.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	_, err = io.Copy(file, r)
+	if err != nil {
+		return nil, err
+	}
+
+	// resets the read pointer.
+	file.Seek(0, 0)
+
+	t, err := findFileType(file)
+	if err != nil {
+		return nil, err
+	}
+
+	f.Type = t
+
+	f, err = reworkFilePath(workingDir, f)
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+// MakeFilePath is a simple helper which generates a random file name
+// and associates it with the considered directory to make a path.
+func MakeFilePath(workingDir string) string {
+	return fmt.Sprintf("%s%s", workingDir, uuid.NewV4().String())
+}
+
+// filesTypes associates a content type with its file kind counterpart.
+var filesTypes = map[ghttp.ContentType]Type{
+	ghttp.PDFContentType:         PDFType,
+	ghttp.HTMLContentType:        HTMLType,
+	ghttp.OctetStreamContentType: OfficeType,
+	ghttp.ZipContentType:         OfficeType,
+}
+
+type fileTypeNotFound struct{}
+
+func (e *fileTypeNotFound) Error() string {
+	return "The file type was not found for the given 'Content-Type'"
+}
+
+// findFileType tries to detect what kind of file is the given file.
+func findFileType(f *os.File) (Type, error) {
+	ct, err := ghttp.SniffContentType(f)
+	if err != nil {
+		return 999, err
+	}
+
+	t, ok := filesTypes[ct]
+	if !ok {
+		return 999, &fileTypeNotFound{}
+	}
+
+	return t, nil
+}
+
+// Ext represents a file extension.
+type Ext string
+
+const (
+	// PDFExt represents a... PDF extension.
+	PDFExt Ext = ".pdf"
+	// HTMLExt represents an... HTML extension.
+	HTMLExt Ext = ".html"
+	// OfficeExt is a empty string, as Office documents
+	// have a lot of different extensions (.docx, .doc and so on).
+	OfficeExt Ext = ""
+)
+
+// filesExtensions associates a kind of file with its extension.
+var filesExtensions = map[Type]Ext{
+	PDFType:    PDFExt,
+	HTMLType:   HTMLExt,
+	OfficeType: OfficeExt,
+}
+
+type fileExtNotFound struct{}
+
+func (e *fileExtNotFound) Error() string {
+	return "The file extension was not found for the given file type"
+}
+
+// reworkFilePath renames a file in the considered directory and adds its extension.
+func reworkFilePath(workingDir string, f *File) (*File, error) {
+	ext, ok := filesExtensions[f.Type]
+	if !ok {
+		return nil, &fileExtNotFound{}
+	}
+
+	if ext != OfficeExt {
+		newPath := fmt.Sprintf("%s%s", MakeFilePath(workingDir), ext)
+
+		err := os.Rename(f.Path, newPath)
+		if err != nil {
+			return nil, err
+		}
+
+		f.Path = newPath
+	}
+
+	return f, nil
+}

app/converter/file/file_test.go

@@ -0,0 +1,52 @@
+package file
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestNewFile(t *testing.T) {
+	workingDir := "test"
+	os.Mkdir(workingDir, 0666)
+
+	// case 1: uses an empty reader.
+	if _, err := NewFile(workingDir, new(bytes.Buffer)); err == nil {
+		t.Error("File should not have been instantiated!")
+	}
+
+	// case 2: uses a reader from a wrong file type.
+	path, _ := filepath.Abs("../../../_tests/configurations/gotenberg.yml")
+	r, _ := os.Open(path)
+	defer r.Close()
+	if _, err := NewFile(workingDir, r); err == nil {
+		t.Error("File should not have been instantiated!")
+	}
+
+	// case 3: uses a reader from a correct file type.
+	path, _ = filepath.Abs("../../../_tests/file.pdf")
+	r, _ = os.Open(path)
+	defer r.Close()
+	if _, err := NewFile(workingDir, r); err != nil {
+		t.Error("File should have been instantiated!")
+	}
+
+	os.RemoveAll(workingDir)
+}
+
+func TestReworkFilePath(t *testing.T) {
+	workingDir := "test"
+	os.Mkdir(workingDir, 0666)
+
+	f := &File{
+		Path: MakeFilePath(workingDir),
+		Type: 999,
+	}
+
+	if _, err := reworkFilePath(workingDir, f); err == nil {
+		t.Error("It should not have been able to found the file extension!")
+	}
+
+	os.RemoveAll(workingDir)
+}