addenda11_test.go

// Copyright 2018 The Moov Authors
// Use of this source code is governed by an Apache License
// license that can be found in the LICENSE file.

package ach

import (
	"testing"

	"github.com/moov-io/base"
)

// mockAddenda11 creates a mock Addenda11 record
func mockAddenda11() *Addenda11 {
	addenda11 := NewAddenda11()
	addenda11.OriginatorName = "BEK Solutions"
	addenda11.OriginatorStreetAddress = "15 West Place Street"
	addenda11.EntryDetailSequenceNumber = 00000001
	return addenda11
}

// TestMockAddenda11 validates mockAddenda11
func TestMockAddenda11(t *testing.T) {
	addenda11 := mockAddenda11()
	if err := addenda11.Validate(); err != nil {
		t.Error("mockAddenda11 does not validate and will break other tests")
	}
}

// testAddenda11Parse parses Addenda11 record
func testAddenda11Parse(t testing.TB) {
	Addenda11 := NewAddenda11()
	line := "711BEK Solutions                      15 West Place Street                             0000001"
	Addenda11.Parse(line)
	// walk the Addenda11 struct
	if Addenda11.recordType != "7" {
		t.Errorf("expected %v got %v", "7", Addenda11.recordType)
	}
	if Addenda11.TypeCode != "11" {
		t.Errorf("expected %v got %v", "11", Addenda11.TypeCode)
	}
	if Addenda11.OriginatorName != "BEK Solutions" {
		t.Errorf("expected %v got %v", "BEK Solutions", Addenda11.OriginatorName)
	}
	if Addenda11.OriginatorStreetAddress != "15 West Place Street" {
		t.Errorf("expected: %v got: %v", "15 West Place Street", Addenda11.OriginatorStreetAddress)
	}
	if Addenda11.reserved != "              " {
		t.Errorf("expected: %v got: %v", "              ", Addenda11.reserved)
	}
	if Addenda11.EntryDetailSequenceNumber != 0000001 {
		t.Errorf("expected: %v got: %v", 0000001, Addenda11.EntryDetailSequenceNumber)
	}
}

// TestAddenda11Parse tests parsing Addenda11 record
func TestAddenda11Parse(t *testing.T) {
	testAddenda11Parse(t)
}

// BenchmarkAddenda11Parse benchmarks parsing Addenda11 record
func BenchmarkAddenda11Parse(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11Parse(b)
	}
}

// testAddenda11ValidRecordType validates Addenda11 recordType
func testAddenda11ValidRecordType(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.recordType = "63"
	err := addenda11.Validate()
	if !base.Match(err, NewErrRecordType(7)) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11ValidRecordType tests validating Addenda11 recordType
func TestAddenda11ValidRecordType(t *testing.T) {
	testAddenda11ValidRecordType(t)
}

// BenchmarkAddenda11ValidRecordType benchmarks validating Addenda11 recordType
func BenchmarkAddenda11ValidRecordType(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11ValidRecordType(b)
	}
}

// testAddenda11ValidTypeCode validates Addenda11 TypeCode
func testAddenda11ValidTypeCode(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.TypeCode = "65"
	err := addenda11.Validate()
	if !base.Match(err, ErrAddendaTypeCode) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11ValidTypeCode tests validating Addenda11 TypeCode
func TestAddenda11ValidTypeCode(t *testing.T) {
	testAddenda11ValidTypeCode(t)
}

// BenchmarkAddenda11ValidTypeCode benchmarks validating Addenda11 TypeCode
func BenchmarkAddenda11ValidTypeCode(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11ValidTypeCode(b)
	}
}

// testAddenda11TypeCode11 TypeCode is 11 if TypeCode is a valid TypeCode
func testAddenda11TypeCode11(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.TypeCode = "05"
	err := addenda11.Validate()
	if !base.Match(err, ErrAddendaTypeCode) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11TypeCode11 tests TypeCode is 11 if TypeCode is a valid TypeCode
func TestAddenda11TypeCode11(t *testing.T) {
	testAddenda11TypeCode11(t)
}

// BenchmarkAddenda11TypeCode11 benchmarks TypeCode is 11 if TypeCode is a valid TypeCode
func BenchmarkAddenda11TypeCode11(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11TypeCode11(b)
	}
}

// testOriginatorNameAlphaNumeric validates OriginatorName is alphanumeric
func testOriginatorNameAlphaNumeric(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.OriginatorName = "BEK S®lutions"
	err := addenda11.Validate()
	if !base.Match(err, ErrNonAlphanumeric) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestOriginatorNameAlphaNumeric tests validating OriginatorName is alphanumeric
func TestOriginatorNameAlphaNumeric(t *testing.T) {
	testOriginatorNameAlphaNumeric(t)
}

// BenchmarkOriginatorNameAlphaNumeric benchmarks validating OriginatorName is alphanumeric
func BenchmarkOriginatorNameAlphaNumeric(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testOriginatorNameAlphaNumeric(b)
	}
}

