fixup! fix: parse time function for nedlib

added detected format and turned tests into a table
nlnwa · May 3, 2024 · d2c36df · d2c36df
1 parent 3aacc01
commit d2c36df
Show file tree

Hide file tree

Showing 3 changed files with 80 additions and 139 deletions.
diff --git a/nedlibreader/nedlibreader.go b/nedlibreader/nedlibreader.go
@@ -56,7 +56,7 @@ func (nedlibReader *NedlibReader) Next() (gowarc.WarcRecord, int64, *gowarc.Vali
 	header := response.Header
 	dateString := header.Get("Date")
 	if dateString != "" {
-		t, err := parseTime(dateString)
+		t, _, err := parseTime(dateString)
 		if err != nil {
 			return nil, 0, validation, err
 		}

diff --git a/nedlibreader/time.go b/nedlibreader/time.go
@@ -5,27 +5,34 @@ import (
 	"time"
 )
 
-func parseTime(dateString string) (parsedTime time.Time, err error) {
-	parsedTime, err = time.Parse(time.RFC1123, dateString)
+const (
+	RFC1123  = "RFC1123"
+	RFC850   = "RFC850"
+	ANSIC    = "ANSIC"
+	UnixDate = "UnixDate"
+)
+
+func parseTime(dateString string) (time.Time, string, error) {
+	parsedTime, err := time.Parse(time.RFC1123, dateString)
 	if err == nil {
-		return
+		return parsedTime, RFC1123, err
 	}
 
 	parsedTime, err = time.Parse(time.RFC850, dateString)
 	if err == nil {
-		return
+		return parsedTime, RFC850, err
 	}
 
 	parsedTime, err = time.Parse(time.ANSIC, dateString)
 	if err == nil {
-		return
+		return parsedTime, ANSIC, err
 	}
 
 	parsedTime, err = time.Parse(time.UnixDate, dateString)
 	if err == nil {
-		return
+		return parsedTime, UnixDate, err
 	}
 
 	err = fmt.Errorf("failed to parse string as time.Time: '%s': '%w'", dateString, err)
-	return
+	return time.Time{}, "", err
 }
diff --git a/nedlibreader/time_test.go b/nedlibreader/time_test.go
@@ -1,144 +1,78 @@
 package nedlibreader
 
 import (
-	"errors"
-	"fmt"
 	"testing"
 	"time"
 )
 
-func TestParseValidRFC1123(t *testing.T) {
-	dateString := "Tue, 05 Apr 2024 15:30:00 GMT"
-	expectedTime := time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC)
-
-	parsedTime, err := parseTime(dateString)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-		return
-	}
-
-	if !parsedTime.Equal(expectedTime) {
-		t.Errorf("expected time: %v, got: %v", expectedTime, parsedTime)
-	}
+type testTime struct {
+	timeAsString string
+	time         time.Time
+	shouldFail   bool
 }
 
-func TestParseInvalidRFC1123(t *testing.T) {
-	dateString := "Tue, 05 Apr 2024 15:30:00"
-
-	_, err := parseTime(dateString)
-	if err == nil {
-		t.Errorf("expected error, got nil")
-		return
-	}
-
-	var parseErr *time.ParseError
-
-	if errors.As(err, &parseErr) {
-		fmt.Println("Found a *time.ParseError in the error chain")
-		fmt.Printf("Error: %v\n", parseErr)
-	} else {
-		t.Errorf("expected error to be of type time.ParseError, got: '%T'", err)
-	}
+type testTable struct {
+	expectedFormat string
+	tests          []testTime
 }
 
-func TestParseValidRFC850(t *testing.T) {
-	dateString := "Tuesday, 05-Apr-24 15:30:00 GMT"
-	expectedTime := time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC)
-
-	parsedTime, err := parseTime(dateString)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-		return
-	}
-
-	if !parsedTime.Equal(expectedTime) {
-		t.Errorf("expected time: %v, got: %v", expectedTime, parsedTime)
-	}
-}
-
-func TestParseInvalidRFC850(t *testing.T) {
-	dateString := "Tuesday, 05-Apr-24 15:30:00"
-
-	_, err := parseTime(dateString)
-	if err == nil {
-		t.Errorf("expected error, got nil")
-		return
-	}
-
-	var parseErr *time.ParseError
-
-	if errors.As(err, &parseErr) {
-		fmt.Println("Found a *time.ParseError in the error chain")
-		fmt.Printf("Error: %v\n", parseErr)
-	} else {
-		t.Errorf("expected error to be of type time.ParseError, got: '%T'", err)
-	}
-}
-
-func TestParseValidANSIC(t *testing.T) {
-	dateString := "Tue Apr  5 15:30:00 2024"
-	expectedTime := time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC)
-
-	parsedTime, err := parseTime(dateString)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-		return
-	}
-
-	if !parsedTime.Equal(expectedTime) {
-		t.Errorf("expected time: %v, got: %v", expectedTime, parsedTime)
-	}
-}
-
-func TestParseInvalidANSIC(t *testing.T) {
-	dateString := "Tue Apr  5 15:30:00"
-
-	_, err := parseTime(dateString)
-	if err == nil {
-		t.Errorf("expected error, got nil")
-		return
-	}
-
-	var parseErr *time.ParseError
-
-	if errors.As(err, &parseErr) {
-		fmt.Println("Found a *time.ParseError in the error chain")
-		fmt.Printf("Error: %v\n", parseErr)
-	} else {
-		t.Errorf("expected error to be of type time.ParseError, got: '%T'", err)
-	}
-}
-
-func TestParseValidUnixDate(t *testing.T) {
-	dateString := "Tue Apr  5 15:30:00 UTC 2024"
-	expectedTime := time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC)
-
-	parsedTime, err := parseTime(dateString)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-		return
-	}
-
-	if !parsedTime.Equal(expectedTime) {
-		t.Errorf("expected time: %v, got: %v", expectedTime, parsedTime)
-	}
-}
-
-func TestParseInvalidUnixDate(t *testing.T) {
-	dateString := "Tue Apr  5 15:30:00 UTC"
-
-	_, err := parseTime(dateString)
-	if err == nil {
-		t.Errorf("expected error, got nil")
-		return
-	}
-
-	var parseErr *time.ParseError
-
-	if errors.As(err, &parseErr) {
-		fmt.Println("Found a *time.ParseError in the error chain")
-		fmt.Printf("Error: %v\n", parseErr)
-	} else {
-		t.Errorf("expected error to be of type time.ParseError, got: '%T'", err)
+func TestParseTime(t *testing.T) {
+	var testTable = []testTable{
+		{
+			expectedFormat: RFC1123,
+			tests: []testTime{
+				{"Tue, 05 Apr 2024 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), false},
+				{"Tue, 05 Apr 202 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), true},
+			},
+		},
+		{
+			expectedFormat: RFC850,
+			tests: []testTime{
+				{"Tuesday, 05-Apr-24 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), false},
+				{"Tue, 05 Ap 2024 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), true},
+			},
+		},
+		{
+			expectedFormat: ANSIC,
+			tests: []testTime{
+				{"Tue Apr  5 15:30:00 2024", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), false},
+				{"Tue, 05 Apr 204 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), true},
+			},
+		},
+		{
+			expectedFormat: UnixDate,
+			tests: []testTime{
+				{"Tue Apr  5 15:30:00 UTC 2024", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), false},
+				{"Tue, 5 Apr 2024 15:30:00 GMT", time.Date(2024, time.April, 5, 15, 30, 0, 0, time.UTC), true},
+			},
+		},
+	}
+
+	for _, formatGroup := range testTable {
+		for _, test := range formatGroup.tests {
+			t.Run(formatGroup.expectedFormat+"-"+test.timeAsString, func(t *testing.T) {
+				t.Log("Time string: ", test.timeAsString)
+				t.Log("Expected time: ", test.time)
+				t.Log("Should fail: ", test.shouldFail)
+				t.Log("Expected format: ", formatGroup.expectedFormat)
+				parsedTime, detectedFormat, err := parseTime(test.timeAsString)
+
+				if err != nil {
+					if !test.shouldFail {
+						t.Errorf("expected no error, got: %v", err)
+					}
+				} else {
+					if test.shouldFail {
+						t.Errorf("expected error, got none")
+					}
+					if detectedFormat != formatGroup.expectedFormat {
+						t.Errorf("expected format: '%v', got: '%v'", formatGroup.expectedFormat, detectedFormat)
+					}
+					if !parsedTime.Equal(test.time) {
+						t.Errorf("expected time: '%v', got: '%v'", test.time, parsedTime)
+					}
+				}
+			})
+		}
 	}
 }