Enhance Track2 Data Implementation (#336)

* fix some comment errors

* implement track2 packer and unpacker. add some convenience methods to track1 and track2 to make interacting with them cleaner and closer to what we have implemented for other fields. Add tests for all new code added, except for constructors

* format code should be in options not in constructor

* [PR] remove the options and just use params in the constructor. Update test to use constructor. Cleanup unpacker and make it simple

Author: bpross

field/bitmap.go

@@ -148,7 +148,7 @@ func (f *Bitmap) Marshal(v interface{}) error {
 	return nil
 }
 
-// Reset resets the bitmap to its initial state because of how message works,
+// Reset the bitmap to its initial state because of how message works,
 // Message need a way to initialize bitmap. That's why we set parameters to
 // their default values here like we do in constructor.
 func (f *Bitmap) Reset() {

field/composite.go

@@ -138,17 +138,17 @@ func (f *Composite) getSubfields() map[string]Field {
 // SetSpec validates the spec and creates new instances of Subfields defined
 // in the specification.
 // NOTE: Composite does not support padding on the base spec. Therefore, users
-// should only pass None or nil values for ths type. Passing any other value
+// should only pass None or nil values for this type. Passing any other value
 // will result in a panic.
 func (f *Composite) SetSpec(spec *Spec) {
 	if err := spec.Validate(); err != nil {
-		panic(err) //nolint:forbidigo,nolintlint // as specs moslty static, we panic on spec validation errors
+		panic(err) //nolint:forbidigo,nolintlint // as specs mostly static, we panic on spec validation errors
 	}
 	f.spec = spec
 
 	var sortFn sort.StringSlice
 
-	// When bitmap is defined, always order tags by int.
+	// When bitmap is not defined, always order tags by int.
 	if spec.Bitmap != nil {
 		sortFn = sort.StringsByInt
 	} else {

field/packer_unpacker.go

@@ -51,3 +51,61 @@ func (u defaultUnpacker) Unpack(packedFieldValue []byte, spec *Spec) ([]byte, in
 
 	return value, read + prefBytes, nil
 }
+
+type Track2Packer struct{}
+
+// This is a custom packer for Track2 Data. Some specifications require the length
+// to be equal to the length of the pre-padded value.
+func (p Track2Packer) Pack(value []byte, spec *Spec) ([]byte, error) {
+	data := value
+
+	// Only pad if the length is odd. If so, just add
+	// one pad character, so tell the Pad function that
+	// the length we want is +1 to what the value is
+	if spec.Pad != nil && len(value)%2 != 0 {
+		data = spec.Pad.Pad(data, len(value)+1)
+	}
+
+	packed, err := spec.Enc.Encode(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode content: %w", err)
+	}
+
+	// Encode the length to that of the original string, not the potentially
+	// padded length
+	packedLength, err := spec.Pref.EncodeLength(spec.Length, len(value))
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode length: %w", err)
+	}
+
+	return append(packedLength, packed...), nil
+}
+
+type Track2Unpacker struct{}
+
+func (p Track2Unpacker) Unpack(packedFieldValue []byte, spec *Spec) ([]byte, int, error) {
+	// decode the length
+	valueLength, prefBytes, err := spec.Pref.DecodeLength(spec.Length, packedFieldValue)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to decode length: %w", err)
+	}
+
+	// if valueLength is odd we need to make it even to adjust for
+	// the padding in our Packer
+	if valueLength%2 != 0 {
+		valueLength++
+	}
+
+	// decode the value
+	value, read, err := spec.Enc.Decode(packedFieldValue[prefBytes:], valueLength)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to decode content: %w", err)
+	}
+
+	// unpad the value if needed
+	if spec.Pad != nil {
+		value = spec.Pad.Unpad(value)
+	}
+
+	return value, read + prefBytes, nil
+}

field/packer_unpacker_test.go

@@ -3,9 +3,11 @@ package field_test
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/moov-io/iso8583/encoding"
 	"github.com/moov-io/iso8583/field"
+	"github.com/moov-io/iso8583/padding"
 	"github.com/moov-io/iso8583/prefix"
 	"github.com/stretchr/testify/require"
 )
@@ -109,3 +111,76 @@ func TestCustomPackerAndUnpacker(t *testing.T) {
 	// data is 2 bytes.
 	require.Equal(t, []byte{0x02, 0x01, 0x23}, packed)
 }
+
+func TestTrack2Packer(t *testing.T) {
+	type testCase struct {
+		name, primaryAccountNumber, serviceCode, discretionaryData, separator string
+		expirationDate                                                        time.Time
+		expectedPack                                                          []byte
+	}
+
+	s := &field.Spec{
+		Length:      37,
+		Description: "Track 2 Data",
+		Enc:         encoding.ASCII,
+		Pref:        prefix.ASCII.LL,
+		Pad:         padding.Left('0'),
+		Packer:      field.Track2Packer{},
+		Unpacker:    field.Track2Unpacker{},
+	}
+
+	expirationDate, err := time.Parse("0601", "3112")
+	require.NoError(t, err)
+
+	testCases := []testCase{
+		{
+			name:                 "even length",
+			primaryAccountNumber: "4444444444444444",
+			serviceCode:          "201",
+			discretionaryData:    "1474900373",
+			separator:            "D",
+			expirationDate:       expirationDate,
+			// Two bytes for length then: 44444444444444D31122011474900373
+			expectedPack: []byte{0x33, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x44, 0x33, 0x31, 0x31, 0x32, 0x32, 0x30, 0x31, 0x31, 0x34, 0x37, 0x34, 0x39, 0x30, 0x30, 0x33, 0x37, 0x33},
+		},
+		{
+			name:                 "odd length",
+			primaryAccountNumber: "4444444444444444",
+			serviceCode:          "201",
+			discretionaryData:    "147",
+			separator:            "D",
+			expirationDate:       expirationDate,
+			// Two bytes for length then: 04444444444444444D3112201147
+			expectedPack: []byte{0x32, 0x37, 0x30, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x44, 0x33, 0x31, 0x31, 0x32, 0x32, 0x30, 0x31, 0x31, 0x34, 0x37},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			fd := field.NewTrack2Value(
+				tc.primaryAccountNumber,
+				&tc.expirationDate,
+				tc.serviceCode,
+				tc.discretionaryData,
+				tc.separator,
+			)
+			fd.SetSpec(s)
+
+			packed, err := fd.Pack()
+			require.NoError(t, err)
+
+			require.Equal(t, tc.expectedPack, packed)
+
+			// unpack and verify that it is the same
+			unpackedFd := field.NewTrack2(s)
+			_, err = unpackedFd.Unpack(packed)
+			require.NoError(t, err)
+
+			require.Equal(t, fd.PrimaryAccountNumber, unpackedFd.PrimaryAccountNumber)
+			require.Equal(t, fd.ExpirationDate, unpackedFd.ExpirationDate)
+			require.Equal(t, fd.ServiceCode, unpackedFd.ServiceCode)
+			require.Equal(t, fd.DiscretionaryData, unpackedFd.DiscretionaryData)
+			require.Equal(t, fd.Separator, unpackedFd.Separator)
+		})
+	}
+}

