github.com/moov-io/imagecashletter@v0.10.1/imageViewDetail_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  // mockImageViewDetail crates an imageViewDetail
    16  func mockImageViewDetail() ImageViewDetail {
    17  	ivDetail := NewImageViewDetail()
    18  	ivDetail.ImageIndicator = 1
    19  	ivDetail.ImageCreatorRoutingNumber = "031300012"
    20  	ivDetail.ImageCreatorDate = time.Now()
    21  	ivDetail.ImageViewFormatIndicator = "00"
    22  	ivDetail.ImageViewCompressionAlgorithm = "00"
    23  	// use of ivDetail.ImageViewDataSize is not recommended
    24  	ivDetail.ImageViewDataSize = "0000000"
    25  	ivDetail.ViewSideIndicator = 0
    26  	ivDetail.ViewDescriptor = "00"
    27  	ivDetail.DigitalSignatureIndicator = 0
    28  	ivDetail.DigitalSignatureMethod = "00"
    29  	ivDetail.SecurityKeySize = 00000
    30  	ivDetail.ProtectedDataStart = 0000000
    31  	ivDetail.ProtectedDataLength = 0000000
    32  	ivDetail.ImageRecreateIndicator = 0
    33  	ivDetail.UserField = ""
    34  	ivDetail.OverrideIndicator = "0"
    35  	return ivDetail
    36  }
    37  
    38  // TestMockImageViewDetail creates an ImageViewData
    39  func TestMockImageViewDetail(t *testing.T) {
    40  	ivDetail := mockImageViewDetail()
    41  	require.NoError(t, ivDetail.Validate())
    42  	require.Equal(t, "50", ivDetail.recordType)
    43  	require.Equal(t, 1, ivDetail.ImageIndicator)
    44  	require.Equal(t, "031300012", ivDetail.ImageCreatorRoutingNumber)
    45  	require.Equal(t, "00", ivDetail.ImageViewFormatIndicator)
    46  	require.Equal(t, "00", ivDetail.ImageViewCompressionAlgorithm)
    47  	require.Equal(t, "0000000", ivDetail.ImageViewDataSize)
    48  	require.Equal(t, 0, ivDetail.ViewSideIndicator)
    49  	require.Equal(t, "00", ivDetail.ViewDescriptor)
    50  	require.Equal(t, 0, ivDetail.DigitalSignatureIndicator)
    51  	require.Equal(t, "00", ivDetail.DigitalSignatureMethod)
    52  	require.Equal(t, 00000, ivDetail.SecurityKeySize)
    53  	require.Equal(t, 0000000, ivDetail.ProtectedDataStart)
    54  	require.Equal(t, 0000000, ivDetail.ProtectedDataLength)
    55  	require.Equal(t, 0, ivDetail.ImageRecreateIndicator)
    56  	require.Equal(t, "", ivDetail.UserField)
    57  	require.Equal(t, "", ivDetail.reserved)
    58  	require.Equal(t, "0", ivDetail.OverrideIndicator)
    59  	require.Equal(t, "", ivDetail.reservedTwo)
    60  
    61  }
    62  
    63  // TestParseIVDetail validates parsing an ImageViewDetail
    64  func TestParseIVDetail(t *testing.T) {
    65  	var line = "501031300012201809050000000000000000000000000000000000000         0             "
    66  	r := NewReader(strings.NewReader(line))
    67  	r.line = line
    68  	clh := mockCashLetterHeader()
    69  	r.addCurrentCashLetter(NewCashLetter(clh))
    70  	bh := mockBundleHeader()
    71  	b := NewBundle(bh)
    72  	r.currentCashLetter.AddBundle(b)
    73  	r.addCurrentBundle(b)
    74  	cd := mockCheckDetail()
    75  	r.currentCashLetter.currentBundle.AddCheckDetail(cd)
    76  	require.NoError(t, r.parseImageViewDetail())
    77  	record := r.currentCashLetter.currentBundle.GetChecks()[0].ImageViewDetail[0]
    78  
    79  	require.Equal(t, "50", record.recordType)
    80  	require.Equal(t, "1", record.ImageIndicatorField())
    81  	require.Equal(t, "031300012", record.ImageCreatorRoutingNumberField())
    82  	require.Equal(t, "00", record.ImageViewFormatIndicatorField())
    83  	require.Equal(t, "00", record.ImageViewCompressionAlgorithmField())
    84  	require.Equal(t, "0000000", record.ImageViewDataSizeField())
    85  	require.Equal(t, "0", record.ViewSideIndicatorField())
    86  	require.Equal(t, "00", record.ViewDescriptorField())
    87  	require.Equal(t, "0", record.DigitalSignatureIndicatorField())
    88  	require.Equal(t, "00", record.DigitalSignatureMethodField())
    89  	require.Equal(t, "     ", record.SecurityKeySizeField())
    90  	require.Equal(t, "0000000", record.ProtectedDataStartField())
    91  	require.Equal(t, "0000000", record.ProtectedDataLengthField())
    92  	require.Equal(t, "0", record.ImageRecreateIndicatorField())
    93  	require.Equal(t, "        ", record.UserFieldField())
    94  	require.Equal(t, " ", record.reservedField())
    95  	require.Equal(t, "0", record.OverrideIndicatorField())
    96  	require.Equal(t, "             ", record.reservedTwoField())
    97  }
    98  
    99  // testIVDetailString validates that a known parsed ImageViewDetail can return to a string of the same value
   100  func testIVDetailString(t testing.TB) {
   101  	var line = "5010313000122018090500000000000000000     000000000000000         0             "
   102  	r := NewReader(strings.NewReader(line))
   103  	r.line = line
   104  	clh := mockCashLetterHeader()
   105  	r.addCurrentCashLetter(NewCashLetter(clh))
   106  	bh := mockBundleHeader()
   107  	b := NewBundle(bh)
   108  	r.currentCashLetter.AddBundle(b)
   109  	r.addCurrentBundle(b)
   110  	cd := mockCheckDetail()
   111  	r.currentCashLetter.currentBundle.AddCheckDetail(cd)
   112  
   113  	require.NoError(t, r.parseImageViewDetail())
   114  	record := r.currentCashLetter.currentBundle.GetChecks()[0].ImageViewDetail[0]
   115  
   116  	require.Equal(t, line, record.String())
   117  }
   118  
   119  // TestIVDetailString tests validating that a known parsed ImageViewDetail can return to a string of the
   120  // same value
   121  func TestIVDetailString(t *testing.T) {
   122  	testIVDetailString(t)
   123  }
   124  
   125  // BenchmarkIVDetailString benchmarks validating that a known parsed ImageViewDetail
   126  // can return to a string of the same value
   127  func BenchmarkIVDetailString(b *testing.B) {
   128  	b.ReportAllocs()
   129  	for i := 0; i < b.N; i++ {
   130  		testIVDetailString(b)
   131  	}
   132  }
   133  
   134  // TestIVDetailRecordType validation
   135  func TestIVDetailRecordType(t *testing.T) {
   136  	ivDetail := mockImageViewDetail()
   137  	ivDetail.recordType = "00"
   138  	err := ivDetail.Validate()
   139  	var e *FieldError
   140  	require.ErrorAs(t, err, &e)
   141  	require.Equal(t, "recordType", e.FieldName)
   142  }
   143  
   144  // TestIVDetailImageIndicator validation
   145  func TestIVDetailImageIndicator(t *testing.T) {
   146  	ivDetail := mockImageViewDetail()
   147  	ivDetail.ImageIndicator = 9
   148  	err := ivDetail.Validate()
   149  	var e *FieldError
   150  	require.ErrorAs(t, err, &e)
   151  	require.Equal(t, "ImageIndicator", e.FieldName)
   152  }
   153  
   154  // TestIVDetailImageViewFormatIndicator validation
   155  func TestIVDetailImageViewFormatIndicator(t *testing.T) {
   156  	ivDetail := mockImageViewDetail()
   157  	ivDetail.ImageViewFormatIndicator = "30"
   158  	err := ivDetail.Validate()
   159  	var e *FieldError
   160  	require.ErrorAs(t, err, &e)
   161  	require.Equal(t, "ImageViewFormatIndicator", e.FieldName)
   162  }
   163  
   164  // TestIVDetailImageViewCompressionAlgorithm validation
   165  func TestIVDetailImageViewCompressionAlgorithm(t *testing.T) {
   166  	ivDetail := mockImageViewDetail()
   167  	ivDetail.ImageViewCompressionAlgorithm = "30"
   168  	err := ivDetail.Validate()
   169  	var e *FieldError
   170  	require.ErrorAs(t, err, &e)
   171  	require.Equal(t, "ImageViewCompressionAlgorithm", e.FieldName)
   172  }
   173  
   174  // TestIVDetailViewSideIndicator validation
   175  func TestIVDetailViewSideIndicator(t *testing.T) {
   176  	ivDetail := mockImageViewDetail()
   177  	ivDetail.ViewSideIndicator = 5
   178  	err := ivDetail.Validate()
   179  	var e *FieldError
   180  	require.ErrorAs(t, err, &e)
   181  	require.Equal(t, "ViewSideIndicator", e.FieldName)
   182  }
   183  
   184  // TestIVDetailViewDescriptor validation
   185  func TestIVDetailViewDescriptor(t *testing.T) {
   186  	ivDetail := mockImageViewDetail()
   187  	ivDetail.ViewDescriptor = "20"
   188  	err := ivDetail.Validate()
   189  	var e *FieldError
   190  	require.ErrorAs(t, err, &e)
   191  	require.Equal(t, "ViewDescriptor", e.FieldName)
   192  }
   193  
   194  // TestIVDetailDigitalSignatureIndicator validation
   195  func TestIVDetailDigitalSignatureIndicator(t *testing.T) {
   196  	ivDetail := mockImageViewDetail()
   197  	ivDetail.DigitalSignatureIndicator = 5
   198  	err := ivDetail.Validate()
   199  	var e *FieldError
   200  	require.ErrorAs(t, err, &e)
   201  	require.Equal(t, "DigitalSignatureIndicator", e.FieldName)
   202  }
   203  
   204  // TestIVDetailDigitalSignatureMethod validation
   205  func TestIVDetailDigitalSignatureMethod(t *testing.T) {
   206  	ivDetail := mockImageViewDetail()
   207  	ivDetail.DigitalSignatureMethod = "10"
   208  	err := ivDetail.Validate()
   209  	var e *FieldError
   210  	require.ErrorAs(t, err, &e)
   211  	require.Equal(t, "DigitalSignatureMethod", e.FieldName)
   212  }
   213  
   214  // TestIVDetailImageRecreateIndicator validation
   215  func TestIVDetailImageRecreateIndicator(t *testing.T) {
   216  	ivDetail := mockImageViewDetail()
   217  	ivDetail.ImageRecreateIndicator = 5
   218  	err := ivDetail.Validate()
   219  	var e *FieldError
   220  	require.ErrorAs(t, err, &e)
   221  	require.Equal(t, "ImageRecreateIndicator", e.FieldName)
   222  }
   223  
   224  // TestIVDetailOverrideIndicator validation
   225  func TestIVDetailOverrideIndicator(t *testing.T) {
   226  	ivDetail := mockImageViewDetail()
   227  	ivDetail.OverrideIndicator = "W"
   228  	err := ivDetail.Validate()
   229  	var e *FieldError
   230  	require.ErrorAs(t, err, &e)
   231  	require.Equal(t, "OverrideIndicator", e.FieldName)
   232  }
   233  
   234  // TestIVDetailUserField validation
   235  func TestIVDetailUserField(t *testing.T) {
   236  	ivDetail := mockImageViewDetail()
   237  	ivDetail.UserField = "®©"
   238  	err := ivDetail.Validate()
   239  	var e *FieldError
   240  	require.ErrorAs(t, err, &e)
   241  	require.Equal(t, "UserField", e.FieldName)
   242  }
   243  
   244  // Field Inclusion
   245  
   246  // TestIVDetailFIRecordType validation
   247  func TestIVDetailFIRecordType(t *testing.T) {
   248  	ivDetail := mockImageViewDetail()
   249  	ivDetail.recordType = ""
   250  	err := ivDetail.Validate()
   251  	var e *FieldError
   252  	require.ErrorAs(t, err, &e)
   253  	require.Equal(t, "recordType", e.FieldName)
   254  }
   255  
   256  // TestIVDetailFIImageCreatorRoutingNumber validation
   257  func TestIVDetailFIImageCreatorRoutingNumber(t *testing.T) {
   258  	ivDetail := mockImageViewDetail()
   259  	ivDetail.ImageCreatorRoutingNumber = ""
   260  	err := ivDetail.Validate()
   261  	var e *FieldError
   262  	require.ErrorAs(t, err, &e)
   263  	require.Equal(t, "ImageCreatorRoutingNumber", e.FieldName)
   264  }
   265  
   266  // TestIVDetailFIImageCreatorRoutingNumberZero validation
   267  func TestIVDetailFIImageCreatorRoutingNumberZero(t *testing.T) {
   268  	ivDetail := mockImageViewDetail()
   269  	ivDetail.ImageCreatorRoutingNumber = "000000000"
   270  	err := ivDetail.Validate()
   271  	var e *FieldError
   272  	require.ErrorAs(t, err, &e)
   273  	require.Equal(t, "ImageCreatorRoutingNumber", e.FieldName)
   274  }
   275  
   276  // TestIVDetailFIImageCreatorDate validation
   277  func TestIVDetailFIImageCreatorDate(t *testing.T) {
   278  	ivDetail := mockImageViewDetail()
   279  	ivDetail.ImageCreatorDate = time.Time{}
   280  	err := ivDetail.Validate()
   281  	var e *FieldError
   282  	require.ErrorAs(t, err, &e)
   283  	require.Equal(t, "ImageCreatorDate", e.FieldName)
   284  }
   285  
   286  // TestIVDetailFIViewDescriptor validation
   287  func TestIVDetailFIViewDescriptor(t *testing.T) {
   288  	ivDetail := mockImageViewDetail()
   289  	ivDetail.ViewDescriptor = ""
   290  	err := ivDetail.Validate()
   291  	var e *FieldError
   292  	require.ErrorAs(t, err, &e)
   293  	require.Equal(t, "ViewDescriptor", e.FieldName)
   294  }
   295  
   296  // TestIVDetailRuneCountInString validates RuneCountInString
   297  func TestIVDetailRuneCountInString(t *testing.T) {
   298  	ivDetail := NewImageViewDetail()
   299  	var line = "50"
   300  	ivDetail.Parse(line)
   301  
   302  	require.Equal(t, "", ivDetail.ImageCreatorRoutingNumber)
   303  }