test error cleanup

internal/framer/framer_test.go

@@ -10,6 +10,6 @@ func TestNilGetFramer(t *testing.T) {
 	nilFramer := framer.GetFramer("asldfiudchuehrkbjbkjrbb")
 
 	if nilFramer != nil {
-		t.Errorf("Expected nil framer, got %v", nilFramer)
+		t.Fatalf("Expected nil framer, got %v", nilFramer)
 	}
 }

internal/framer/raw_test.go

@@ -28,7 +28,7 @@ func TestGoodRawFramerDecode(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			frames := test.framer.Decode(test.input)
 			if len(frames) != len(test.expected) {
-				t.Errorf("raw framer got %d frames, expected %d", len(frames), len(test.expected))
+				t.Fatalf("raw framer got %d frames, expected %d", len(frames), len(test.expected))
 			}
 			for i, frame := range frames {
 				if !slices.Equal(frame, test.expected[i]) {
@@ -57,11 +57,8 @@ func TestGoodRawFramerEncode(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			frame := test.framer.Encode(test.input)
-			if len(frame) != len(test.expected) {
-				t.Errorf("raw framer got %d frames, expected %d", len(frame), len(test.expected))
-			}
 			if !slices.Equal(frame, test.expected) {
-				t.Errorf("raw frame got %s, expected %s", frame, test.expected)
+				t.Fatalf("raw frame encode got %s, expected %s", frame, test.expected)
 			}
 		})
 	}
@@ -72,10 +69,10 @@ func TestRawFramerBuffer(t *testing.T) {
 	framer.Decode([]byte("Hello, World!"))
 
 	if !slices.Equal(framer.Buffer(), []byte{}) {
-		t.Errorf("raw framer buffer got %s, expected empty", framer.Buffer())
+		t.Fatalf("raw framer buffer got %s, expected empty", framer.Buffer())
 	}
 	framer.Clear()
 	if !slices.Equal(framer.Buffer(), []byte{}) {
-		t.Errorf("raw framer buffer got %s, expected empty after clear", framer.Buffer())
+		t.Fatalf("raw framer buffer got %s, expected empty after clear", framer.Buffer())
 	}
 }

internal/framer/separator_test.go

@@ -65,7 +65,7 @@ func TestGoodSeparatorFramerDecode(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			frames := test.framer.Decode(test.input)
 			if len(frames) != len(test.expected) {
-				t.Errorf("separator framer got %d frames, expected %d", len(frames), len(test.expected))
+				t.Fatalf("separator framer got %d frames, expected %d", len(frames), len(test.expected))
 			}
 			for i, frame := range frames {
 				if !slices.Equal(frame, test.expected[i]) {
@@ -73,7 +73,7 @@ func TestGoodSeparatorFramerDecode(t *testing.T) {
 				}
 			}
 			if !slices.Equal(test.framer.Buffer(), test.buffer) {
-				t.Errorf("separator framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
+				t.Fatalf("separator framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
 			}
 		})
 	}
@@ -110,7 +110,7 @@ func TestGoodSeparatorFramerEncode(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			frame := test.framer.Encode(test.input)
 			if !slices.Equal(frame, test.expected) {
-				t.Errorf("separator framer got %s, expected %s", frame, test.expected)
+				t.Fatalf("separator framer got %s, expected %s", frame, test.expected)
 			}
 		})
 	}
@@ -120,11 +120,11 @@ func TestSeparatorFrameBuffer(t *testing.T) {
 	framer := framer.GetFramer("LF")
 	framer.Decode([]byte("Hello\nWorld\nThis is a test\nextra"))
 	if !slices.Equal(framer.Buffer(), []byte("extra")) {
-		t.Errorf("separator framer buffer got %s, expected %s", framer.Buffer(), []byte("extra"))
+		t.Fatalf("separator framer buffer got %s, expected %s", framer.Buffer(), []byte("extra"))
 	}
 
 	framer.Clear()
 	if !slices.Equal(framer.Buffer(), []byte{}) {
-		t.Errorf("separator framer buffer got %s, expected empty slice", framer.Buffer())
+		t.Fatalf("separator framer buffer got %s, expected empty slice", framer.Buffer())
 	}
 }

internal/framer/slip_test.go

