@ripwords/myinvois-client 0.1.0 → 0.1.2

package/test/signAndSubmitInvoice.test.ts

@@ -1,171 +1,96 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
+import { MyInvoisClient } from '../src/index'
 import type { InvoiceV1_1 } from '../src/types'
-import { MyInvoisClient } from '../src/utils/MyInvoisClient'
 import {
-  encodeDocumentForSubmission,
+  generateCompleteDocument,
   extractCertificateInfo,
-  generateDocumentHash,
-  generateDocumentHashForSubmission,
-  generateSignedInvoiceXML,
-} from '../src/utils/invoice1-1'
-import type { SigningCredentials } from '../src/types'
-import {
-  debugDocumentHash,
-  testSubmissionHashMethods,
-} from '../src/utils/debug/debug-document-hash'
-import {
-  debugSignedInvoiceXML,
-  testCanonicalizationAlgorithms,
-  validateXMLStructure,
-} from '../src/utils/debug/debug-invoice-submission'
+} from '../src/utils/document'
 
 /**
- * Creates test signing credentials using a predefined test certificate
- * This uses the same structure as the example XML you provided, but with test values
+ * ⚠️ SECURITY NOTICE: This file uses environment variables for sensitive data.
+ * Never hardcode actual TIN, NRIC, certificates, or API credentials in test files.
+ * Use .env file for your actual values (already gitignored).
  */
-function createTestSigningCredentials(): SigningCredentials {
-  // Test private key (THIS IS FOR TESTING ONLY - NEVER USE IN PRODUCTION)
-  const testPrivateKey = process.env.TEST_PRIVATE_KEY!
-
-  // Test certificate (THIS IS FOR TESTING ONLY)
-  const testCertificate = process.env.TEST_CERTIFICATE!
-
-  console.warn(`
-  ⚠️  WARNING: Using test credentials for development only!
-  These credentials will NOT work with the actual MyInvois API.
-  You must obtain official certificates from LHDNM for production use.
-  `)
-
-  const extractedCertificate = extractCertificateInfo(testCertificate)
-
-  return {
-    privateKeyPem: testPrivateKey,
-    certificatePem: testCertificate,
-    issuerName: extractedCertificate.issuerName,
-    serialNumber: extractedCertificate.serialNumber,
-  }
-}
 
