Add multipart form file bind and add basic zip file functionalities (#394)

Vipul Rawat · aryanmehrotra · web-flow · commit 32277080fc17 · 2024-03-22T17:53:01.000+05:30
---------

Co-authored-by: Aryan Mehrotra &lt;44036979+aryanmehrotra@users.noreply.github.com&gt;
diff --git a/examples/http-server-using-redis/main_test.go b/examples/http-server-using-redis/main_test.go
@@ -43,6 +43,7 @@ func TestHTTPServerUsingRedis(t *testing.T) {
 
 	for i, tc := range tests {
 		req, _ := http.NewRequest(tc.method, host+tc.path, bytes.NewBuffer(tc.body))
+		req.Header.Set("content-type", "application/json")
 		c := http.Client{}
 		resp, err := c.Do(req)
 
@@ -63,7 +64,7 @@ func TestRedisSetHandler(t *testing.T) {
 	mock.ExpectSet("key", "value", 5*time.Minute).SetErr(testutil.CustomError{ErrorMessage: "redis get error"})
 
 	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
-
+	req.Header.Set("content-type", "application/json")
 	gofrReq := gofrHTTP.NewRequest(req)
 
 	ctx := &gofr.Context{Context: context.Background(),
@@ -87,6 +88,7 @@ func TestRedisPipelineHandler(t *testing.T) {
 	mock.ClearExpect()
 
 	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+	req.Header.Set("content-type", "application/json")
 
 	gofrReq := gofrHTTP.NewRequest(req)
 
diff --git a/examples/http-server/main_test.go b/examples/http-server/main_test.go
@@ -39,6 +39,8 @@ func TestIntegration_SimpleAPIServer(t *testing.T) {
 
 	for i, tc := range tests {
 		req, _ := http.NewRequest("GET", host+tc.path, nil)
+		req.Header.Set("content-type", "application/json")
+
 		c := http.Client{}
 		resp, err := c.Do(req)
 
diff --git a/examples/using-custom-metrics/main_test.go b/examples/using-custom-metrics/main_test.go
@@ -17,6 +17,7 @@ func TestIntegration(t *testing.T) {
 	c := http.Client{}
 
 	req, _ := http.NewRequest("POST", host+"/transaction", nil)
+	req.Header.Set("content-type", "application/json")
 
 	_, err := c.Do(req)
 	if err != nil {
diff --git a/examples/using-file-bind/configs/.env b/examples/using-file-bind/configs/.env
@@ -0,0 +1,4 @@
+APP_NAME=file-upload-api
+HTTP_PORT=8300
+
+LOG_LEVEL=DEBUG
diff --git a/examples/using-file-bind/main.go b/examples/using-file-bind/main.go
@@ -0,0 +1,65 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"mime/multipart"
+	"os"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/file"
+)
+
+func main() {
+	app := gofr.New()
+
+	app.POST("/upload", UploadHandler)
+
+	app.Run()
+}
+
+// Data is the struct that we are trying to bind files to
+type Data struct {
+	// The Compressed field is of type zip,
+	// the tag `upload` signifies the key for the form where the file is uploaded
+	// if the tag is not present, the field name would be taken as a key.
+	Compressed file.Zip `file:"upload"`
+
+	// The FileHeader determines the generic file format that we can get
+	// from the multipart form that gets parsed by the incoming http request
+	FileHeader *multipart.FileHeader `file:"a"`
+}
+
+func UploadHandler(c *gofr.Context) (interface{}, error) {
+	var d Data
+
+	// bind the multipart data into the variable d
+	err := c.Bind(&d)
+	if err != nil {
+		return nil, err
+	}
+
+	// create local copies of the zipped files in tmp folder
+	err = d.Compressed.CreateLocalCopies("tmp")
+	if err != nil {
+		return nil, err
+	}
+
+	defer os.RemoveAll("tmp")
+
+	f, err := d.FileHeader.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	defer f.Close()
+
+	// read the file content
+	content, err := io.ReadAll(f)
+	if err != nil {
+		return false, err
+	}
+
+	// return the number of compressed files recieved
+	return fmt.Sprintf("zipped files: %d, len of file `a`: %d", len(d.Compressed.Files), len(content)), nil
+}
diff --git a/examples/using-file-bind/main_test.go b/examples/using-file-bind/main_test.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"bytes"
+	"github.com/stretchr/testify/assert"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestMain_BindError(t *testing.T) {
+	const host = "http://localhost:8300"
+	go main()
+	time.Sleep(time.Second * 1)
+
+	c := http.Client{}
+
+	req, _ := http.NewRequest(http.MethodPost, host+"/upload", http.NoBody)
+	req.Header.Set("content-type", "multipart/form-data")
+	resp, err := c.Do(req)
+
+	assert.Equal(t, 500, resp.StatusCode)
+	assert.NoError(t, err)
+
+	buf, contentType := generateMultiPartBody(t)
+	req, _ = http.NewRequest(http.MethodPost, host+"/upload", buf)
+	req.Header.Set("content-type", contentType)
+
+	resp, err = c.Do(req)
+	assert.Equal(t, 200, resp.StatusCode)
+}
+
+func generateMultiPartBody(t *testing.T) (*bytes.Buffer, string) {
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+
+	f, err := os.Open("../../pkg/gofr/testutil/test.zip")
+	if err != nil {
+		t.Fatalf("Failed to open test.zip: %v", err)
+	}
+	defer f.Close()
+
+	zipPart, err := writer.CreateFormFile("upload", "test.zip")
+	if err != nil {
+		t.Fatalf("Failed to create form file: %v", err)
+	}
+
+	_, err = io.Copy(zipPart, f)
+	if err != nil {
+		t.Fatalf("Failed to write file to form: %v", err)
+	}
+
+	fileHeader, err := writer.CreateFormFile("a", "hello.txt")
+	if err != nil {
+		t.Fatalf("Failed to create form file: %v", err)
+	}
+
+	_, err = io.Copy(fileHeader, bytes.NewReader([]byte(`Test hello!`)))
+	if err != nil {
+		t.Fatalf("Failed to write file to form: %v", err)
+	}
+
+	// Close the multipart writer
+	writer.Close()
+
+	return &buf, writer.FormDataContentType()
+}
diff --git a/examples/using-migrations/main_test.go b/examples/using-migrations/main_test.go
@@ -34,6 +34,7 @@ func TestExampleMigration(t *testing.T) {
 
 	for i, tc := range tests {
 		req, _ := http.NewRequest(tc.method, host+tc.path, bytes.NewBuffer(tc.body))
+		req.Header.Set("content-type", "application/json")
 		c := http.Client{}
 		resp, err := c.Do(req)
 
diff --git a/examples/using-publisher/main_test.go b/examples/using-publisher/main_test.go
@@ -51,6 +51,7 @@ func TestExamplePublisher(t *testing.T) {
 
 	for i, tc := range testCases {
 		req, _ := http.NewRequest(http.MethodPost, host+tc.path, bytes.NewBuffer(tc.body))
+		req.Header.Set("content-type", "application/json")
 		resp, err := c.Do(req)
 
 		assert.Equal(t, tc.expectedStatusCode, resp.StatusCode, "TEST[%d], Failed.\n%s", i, tc.desc)
@@ -94,6 +95,7 @@ func TestExamplePublisherError(t *testing.T) {
 
 	for i, tc := range testCases {
 		req, _ := http.NewRequest(http.MethodPost, host+tc.path, bytes.NewBuffer(tc.body))
+		req.Header.Set("content-type", "application/json")
 		resp, err := c.Do(req)
 
 		assert.Equal(t, tc.expectedStatusCode, resp.StatusCode, "TEST[%d], Failed.\n%s", i, tc.desc)
diff --git a/pkg/gofr/context_test.go b/pkg/gofr/context_test.go
@@ -16,6 +16,8 @@ import (
 func Test_newContextSuccess(t *testing.T) {
 	httpRequest, err := http.NewRequestWithContext(context.Background(),
 		http.MethodPost, "/test", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+	httpRequest.Header.Set("content-type", "application/json")
+
 	if err != nil {
 		t.Fatalf("unable to create request with context %v", err)
 	}
diff --git a/pkg/gofr/file/file.go b/pkg/gofr/file/file.go
@@ -0,0 +1,24 @@
+package file
+
+type file struct {
+	name    string
+	content []byte
+	size    int64
+	isDir   bool
+}
+
+func (f file) GetName() string {
+	return f.name
+}
+
+func (f file) GetSize() int64 {
+	return f.size
+}
+
+func (f file) Bytes() []byte {
+	return f.content
+}
+
+func (f file) IsDir() bool {
+	return f.isDir
+}
diff --git a/pkg/gofr/file/file_test.go b/pkg/gofr/file/file_test.go
@@ -0,0 +1,30 @@
+package file
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFile(t *testing.T) {
+	// Create a sample file
+	content := []byte("This is a test file.")
+	f := file{
+		name:    "test.txt",
+		content: content,
+		size:    int64(len(content)),
+		isDir:   false,
+	}
+
+	// Test GetName method
+	assert.Equal(t, "test.txt", f.GetName(), "File name should be 'test.txt'")
+
+	// Test GetSize method
+	assert.Equal(t, int64(20), f.GetSize(), "File size should be 20 bytes")
+
+	// Test Bytes method
+	assert.Equal(t, content, f.Bytes(), "File content should match")
+
+	// Test IsDir method
+	assert.False(t, f.IsDir(), "File should not be a directory")
+}
diff --git a/pkg/gofr/file/zip.go b/pkg/gofr/file/zip.go
@@ -0,0 +1,105 @@
+package file
+
+import (
+	"archive/zip"
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+const (
+	maxFileSize = 100 * 1024 * 1024 // 100MB
+)
+
+var (
+	errMaxFileSize = errors.New("uncompressed file is greater than file size limit of 100MBs")
+)
+
+type Zip struct {
+	Files map[string]file
+}
+
+func NewZip(content []byte) (*Zip, error) {
+	reader := bytes.NewReader(content)
+
+	zipReader, err := zip.NewReader(reader, int64(len(content)))
+	if err != nil {
+		return nil, err
+	}
+	// Create a map to store file contents
+	files := make(map[string]file)
+
+	for _, zrf := range zipReader.File {
+		f, err := zrf.Open()
+		if err != nil {
+			return nil, err
+		}
+
+		buf, err := copyToBuffer(f, zrf.UncompressedSize64)
+		if err != nil {
+			return nil, err
+		}
+
+		files[zrf.Name] = file{
+			name:    zrf.Name,
+			content: buf.Bytes(),
+			isDir:   zrf.FileInfo().IsDir(),
+			size:    zrf.FileInfo().Size(),
+		}
+
+		f.Close()
+	}
+
+	return &Zip{Files: files}, nil
+}
+
+func (z *Zip) CreateLocalCopies(dest string) error {
+	dest = filepath.Clean(dest)
+	for _, zf := range z.Files {
+		destPath := filepath.Join(dest, zf.name)
+
+		if zf.isDir {
+			err := os.MkdirAll(destPath, os.ModeDir)
+			if err != nil {
+				return err
+			}
+
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(destPath), os.ModePerm); err != nil {
+			return err
+		}
+
+		destFile, err := os.Create(destPath)
+		if err != nil {
+			return err
+		}
+
+		if _, err := io.Copy(destFile, bytes.NewReader(zf.content)); err != nil {
+			return err
+		}
+
+		destFile.Close()
+	}
+
+	return nil
+}
+
+func copyToBuffer(f io.ReadCloser, size uint64) (*bytes.Buffer, error) {
+	// check that max file size of unzipped file is less than 100MB
+	if size > maxFileSize {
+		return nil, errMaxFileSize
+	}
+
+	buf := new(bytes.Buffer)
+	if n, err := io.CopyN(buf, f, maxFileSize); err != nil && err != io.EOF && uint64(n) < size {
+		f.Close()
+
+		return nil, err
+	}
+
+	return buf, nil
+}
diff --git a/pkg/gofr/file/zip_test.go b/pkg/gofr/file/zip_test.go
diff --git a/pkg/gofr/http/multipartFileBind.go b/pkg/gofr/http/multipartFileBind.go
diff --git a/pkg/gofr/http/multipartFileBind_test.go b/pkg/gofr/http/multipartFileBind_test.go
diff --git a/pkg/gofr/http/request.go b/pkg/gofr/http/request.go
diff --git a/pkg/gofr/http/request_test.go b/pkg/gofr/http/request_test.go
diff --git a/pkg/gofr/testutil/test.zip b/pkg/gofr/testutil/test.zip

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,8 @@ import (`
`16`	`16`	`func Test_newContextSuccess(t *testing.T) {`
`17`	`17`	`httpRequest, err := http.NewRequestWithContext(context.Background(),`
`18`	`18`	http.MethodPost, "/test", bytes.NewBuffer([]byte(`{"key":"value"}`)))
	`19`	`+ httpRequest.Header.Set("content-type", "application/json")`
	`20`	`+`
`19`	`21`	`if err != nil {`
`20`	`22`	`t.Fatalf("unable to create request with context %v", err)`
`21`	`23`	`}`