encoder,decoder: Using timeformatter when provided or default

Author: alexejk

decode.go

@@ -26,6 +26,9 @@ type Decoder interface {
 // StdDecoder is the default implementation of the Decoder interface.
 type StdDecoder struct {
 	skipUnknownFields bool
+
+	// timeFormatter is optional - defaultTimeFormatter is used when unset.
+	timeFormatter TimeFormatter
 }
 
 func (d *StdDecoder) DecodeRaw(body []byte, v interface{}) error {
@@ -271,7 +274,8 @@ func (d *StdDecoder) decodeDateTime(value string) (time.Time, error) {
 	if value == "" {
 		return time.Time{}, nil
 	}
-	return time.Parse(time.RFC3339, value)
+
+	return timeFormatterOrDefault(d.timeFormatter).ParseTime(value)
 }
 
 func findFieldByNameOrTag(field reflect.Value, fName string) reflect.Value {

decode_test.go

@@ -667,3 +667,56 @@ func loadTestFile(t *testing.T, name string) []byte {
 
 	return bytes
 }
+
+func Test_decodeDateTime_withTimeFormatter(t *testing.T) {
+	tests := []struct {
+		name      string
+		decoder   *StdDecoder
+		input     string
+		expect    string
+		expectErr bool
+	}{
+		{
+			name:    "unset formatter retains RFC3339",
+			decoder: &StdDecoder{},
+			input:   "2019-10-11T13:40:30Z",
+			expect:  "2019-10-11T13:40:30Z",
+		},
+		{
+			name:      "unset formatter rejects compact form",
+			decoder:   &StdDecoder{},
+			input:     "20191011T13:40:30",
+			expectErr: true,
+		},
+		{
+			name: "custom formatter",
+			decoder: &StdDecoder{
+				timeFormatter: &LayoutTimeFormatter{FormatLayout: LayoutISO8601Compact},
+			},
+			input:  "20191011T13:40:30",
+			expect: "2019-10-11T13:40:30Z",
+		},
+		{
+			name: "empty value decodes to zero time regardless of formatter",
+			decoder: &StdDecoder{
+				timeFormatter: &LayoutTimeFormatter{FormatLayout: LayoutISO8601Compact},
+			},
+			input:  "",
+			expect: "0001-01-01T00:00:00Z",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.decoder.decodeDateTime(tt.input)
+			if tt.expectErr {
+				require.Error(t, err)
+
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tt.expect, got.Format(time.RFC3339))
+		})
+	}
+}

encode.go

@@ -15,7 +15,10 @@ type Encoder interface {
 }
 
 // StdEncoder is the default implementation of Encoder interface.
-type StdEncoder struct{}
+type StdEncoder struct {
+	// timeFormatter is optional - defaultTimeFormatter is used when unset.
+	timeFormatter TimeFormatter
+}
 
 func (e *StdEncoder) Encode(w io.Writer, methodName string, args interface{}) error {
 	_, _ = fmt.Fprintf(w, "<methodCall><methodName>%s</methodName>", methodName)
@@ -251,8 +254,21 @@ func (e *StdEncoder) encodeBase64(w io.Writer, val []byte) error {
 }
 
 func (e *StdEncoder) encodeTime(w io.Writer, val time.Time) error {
-	_, err := fmt.Fprintf(w, "<dateTime.iso8601>%s</dateTime.iso8601>", val.Format(time.RFC3339))
-	return err
+	formatted := timeFormatterOrDefault(e.timeFormatter).FormatTime(val)
+
+	if _, err := fmt.Fprint(w, "<dateTime.iso8601>"); err != nil {
+		return err
+	}
+
+	if err := xml.EscapeText(w, []byte(formatted)); err != nil {
+		return fmt.Errorf("failed to escape time value: %w", err)
+	}
+
+	if _, err := fmt.Fprint(w, "</dateTime.iso8601>"); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (e *StdEncoder) encodeMap(w io.Writer, val interface{}) error {

encode_test.go

@@ -1,6 +1,7 @@
 package xmlrpc
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"testing"
@@ -579,3 +580,71 @@ func Test_encodeMap(t *testing.T) {
 		})
 	}
 }
+
+func Test_encodeTime_withTimeFormatter(t *testing.T) {
+	input := time.Date(2019, 10, 11, 13, 40, 30, 0, time.UTC)
+
+	tests := []struct {
+		name    string
+		encoder *StdEncoder
+		expect  string
+	}{
+		{
+			name:    "unset formatter retains RFC3339",
+			encoder: &StdEncoder{},
+			expect:  "<dateTime.iso8601>2019-10-11T13:40:30Z</dateTime.iso8601>",
+		},
+		{
+			name: "custom formatter",
+			encoder: &StdEncoder{
+				timeFormatter: &LayoutTimeFormatter{FormatLayout: LayoutISO8601Compact},
+			},
+			expect: "<dateTime.iso8601>20191011T13:40:30</dateTime.iso8601>",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := new(strings.Builder)
+			require.NoError(t, tt.encoder.encodeTime(buf, input))
+			require.Equal(t, tt.expect, buf.String())
+		})
+	}
+}
+
+// failingWriter fails once more than limit bytes have been written, so a failure can be
+// injected at any point of an element.
+type failingWriter struct {
+	limit   int
+	written int
+}
+
+func (w *failingWriter) Write(p []byte) (int, error) {
+	if w.written+len(p) > w.limit {
+		return 0, errors.New("write failed")
+	}
+	w.written += len(p)
+
+	return len(p), nil
+}
+
+func Test_encodeTime_writerErrors(t *testing.T) {
+	input := time.Date(2019, 10, 11, 13, 40, 30, 0, time.UTC)
+
+	// Full output is "<dateTime.iso8601>2019-10-11T13:40:30Z</dateTime.iso8601>"
+	tests := []struct {
+		name  string
+		limit int
+	}{
+		{name: "fails on opening tag", limit: 0},
+		{name: "fails on value", limit: len("<dateTime.iso8601>")},
+		{name: "fails on closing tag", limit: len("<dateTime.iso8601>2019-10-11T13:40:30Z")},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := (&StdEncoder{}).encodeTime(&failingWriter{limit: tt.limit}, input)
+			require.Error(t, err, "writer failure must not be discarded")
+		})
+	}
+}