test add test cases to increase coverage

Author: nicholas-fedor

internal/app/tests/run_test.go

@@ -16,8 +16,6 @@ var (
 )
 
 func TestRun(t *testing.T) {
-	t.Parallel()
-
 	tests := []struct {
 		name       string
 		configPort string
@@ -38,16 +36,13 @@ func TestRun(t *testing.T) {
 			name:       "Config load error",
 			configPort: ":0",
 			configErr:  ErrConfigLoadFailed,
-			setupErr:   nil,
-			runErr:     nil,
 			wantErr:    true,
 		},
 		{
 			name:       "Router setup error",
 			configPort: ":0",
 			configErr:  nil,
 			setupErr:   ErrSetupFailed,
-			runErr:     nil,
 			wantErr:    true,
 		},
 		{
@@ -58,86 +53,47 @@ func TestRun(t *testing.T) {
 			runErr:     ErrRouterRunFailed,
 			wantErr:    true,
 		},
-		{
-			name:       "Default NewApp run",
-			configPort: ":8082",
-			configErr:  nil,
-			setupErr:   nil,
-			runErr:     ErrRouterRunFailed,
-			wantErr:    true,
-		},
-		{
-			name:       "SetupRouter fails",
-			configPort: ":0",
-			configErr:  nil,
-			setupErr:   ErrSetupFailed,
-			runErr:     nil,
-			wantErr:    true,
-		},
-		{
-			name:       "RunEngine fails explicitly",
-			configPort: ":0",
-			configErr:  nil,
-			setupErr:   nil,
-			runErr:     ErrRouterRunFailed,
-			wantErr:    true,
-		},
 	}
 
 	for _, testCase := range tests {
 		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-			runTestCase(t, testCase)
-		})
-	}
-}
-
-// runTestCase executes a single TestRun case with setup and assertions.
-func runTestCase(t *testing.T, testCase struct {
-	name       string
-	configPort string
-	configErr  error
-	setupErr   error
-	runErr     error
-	wantErr    bool
-}) {
-	t.Helper()
+			appInstance := app.NewApp() // Covers lines 25-29
+			origLoadConfig := appInstance.LoadConfig
+			origSetupRouter := appInstance.SetupRouter
+			origRunEngine := appInstance.RunEngine
 
-	appInstance := app.NewApp()
-	origLoadConfig := appInstance.LoadConfig
-	origSetupRouter := appInstance.SetupRouter
-	origRunEngine := appInstance.RunEngine
+			defer func() {
+				appInstance.LoadConfig = origLoadConfig
+				appInstance.SetupRouter = origSetupRouter
+				appInstance.RunEngine = origRunEngine
+			}()
 
-	defer func() {
-		appInstance.LoadConfig = origLoadConfig
-		appInstance.SetupRouter = origSetupRouter
-		appInstance.RunEngine = origRunEngine
-	}()
+			appInstance.LoadConfig = func(_ string) (server.Config, error) {
+				if testCase.configErr != nil {
+					return server.Config{}, testCase.configErr // Covers 35-39
+				}
 
-	appInstance.LoadConfig = func(_ string) (server.Config, error) {
-		if testCase.configErr != nil {
-			return server.Config{}, testCase.configErr
-		}
+				return server.Config{
+					Port:           testCase.configPort,
+					StaticDir:      "/tmp/static",
+					TrustedProxies: []string{"127.0.0.1"},
+				}, nil
+			}
 
-		return server.Config{
-			Port:           testCase.configPort,
-			StaticDir:      "/tmp/static",
-			TrustedProxies: []string{"127.0.0.1"},
-		}, nil
-	}
+			appInstance.SetupRouter = func(_ server.Config, _, _ gin.HandlerFunc) (*gin.Engine, error) {
+				if testCase.setupErr != nil {
+					return nil, testCase.setupErr // Covers 41-44
+				}
 
-	appInstance.SetupRouter = func(_ server.Config, _, _ gin.HandlerFunc) (*gin.Engine, error) {
-		if testCase.setupErr != nil {
-			return nil, testCase.setupErr
-		}
+				return gin.New(), nil
+			}
 
-		return gin.New(), nil
-	}
+			appInstance.RunEngine = func(_ *gin.Engine, _ string) error {
+				return testCase.runErr // Covers 46
+			}
 
-	appInstance.RunEngine = func(_ *gin.Engine, _ string) error {
-		return testCase.runErr
+			err := appInstance.Run()
+			assertRunError(t, err, testCase.wantErr, testCase.runErr)
+		})
 	}
-
-	err := appInstance.Run()
-	assertRunError(t, err, testCase.wantErr, testCase.runErr)
 }

internal/eui64/tests/calculator_test.go

@@ -146,6 +146,45 @@ func TestCalculateEUI64(t *testing.T) {
 			wantFullIP:      "",
 			wantErr:         "invalid empty hextet",
 		},
+		{
+			name:            "Invalid MAC parse",
+			mac:             "invalid-mac",
+			prefix:          "2001:0db8",
+			wantInterfaceID: "",
+			wantFullIP:      "",
+			wantErr:         "parsing MAC address failed", // Covers 48-52
+		},
+		{
+			name:            "GenerateInterfaceID only",
+			mac:             "00-14-22-01-23-45",
+			prefix:          "",
+			wantInterfaceID: "0214:22ff:fe01:2345",
+			wantFullIP:      "", // Covers 58-61, parts of 74-84
+		},
+		{
+			name:            "Invalid MAC length",
+			mac:             "00-14-22-01-23-45-67", // 7 bytes
+			prefix:          "2001:0db8",
+			wantInterfaceID: "",
+			wantFullIP:      "",
+			wantErr:         "parsing MAC address failed", // Covers 54-56 indirectly via ParseMAC
+		},
+		{
+			name:            "Invalid prefix too long",
+			mac:             "00-14-22-01-23-45",
+			prefix:          "2001:0db8:85a3:0000:1234",
+			wantInterfaceID: "",
+			wantFullIP:      "",
+			wantErr:         "IPv6 prefix exceeds 4 hextets", // Covers 63-66, 88-94
+		},
+		{
+			name:            "Prefix with full IP",
+			mac:             "00-14-22-01-23-45",
+			prefix:          "2001:0db8:85a3:0000",
+			wantInterfaceID: "0214:22ff:fe01:2345",
+			wantFullIP:      "2001:db8:85a3:0:214:22ff:fe01:2345",
+			wantErr:         "", // Covers 68-70, parts of 115-148
+		},
 	}
 
 	for _, tt := range tests {
@@ -248,6 +287,18 @@ func TestParsePrefix(t *testing.T) {
 			wantParts: nil,
 			wantErr:   "invalid hextet in IPv6 prefix: \"xyz\"",
 		},
+		{
+			name:      "Empty hextet in middle",
+			prefix:    "2001::85a3",
+			wantParts: nil,
+			wantErr:   "invalid empty hextet", // Covers 105-108
+		},
+		{
+			name:      "Invalid hextet char",
+			prefix:    "2001:0db8:xyz",
+			wantParts: nil,
+			wantErr:   "invalid hextet in IPv6 prefix", // Covers 96-100, 102
+		},
 	}
 
 	for _, testCase := range tests {