def test_customer(self):
        logger.info("begin test_customer")
        fields_by_name = {}
        for field in self.meta.record_defs["customer"]:
            fields_by_name[field["field_name"]] = field
        crc = CustomerRecord()
        record = crc.record

        key_value = field_metadata.get_bind_map(self.record_types["CD"], record)
        self.assertEqual(key_value["SHIP_TO_CUST_ID"], crc.ship_to_id)

        self.assertEqual(key_value["CUST_NM"], crc.cust_name.rstrip())
        self.assertEqual(key_value["ADDR_1"], crc.addr1.rstrip())
        self.assertEqual(key_value["ADDR_2"], crc.addr2.rstrip())
        self.assertEqual(key_value["CITY"], crc.city.rstrip())
        self.assertEqual(key_value["STATE"], crc.state.rstrip())
        self.assertEqual(key_value["POSTAL_CD"], crc.postal_code.rstrip())
        self.assertEqual(key_value["TEL_NBR"], crc.phone.rstrip())
        self.assertEqual(key_value["NATIONAL_ACCT_ID"], crc.nat.rstrip())
        self.assertEqual(key_value["SPECIAL_FLG"], crc.flag.rstrip())
        self.assertEqual(key_value["FILLER_1"].rstrip(), crc.filler_1.rstrip())
        self.assertEqual(key_value["RECORD_TYPE"], crc.record_type.rstrip())

        # x = FieldMetadata("SA", field_metadata.NUMERIC, length=2)

        # print x

        outrec = field_metadata.format_line(self.record_types["CD"], key_value)
        # rulers.print_rulers()
        # print (record)
        # print (outrec)
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
        logger.info("end test_customer")
    def test_sale(self):
        fields_by_name = {}
        for field in self.meta.record_defs["customer"]:
            fields_by_name[field["field_name"]] = field

        sr = SalesRecord()
        record = sr.record
        # rulers.print_rulers()
        # print (record)
        record_def = self.record_types["SA"]
        # for field_def in record_def:
        #    print (field_def)


        key_value = field_metadata.get_bind_map(record_def, record)

        self.assertEqual(key_value["DISTRIB_ID"], sr.distributor_id)
        self.assertEqual(key_value["MFR_ID"], sr.mfr_id)
        self.assertEqual(key_value["MFR_PRODUCT_ID"], sr.mfr_product_id)
        self.assertEqual(key_value["SHIP_TO_CUST_ID"], sr.ship_to_cust_id)
        self.assertEqual(key_value["INVOICE_CD"], sr.invoice_nbr)

        self.assertEqual(key_value["INVOICE_DT"], datetime.datetime.strptime(sr.invoice_dt, "%Y%m%d"))

        self.assertEqual(
            key_value["SHIP_DT"], datetime.datetime.strptime(sr.ship_dt, "%Y%m%d")
        )
        self.assertEqual(key_value["EXTENDED_NET_AMT"], int(sr.extended_net))  # TODO need to divide by 100
        self.assertEqual(key_value["DISTRIB_PRODUCT_REF"], sr.distrib_product_id)
        self.assertEqual(key_value["PRODUCT_DESCR"], sr.product_description.rstrip())
        self.assertEqual(key_value["CASES_SHIPPED"], int(sr.cases_shipped))
        self.assertEqual(key_value["BOXES_SHIPPED"], int(sr.boxes_shipped))
        self.assertEqual(key_value["UNITS_SHIPPED"], int(sr.units_shipped))
        self.assertEqual(key_value["CASE_GTIN"], sr.case_gtin)
        self.assertEqual(key_value["RECORD_TYPE"], sr.record_type)

        outrec = field_metadata.format_line(self.record_types["SA"], key_value)
        # rulers.print_rulers()

        self.sales_rec = outrec
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
    def test_customer_total(self):
        logger.info("begin test_customer_total")
        # field_dictionary = field_metadata.get_field_dictionary(self.meta.record_defs["inventory"])
        ct = CustomerTotalRecord()
        record = ct.record
        key_value = field_metadata.get_bind_map(self.record_types["CT"], record)

        self.assertEqual(key_value["HEADER"], ct.header)
        self.assertEqual(key_value["FILLER_127"], ct.filler127)
        self.assertEqual(key_value["CUSTOMER_COUNT"], int(ct.total_record_count))
        self.assertEqual(key_value["FILLER_22"], ct.filler22)
        self.assertEqual(key_value["RECORD_TYPE"], ct.record_type)

        outrec = field_metadata.format_line(self.record_types["CT"], key_value)
        self.customer_total_rec = outrec

        # rulers.print_rulers()
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
        logger.info("end test_customer_total")
    def test_sales_total(self):
        logger.info("begin test_sales_total")
        sales_tot = SalesTotalRecord()
        record = sales_tot.record
        key_value = field_metadata.get_bind_map(self.record_types["AT"], record)

        self.assertEqual(key_value["HEADER"], sales_tot.record_header)
        self.assertEqual(key_value["FILLER_28"], sales_tot.filler28)
        self.assertEqual(key_value["SALES_START_DT"], datetime.datetime.strptime(sales_tot.period_covered_start_date, '%Y%m%d'))
        self.assertEqual(key_value["SALES_END_DT"], datetime.datetime.strptime(sales_tot.period_covered_end_date, '%Y%m%d'))
        self.assertEqual(key_value["FILE_CREATE_DT"], datetime.datetime.strptime(sales_tot.file_creation_date, '%Y%m%d'))
        self.assertEqual(key_value["SALES_REC_CNT"], int(sales_tot.total_record_count))
        self.assertEqual(key_value["SUM_EXT_NET_AMT"], int(sales_tot.total_amount))
        self.assertEqual(key_value["RECORD_TYPE"], sales_tot.record_type)
        outrec = field_metadata.format_line(self.record_types["AT"], key_value)
        # rulers.print_rulers()
        self.sales_total_rec = outrec
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
        logger.info("end test_sales_total")
    def test_inventory_total(self):
        logger.info("begin test_inventory_total")
        itr = InventoryTotalRecord()
        record = itr.record
        key_value = field_metadata.get_bind_map(self.record_types["IT"], record)

        self.assertEqual(key_value["HEADER"], itr.header)
        self.assertEqual(len(key_value["FILLER36"]), 36)
        self.assertEqual(key_value["FILLER36"], itr.filler36)
        self.assertEqual(key_value["INVENTORY_DT"], datetime.datetime.strptime(itr.inventory_date, '%Y%m%d'))
        self.assertEqual(key_value["FILE_CREATION_DT"], datetime.datetime.strptime(itr.file_creation_date, '%Y%m%d'))
        self.assertEqual(key_value["RECORD_CNT_REPORTED"], int(itr.total_record_count))
        self.assertEqual(key_value["FILLER97"], itr.filler97)
        self.assertEqual(key_value["RECORD_TYPE"], itr.record_type)
        outrec = field_metadata.format_line(self.record_types["IT"], key_value)
        self.inventory_total_rec = outrec

        # rulers.print_rulers()
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
        logger.info("end test_inventory_total")
    def test_inventory(self):
        logger.info("begin test_inventory")
        ir = InventoryRecord()
        record = ir.record
        key_value = field_metadata.get_bind_map(self.record_types["IR"], record)

        self.assertEqual(key_value["DISTRIBUTOR_ID"], ir.distributor_id)
        self.assertEqual(key_value["MFR_PRODUCT_ID"], ir.mfr_product_id)
        self.assertEqual(key_value["COMMENTS"], ir.comments)
        self.assertEqual(key_value["CASES"], int(ir.cases))
        self.assertEqual(key_value["BOXES"], int(ir.boxes))
        self.assertEqual(key_value["UNITS"], int(ir.units))
        self.assertEqual(key_value["CASE_GTIN"], ir.case_gtin)
        self.assertEqual(key_value["RECORD_TYPE"], ir.record_type)

        outrec = field_metadata.format_line(self.record_types["IR"], key_value)
        self.inventory_rec = outrec

        logger.info("about to print records")
        logger.info(record)
        logger.info(outrec)
        self.assertEqual(record, outrec)
        logger.info("end test_inventory")