refactor(tw): improve test quality & refactor ParseError

internal/tw/client.go

@@ -126,7 +126,7 @@ func (c *Client) GetServerConfig(ctx context.Context, baseURLRaw string) (Server
 
 	var cfg ServerConfig
 
-	if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryConfig), &cfg); err != nil {
+	if err = c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryConfig), &cfg); err != nil {
 		return ServerConfig{}, err
 	}
 
@@ -141,7 +141,7 @@ func (c *Client) GetBuildingInfo(ctx context.Context, baseURLRaw string) (Buildi
 
 	var info BuildingInfo
 
-	if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryBuildingInfo), &info); err != nil {
+	if err = c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryBuildingInfo), &info); err != nil {
 		return BuildingInfo{}, err
 	}
 
@@ -156,7 +156,7 @@ func (c *Client) GetUnitInfo(ctx context.Context, baseURLRaw string) (UnitInfo,
 
 	var info UnitInfo
 
-	if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryUnitInfo), &info); err != nil {
+	if err = c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryUnitInfo), &info); err != nil {
 		return UnitInfo{}, err
 	}
 
@@ -373,10 +373,12 @@ func (t tribeCSVParser) parse() ([]Tribe, error) {
 		if err != nil {
 			return nil, err
 		}
+
 		tribe, err := t.parseRecord(rec)
 		if err != nil {
 			return nil, err
 		}
+
 		tribes = append(tribes, tribe)
 	}
 
@@ -393,42 +395,42 @@ func (t tribeCSVParser) parseRecord(record []string) (Tribe, error) {
 
 	tribe.ID, err = strconv.ParseInt(record[0], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.ID")
+		return Tribe{}, ParseError{Err: err, Str: record[0], Field: "Tribe.ID"}
 	}
 
 	tribe.Name, err = urlpkg.QueryUnescape(record[1])
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.Name")
+		return Tribe{}, ParseError{Err: err, Str: record[1], Field: "Tribe.Name"}
 	}
 
 	tribe.Tag, err = urlpkg.QueryUnescape(record[2])
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.Tag")
+		return Tribe{}, ParseError{Err: err, Str: record[2], Field: "Tribe.Tag"}
 	}
 
 	tribe.NumMembers, err = strconv.ParseInt(record[3], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.NumMembers")
+		return Tribe{}, ParseError{Err: err, Str: record[3], Field: "Tribe.NumMembers"}
 	}
 
 	tribe.NumVillages, err = strconv.ParseInt(record[4], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.NumVillages")
+		return Tribe{}, ParseError{Err: err, Str: record[4], Field: "Tribe.NumVillages"}
 	}
 
 	tribe.Points, err = strconv.ParseInt(record[5], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.Points")
+		return Tribe{}, ParseError{Err: err, Str: record[5], Field: "Tribe.Points"}
 	}
 
 	tribe.AllPoints, err = strconv.ParseInt(record[6], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.AllPoints")
+		return Tribe{}, ParseError{Err: err, Str: record[6], Field: "Tribe.AllPoints"}
 	}
 
 	tribe.Rank, err = strconv.ParseInt(record[7], 10, 64)
 	if err != nil {
-		return Tribe{}, NewParseError(err, record, "tribe.Rank")
+		return Tribe{}, ParseError{Err: err, Str: record[7], Field: "Tribe.Rank"}
 	}
 
 	tribe.OpponentsDefeated = t.od[tribe.ID]
@@ -456,10 +458,12 @@ func (p playerCSVParser) parse() ([]Player, error) {
 		if err != nil {
 			return nil, err
 		}
+
 		player, err := p.parseRecord(rec)
 		if err != nil {
 			return nil, err
 		}
+
 		players = append(players, player)
 	}
 