@@ -44,7 +44,7 @@ func TestGoodSLIPFramerDecode(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			frames := test.framer.Decode(test.input)
 			if len(frames) != len(test.expected) {
-				t.Errorf("SLIP framer got %d frames, expected %d", len(frames), len(test.expected))
+				t.Fatalf("SLIP framer got %d frames, expected %d", len(frames), len(test.expected))
 			}
 			for i, frame := range frames {
 				if !slices.Equal(frame, test.expected[i]) {
@@ -52,7 +52,7 @@ func TestGoodSLIPFramerDecode(t *testing.T) {
 				}
 			}
 			if !slices.Equal(test.framer.Buffer(), test.buffer) {
-				t.Errorf("SLIP framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
+				t.Fatalf("SLIP framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
 			}
 		})
 	}
@@ -91,7 +91,7 @@ func TestGoodSLIPFramerEncode(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			frame := test.framer.Encode(test.input)
 			if !slices.Equal(frame, test.expected) {
-				t.Errorf("SLIP framer frame got %s, expected %s", frame, test.expected)
+				t.Fatalf("SLIP framer frame got %s, expected %s", frame, test.expected)
 			}
 		})
 	}
@@ -101,10 +101,10 @@ func TestSlipFramerBuffer(t *testing.T) {
 	framer := framer.GetFramer("SLIP")
 	framer.Decode([]byte{0xc0, 0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x45})
 	if !slices.Equal(framer.Buffer(), []byte{0x45}) {
-		t.Errorf("SLIP framer buffer got %s, expected %s", framer.Buffer(), []byte{0x45})
+		t.Fatalf("SLIP framer buffer got %s, expected %s", framer.Buffer(), []byte{0x45})
 	}
 	framer.Clear()
 	if !slices.Equal(framer.Buffer(), []byte{}) {
-		t.Errorf("SLIP framer buffer got %s, expected empty slice", framer.Buffer())
+		t.Fatalf("SLIP framer buffer got %s, expected empty slice", framer.Buffer())
 	}
 }

internal/processor/float-parse_test.go

@@ -37,13 +37,13 @@ func TestGoodFloatParse(t *testing.T) {
 
 			gotFloat, ok := got.(float64)
 			if !ok {
-				t.Errorf("float.parse returned a %T payload: %s", got, got)
+				t.Fatalf("float.parse returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("float.parse failed: %s", err)
+				t.Fatalf("float.parse failed: %s", err)
 			}
 			if gotFloat != test.expected {
-				t.Errorf("float.parse got %f, expected %f", gotFloat, test.expected)
+				t.Fatalf("float.parse got %f, expected %f", gotFloat, test.expected)
 			}
 		})
 	}