field/track1.go

@@ -36,6 +36,28 @@ func NewTrack1(spec *Spec) *Track1 {
 	}
 }
 
+func NewTrack1Value(
+	primaryAccountNumber,
+	name string,
+	expirationDate *time.Time,
+	serviceCode,
+	discretionaryData,
+	formatCode string,
+	fixedLength bool,
+) *Track1 {
+	t := &Track1{
+		PrimaryAccountNumber: primaryAccountNumber,
+		Name:                 name,
+		ExpirationDate:       expirationDate,
+		ServiceCode:          serviceCode,
+		DiscretionaryData:    discretionaryData,
+		FormatCode:           formatCode,
+		FixedLength:          fixedLength,
+	}
+
+	return t
+}
+
 func (f *Track1) Spec() *Spec {
 	return f.spec
 }

field/track2.go

@@ -35,6 +35,24 @@ func NewTrack2(spec *Spec) *Track2 {
 	}
 }
 
+func NewTrack2Value(
+	primaryAccountNumber string,
+	expirationDate *time.Time,
+	serviceCode,
+	discretionaryData,
+	separator string,
+) *Track2 {
+	t := &Track2{
+		PrimaryAccountNumber: primaryAccountNumber,
+		Separator:            separator,
+		ExpirationDate:       expirationDate,
+		ServiceCode:          serviceCode,
+		DiscretionaryData:    discretionaryData,
+	}
+
+	return t
+}
+
 func (f *Track2) Spec() *Spec {
 	return f.spec
 }
@@ -180,6 +198,7 @@ func (f *Track2) pack() ([]byte, error) {
 	if len(f.ServiceCode) > 0 {
 		code = f.ServiceCode
 	}
+
 	separator := defaultSeparator
 	if f.Separator != "" {
 		separator = f.Separator