Refactor formatValue

formatter_test.go

@@ -93,3 +93,159 @@ func TestFormatDiff(t *testing.T) {
 	checkOK(map[string]interface{}{"a": 1}, map[string]interface{}{})
 	checkOK([]interface{}{"a"}, []interface{}{})
 }
+
+func TestFormatFailure_Actual(t *testing.T) {
+	df := &DefaultFormatter{}
+	ctx := &AssertionContext{}
+
+	t.Run("assert type integer", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertType,
+			Actual: &AssertionValue{
+				Value: int(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "int(1000000)")
+	})
+
+	t.Run("assert type float32", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertType,
+			Actual: &AssertionValue{
+				Value: float32(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "float32(1e+06)")
+	})
+
+	t.Run("assert type float64", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertType,
+			Actual: &AssertionValue{
+				Value: float64(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "float64(1e+06)")
+	})
+
+	t.Run("assert type string", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertType,
+			Actual: &AssertionValue{
+				Value: "value string",
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, `string("value string")`)
+	})
+}
+
+func TestFormatFailure_Expected(t *testing.T) {
+	df := &DefaultFormatter{}
+	ctx := &AssertionContext{}
+
+	t.Run("assert in range integer", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertInRange,
+			Expected: &AssertionValue{
+				AssertionRange{
+					Min: int(1_000_000),
+					Max: int(2_000_000),
+				},
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "[1000000; 2000000]")
+	})
+
+	t.Run("assert in range float32", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertInRange,
+			Expected: &AssertionValue{
+				AssertionRange{
+					Min: float32(1_000_000),
+					Max: float32(2_000_000),
+				},
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "[1e+06; 2e+06]")
+	})
+
+	t.Run("assert in range float64", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertInRange,
+			Expected: &AssertionValue{
+				AssertionRange{
+					Min: float64(1_000_000),
+					Max: float64(2_000_000),
+				},
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "[1e+06; 2e+06]")
+	})
+
+	t.Run("assert in range string", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Type: AssertInRange,
+			Expected: &AssertionValue{
+				AssertionRange{
+					Min: "min string",
+					Max: "max string",
+				},
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "min string")
+		assert.Contains(t, tmpl, "max string")
+	})
+}
+
+func TestFormatFailure_Delta(t *testing.T) {
+	df := &DefaultFormatter{}
+	ctx := &AssertionContext{}
+
+	t.Run("integer", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Delta: &AssertionValue{
+				Value: int(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "1000000")
+	})
+
+	t.Run("float32", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Delta: &AssertionValue{
+				Value: float32(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "1000000.000000")
+	})
+
+	t.Run("float64", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Delta: &AssertionValue{
+				Value: float64(1_000_000),
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "1000000.000000")
+	})
+
+	t.Run("string", func(t *testing.T) {
+		fl := &AssertionFailure{
+			Delta: &AssertionValue{
+				Value: "delta string",
+			},
+		}
+		tmpl := df.FormatFailure(ctx, fl)
+		assert.Contains(t, tmpl, "delta string")
+	})
+}