@@ -74,11 +74,11 @@ func TestBadFloatParse(t *testing.T) {
 			got, err := floatParser.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("float.parse expected to fail but succeeded, got: %v", got)
+				t.Fatalf("float.parse expected to fail but succeeded, got: %v", got)
 
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("float.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("float.parse got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/processor/int-parse_test.go

@@ -37,13 +37,13 @@ func TestGoodIntParse(t *testing.T) {
 
 			gotInt, ok := got.(int64)
 			if !ok {
-				t.Errorf("int.parse returned a %T payload: %s", got, got)
+				t.Fatalf("int.parse returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("int.parse failed: %s", err)
+				t.Fatalf("int.parse failed: %s", err)
 			}
 			if gotInt != test.expected {
-				t.Errorf("int.parse got %d, expected %d", gotInt, test.expected)
+				t.Fatalf("int.parse got %d, expected %d", gotInt, test.expected)
 			}
 		})
 	}
@@ -74,11 +74,11 @@ func TestBadIntParse(t *testing.T) {
 			got, err := intParser.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("int.parse expected to fail but succeeded, got: %v", got)
+				t.Fatalf("int.parse expected to fail but succeeded, got: %v", got)
 
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("int.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("int.parse got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/processor/script-expr_test.go

@@ -38,7 +38,7 @@ func TestGoodScriptExpr(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			program, err := expr.Compile(test.program)
 			if err != nil {
-				t.Errorf("script.expr failed to compile program: %s", err)
+				t.Fatalf("script.expr failed to compile program: %s", err)
 			}
 
 			exprProcessor := &processor.ScriptExpr{Program: program}
@@ -46,12 +46,12 @@ func TestGoodScriptExpr(t *testing.T) {
 			got, err := exprProcessor.Process(t.Context(), test.payload)
 
 			if err != nil {
-				t.Errorf("script.expr failed: %s", err)
+				t.Fatalf("script.expr failed: %s", err)
 			}
 
 			//TODO(jwetzell): work out better way to compare the any/any
 			if got != test.expected {
-				t.Errorf("script.expr got %+v (%T), expected %+v (%T)", got, got, test.expected, test.expected)
+				t.Fatalf("script.expr got %+v (%T), expected %+v (%T)", got, got, test.expected, test.expected)
 			}
 		})
 	}

internal/processor/string-create_test.go

@@ -59,7 +59,7 @@ func TestGoodStringCreate(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			template, err := template.New("template").Parse(test.template)
 			if err != nil {
-				t.Errorf("string.create template parsing failed: %s", err)
+				t.Fatalf("string.create template parsing failed: %s", err)
 			}
 
 			processor := &processor.StringCreate{Template: template}
@@ -68,13 +68,13 @@ func TestGoodStringCreate(t *testing.T) {
 
 			gotStrings, ok := got.(string)
 			if !ok {
-				t.Errorf("string.create returned a %T payload: %s", got, got)
+				t.Fatalf("string.create returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("string.create failed: %s", err)
+				t.Fatalf("string.create failed: %s", err)
 			}
 			if gotStrings != test.expected {
-				t.Errorf("string.create got %s, expected %s", got, test.expected)
+				t.Fatalf("string.create got %s, expected %s", got, test.expected)
 			}
 		})
 	}

internal/processor/string-decode_test.go

@@ -28,13 +28,13 @@ func TestGoodStringDecode(t *testing.T) {
 
 			gotString, ok := got.(string)
 			if !ok {
-				t.Errorf("string.decode returned a %T payload: %s", got, got)
+				t.Fatalf("string.decode returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("string.decode failed: %s", err)
+				t.Fatalf("string.decode failed: %s", err)
 			}
 			if gotString != test.expected {
-				t.Errorf("string.decode got %s, expected %s", got, test.expected)
+				t.Fatalf("string.decode got %s, expected %s", got, test.expected)
 			}
 		})
 	}
@@ -61,10 +61,10 @@ func TestBadStringDecode(t *testing.T) {
 			got, err := test.processor.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("string.decode expected to fail but got payload: %s", got)
+				t.Fatalf("string.decode expected to fail but got payload: %s", got)
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("string.decode got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("string.decode got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/processor/string-encode_test.go

@@ -29,13 +29,13 @@ func TestGoodStringEncode(t *testing.T) {
 
 			gotBytes, ok := got.([]byte)
 			if !ok {
-				t.Errorf("string.encode returned a %T payload: %s", got, got)
+				t.Fatalf("string.encode returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("string.encode failed: %s", err)
+				t.Fatalf("string.encode failed: %s", err)
 			}
 			if !slices.Equal(gotBytes, test.expected) {
-				t.Errorf("string.encode got %s, expected %s", got, test.expected)
+				t.Fatalf("string.encode got %s, expected %s", got, test.expected)
 			}
 		})
 	}
@@ -62,10 +62,10 @@ func TestBadStringEncode(t *testing.T) {
 			got, err := test.processor.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("string.encode expected to fail but got payload: %s", got)
+				t.Fatalf("string.encode expected to fail but got payload: %s", got)
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("string.encode got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("string.encode got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/processor/string-split_test.go

@@ -28,13 +28,13 @@ func TestGoodStringSplit(t *testing.T) {
 
 			gotStrings, ok := got.([]string)
 			if !ok {
-				t.Errorf("string.split returned a %T payload: %s", got, got)
+				t.Fatalf("string.split returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("string.split failed: %s", err)
+				t.Fatalf("string.split failed: %s", err)
 			}
 			if !slices.Equal(gotStrings, test.expected) {
-				t.Errorf("string.split got %s, expected %s", got, test.expected)
+				t.Fatalf("string.split got %s, expected %s", got, test.expected)
 			}
 		})
 	}
@@ -60,10 +60,10 @@ func TestBadStringSplit(t *testing.T) {
 			got, err := test.processor.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("string.split expected error but got none, payload: %s", got)
+				t.Fatalf("string.split expected error but got none, payload: %s", got)
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("string.split got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("string.split got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/processor/uint-parse_test.go

@@ -32,13 +32,13 @@ func TestGoodUintParse(t *testing.T) {
 
 			gotUint, ok := got.(uint64)
 			if !ok {
-				t.Errorf("uint.parse returned a %T payload: %s", got, got)
+				t.Fatalf("uint.parse returned a %T payload: %s", got, got)
 			}
 			if err != nil {
-				t.Errorf("uint.parse failed: %s", err)
+				t.Fatalf("uint.parse failed: %s", err)
 			}
 			if gotUint != test.expected {
-				t.Errorf("uint.parse got %d, expected %d", gotUint, test.expected)
+				t.Fatalf("uint.parse got %d, expected %d", gotUint, test.expected)
 			}
 		})
 	}
@@ -69,11 +69,11 @@ func TestBadUintParse(t *testing.T) {
 			got, err := uintParser.Process(t.Context(), test.payload)
 
 			if err == nil {
-				t.Errorf("uint.parse expected to fail but succeeded, got: %v", got)
+				t.Fatalf("uint.parse expected to fail but succeeded, got: %v", got)
 
 			}
 			if err.Error() != test.errorString {
-				t.Errorf("uint.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+				t.Fatalf("uint.parse got error '%s', expected '%s'", err.Error(), test.errorString)
 			}
 		})
 	}

internal/route/route_test.go

@@ -15,15 +15,14 @@ func TestRouteCreate(t *testing.T) {
 
 	testRoute, err := route.NewRoute(routeConfig)
 	if err != nil {
-		t.Errorf("Failed to create route: %v", err)
+		t.Fatalf("route failed to create: %v", err)
-		return
 	}
 
 	if testRoute.Input() != routeConfig.Input {
-		t.Errorf("route input does not match expected input")
+		t.Fatalf("route input does not match expected input")
 	}
 	if testRoute.Output() != routeConfig.Output {
-		t.Errorf("route output does not match expected output")
+		t.Fatalf("route output does not match expected output")
 	}
 }
 
@@ -48,14 +47,13 @@ func TestGoodRouteHandleInput(t *testing.T) {
 
 	testRoute, err := route.NewRoute(routeConfig)
 	if err != nil {
-		t.Errorf("Failed to create route: %v", err)
+		t.Fatalf("route failed to create: %v", err)
-		return
 	}
 
 	inputData := "test input data"
 	err = testRoute.HandleInput(t.Context(), "input", inputData, &MockRouter{})
 	if err != nil {
-		t.Errorf("Route HandleOutput returned error: %v", err)
+		t.Fatalf("route HandleOutput returned error: %v", err)
 	}
 }
 
@@ -70,14 +68,13 @@ func TestRouteHandleInputWithProcessorError(t *testing.T) {
 
 	testRoute, err := route.NewRoute(routeConfig)
 	if err != nil {
-		t.Errorf("Failed to create route: %v", err)
+		t.Fatalf("route failed to create: %v", err)
-		return
 	}
 
 	inputData := "test input data"
 	err = testRoute.HandleInput(t.Context(), "input", inputData, &MockRouter{})
 	if err == nil {
-		t.Errorf("Route HandleOutput did not return error for bad processor")
+		t.Fatalf("route HandleOutput did not return error for bad processor")
 	}
 }
 
@@ -90,13 +87,13 @@ func TestRouteHandleNilPayload(t *testing.T) {
 
 	testRoute, err := route.NewRoute(routeConfig)
 	if err != nil {
-		t.Errorf("Failed to create route: %v", err)
+		t.Fatalf("route failed to create: %v", err)
 		return
 	}
 
 	err = testRoute.HandleInput(t.Context(), "input", nil, &MockRouter{})
 	if err != nil {
-		t.Errorf("Route HandleOutput returned error for nil payload: %v", err)
+		t.Fatalf("route HandleOutput returned error for nil payload: %v", err)
 	}
 }
 
@@ -111,13 +108,12 @@ func TestRouteHandleNilPayloadFromProcessor(t *testing.T) {
 
 	testRoute, err := route.NewRoute(routeConfig)
 	if err != nil {
-		t.Errorf("Failed to create route: %v", err)
+		t.Fatalf("route failed to create: %v", err)
-		return
 	}
 
 	err = testRoute.HandleInput(t.Context(), "input", nil, &MockRouter{})
 	if err != nil {
-		t.Errorf("Route HandleOutput returned error for nil payload: %v", err)
+		t.Fatalf("route HandleOutput returned error for nil payload: %v", err)
 	}
 }
 
@@ -132,8 +128,7 @@ func TestRouteUnknownProcessor(t *testing.T) {
 
 	_, err := route.NewRoute(routeConfig)
 	if err == nil {
-		t.Errorf("Expected error when creating route with unknown processor, got nil")
+		t.Fatalf("route error expected when creating route with an unknown processor, got nil")
-		return
 	}
 }
 
@@ -148,7 +143,6 @@ func TestRouteBadProcessorConfig(t *testing.T) {
 
 	_, err := route.NewRoute(routeConfig)
 	if err == nil {
-		t.Errorf("Expected error when creating route with bad processor, got nil")
+		t.Fatalf("route error expected creating route with bad processor, got nil")
-		return
 	}
 }