github.com/moov-io/imagecashletter@v0.10.1/fileHeader_test.go (about)

     1  // Copyright 2020 The Moov Authors
     2  // Use of this source code is governed by an Apache License
     3  // license that can be found in the LICENSE file.
     4  
     5  package imagecashletter
     6  
     7  import (
     8  	"strings"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  // mockFileHeader creates a FileHeader
    16  func mockFileHeader() FileHeader {
    17  	fh := NewFileHeader()
    18  	fh.StandardLevel = "35"
    19  	fh.TestFileIndicator = "T"
    20  	fh.ImmediateDestination = "231380104"
    21  	fh.ImmediateOrigin = "121042882"
    22  	fh.FileCreationDate = time.Now()
    23  	fh.FileCreationTime = time.Now()
    24  	fh.ResendIndicator = "N"
    25  	fh.ImmediateDestinationName = "Citadel"
    26  	fh.ImmediateOriginName = "Wells Fargo"
    27  	fh.FileIDModifier = ""
    28  	fh.CountryCode = "US"
    29  	fh.UserField = ""
    30  	fh.CompanionDocumentIndicator = ""
    31  	return fh
    32  }
    33  
    34  // testMockFileHeader creates a FileHeader
    35  func testMockFileHeader(t testing.TB) {
    36  	fh := mockFileHeader()
    37  	require.NoError(t, fh.Validate())
    38  	require.Equal(t, "01", fh.recordType)
    39  	require.Equal(t, "35", fh.StandardLevel)
    40  	require.Equal(t, "T", fh.TestFileIndicator)
    41  	require.Equal(t, "N", fh.ResendIndicator)
    42  	require.Equal(t, "231380104", fh.ImmediateDestination)
    43  	require.Equal(t, "121042882", fh.ImmediateOrigin)
    44  	require.Equal(t, "Citadel", fh.ImmediateDestinationName)
    45  	require.Equal(t, "Wells Fargo", fh.ImmediateOriginName)
    46  	require.Equal(t, "", fh.FileIDModifier)
    47  	require.Equal(t, "US", fh.CountryCode)
    48  	require.Equal(t, "", fh.UserField)
    49  	require.Equal(t, "", fh.CompanionDocumentIndicator)
    50  }
    51  
    52  // TestMockFileHeader tests creating a FileHeader
    53  func TestMockFileHeader(t *testing.T) {
    54  	testMockFileHeader(t)
    55  }
    56  
    57  // BenchmarkMockFileHeader benchmarks creating a FileHeader
    58  func BenchmarkMockFileHeader(b *testing.B) {
    59  	b.ReportAllocs()
    60  	for i := 0; i < b.N; i++ {
    61  		testMockFileHeader(b)
    62  	}
    63  }
    64  
    65  // parseFileHeader validates parsing a FileHeader
    66  func parseFileHeader(t testing.TB) {
    67  	var line = "0135T231380104121042882201809051523NCitadel           Wells Fargo        US     "
    68  	r := NewReader(strings.NewReader(line))
    69  	r.line = line
    70  	require.NoError(t, r.parseFileHeader())
    71  	record := r.File.Header
    72  
    73  	require.Equal(t, "01", record.recordType)
    74  	require.Equal(t, "35", record.StandardLevelField())
    75  	require.Equal(t, "T", record.TestFileIndicatorField())
    76  	require.Equal(t, "231380104", record.ImmediateDestinationField())
    77  	require.Equal(t, "121042882", record.ImmediateOriginField())
    78  	require.Equal(t, "20180905", record.FileCreationDateField())
    79  	require.Equal(t, "1523", record.FileCreationTimeField())
    80  	require.Equal(t, "N", record.ResendIndicatorField())
    81  	require.Equal(t, "Citadel           ", record.ImmediateDestinationNameField())
    82  	require.Equal(t, "Wells Fargo       ", record.ImmediateOriginNameField())
    83  	require.Equal(t, " ", record.FileIDModifierField())
    84  	require.Equal(t, "US", record.CountryCodeField())
    85  	require.Equal(t, "    ", record.UserFieldField())
    86  	require.Equal(t, " ", record.CompanionDocumentIndicatorField())
    87  }
    88  
    89  // TestParseFileHeader tests validating parsing a FileHeader
    90  func TestParseFileHeader(t *testing.T) {
    91  	parseFileHeader(t)
    92  }
    93  
    94  // BenchmarkParseFileHeader benchmarks validating parsing a FileHeader
    95  func BenchmarkParseFileHeader(b *testing.B) {
    96  	b.ReportAllocs()
    97  	for i := 0; i < b.N; i++ {
    98  		parseFileHeader(b)
    99  	}
   100  }
   101  
   102  // testFHString validates that a known parsed FileHeader can return to a string of the same value
   103  func testFHString(t testing.TB) {
   104  	var line = "0135T231380104121042882201809051523NCitadel           Wells Fargo        US     "
   105  	r := NewReader(strings.NewReader(line))
   106  	r.line = line
   107  	require.NoError(t, r.parseFileHeader())
   108  	record := r.File.Header
   109  
   110  	require.Equal(t, line, record.String())
   111  }
   112  
   113  // TestFHString tests validating that a known parsed FileHeader can return to a string of the same value
   114  func TestFHString(t *testing.T) {
   115  	testFHString(t)
   116  }
   117  
   118  // BenchmarkFHString benchmarks validating that a known parsed FileHeader
   119  // can return to a string of the same value
   120  func BenchmarkFHString(b *testing.B) {
   121  	b.ReportAllocs()
   122  	for i := 0; i < b.N; i++ {
   123  		testFHString(b)
   124  	}
   125  }
   126  
   127  // TestFHRecordType validation
   128  func TestFHRecordType(t *testing.T) {
   129  	fh := mockFileHeader()
   130  	fh.recordType = "00"
   131  	err := fh.Validate()
   132  	var e *FieldError
   133  	require.ErrorAs(t, err, &e)
   134  	require.Equal(t, "recordType", e.FieldName)
   135  }
   136  
   137  // TestStandardLevel validation
   138  func TestStandardLevel(t *testing.T) {
   139  	fh := mockFileHeader()
   140  	fh.StandardLevel = "01"
   141  	err := fh.Validate()
   142  	var e *FieldError
   143  	require.ErrorAs(t, err, &e)
   144  	require.Equal(t, "StandardLevel", e.FieldName)
   145  }
   146  
   147  // TestTestFileIndicator validation
   148  func TestTestFileIndicator(t *testing.T) {
   149  	fh := mockFileHeader()
   150  	fh.TestFileIndicator = "S"
   151  	err := fh.Validate()
   152  	var e *FieldError
   153  	require.ErrorAs(t, err, &e)
   154  	require.Equal(t, "TestFileIndicator", e.FieldName)
   155  }
   156  
   157  // TestResendIndicator validation
   158  func TestResendIndicator(t *testing.T) {
   159  	fh := mockFileHeader()
   160  	fh.ResendIndicator = "R"
   161  	err := fh.Validate()
   162  	var e *FieldError
   163  	require.ErrorAs(t, err, &e)
   164  	require.Equal(t, "ResendIndicator", e.FieldName)
   165  }
   166  
   167  // TestImmediateDestinationName validation
   168  func TestImmediateDestinationName(t *testing.T) {
   169  	fh := mockFileHeader()
   170  	fh.ImmediateDestinationName = "®©"
   171  	err := fh.Validate()
   172  	var e *FieldError
   173  	require.ErrorAs(t, err, &e)
   174  	require.Equal(t, "ImmediateDestinationName", e.FieldName)
   175  }
   176  
   177  // TestImmediateOriginName validation
   178  func TestImmediateOriginName(t *testing.T) {
   179  	fh := mockFileHeader()
   180  	fh.ImmediateOriginName = "®©"
   181  	err := fh.Validate()
   182  	var e *FieldError
   183  	require.ErrorAs(t, err, &e)
   184  	require.Equal(t, "ImmediateOriginName", e.FieldName)
   185  }
   186  
   187  // TestFileIDModifier validation
   188  func TestFileIDModifier(t *testing.T) {
   189  	fh := mockFileHeader()
   190  	fh.FileIDModifier = "--"
   191  	err := fh.Validate()
   192  	var e *FieldError
   193  	require.ErrorAs(t, err, &e)
   194  	require.Equal(t, "FileIDModifier", e.FieldName)
   195  }
   196  
   197  // TestCountryCode validation
   198  func TestCountryCode(t *testing.T) {
   199  	fh := mockFileHeader()
   200  	fh.CompanionDocumentIndicator = "D"
   201  	err := fh.Validate()
   202  	var e *FieldError
   203  	require.ErrorAs(t, err, &e)
   204  	require.Equal(t, "CompanionDocumentIndicator", e.FieldName)
   205  }
   206  
   207  // TestCACountryCode validation
   208  func TestCACountryCode(t *testing.T) {
   209  	fh := mockFileHeader()
   210  	fh.CountryCode = "CA"
   211  	fh.CompanionDocumentIndicator = "1"
   212  	err := fh.Validate()
   213  	var e *FieldError
   214  	require.ErrorAs(t, err, &e)
   215  	require.Equal(t, "CompanionDocumentIndicator", e.FieldName)
   216  }
   217  
   218  // TestUserField validation
   219  func TestUserFieldI(t *testing.T) {
   220  	fh := mockFileHeader()
   221  	fh.UserField = "®©"
   222  	err := fh.Validate()
   223  	var e *FieldError
   224  	require.ErrorAs(t, err, &e)
   225  	require.Equal(t, "UserField", e.FieldName)
   226  }
   227  
   228  // TestFHFieldInclusionRecordType validates FieldInclusion
   229  func TestFHFieldInclusionRecordType(t *testing.T) {
   230  	fh := mockFileHeader()
   231  	fh.recordType = ""
   232  	err := fh.Validate()
   233  	var e *FieldError
   234  	require.ErrorAs(t, err, &e)
   235  	require.Equal(t, "recordType", e.FieldName)
   236  }
   237  
   238  // TestFHFieldInclusionStandardLevel validates FieldInclusion
   239  func TestFHFieldInclusionStandardLevel(t *testing.T) {
   240  	fh := mockFileHeader()
   241  	fh.StandardLevel = ""
   242  	err := fh.Validate()
   243  	var e *FieldError
   244  	require.ErrorAs(t, err, &e)
   245  	require.Equal(t, "StandardLevel", e.FieldName)
   246  }
   247  
   248  // TestFHFieldInclusionTestFileIndicator validates FieldInclusion
   249  func TestFHFieldInclusionTestFileIndicator(t *testing.T) {
   250  	fh := mockFileHeader()
   251  	fh.TestFileIndicator = ""
   252  	err := fh.Validate()
   253  	var e *FieldError
   254  	require.ErrorAs(t, err, &e)
   255  	require.Equal(t, "TestFileIndicator", e.FieldName)
   256  }
   257  
   258  // TestFHFieldInclusionResendIndicator validates FieldInclusion
   259  func TestFHFieldInclusionResendIndicator(t *testing.T) {
   260  	fh := mockFileHeader()
   261  	fh.ResendIndicator = ""
   262  	err := fh.Validate()
   263  	var e *FieldError
   264  	require.ErrorAs(t, err, &e)
   265  	require.Equal(t, "ResendIndicator", e.FieldName)
   266  }
   267  
   268  // TestFHFieldInclusionImmediateDestination validates FieldInclusion
   269  func TestFHFieldInclusionImmediateDestination(t *testing.T) {
   270  	fh := mockFileHeader()
   271  	fh.ImmediateDestination = ""
   272  	err := fh.Validate()
   273  	var e *FieldError
   274  	require.ErrorAs(t, err, &e)
   275  	require.Equal(t, "ImmediateDestination", e.FieldName)
   276  }
   277  
   278  // TestFHFieldInclusionImmediateDestinationZero validates FieldInclusion
   279  func TestFHFieldInclusionImmediateDestinationZero(t *testing.T) {
   280  	fh := mockFileHeader()
   281  	fh.ImmediateDestination = "000000000"
   282  	err := fh.Validate()
   283  	var e *FieldError
   284  	require.ErrorAs(t, err, &e)
   285  	require.Equal(t, "ImmediateDestination", e.FieldName)
   286  }
   287  
   288  // TestFHFieldInclusionImmediateOrigin validates FieldInclusion
   289  func TestFHFieldInclusionImmediateOrigin(t *testing.T) {
   290  	fh := mockFileHeader()
   291  	fh.ImmediateOrigin = ""
   292  	err := fh.Validate()
   293  	var e *FieldError
   294  	require.ErrorAs(t, err, &e)
   295  	require.Equal(t, "ImmediateOrigin", e.FieldName)
   296  }
   297  
   298  // TestFHFieldInclusionImmediateOriginZero validates FieldInclusion
   299  func TestFHFieldInclusionImmediateOriginZero(t *testing.T) {
   300  	fh := mockFileHeader()
   301  	fh.ImmediateOrigin = "000000000"
   302  	err := fh.Validate()
   303  	var e *FieldError
   304  	require.ErrorAs(t, err, &e)
   305  	require.Equal(t, "ImmediateOrigin", e.FieldName)
   306  }
   307  
   308  // TestFHFieldInclusionCreationDate validates FieldInclusion
   309  func TestFHFieldInclusionCreationDate(t *testing.T) {
   310  	fh := mockFileHeader()
   311  	fh.FileCreationDate = time.Time{}
   312  	err := fh.Validate()
   313  	var e *FieldError
   314  	require.ErrorAs(t, err, &e)
   315  	require.Equal(t, "FileCreationDate", e.FieldName)
   316  }
   317  
   318  // TestFHFieldInclusionCreationTime validates FieldInclusion
   319  func TestFHFieldInclusionCreationTime(t *testing.T) {
   320  	fh := mockFileHeader()
   321  	fh.FileCreationTime = time.Time{}
   322  	err := fh.Validate()
   323  	var e *FieldError
   324  	require.ErrorAs(t, err, &e)
   325  	require.Equal(t, "FileCreationTime", e.FieldName)
   326  }
   327  
   328  // TestFileHeaderRuneCountInString validates RuneCountInString
   329  func TestFileHeaderRuneCountInString(t *testing.T) {
   330  	fh := NewFileHeader()
   331  	var line = "01"
   332  	fh.Parse(line)
   333  
   334  	require.Equal(t, "", fh.ImmediateOrigin)
   335  }