Refactor and test AddAttachment (#46)

datasetIngestor/addAttachment.go

@@ -11,27 +11,28 @@ import (
 	"strings"
 )
 
-func AddAttachment(client *http.Client, APIServer string, datasetId string, metaDataDataset map[string]interface{}, accessToken string, attachmentFile string, caption string) {
-	// turn image into base64 structure:
+func ReadAndEncodeImage(attachmentFile string) (string, error) {
 	imgFile, err := os.Open(attachmentFile)
 	if err != nil {
-		log.Fatalf("Can not open attachment file %v \n", attachmentFile)
+		return "", err
 	}
-
 	defer imgFile.Close()
-
+	
 	// create a new buffer base on file size
 	fInfo, _ := imgFile.Stat()
 	var size int64 = fInfo.Size()
 	buf := make([]byte, size)
-
+	
 	// read file content into buffer
 	fReader := bufio.NewReader(imgFile)
 	fReader.Read(buf)
-
+	
 	// convert the buffer bytes to base64 string
 	imgBase64Str := base64.StdEncoding.EncodeToString(buf)
+	return imgBase64Str, nil
+}
 
+func CreateMetadataMap(datasetId string, caption string, metaDataDataset map[string]interface{}, imgBase64Str string) (map[string]interface{}, error) {
 	// assemble json structure
 	var metaDataMap map[string]interface{}
 	metaDataMap = make(map[string]interface{})
@@ -47,13 +48,26 @@ func AddAttachment(client *http.Client, APIServer string, datasetId string, meta
 			metaDataMap["accessGroups"], _ = accessGroups.([]interface{})
 		}
 	}
+	return metaDataMap, nil
+}
 
+func AddAttachment(client *http.Client, APIServer string, datasetId string, metaDataDataset map[string]interface{}, accessToken string, attachmentFile string, caption string) {
+	imgBase64Str, err := ReadAndEncodeImage(attachmentFile)
+	if err != nil {
+		log.Fatalf("Can not open attachment file %v \n", attachmentFile)
+	}
+
+	metaDataMap, err := CreateMetadataMap(datasetId, caption, metaDataDataset, imgBase64Str)
+	if err != nil {
+		log.Fatal("Connect serialize meta data map:", metaDataMap)
+	}
+
 	bm, err := json.Marshal(metaDataMap)
 	if err != nil {
 		log.Fatal("Connect serialize meta data map:", metaDataMap)
 	}
 	myurl := APIServer + "/Datasets/" + strings.Replace(datasetId, "/", "%2F", 1) + "/attachments?access_token=" + accessToken
-
+	
 	req, err := http.NewRequest("POST", myurl, bytes.NewBuffer(bm))
 	if err != nil {
 		log.Fatal(err)

datasetIngestor/addAttachment_test.go

@@ -0,0 +1,111 @@
+package datasetIngestor
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"encoding/base64"
+)
+
+//Check whether the function is called without a panic
+func TestAddAttachment(t *testing.T) {
+	// Create a mock server
+	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer mockServer.Close()
+
+	client := &http.Client{}
+	APIServer := mockServer.URL
+	datasetId := "testDatasetId"
+	metaDataDataset := make(map[string]interface{})
+	accessToken := "testAccessToken"
+	caption := "testCaption"
+
+	// Create a temporary file
+	tempFile, err := os.CreateTemp("", "testAttachmentFile")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tempFile.Name()) // clean up
+
+	attachmentFile := tempFile.Name()
+
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("The code panicked with %v", r)
+		}
+	}()
+
+	AddAttachment(client, APIServer, datasetId, metaDataDataset, accessToken, attachmentFile, caption)
+}
+
+func TestReadAndEncodeImage(t *testing.T) {
+	// Create a temporary file
+	tempFile, err := os.CreateTemp("", "testImageFile.jpg")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tempFile.Name()) // clean up
+
+	imageFile := tempFile.Name()
+
+	encodedStr, err := ReadAndEncodeImage(imageFile)
+	if err != nil {
+		t.Errorf("ReadAndEncodeImage returned an error: %v", err)
+	}
+
+	// Check if the output is a valid base64 string
+	_, err = base64.StdEncoding.DecodeString(encodedStr)
+	if err != nil {
+			t.Errorf("ReadAndEncodeImage returned an invalid base64 string: %v", err)
+	}
+}
+
+func TestCreateMetadataMap(t *testing.T) {
+	datasetId := "testDatasetId"
+	caption := "testCaption"
+	metaDataDataset := make(map[string]interface{})
+
+	// Create a temporary file
+	tempFile, err := os.CreateTemp("", "testImageFile")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tempFile.Name()) // clean up
+
+	imageFile := tempFile.Name()
+
+	imgBase64Str, err := ReadAndEncodeImage(imageFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	metaDataMap, err := CreateMetadataMap(datasetId, caption, metaDataDataset, imgBase64Str)
+	if err != nil {
+		t.Errorf("CreateMetadataMap returned an error: %v", err)
+	}
+
+	// Check if the map contains the correct keys and values
+	if metaDataMap["thumbnail"] != "data:image/jpeg;base64,"+imgBase64Str {
+		t.Errorf("Incorrect thumbnail: got %v, want %v", metaDataMap["thumbnail"], "data:image/jpeg;base64,"+imgBase64Str)
+	}
+
+	if metaDataMap["caption"] != caption {
+		t.Errorf("Incorrect caption: got %v, want %v", metaDataMap["caption"], caption)
+	}
+
+	if metaDataMap["datasetId"] != datasetId {
+		t.Errorf("Incorrect datasetId: got %v, want %v", metaDataMap["datasetId"], datasetId)
+	}
+
+	// Check if the map does not contain the keys "ownerGroup" and "accessGroups"
+	if _, ok := metaDataMap["ownerGroup"]; ok {
+		t.Errorf("Map contains unexpected key: ownerGroup")
+	}
+
+	if _, ok := metaDataMap["accessGroups"]; ok {
+		t.Errorf("Map contains unexpected key: accessGroups")
+	}
+}