@@ -476,32 +480,32 @@ func (p playerCSVParser) parseRecord(record []string) (Player, error) {
 
 	player.ID, err = strconv.ParseInt(record[0], 10, 64)
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.ID")
+		return Player{}, ParseError{Err: err, Str: record[0], Field: "Player.ID"}
 	}
 
 	player.Name, err = urlpkg.QueryUnescape(record[1])
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.Name")
+		return Player{}, ParseError{Err: err, Str: record[1], Field: "Player.Name"}
 	}
 
 	player.TribeID, err = strconv.ParseInt(record[2], 10, 64)
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.TribeID")
+		return Player{}, ParseError{Err: err, Str: record[2], Field: "Player.TribeID"}
 	}
 
 	player.NumVillages, err = strconv.ParseInt(record[3], 10, 64)
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.NumVillages")
+		return Player{}, ParseError{Err: err, Str: record[3], Field: "Player.NumVillages"}
 	}
 
 	player.Points, err = strconv.ParseInt(record[4], 10, 64)
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.Points")
+		return Player{}, ParseError{Err: err, Str: record[4], Field: "Player.Points"}
 	}
 
 	player.Rank, err = strconv.ParseInt(record[5], 10, 64)
 	if err != nil {
-		return Player{}, NewParseError(err, record, "player.Rank")
+		return Player{}, ParseError{Err: err, Str: record[5], Field: "Player.Rank"}
 	}
 
 	player.OpponentsDefeated = p.od[player.ID]
@@ -548,37 +552,37 @@ func (v villageCSVParser) parseRecord(record []string) (Village, error) {
 
 	village.ID, err = strconv.ParseInt(record[0], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.ID")
+		return Village{}, ParseError{Err: err, Str: record[0], Field: "Village.ID"}
 	}
 
 	village.Name, err = urlpkg.QueryUnescape(record[1])
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.Name")
+		return Village{}, ParseError{Err: err, Str: record[1], Field: "Village.Name"}
 	}
 
 	village.X, err = strconv.ParseInt(record[2], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.X")
+		return Village{}, ParseError{Err: err, Str: record[2], Field: "Village.X"}
 	}
 
 	village.Y, err = strconv.ParseInt(record[3], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.Y")
+		return Village{}, ParseError{Err: err, Str: record[3], Field: "Village.Y"}
 	}
 
 	village.PlayerID, err = strconv.ParseInt(record[4], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.PlayerID")
+		return Village{}, ParseError{Err: err, Str: record[4], Field: "Village.PlayerID"}
 	}
 
 	village.Points, err = strconv.ParseInt(record[5], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.Points")
+		return Village{}, ParseError{Err: err, Str: record[5], Field: "Village.Points"}
 	}
 
 	village.Bonus, err = strconv.ParseInt(record[6], 10, 64)
 	if err != nil {
-		return Village{}, NewParseError(err, record, "village.Bonus")
+		return Village{}, ParseError{Err: err, Str: record[6], Field: "Village.Bonus"}
 	}
 
 	village.Continent = "K" + string(record[3][0]) + string(record[2][0])
@@ -610,10 +614,12 @@ func (o odCSVParser) parse() ([]odRecord, error) {
 		if err != nil {
 			return nil, err
 		}
+
 		od, err := o.parseRecord(rec)
 		if err != nil {
 			return nil, err
 		}
+
 		odRecords = append(odRecords, od)
 	}
 