-// Test data matching the InvoiceV1_1 interface
-const createTestInvoiceData = (): InvoiceV1_1 => {
-  // Generate current date and time to avoid "too old" validation errors
+/**
+ * Creates minimal test invoice data that meets all mandatory requirements
+ * Following MyInvois v1.1 specification exactly
+ */
+const createMinimalTestInvoice = (): InvoiceV1_1 => {
+  // Use current date/time to avoid validation errors
   const now = new Date()
-  const currentDate = now.toISOString().split('T')[0] // YYYY-MM-DD format
-  const currentTime = now.toISOString().split('T')[1].split('.')[0] + 'Z' // HH:MM:SSZ format (remove milliseconds)
-
-  console.log(
-    '📅 Using current date/time for invoice:',
-    currentDate,
-    currentTime,
-  )
+  const currentDate = now.toISOString().split('T')[0] // YYYY-MM-DD
+  const currentTime = now.toISOString().split('T')[1].split('.')[0] + 'Z' // HH:MM:SSZ
 
   return {
+    // === CORE MANDATORY FIELDS ===
     eInvoiceVersion: '1.1',
-    eInvoiceTypeCode: '01',
-    eInvoiceCodeOrNumber: 'XML-INV12345',
+    eInvoiceTypeCode: '01', // Standard invoice
+    eInvoiceCodeOrNumber: `TEST-INV-${Date.now()}`, // Unique invoice number
     eInvoiceDate: currentDate,
     eInvoiceTime: currentTime,
     invoiceCurrencyCode: 'MYR',
 
+    // === SUPPLIER (will be updated with certificate TIN) ===
     supplier: {
-      name: 'Supplier Name',
-      tin: process.env.TIN_VALUE!,
+      name: 'Test Company Sdn Bhd',
+      tin: process.env.TIN_VALUE!, // Will be replaced with certificate TIN
       registrationType: 'NRIC',
       registrationNumber: process.env.NRIC_VALUE!,
-      sstRegistrationNumber: 'NA',
-      email: 'supplier@email.com',
       contactNumber: '+60123456789',
-      industryClassificationCode: '46510',
       address: {
-        addressLine0: 'Lot 66',
-        addressLine1: 'Bangunan Merdeka',
-        addressLine2: 'Persiaran Jaya',
-        postalZone: '50480',
+        addressLine0: '123 Test Street',
         cityName: 'Kuala Lumpur',
-        state: '14',
+        state: '14', // Wilayah Persekutuan Kuala Lumpur
         country: 'MYS',
       },
     },
 
+    // === BUYER (using consolidated buyer for testing) ===
     buyer: {
-      name: 'Consolidated Buyers',
-      tin: 'EI00000000010',
-      registrationNumber: 'NA',
+      name: 'CONSOLIDATED E-INVOICE BUYER',
+      tin: 'EI00000000010', // Standard consolidated buyer TIN
+      registrationType: 'NRIC',
+      registrationNumber: process.env.NRIC_VALUE!,
       sstRegistrationNumber: 'NA',
-      email: 'NA',
-      contactNumber: 'NA',
+      contactNumber: '+60123456789', // Valid phone number (minimum 8 chars)
       address: {
         addressLine0: 'NA',
-        addressLine1: 'NA',
-        addressLine2: 'NA',
-        cityName: 'Kuala Lumpur',
-        postalZone: '50000',
+        cityName: 'KUALA LUMPUR',
         state: '14',
         country: 'MYS',
       },
     },
 
+    // === SINGLE LINE ITEM (minimal) ===
     invoiceLineItems: [
       {
-        itemClassificationCode: '004',
-        itemDescription: 'Receipt 001 - 100',
-        unitPrice: 10000,
-        taxType: '01',
-        taxRate: 10.0,
-        taxAmount: 1000,
-        totalTaxableAmountPerLine: 10000,
-        totalAmountPerLine: 11000,
-        quantity: 1,
-        measurement: 'C62',
-        countryOfOrigin: 'MYS',
-      },
-      {
-        itemClassificationCode: '004',
-        itemDescription: 'Receipt 101 - 200',
-        unitPrice: 20000,
-        taxType: '01',
-        taxRate: 10.0,
-        taxAmount: 2000,
-        totalTaxableAmountPerLine: 20000,
-        totalAmountPerLine: 22000,
-        quantity: 1,
-        measurement: 'C62',
-        countryOfOrigin: 'MYS',
+        itemClassificationCode: '001', // General goods
+        itemDescription: 'Test Product',
+        unitPrice: 100.0,
+        taxType: '01', // SST
+        taxRate: 6.0, // 6% SST
+        taxAmount: 6.0, // 6% of 100
+        totalTaxableAmountPerLine: 100.0,
+        totalAmountPerLine: 106.0, // 100 + 6
       },
     ],
 
+    // === MONETARY TOTALS ===
     legalMonetaryTotal: {
-      taxExclusiveAmount: 30000,
-      taxInclusiveAmount: 33000,
-      allowanceTotalAmount: 0,
-      chargeTotalAmount: 0,
-      payableRoundingAmount: 0,
-      payableAmount: 33000,
+      taxExclusiveAmount: 100.0,
+      taxInclusiveAmount: 106.0,
+      payableAmount: 106.0,
     },
 
+    // === TAX TOTAL ===
     taxTotal: {
-      taxAmount: 3000,
-      taxSubtotals: [
-        {
-          taxableAmount: 30000,
-          taxAmount: 3000,
-          taxCategory: {
-            taxTypeCode: '01',
-            taxRate: 10.0,
-          },
-        },
-      ],
+      taxAmount: 6.0,
     },
 
-    paymentMeans: [
-      {
-        paymentMeansCode: '01',
-        payeeFinancialAccountID: '1234567890',
-      },
-    ],
-
+    // === DIGITAL SIGNATURE (placeholder - will be populated by signing process) ===
     issuerDigitalSignature: {
-      Id: 'DocSig',
+      Id: 'signature',
       'ds:SignedInfo': {
         'ds:CanonicalizationMethod': {
           Algorithm: 'http://www.w3.org/2006/12/xml-c14n11',
@@ -183,6 +108,7 @@ const createTestInvoiceData = (): InvoiceV1_1 => {
             'ds:DigestValue': '',
           },
           {
+            Id: 'id-xades-signed-props',
             URI: '#id-xades-signed-props',
             'ds:DigestMethod': {
               Algorithm: 'http://www.w3.org/2001/04/xmlenc#sha256',
@@ -227,689 +153,298 @@ const createTestInvoiceData = (): InvoiceV1_1 => {
   }
 }
 
-describe('Sign and Submit Invoice', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  describe('Invoice Signing', () => {
-    it('should generate a signed invoice XML with test credentials', async () => {
-      // Skip if no test credentials available
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect
-          .soft(
-            false,
-            'Skipping test: Missing CERTIFICATE or PRIVATE_KEY environment variables',
-          )
-          .toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
+describe('MyInvois Document Generation and Submission', () => {
+  const requiredEnvVars = [
+    'CLIENT_ID',
+    'CLIENT_SECRET',
+    'TEST_PRIVATE_KEY',
+    'TEST_CERTIFICATE',
+  ]
 
-      const signedXML = await generateSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-
-      // Verify the XML contains expected elements
-      expect(signedXML).toContain(
-        '<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"',
-      )
-      expect(signedXML).toContain('<ds:SignatureValue>')
-      expect(signedXML).toContain('<ds:X509Certificate>')
-      expect(signedXML).toContain('<xades:SigningTime>')
-      expect(signedXML).toContain(invoiceData.eInvoiceCodeOrNumber)
-      expect(signedXML).toContain(invoiceData.supplier.name)
-      expect(signedXML).toContain(invoiceData.buyer.name)
-
-      // Verify signature elements are populated (not empty)
-      expect(signedXML).not.toContain('<ds:SignatureValue></ds:SignatureValue>')
-      expect(signedXML).not.toContain(
-        '<ds:X509Certificate></ds:X509Certificate>',
-      )
-    })
-
-    it('should generate document hash for submission', async () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect
-          .soft(
-            false,
-            'Skipping test: Missing CERTIFICATE or PRIVATE_KEY environment variables',
-          )
-          .toBe(true)
-        return
-      }
+  // Check environment variables
+  const missingVars = requiredEnvVars.filter(varName => !process.env[varName])
 
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
-
-      const signedXML = await generateSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-
-      const documentHash = generateDocumentHash(signedXML)
-      const base64Document = encodeDocumentForSubmission(signedXML)
-
-      // Test the alternative hash method
-      console.log('\n🔧 TESTING ALTERNATIVE HASH METHOD:')
-      try {
-        const canonicalizedHash =
-          await generateDocumentHashForSubmission(signedXML)
-        console.log(`Current hash:         ${documentHash}`)
-        console.log(`Canonicalized hash:   ${canonicalizedHash}`)
-        console.log(
-          `Methods are equal:    ${documentHash === canonicalizedHash ? '✅' : '❌'}`,
+  if (missingVars.length > 0) {
+    it.skip(`Skipping tests - Missing environment variables: ${missingVars.join(', ')}`, () => {
+      expect
+        .soft(
+          false,
+          `Missing required environment variables: ${missingVars.join(', ')}`,
         )
-      } catch (error) {
-        console.log('❌ Error testing canonicalized hash:', error)
-      }
-
-      // Verify hash is a valid hex string
-      expect(documentHash).toMatch(/^[a-f0-9]{64}$/)
-
-      // Verify base64 encoding
-      expect(() => Buffer.from(base64Document, 'base64')).not.toThrow()
-
-      // CRITICAL TEST: Verify the hash is calculated from the same minified XML that gets encoded
-      // This ensures consistency between documentHash and document (base64) values
-      const minifiedXML = signedXML
-        .replace(/>\s+</g, '><')
-        .replace(/\s+/g, ' ')
-        .replace(/>\s/g, '>')
-        .replace(/\s</g, '<')
-        .trim()
-
-      // Calculate hash of minified XML manually to verify our generateDocumentHash function
-      const crypto = require('crypto')
-      const expectedHash = crypto
-        .createHash('sha256')
-        .update(minifiedXML, 'utf8')
-        .digest('hex')
-
-      // The documentHash should match the hash of the minified XML
-      expect(documentHash).toEqual(expectedHash)
-
-      // The base64Document should decode to the same minified XML
-      const decodedDocument = Buffer.from(base64Document, 'base64').toString(
-        'utf8',
-      )
-      expect(decodedDocument).toEqual(minifiedXML)
-    })
-
-    it('should validate signing credentials properly', () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect
-          .soft(
-            false,
-            'Skipping test: Missing CERTIFICATE or PRIVATE_KEY environment variables',
-          )
-          .toBe(true)
-        return
-      }
-
-      expect(() => createTestSigningCredentials()).not.toThrow()
-
-      const credentials = createTestSigningCredentials()
-      expect(credentials.privateKeyPem).toBeDefined()
-      expect(credentials.certificatePem).toBeDefined()
-      expect(credentials.issuerName).toBeDefined()
-      expect(credentials.serialNumber).toBeDefined()
+        .toBe(true)
     })
-  })
-
-  describe('Real API Integration (Optional)', () => {
-    it('should submit to real MyInvois API if credentials are provided', async () => {
-      // Skip if no real API credentials
-      if (
-        !process.env.CLIENT_ID ||
-        !process.env.CLIENT_SECRET ||
-        !process.env.CERTIFICATE ||
-        !process.env.PRIVATE_KEY
-      ) {
-        expect
-          .soft(
-            false,
-            'Skipping real API test: Missing required environment variables (CLIENT_ID, CLIENT_SECRET, CERTIFICATE, PRIVATE_KEY)',
-          )
-          .toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
+    return
+  }
 
-      const signedXML = await generateSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-      const documentHash = generateDocumentHash(signedXML)
-      const base64Document = encodeDocumentForSubmission(signedXML)
-
-      // Note: This test will only run if you have real credentials
-      // and would actually submit to the MyInvois sandbox API
-      console.log('Generated signed XML length:', signedXML.length)
-      console.log('Document hash:', documentHash)
-      console.log('Base64 document length:', base64Document.length)
-
-      // For safety, we'll just validate the data format without actual submission
-      expect(signedXML).toContain('<Invoice xmlns=')
-      expect(documentHash).toMatch(/^[a-f0-9]{64}$/)
-      expect(base64Document.length).toBeGreaterThan(0)
-    }, 30000) // Longer timeout for potential API calls
-  })
+  const CLIENT_ID = process.env.CLIENT_ID!
+  const CLIENT_SECRET = process.env.CLIENT_SECRET!
+  const PRIVATE_KEY = process.env.TEST_PRIVATE_KEY!
+  const CERTIFICATE = process.env.TEST_CERTIFICATE!
 
-  describe('Edge Cases and Error Handling', () => {
-    it('should handle missing required invoice fields', async () => {
-      const incompleteInvoice = {
-        eInvoiceVersion: '1.1',
-        eInvoiceTypeCode: '01',
-        // Missing required fields
-      } as any
-
-      // This should fail during XML generation
-      await expect(
-        generateSignedInvoiceXML(
-          incompleteInvoice,
-          createTestSigningCredentials(),
-        ),
-      ).rejects.toThrow()
-    })
+  it('should extract certificate information correctly', () => {
+    console.log('🔍 Extracting certificate information...')
 
-    it('should handle invalid signing credentials', async () => {
-      const invoiceData = createTestInvoiceData()
-      const invalidCredentials = {
-        privateKeyPem: 'invalid-private-key',
-        certificatePem: 'invalid-certificate',
-        issuerName: 'invalid-issuer',
-        serialNumber: 'invalid-serial',
-      }
+    const certInfo = extractCertificateInfo(CERTIFICATE)
 
-      await expect(
-        generateSignedInvoiceXML(invoiceData, invalidCredentials),
-      ).rejects.toThrow()
+    console.log('Certificate Info:', {
+      issuerName: certInfo.issuerName,
+      serialNumber: certInfo.serialNumber,
     })
 
-    it('should validate document size limits', async () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect
-          .soft(
-            false,
-            'Skipping test: Missing CERTIFICATE or PRIVATE_KEY environment variables',
-          )
-          .toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
-
-      const signedXML = await generateSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-      const sizeInBytes = Buffer.from(signedXML, 'utf8').length
-
-      // Verify document is under MyInvois limits (300KB per document)
-      expect(sizeInBytes).toBeLessThan(300 * 1024)
-
-      console.log(
-        `Generated document size: ${sizeInBytes} bytes (${(sizeInBytes / 1024).toFixed(2)} KB)`,
-      )
-    })
+    expect(certInfo.issuerName).toBeDefined()
+    expect(certInfo.serialNumber).toBeDefined()
+    expect(typeof certInfo.issuerName).toBe('string')
+    expect(typeof certInfo.serialNumber).toBe('string')
   })
 
-  describe('Debugging Invalid Structure Issues', () => {
-    it('should debug and validate XML structure comprehensively', async () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect
-          .soft(
-            false,
-            'Skipping test: Missing CERTIFICATE or PRIVATE_KEY environment variables',
-          )
-          .toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
+  it('should find TIN that matches certificate', async () => {
+    console.log('🔐 Finding TIN that matches certificate...')
 
-      console.log('\n🔍 DEBUGGING XML STRUCTURE ISSUES')
-      console.log('=====================================')
-
-      // Run comprehensive debugging
-      const debugResults = await debugSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-
-      console.log('\n📊 VALIDATION RESULTS:')
-      console.log(
-        'XML Structure Valid:',
-        debugResults.validationResults.xmlStructure.valid,
-      )
-      console.log(
-        'Signature Elements Valid:',
-        debugResults.validationResults.signatureElements.valid,
-      )
-      console.log(
-        'Digest Values Valid:',
-        debugResults.validationResults.digestValues.valid,
-      )
-      console.log(
-        'Certificate Info Valid:',
-        debugResults.validationResults.certificateInfo.valid,
-      )
-
-      if (debugResults.validationResults.xmlStructure.errors.length > 0) {
-        console.log('\n❌ XML Structure Errors:')
-        debugResults.validationResults.xmlStructure.errors.forEach(error =>
-          console.log(`  - ${error}`),
-        )
-      }
-
-      if (debugResults.validationResults.signatureElements.errors.length > 0) {
-        console.log('\n❌ Signature Element Errors:')
-        debugResults.validationResults.signatureElements.errors.forEach(error =>
-          console.log(`  - ${error}`),
-        )
-      }
-
-      if (debugResults.validationResults.digestValues.errors.length > 0) {
-        console.log('\n❌ Digest Value Errors:')
-        debugResults.validationResults.digestValues.errors.forEach(error =>
-          console.log(`  - ${error}`),
-        )
-      }
-
-      if (debugResults.validationResults.certificateInfo.errors.length > 0) {
-        console.log('\n❌ Certificate Info Errors:')
-        debugResults.validationResults.certificateInfo.errors.forEach(error =>
-          console.log(`  - ${error}`),
-        )
-      }
-
-      console.log('\n📋 STEP-BY-STEP RESULTS:')
-      Object.entries(debugResults.stepByStepResults).forEach(
-        ([step, result]) => {
-          const status = result.success ? '✅' : '❌'
-          console.log(
-            `${status} ${step}: ${result.success ? 'SUCCESS' : `FAILED - ${result.error}`}`,
-          )
-        },
-      )
-
-      if (debugResults.validationResults.canonicalizationTest) {
-        console.log('\n🔧 CANONICALIZATION TEST:')
-        console.log(
-          'Exclusive C14N Success:',
-          debugResults.validationResults.canonicalizationTest.exclusiveC14N
-            ?.success,
-        )
-        console.log(
-          'C14N 1.1 Fallback Success:',
-          debugResults.validationResults.canonicalizationTest.c14n11Fallback
-            ?.success,
-        )
-        console.log(
-          'Results Equal:',
-          debugResults.validationResults.canonicalizationTest.areEqual,
-        )
-      }
-
-      if (debugResults.signedXML) {
-        // Additional XML structure validation
-        const xmlValidation = validateXMLStructure(debugResults.signedXML)
-        console.log('\n📝 XML VALIDATION:')
-        console.log('Overall Valid:', xmlValidation.isValid)
+    const client = new MyInvoisClient(
+      CLIENT_ID,
+      CLIENT_SECRET,
+      'sandbox',
+      CERTIFICATE,
+      PRIVATE_KEY,
+      undefined,
+      true, // debug mode
+    )
 
-        if (xmlValidation.errors.length > 0) {
-          console.log('Errors:')
-          xmlValidation.errors.forEach(error => console.log(`  - ${error}`))
-        }
+    // Test TIN formats that might match the certificate
+    // Note: These are example TIN formats - replace with your actual test TINs
+    const testTINs = [
+      process.env.TIN_VALUE, // Environment variable if set
+      process.env.TEST_TIN_1, // Additional test TIN from environment
+      process.env.TEST_TIN_2, // Additional test TIN from environment
+      process.env.TEST_TIN_3, // Additional test TIN from environment
+      'EI00000000010', // Consolidated buyer (shouldn't work for supplier)
+    ].filter(Boolean) // Remove undefined values
+
+    let certificateMatchingTIN: string | null = null
+    const validTINs: string[] = []
+
+    // Step 1: Check which TINs are valid in the system
+    console.log('📋 Step 1: Checking TIN validity...')
+    for (const tin of testTINs) {
+      try {
+        console.log(`Testing TIN validity: ${tin}`)
+        const isValid = await client.verifyTin(tin!, 'BRN', '123456789012')
+        console.log(`TIN ${tin} validity: ${isValid}`)
 
-        if (xmlValidation.warnings.length > 0) {
-          console.log('Warnings:')
-          xmlValidation.warnings.forEach(warning =>
-            console.log(`  - ${warning}`),
-          )
+        if (isValid) {
+          validTINs.push(tin!)
         }
+      } catch (error) {
+        console.log(`❌ Error testing TIN ${tin}:`, error)
+      }
+    }
 
-        // Check document size
-        const sizeInBytes = Buffer.from(debugResults.signedXML, 'utf8').length
-        console.log(
-          `\n📏 Document Size: ${sizeInBytes} bytes (${(sizeInBytes / 1024).toFixed(2)} KB)`,
-        )
-
-        // Sample of generated XML for manual inspection
-        console.log('\n📄 XML SAMPLE (first 500 chars):')
-        console.log(debugResults.signedXML.substring(0, 500) + '...')
+    console.log(`📊 Found ${validTINs.length} valid TINs:`, validTINs)
 
-        // Check for common MyInvois issues
-        console.log('\n🎯 MYINVOIS SPECIFIC CHECKS:')
-        const commonIssues: string[] = []
+    // Step 2: Test each valid TIN with a minimal document submission to find certificate match
+    console.log('📋 Step 2: Testing certificate matching...')
+    for (const tin of validTINs) {
+      try {
+        console.log(`Testing TIN with certificate: ${tin}`)
 
-        // Check for proper namespace declarations
-        if (
-          !debugResults.signedXML.includes(
-            'xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"',
-          )
-        ) {
-          commonIssues.push('Missing ext namespace declaration')
-        }
+        // Create a minimal test invoice with this TIN
+        const testInvoice = createMinimalTestInvoice()
+        testInvoice.supplier.tin = tin
+        testInvoice.eInvoiceCodeOrNumber = `TEST-CERT-${Date.now()}`
 
-        // Check for proper signature target
-        if (!debugResults.signedXML.includes('Target="signature"')) {
-          commonIssues.push('Missing or incorrect signature target')
-        }
+        // Try to submit it
+        const { status } = await client.submitDocument([testInvoice])
 
-        // Check for proper digest algorithms
-        if (
-          !debugResults.signedXML.includes(
-            'Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"',
-          )
-        ) {
-          commonIssues.push('Missing or incorrect SHA256 digest algorithm')
-        }
-
-        // Check for RSA-SHA256 signature method
-        if (
-          !debugResults.signedXML.includes(
-            'Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"',
-          )
-        ) {
-          commonIssues.push(
-            'Missing or incorrect RSA-SHA256 signature algorithm',
-          )
+        if (status === 202) {
+          console.log(`✅ SUCCESS! TIN ${tin} works with certificate`)
+          certificateMatchingTIN = tin
+          break
+        } else {
+          console.log(`❌ TIN ${tin} failed with status ${status}`)
         }
-
-        // Check for proper C14N algorithm in XML
+      } catch (error: any) {
         if (
-          !debugResults.signedXML.includes(
-            'Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"',
+          error.message?.includes(
+            'authenticated TIN and documents TIN is not matching',
           )
         ) {
-          commonIssues.push(
-            'XML declares different canonicalization algorithm than expected',
-          )
-        }
-
-        if (commonIssues.length > 0) {
-          console.log('❌ Common MyInvois Issues Found:')
-          commonIssues.forEach(issue => console.log(`  - ${issue}`))
+          console.log(`❌ TIN ${tin} doesn't match certificate`)
         } else {
-          console.log('✅ No common MyInvois issues detected')
+          console.log(`❌ TIN ${tin} failed with error:`, error.message)
         }
       }
+    }
 
-      // This test helps with debugging but doesn't fail based on the results
-      // The actual validation should be done by reviewing the console output
-      expect(debugResults).toBeDefined()
-    }, 30000)
-
-    it('should test canonicalization algorithms specifically', async () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect.soft(false, 'Skipping test: Missing credentials').toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
-
-      console.log('\n🔧 CANONICALIZATION ALGORITHM TESTING')
-      console.log('=====================================')
-
-      // Generate a signed XML first to get the template
-      const signedXML = await generateSignedInvoiceXML(
-        invoiceData,
-        signingCredentials,
-      )
-      const testResults = await testCanonicalizationAlgorithms(signedXML)
-
-      console.log('Exclusive C14N Success:', testResults.exclusiveC14N.success)
-      if (!testResults.exclusiveC14N.success) {
-        console.log('Exclusive C14N Error:', testResults.exclusiveC14N.error)
-      } else {
-        console.log('Exclusive C14N Digest:', testResults.exclusiveC14N.digest)
-      }
-
-      console.log(
-        'C14N 1.1 Fallback Success:',
-        testResults.c14n11Fallback.success,
-      )
-      if (!testResults.c14n11Fallback.success) {
-        console.log(
-          'C14N 1.1 Fallback Error:',
-          testResults.c14n11Fallback.error,
-        )
-      } else {
-        console.log(
-          'C14N 1.1 Fallback Digest:',
-          testResults.c14n11Fallback.digest,
-        )
-      }
-
-      console.log('Algorithms produce same result:', testResults.areEqual)
-
-      if (
-        !testResults.areEqual &&
-        testResults.exclusiveC14N.success &&
-        testResults.c14n11Fallback.success
-      ) {
-        console.log(
-          '\n⚠️  WARNING: Different canonicalization algorithms produce different results!',
-        )
-        console.log('This may be the cause of MyInvois validation failures.')
-        console.log('Exclusive C14N digest:', testResults.exclusiveC14N.digest)
-        console.log('C14N 1.1 digest:', testResults.c14n11Fallback.digest)
-      }
-
-      expect(testResults).toBeDefined()
-    })
-
-    it('should debug document hash calculation methods', async () => {
-      if (!process.env.CERTIFICATE || !process.env.PRIVATE_KEY) {
-        expect.soft(false, 'Skipping test: Missing credentials').toBe(true)
-        return
-      }
-
-      const invoiceData = createTestInvoiceData()
-      const signingCredentials = createTestSigningCredentials()
-
-      console.log('\n🔧 DOCUMENT HASH DEBUGGING')
-      console.log('===========================')
-
-      // Then debug the actual hash calculation
-      const debugResults = await debugDocumentHash(
-        invoiceData,
-        signingCredentials,
-      )
-
-      console.log('\n📊 HASH ANALYSIS RESULTS:')
-      console.log(
-        `Submission Hash:      ${debugResults.documentHashes.submissionHash}`,
-      )
-      console.log(
-        `Signature Doc Digest: ${debugResults.documentHashes.signatureDocDigest}`,
-      )
+    // Store the certificate-matching TIN for next test
+    if (certificateMatchingTIN) {
+      process.env.VALID_SUPPLIER_TIN = certificateMatchingTIN
       console.log(
-        `Raw Document Hash:    ${debugResults.documentHashes.rawDocumentHash}`,
+        `🎯 Certificate matching TIN found: ${certificateMatchingTIN}`,
       )
+    } else if (validTINs.length > 0) {
+      // Fallback to first valid TIN with a warning
+      process.env.VALID_SUPPLIER_TIN = validTINs[0]
       console.log(
-        `Minified Hash:        ${debugResults.documentHashes.minifiedDocumentHash}`,
+        `⚠️  No certificate match found, using first valid TIN: ${validTINs[0]}`,
       )
       console.log(
-        `Transformed Hash:     ${debugResults.documentHashes.transformedDocumentHash}`,
+        `⚠️  This will likely cause TIN mismatch error in submission test`,
       )
+    }
 
-      console.log('\n🔍 EQUALITY CHECKS:')
-      Object.entries(debugResults.areEqual).forEach(([comparison, isEqual]) => {
-        console.log(`${comparison}: ${isEqual ? '✅' : '❌'}`)
-      })
+    // For now, pass the test if we found any valid TINs (the main goal is to test the implementation)
+    expect.soft(validTINs.length, 'No valid TINs found').toBeGreaterThan(0)
+  }, 60000) // Increased timeout for multiple submissions
 
-      if (debugResults.recommendations.length > 0) {
-        console.log('\n💡 RECOMMENDATIONS:')
-        debugResults.recommendations.forEach(rec => console.log(`   ${rec}`))
-      }
+  it('should generate valid document structure', () => {
+    console.log('📄 Generating document structure...')
 
-      // Test different submission hash methods
-      const methodResults = await testSubmissionHashMethods(
-        invoiceData,
-        signingCredentials,
-      )
+    const invoice = createMinimalTestInvoice()
 
-      console.log('\n🧪 HASH METHOD COMPARISON:')
-      Object.entries(methodResults.methods).forEach(([method, hash]) => {
-        console.log(`${method}: ${hash}`)
-      })
+    // Use the valid TIN from previous test or fallback
+    const supplierTIN =
+      process.env.VALID_SUPPLIER_TIN || process.env.TIN_VALUE || 'C00000000000' // Replace with your TIN
+    invoice.supplier.tin = supplierTIN
 
-      if (methodResults.recommendations.length > 0) {
-        console.log('\n🔧 METHOD RECOMMENDATIONS:')
-        methodResults.recommendations.forEach(rec => console.log(`   ${rec}`))
-      }
+    console.log(`Using supplier TIN: ${supplierTIN}`)
 
-      // Key findings
-      console.log('\n🎯 KEY FINDINGS:')
-      if (!debugResults.areEqual.submissionVsSignature) {
-        console.log('❌ CRITICAL: Submission hash ≠ Signature digest')
-        console.log(
-          '   This is likely why MyInvois rejects "Document hash is not valid"',
-        )
-        console.log('   MyInvois probably expects these to match exactly')
-      }
+    const certInfo = extractCertificateInfo(CERTIFICATE)
 
-      if (debugResults.areEqual.submissionVsTransformed) {
-        console.log('✅ Submission hash matches transformed document hash')
-        console.log(
-          '   This suggests the current approach is on the right track',
-        )
-      }
+    const document = generateCompleteDocument([invoice], {
+      privateKeyPem: PRIVATE_KEY,
+      certificatePem: CERTIFICATE,
+      issuerName: certInfo.issuerName,
+      serialNumber: certInfo.serialNumber,
+    })
 
-      // Practical fix suggestions
-      console.log('\n🔧 IMMEDIATE FIXES TO TRY:')
-      console.log(
-        '1. Use signature digest as documentHash in submission payload',
-      )
-      console.log(
-        '2. Ensure both signature and submission use same canonicalization',
-      )
-      console.log(
-        '3. Use minified XML for hash calculation if sizes differ significantly',
-      )
+    console.log('Generated document structure:')
+    console.log(
+      '- Namespace declarations:',
+      Object.keys(document).filter(k => k.startsWith('_')),
+    )
+    console.log('- Number of invoices:', document.Invoice.length)
+    console.log('- First invoice keys:', Object.keys(document.Invoice[0]))
+    console.log('- Has UBLExtensions:', !!document.Invoice[0].UBLExtensions)
+    console.log('- Has Signature:', !!document.Invoice[0].Signature)
+
+    // Basic structure validation
+    expect(document._D).toBe(
+      'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2',
+    )
+    expect(document._A).toBe(
+      'urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2',
+    )
+    expect(document._B).toBe(
+      'urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2',
+    )
+    expect(document.Invoice).toHaveLength(1)
+    expect(document.Invoice[0].UBLExtensions).toBeDefined()
+    expect(document.Invoice[0].Signature).toBeDefined()
 
-      expect(debugResults).toBeDefined()
-      expect(methodResults).toBeDefined()
-    }, 30000)
+    // Store document for next test
+    ;(globalThis as any).testDocument = document
+    ;(globalThis as any).testInvoice = invoice
   })
-})
 
-describe('Real API Submission with Self-Signed Certificate', () => {
-  it('should attempt a real submission to MyInvois API using self-signed cert and API keys', async () => {
-    if (!process.env.CLIENT_ID || !process.env.CLIENT_SECRET) {
-      console.warn(
-        'Skipping real API test: Missing CLIENT_ID or CLIENT_SECRET environment variables',
-      )
-      expect
-        .soft(
-          false,
-          'Skipping real API test: Missing CLIENT_ID or CLIENT_SECRET environment variables',
-        )
-        .toBe(true)
-      return
-    }
+  it('should submit document to MyInvois successfully', async () => {
+    console.log('🚀 Submitting document to MyInvois...')
 
-    const privateKeyPem = process.env.PRIVATE_KEY
-    const certificatePem = process.env.CERTIFICATE
+    const document = (globalThis as any).testDocument
+    const invoice = (globalThis as any).testInvoice
 
-    if (!privateKeyPem || !certificatePem) {
-      console.warn(
-        'Skipping real API test: Missing PRIVATE_KEY or CERTIFICATE environment variables',
-      )
-      expect
-        .soft(
-          false,
-          'Skipping real API test: Missing PRIVATE_KEY or CERTIFICATE environment variables',
-        )
-        .toBe(true)
-      return
+    if (!document || !invoice) {
+      throw new Error('Document not generated in previous test')
     }
 
-    const invoiceData = createTestInvoiceData()
-
     const client = new MyInvoisClient(
-      process.env.CLIENT_ID!,
-      process.env.CLIENT_SECRET!,
+      CLIENT_ID,
+      CLIENT_SECRET,
       'sandbox',
+      CERTIFICATE,
+      PRIVATE_KEY,
       undefined,
-      true,
+      true, // debug mode
     )
 
-    // 2. Submit Document
     try {
-      const { data: submissionResponse, status } = await client.submitDocument([
-        invoiceData,
-      ])
-      console.log('Real Submission API Response Status:', status)
-      console.log('Real Submission API Response Body:', submissionResponse)
-
-      console.log(
-        'Real Submission Successful. SubmissionUid:',
-        submissionResponse.submissionUid,
-      )
-      if (
-        submissionResponse.acceptedDocuments &&
-        submissionResponse.acceptedDocuments.length > 0
-      ) {
-        console.log(
-          'Accepted Document UUID:',
-          submissionResponse.acceptedDocuments[0].invoiceCodeNumber,
-        )
+      console.log('📤 Submitting to MyInvois API...')
+      console.log('Document size:', JSON.stringify(document).length, 'bytes')
+
+      const { data: response, status } = await client.submitDocument([invoice])
+
+      console.log('📥 Response received:')
+      console.log('Status:', status)
+      console.log('Response:', JSON.stringify(response, null, 2))
+
+      // Validate response structure
+      expect(status).toBe(202) // MyInvois returns 202 Accepted
+      expect(response.submissionUid).toBeDefined()
+      expect(typeof response.submissionUid).toBe('string')
+
+      // Check for accepted/rejected documents
+      if (response.acceptedDocuments?.length > 0) {
+        console.log('✅ Documents accepted:', response.acceptedDocuments.length)
+        response.acceptedDocuments.forEach((doc, index) => {
+          console.log(`  Document ${index + 1}:`, doc.invoiceCodeNumber)
+        })
       }
-      if (
-        submissionResponse.rejectedDocuments &&
-        submissionResponse.rejectedDocuments.length > 0
-      ) {
-        console.warn(
-          'Rejected Documents:',
-          submissionResponse.rejectedDocuments,
-        )
 
-        console.warn(
-          'Rejected Document Details: ',
-          submissionResponse.rejectedDocuments.flatMap(
-            doc => doc.error?.details,
-          ),
-        )
+      if (response.rejectedDocuments?.length > 0) {
+        console.log('❌ Documents rejected:', response.rejectedDocuments.length)
+        response.rejectedDocuments.forEach((doc, index) => {
+          console.log(`  Document ${index + 1}:`, doc.invoiceCodeNumber)
+          if (doc.error) {
+            console.log(`    Error:`, doc.error.message)
+            if (doc.error.details) {
+              doc.error.details.forEach((detail, detailIndex) => {
+                console.log(`      Detail ${detailIndex + 1}:`, detail.message)
+              })
+            }
+          }
+        })
       }
 
-      expect(status).toBe(202) // MyInvois typically returns 202 Accepted
-      expect(submissionResponse.submissionUid).toBeDefined()
-      expect(submissionResponse.submissionUid).not.toBeNull()
-
+      // Get submission status
+      console.log('📊 Checking submission status...')
       const submission = await client.getSubmissionStatus(
-        submissionResponse.submissionUid,
+        response.submissionUid,
       )
-      console.log('Submission:', submission)
+      console.log('Submission status:', submission?.status)
+
       expect(submission).toBeDefined()
-      expect(submission.status).oneOf(['Validated', 'Invalid'])
+      expect(['InProgress', 'Valid', 'PartiallyValid', 'Invalid']).toContain(
+        submission?.status,
+      )
     } catch (error: any) {
-      console.error('Error during real document submission:', error)
+      console.error('💥 Submission failed:', error)
 
-      // Check if this is a TIN mismatch error
-      const errorMessage = error.message || error.toString()
+      // Analyze common error types
       if (
-        errorMessage.includes(
+        error.message?.includes(
           'authenticated TIN and documents TIN is not matching',
         )
       ) {
-        console.log('\n❌ TIN MISMATCH ERROR DETECTED!')
-        console.log('=====================================')
+        console.log('\n🔍 TIN MISMATCH ERROR DETECTED!')
+        console.log(
+          'This means the TIN in the certificate does not match the TIN in the invoice.',
+        )
+        console.log(
+          'The certificate is registered to a different TIN in MyInvois system.',
+        )
+        console.log(
+          'Solution: Get the correct TIN for your certificate or get a certificate for your TIN.',
+        )
+      } else if (error.message?.includes('Invalid structure')) {
+        console.log('\n🔍 INVALID STRUCTURE ERROR DETECTED!')
+        console.log('This could be due to:')
+        console.log('1. Missing mandatory fields')
+        console.log('2. Incorrect field values')
+        console.log('3. Wrong data types')
+        console.log('4. Business rule violations')
       }
 
-      expect.soft(false, 'Error during real document submission.').toBe(true)
+      // Re-throw to fail the test
       throw error
     }
-  }, 45000) // Increased timeout for real API calls
+  }, 60000) // Extended timeout for API calls
 })