// testOriginatorStreetAddressAlphaNumeric validates OriginatorStreetAddress is alphanumeric
func testOriginatorStreetAddressAlphaNumeric(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.OriginatorStreetAddress = "15 W®st"
	err := addenda11.Validate()
	if !base.Match(err, ErrNonAlphanumeric) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestOriginatorStreetAddressAlphaNumeric tests validating OriginatorStreetAddress is alphanumeric
func TestOriginatorStreetAddressAlphaNumeric(t *testing.T) {
	testOriginatorStreetAddressAlphaNumeric(t)
}

// BenchmarkOriginatorStreetAddressAlphaNumeric benchmarks validating OriginatorStreetAddress is alphanumeric
func BenchmarkOriginatorStreetAddressAlphaNumeric(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testOriginatorStreetAddressAlphaNumeric(b)
	}
}

// testAddenda11FieldInclusionRecordType validates recordType fieldInclusion
func testAddenda11FieldInclusionRecordType(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.recordType = ""
	err := addenda11.Validate()
	if !base.Match(err, ErrConstructor) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11FieldInclusionRecordType tests validating recordType fieldInclusion
func TestAddenda11FieldInclusionRecordType(t *testing.T) {
	testAddenda11FieldInclusionRecordType(t)
}

// BenchmarkAddenda11FieldInclusionRecordType benchmarks validating recordType fieldInclusion
func BenchmarkAddenda11FieldInclusionRecordType(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11FieldInclusionRecordType(b)
	}
}

// testAddenda11FieldInclusionTypeCode validates TypeCode fieldInclusion
func testAddenda11FieldInclusionTypeCode(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.TypeCode = ""
	err := addenda11.Validate()
	if !base.Match(err, ErrConstructor) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11FieldInclusionTypeCode tests validating TypeCode fieldInclusion
func TestAddenda11FieldInclusionTypeCode(t *testing.T) {
	testAddenda11FieldInclusionTypeCode(t)
}

// BenchmarkAddenda11FieldInclusionTypeCode benchmarks validating TypeCode fieldInclusion
func BenchmarkAddenda11FieldInclusionTypeCode(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11FieldInclusionTypeCode(b)
	}
}

// testAddenda11FieldInclusionOriginatorName validates OriginatorName fieldInclusion
func testAddenda11FieldInclusionOriginatorName(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.OriginatorName = ""
	err := addenda11.Validate()
	if !base.Match(err, ErrConstructor) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11FieldInclusionOriginatorName tests validating OriginatorName fieldInclusion
func TestAddenda11FieldInclusionOriginatorName(t *testing.T) {
	testAddenda11FieldInclusionOriginatorName(t)
}

// BenchmarkAddenda11FieldInclusionOriginatorName benchmarks validating OriginatorName fieldInclusion
func BenchmarkAddenda11FieldInclusionOriginatorName(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11FieldInclusionOriginatorName(b)
	}
}

// testAddenda11FieldInclusionOriginatorStreetAddress validates OriginatorStreetAddress fieldInclusion
func testAddenda11FieldInclusionOriginatorStreetAddress(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.OriginatorStreetAddress = ""
	err := addenda11.Validate()
	if !base.Match(err, ErrConstructor) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11FieldInclusionOriginatorStreetAddress tests validating OriginatorStreetAddress fieldInclusion
func TestAddenda11FieldInclusionOriginatorStreetAddress(t *testing.T) {
	testAddenda11FieldInclusionOriginatorStreetAddress(t)
}

// BenchmarkAddenda11FieldInclusionOriginatorStreetAddress benchmarks validating OriginatorStreetAddress fieldInclusion
func BenchmarkAddenda11FieldInclusionOriginatorStreetAddress(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11FieldInclusionOriginatorStreetAddress(b)
	}
}

// testAddenda11FieldInclusionEntryDetailSequenceNumber validates EntryDetailSequenceNumber fieldInclusion
func testAddenda11FieldInclusionEntryDetailSequenceNumber(t testing.TB) {
	addenda11 := mockAddenda11()
	addenda11.EntryDetailSequenceNumber = 0
	err := addenda11.Validate()
	if !base.Match(err, ErrConstructor) {
		t.Errorf("%T: %s", err, err)
	}
}

// TestAddenda11FieldInclusionEntryDetailSequenceNumber tests validating
// EntryDetailSequenceNumber fieldInclusion
func TestAddenda11FieldInclusionEntryDetailSequenceNumber(t *testing.T) {
	testAddenda11FieldInclusionEntryDetailSequenceNumber(t)
}

// BenchmarkAddenda11FieldInclusionEntryDetailSequenceNumber benchmarks validating
// EntryDetailSequenceNumber fieldInclusion
func BenchmarkAddenda11FieldInclusionEntryDetailSequenceNumber(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11FieldInclusionEntryDetailSequenceNumber(b)
	}
}

// TestAddenda11String validates that a known parsed Addenda11 record can be return to a string of the same value
func testAddenda11String(t testing.TB) {
	addenda11 := NewAddenda11()
	var line = "711BEK Solutions                      15 West Place Street                             0000001"
	addenda11.Parse(line)

	if addenda11.String() != line {
		t.Errorf("Strings do not match")
	}
	if addenda11.TypeCode != "11" {
		t.Errorf("TypeCode Expected 11 got: %v", addenda11.TypeCode)
	}
}

// TestAddenda11String tests validating that a known parsed Addenda11 record can be return to a string of the same value
func TestAddenda11String(t *testing.T) {
	testAddenda11String(t)
}

// BenchmarkAddenda11String benchmarks validating that a known parsed Addenda11 record can be return to a string of the same value
func BenchmarkAddenda11String(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		testAddenda11String(b)
	}
}