feat: Implement unit tests for setIncludeExtensionType (#12)

Implement unit tests for the function setIncludeTypeExtensions.
Add unit tests for IncludeType Set method

---------

Co-authored-by: Hugo Sacilotto <[email protected]>

Author: 2 people

internal/cliFlags/stringlist_test.go

@@ -1,6 +1,12 @@
 package cliflags
 
-import "testing"
+import (
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/simulot/immich-go/internal/filetypes"
+)
 
 func TestStringList_Include(t *testing.T) {
 	tests := []struct {
@@ -95,3 +101,150 @@ func TestStringList_Exclude(t *testing.T) {
 		})
 	}
 }
+
+func TestStringList_IncludeType(t *testing.T) {
+	var photoTypes []string
+	var videoTypes []string
+
+	for ext, mediaType := range filetypes.DefaultSupportedMedia {
+		switch mediaType {
+		case filetypes.TypeImage:
+			photoTypes = append(photoTypes, ext)
+		case filetypes.TypeVideo:
+			videoTypes = append(videoTypes, ext)
+		case filetypes.TypeSidecar:
+			// Sidecar should always be included in the extensions if it's main picture gets added.
+			videoTypes = append(videoTypes, ext)
+			photoTypes = append(photoTypes, ext)
+		default:
+			continue
+		}
+	}
+
+	tests := []struct {
+		name         string
+		includeType  string
+		expectedExts ExtensionList
+	}{
+		{
+			name:         "Include only images, no videos",
+			includeType:  "image",
+			expectedExts: ExtensionList(slices.Clone(photoTypes)),
+		},
+		{
+			name:         "Include only videos no, photos",
+			includeType:  "video",
+			expectedExts: ExtensionList(slices.Clone(videoTypes)),
+		},
+	}
+
+	for _, tt := range tests {
+		flags := InclusionFlags{
+			IncludedExtensions: ExtensionList{},
+			IncludedType:       IncludeType(strings.ToUpper(tt.includeType)),
+		}
+
+		t.Run(tt.name, func(t *testing.T) {
+			setIncludeTypeExtensions(&flags)
+
+			for _, ext := range flags.IncludedExtensions {
+				if len(tt.expectedExts) == 0 {
+					t.Errorf("Expected was empty but still gave %v\n", ext)
+				} else if !slices.Contains(tt.expectedExts, ext) {
+					t.Errorf("Extension: &v missing in %v %v\n", ext, tt.expectedExts)
+				}
+			}
+		})
+	}
+}
+
+func TestStringList_IncludeType_Set(t *testing.T) {
+	validTests := []struct {
+		name                string
+		str                 string
+		expectedIncludeType IncludeType
+	}{
+		{
+			name:                "Lower case video type",
+			str:                 "video",
+			expectedIncludeType: IncludeVideo,
+		},
+		{
+			name:                "Upper case video type",
+			str:                 "VIDEO",
+			expectedIncludeType: IncludeVideo,
+		},
+		{
+			name:                "Mixed casing video type",
+			str:                 "viDEo",
+			expectedIncludeType: IncludeVideo,
+		},
+		{
+			name:                "Leading and trailing whitespace video type",
+			str:                 "  VIDEO     ",
+			expectedIncludeType: IncludeVideo,
+		},
+		{
+			name:                "Lower case image type",
+			str:                 "image",
+			expectedIncludeType: IncludeImage,
+		},
+		{
+			name:                "Upper case image type",
+			str:                 "IMAGE",
+			expectedIncludeType: IncludeImage,
+		},
+		{
+			name:                "Mixed casing image type",
+			str:                 "ImaGe",
+			expectedIncludeType: IncludeImage,
+		},
+		{
+			name:                "Leading and trailing whitespace image type",
+			str:                 "  IMAGE     ",
+			expectedIncludeType: IncludeImage,
+		},
+	}
+
+	for _, tt := range validTests {
+		var includeType IncludeType
+
+		t.Run(tt.name, func(t *testing.T) {
+			err := includeType.Set(tt.str)
+
+			if err != nil {
+				t.Errorf("Expected no error but error is: %v", err)
+			}
+
+			if includeType != tt.expectedIncludeType {
+				t.Errorf("IncludeType was expected to be %v, but is %v", tt.expectedIncludeType, includeType)
+			}
+		})
+	}
+
+	testsThatShouldFail := []struct {
+		name string
+		str  string
+	}{
+		{
+			name: "Empty string",
+			str:  "",
+		},
+		{
+			name: "Invalid string",
+			str:  "imagevideo",
+		},
+	}
+
+	for _, tt := range testsThatShouldFail {
+		var includeType IncludeType
+
+		t.Run(tt.name, func(t *testing.T) {
+			err := includeType.Set(tt.str)
+
+			if err == nil {
+				t.Errorf("The error was expected to be defined but is nil")
+			}
+		})
+	}
+}