@@ -626,17 +632,17 @@ func (o odCSVParser) parseRecord(record []string) (odRecord, error) {
 
 	rec.Rank, err = strconv.ParseInt(record[0], 10, 64)
 	if err != nil {
-		return odRecord{}, NewParseError(err, record, "odRecord.Rank")
+		return odRecord{}, ParseError{Err: err, Str: record[0], Field: "odRecord.Rank"}
 	}
 
 	rec.ID, err = strconv.ParseInt(record[1], 10, 64)
 	if err != nil {
-		return odRecord{}, NewParseError(err, record, "odRecord.ID")
+		return odRecord{}, ParseError{Err: err, Str: record[1], Field: "odRecord.ID"}
 	}
 
 	rec.Score, err = strconv.ParseInt(record[2], 10, 64)
 	if err != nil {
-		return odRecord{}, NewParseError(err, record, "odRecord.Score")
+		return odRecord{}, ParseError{Err: err, Str: record[2], Field: "odRecord.Score"}
 	}
 
 	return rec, nil
@@ -664,9 +670,11 @@ func (e ennoblementCSVParser) parse() ([]Ennoblement, error) {
 		if err != nil {
 			return nil, err
 		}
+
 		if ennoblement.CreatedAt.Before(e.since) {
 			continue
 		}
+
 		ennoblements = append(ennoblements, ennoblement)
 	}
 
@@ -683,37 +691,37 @@ func (e ennoblementCSVParser) parseRecord(record []string) (Ennoblement, error)
 
 	ennoblement.VillageID, err = strconv.ParseInt(record[0], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.VillageID")
+		return Ennoblement{}, ParseError{Err: err, Str: record[0], Field: "Ennoblement.VillageID"}
 	}
 
 	ennoblement.CreatedAt, err = e.parseTimestamp(record[1])
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.CreatedAt")
+		return Ennoblement{}, ParseError{Err: err, Str: record[1], Field: "Ennoblement.CreatedAt"}
 	}
 
 	ennoblement.NewOwnerID, err = strconv.ParseInt(record[2], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.NewOwnerID")
+		return Ennoblement{}, ParseError{Err: err, Str: record[2], Field: "Ennoblement.NewOwnerID"}
 	}
 
 	ennoblement.OldOwnerID, err = strconv.ParseInt(record[3], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.OldOwnerID")
+		return Ennoblement{}, ParseError{Err: err, Str: record[3], Field: "Ennoblement.OldOwnerID"}
 	}
 
 	ennoblement.OldTribeID, err = strconv.ParseInt(record[4], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.OldTribeID")
+		return Ennoblement{}, ParseError{Err: err, Str: record[4], Field: "Ennoblement.OldTribeID"}
 	}
 
 	ennoblement.NewTribeID, err = strconv.ParseInt(record[5], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.NewTribeID")
+		return Ennoblement{}, ParseError{Err: err, Str: record[5], Field: "Ennoblement.NewTribeID"}
 	}
 
 	ennoblement.Points, err = strconv.ParseInt(record[6], 10, 64)
 	if err != nil {
-		return Ennoblement{}, NewParseError(err, record, "ennoblement.Points")
+		return Ennoblement{}, ParseError{Err: err, Str: record[6], Field: "Ennoblement.Points"}
 	}
 
 	return ennoblement, nil

internal/tw/parse_error.go

@@ -1,42 +1,15 @@
 package tw
 
-import (
-	"strings"
-)
-
-const (
-	recordLenLimit = 100
-)
-
 type ParseError struct {
-	record []string
-	field  string
-	err    error
+	Field string
+	Str   string
+	Err   error
 }
 
-func NewParseError(err error, record []string, field string) ParseError {
-	return ParseError{
-		err:    err,
-		record: record,
-		field:  field,
-	}
-}
 func (e ParseError) Error() string {
-	recordStr := strings.Join(e.record, ",")
-	if len(recordStr) > recordLenLimit {
-		recordStr = recordStr[0:recordLenLimit-3] + "..."
-	}
-	return "parse error (field=" + e.field + " record=" + recordStr + "): " + e.err.Error()
-}
-
-func (e ParseError) Field() string {
-	return e.field
-}
-
-func (e ParseError) Record() []string {
-	return e.record
+	return e.Field + ": parsing \"" + e.Str + "\": " + e.Err.Error()
 }
 
 func (e ParseError) Unwrap() error {
-	return e.err
+	return e.Err
 }

internal/tw/parse_error_test.go

@@ -0,0 +1,22 @@
+package tw_test
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/tw"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseError(t *testing.T) {
+	t.Parallel()
+
+	err := tw.ParseError{
+		Field: "test",
+		Str:   "anything",
+		Err:   errors.New("err"),
+	}
+	assert.Equal(t, fmt.Sprintf("%s: parsing \"%s\": %s", err.Field, err.Str, err.Err.Error()), err.Error())
+	assert.ErrorIs(t, err, err.Err)
+}