Add tests for core template ubuntu-jammy and invalid image. Better errs.

Author: cruizba

pkg/core/image/coretmpl_test.go

@@ -1,14 +1,70 @@
 package image
 
 import (
-	"fmt"
 	"testing"
 )
 
-func BasicTestCoreTemplateOSValidImage(t *testing.T) {
+func TestCoreTemplateUbuntuJammy(t *testing.T) {
 	validCoreTemplateOS, err := newCoreTemplateOS("ubuntu-jammy")
 	if err != nil {
 		t.Errorf("Error creating core template OS: %s", err)
 	}
-	fmt.Println(validCoreTemplateOS)
+	if validCoreTemplateOS.name != "ubuntu-jammy" {
+		t.Errorf("Expected core template OS name to be ubuntu-jammy, got %s", validCoreTemplateOS.name)
+	}
+	if len(validCoreTemplateOS.rootScripts) == 0 {
+		t.Errorf("Expected core template OS rootScripts to be non-empty, got empty")
+	}
+	// Check that all predefined root scripts exist in the FS
+	for _, fileDir := range validCoreTemplateOS.rootScripts {
+		_, err := coreTemplatesFS.ReadFile(fileDir)
+		if err != nil {
+			t.Errorf("Error reading root script %s: %s", fileDir, err)
+		}
+	}
+
+	if len(validCoreTemplateOS.patches) == 0 {
+		t.Errorf("Expected core template OS patches to be non-empty, got empty")
+	}
+
+	if validCoreTemplateOS.dockerfile == "" {
+		t.Errorf("Expected core template OS dockerfile to be non-empty, got empty")
+	}
+	_, err = coreTemplatesFS.ReadFile(validCoreTemplateOS.dockerfile)
+	if err != nil {
+		t.Errorf("Error reading Dockerfile %s: %s", validCoreTemplateOS.dockerfile, err)
+	}
+
+	if len(validCoreTemplateOS.commonModules) == 0 {
+		t.Errorf("Expected core template OS commonModules to be non-empty, got empty")
+	}
+
+	for module, fileDir := range validCoreTemplateOS.commonModules {
+		_, err := coreTemplatesFS.ReadFile(fileDir)
+		if err != nil {
+			t.Errorf("Error reading common module %s: %s", module, err)
+		}
+	}
+
+	if len(validCoreTemplateOS.modules) == 0 {
+		t.Errorf("Expected core template OS modules to be non-empty, got empty")
+	}
+
+	for module, fileDir := range validCoreTemplateOS.modules {
+		_, err := coreTemplatesFS.ReadFile(fileDir)
+		if err != nil {
+			t.Errorf("Error reading module %s: %s", module, err)
+		}
+	}
+
+}
+
+func TestCoreTemplateInvalidImage(t *testing.T) {
+	_, err := newCoreTemplateOS("nonexistent-os")
+	if err == nil {
+		t.Errorf("Expected error creating core template OS, got nil")
+	}
+	if _, ok := err.(*ErrCoreTemplateOSNotFound); !ok {
+		t.Errorf("Expected error type ErrCoreTemplateOSNotFound, got %T", err)
+	}
 }

pkg/core/image/errors.go

@@ -2,37 +2,46 @@ package image
 
 import "desktopus/pkg/core/utils"
 
-// Specific error types
+// Specific error types embedding DesktopusError
 type ErrCoreTemplateReadingIndexMeta struct {
-	utils.DesktopusError
+	*utils.DesktopusError
+}
+
+func (e *ErrCoreTemplateReadingIndexMeta) Error() string {
+	return e.DesktopusError.Error()
 }
 
 type ErrCoreTemplateReadingCoreMeta struct {
-	utils.DesktopusError
+	*utils.DesktopusError
+}
+
+func (e *ErrCoreTemplateReadingCoreMeta) Error() string {
+	return e.DesktopusError.Error()
 }
 
 type ErrCoreTemplateOSNotFound struct {
-	utils.DesktopusError
+	*utils.DesktopusError
+}
+
+func (e *ErrCoreTemplateOSNotFound) Error() string {
+	return e.DesktopusError.Error()
 }
 
 // Functions to create specific errors with parameters
 func newErrCoreTemplateReadingIndexMeta(errMessage string) error {
-	return &utils.DesktopusError{
-		Message: "error reading core template index metadata: %s",
-		Params:  []interface{}{errMessage},
+	return &ErrCoreTemplateReadingIndexMeta{
+		DesktopusError: utils.NewDesktopusError("error reading core templates index metadata: %s", errMessage),
 	}
 }
 
 func newErrCoreTemplateReadingCoreMeta(os string, errMessage string) error {
-	return &utils.DesktopusError{
-		Message: "error reading OS %s metadata: %s",
-		Params:  []interface{}{os, errMessage},
+	return &ErrCoreTemplateReadingCoreMeta{
+		DesktopusError: utils.NewDesktopusError("error reading OS %s metadata: %s", os, errMessage),
 	}
 }
 
 func newErrCoreTemplateOSNotFound(name string) error {
-	return &utils.DesktopusError{
-		Message: "error: OS %s not found in core templates",
-		Params:  []interface{}{name},
+	return &ErrCoreTemplateOSNotFound{
+		DesktopusError: utils.NewDesktopusError("error: OS %s not found in core templates", name),
 	}
 }

pkg/core/utils/error.go

@@ -4,13 +4,21 @@ import (
 	"fmt"
 )
 
-// BaseError is the base struct for all custom errors
+// DesktopusError is the base struct for all custom errors
 type DesktopusError struct {
 	Message string
 	Params  []interface{}
 }
 
-// Error implements the error interface for BaseError
+// Error implements the error interface for DesktopusError
 func (e *DesktopusError) Error() string {
 	return fmt.Sprintf(e.Message, e.Params...)
 }
+
+// NewDesktopusError creates a new DesktopusError with the given message and parameters
+func NewDesktopusError(message string, params ...interface{}) *DesktopusError {
+	return &DesktopusError{
+		Message: message,
+		Params:  params,
+	}
+}