tests: enhance global tests (#371)

Author: carlosthe19916

Cargo.lock

@@ -7,6 +7,7 @@ chrono = { version = "0.4.31", features = ["serde"] }
 regex = "1.10.6"
 log = "0.4.20"
 tera = "1.19.1"
+static-files = "0.2.1"
 lazy_static = "1.4.0"
 serde = { version = "1.0.205", features = ["derive"] }
 rust_decimal = { version = "1.33.1", features = [

Cargo.toml

@@ -16,4 +16,10 @@ rust_decimal = { workspace = true, features = ["serde-str", "serde-with-str"] }
 rust_decimal_macros = { workspace = true }
 
 [dev-dependencies]
+libxml = { workspace = true }
+
+serial_test = { workspace = true }
+tokio = { workspace = true, features = ["macros"] }
+
 xsender = { path = "../xsender" }
+xsigner = { path = "../xsigner" }

xbuilder/Cargo.toml

@@ -5,7 +5,7 @@ use rust_decimal::Decimal;
 use serde::Serialize;
 
 /// Quien provee el documento electronico. Quien genera o crea el documento.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Default)]
 pub struct Proveedor {
     pub ruc: &'static str,
     pub razon_social: &'static str,
@@ -22,7 +22,7 @@ pub struct Firmante {
 }
 
 /// Quien es el cliente de la transaccion
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Default)]
 pub struct Cliente {
     /// Catalog6
     pub tipo_documento_identidad: &'static str,
@@ -141,7 +141,7 @@ pub struct DocumentoRelacionado {
 }
 
 /// Detalle de las ventas en Boleta/Factura/Nota Credito/Nota Debito
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Default)]
 pub struct Detalle {
     pub descripcion: &'static str,
     pub cantidad: Decimal,

xbuilder/src/models/common.rs

@@ -10,7 +10,7 @@ use crate::models::common::{
 };
 
 /// Boleta o Factura
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Default)]
 pub struct Invoice {
     pub leyendas: HashMap<&'static str, &'static str>,
 

xbuilder/src/models/invoice.rs

@@ -2,11 +2,47 @@ use std::collections::HashMap;
 use std::fs;
 
 use chrono::NaiveDate;
+use libxml::tree::Document;
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 
 use xbuilder::prelude::*;
 
+use libxml::schemas::SchemaParserContext;
+use libxml::schemas::SchemaValidationContext;
+use xsender::prelude::Credentials;
+use xsender::prelude::DocumentType;
+use xsender::prelude::FileSender;
+use xsender::prelude::SendFileAggregatedResponse;
+use xsender::prelude::UblFile;
+use xsender::prelude::Urls;
+use xsigner::RsaKeyPair;
+use xsigner::XSigner;
+
+const INVOICE_XSD: &str = "tests/resources/xsd/2.1/maindoc/UBL-Invoice-2.1.xsd";
+const CREDIT_NOTE_XSD: &str = "tests/resources/xsd/2.1/maindoc/UBL-CreditNote-2.1.xsd";
+const DEBIT_NOTE_XSD: &str = "tests/resources/xsd/2.1/maindoc/UBL-DebitNote-2.1.xsd";
+const _DESPATCH_ADVICE_XSD: &str = "tests/resources/xsd/2.1/maindoc/UBL-DespatchAdvice-2.1.xsd";
+const _VOIDED_DOCUMENTS_XSD: &str = "tests/resources/xsd/2.0/maindoc/UBLPE-VoidedDocuments-1.0.xsd";
+const _SUMMARY_DOCUMENTS_XSD: &str =
+    "tests/resources/xsd/2.0/maindoc/UBLPE-SummaryDocuments-1.0.xsd";
+const _PERCEPTION_XSD: &str = "tests/resources/xsd/2.0/maindoc/UBLPE-Perception-1.0.xsd";
+const _RETENTION_XSD: &str = "tests/resources/xsd/2.0/maindoc/UBLPE-Retention-1.0.xsd";
+
+lazy_static::lazy_static! {
+    pub static ref CLIENT: FileSender = FileSender {
+        urls: Urls {
+            invoice: "https://e-beta.sunat.gob.pe/ol-ti-itcpfegem-beta/billService".to_string(),
+            perception_retention:"https://e-beta.sunat.gob.pe/ol-ti-itemision-otroscpe-gem-beta/billService".to_string(),
+            despatch: "https://api-cpe.sunat.gob.pe/v1/contribuyente/gem".to_string(),
+        },
+        credentials: Credentials {
+            username: "12345678959MODDATOS".to_string(),
+            password: "MODDATOS".to_string(),
+        },
+    };
+}
+
 pub fn defaults_base() -> Defaults {
     Defaults {
         date: NaiveDate::from_ymd_opt(2019, 12, 24).unwrap(),
@@ -179,40 +215,65 @@ pub fn detalle_base() -> Detalle {
     }
 }
 
+fn sign_xml(xml: &str) -> Document {
+    let private_key_from_file = fs::read_to_string("tests/resources/certificates/private.key")
+        .expect("Could not read private.key");
+    let certificate_from_file = fs::read_to_string("tests/resources/certificates/public.cer")
+        .expect("Could not read public.cer");
+
+    let rsa_key_pair =
+        RsaKeyPair::from_pkcs1_pem_and_certificate(&private_key_from_file, &certificate_from_file)
+            .expect("Could not initialize RsaKeyPair");
+
+    let signer = XSigner::from_string(xml).expect("Could parse xml");
+    signer.sign(&rsa_key_pair).expect("Could not sign document");
+
+    signer.xml_document
+}
+
 #[allow(dead_code)]
-pub fn assert_invoice(invoice: &mut Invoice, snapshot_filename: &str) {
+pub async fn assert_invoice(invoice: &mut Invoice, snapshot_filename: &str) {
     let defaults = defaults_base();
     invoice.enrich(&defaults);
 
-    let result = invoice.render();
-    assert!(result.is_ok());
+    let xml = invoice.render().expect("Could not render invoice");
+
+    assert_snapshot(&xml, snapshot_filename);
 
-    assert_snapshot(result.ok().unwrap(), snapshot_filename)
+    let xml_signed = sign_xml(&xml);
+    assert_xsd(&xml_signed, INVOICE_XSD);
+    assert_sunat(&xml_signed).await;
 }
 
 #[allow(dead_code)]
-pub fn assert_credit_note(credit_note: &mut CreditNote, snapshot_filename: &str) {
+pub async fn assert_credit_note(credit_note: &mut CreditNote, snapshot_filename: &str) {
     let defaults = defaults_base();
     credit_note.enrich(&defaults);
 
-    let result = credit_note.render();
-    assert!(result.is_ok());
+    let xml = credit_note.render().expect("Could not render credit note");
+
+    assert_snapshot(&xml, snapshot_filename);
 
-    assert_snapshot(result.ok().unwrap(), snapshot_filename)
+    let xml_signed = sign_xml(&xml);
+    assert_xsd(&xml_signed, CREDIT_NOTE_XSD);
+    assert_sunat(&xml_signed).await;
 }
 
 #[allow(dead_code)]
-pub fn assert_debit_note(debit_note: &mut DebitNote, snapshot_filename: &str) {
+pub async fn assert_debit_note(debit_note: &mut DebitNote, snapshot_filename: &str) {
     let defaults = defaults_base();
     debit_note.enrich(&defaults);
 
-    let result = debit_note.render();
-    assert!(result.is_ok());
+    let xml = debit_note.render().expect("Could not render debit note");
 
-    assert_snapshot(result.ok().unwrap(), snapshot_filename)
+    assert_snapshot(&xml, snapshot_filename);
+
+    let xml_signed = sign_xml(&xml);
+    assert_xsd(&xml_signed, DEBIT_NOTE_XSD);
+    assert_sunat(&xml_signed).await;
 }
 
-fn assert_snapshot(expected: String, snapshot_filename: &str) {
+fn assert_snapshot(expected: &str, snapshot_filename: &str) {
     let snapshot_file_content = fs::read_to_string(snapshot_filename);
     assert!(snapshot_file_content.is_ok());
 
@@ -223,3 +284,65 @@ fn assert_snapshot(expected: String, snapshot_filename: &str) {
         snapshot_filename
     );
 }
+
+fn assert_xsd(xml: &Document, schema: &str) {
+    let mut xsdparser = SchemaParserContext::from_file(schema);
+    let xsd = SchemaValidationContext::from_parser(&mut xsdparser);
+
+    if let Err(errors) = xsd {
+        for err in &errors {
+            println!("{}", err.message.as_ref().unwrap());
+        }
+
+        panic!("Failed to parse schema");
+    }
+
+    let mut xsd = xsd.unwrap();
+
+    if let Err(errors) = xsd.validate_document(xml) {
+        for err in &errors {
+            println!("{}", err.message.as_ref().unwrap());
+        }
+
+        panic!("Invalid XML accoding to XSD schema");
+    }
+}
+
+async fn assert_sunat(xml: &Document) {
+    let xml_file = UblFile {
+        file_content: xml.to_string(),
+    };
+
+    let result = CLIENT
+        .send_file(&xml_file)
+        .await
+        .expect("Could not get a valid response");
+
+    let documet_type = xml_file
+        .metadata()
+        .expect("Could not extract xml metadata")
+        .document_type;
+
+    match documet_type.as_str() {
+        DocumentType::VOIDED_DOCUMENTS | DocumentType::SUMMARY_DOCUMENTS => {
+            let result = match result.response {
+                SendFileAggregatedResponse::Cdr(_, _) => false,
+                SendFileAggregatedResponse::Ticket(_) => true,
+                SendFileAggregatedResponse::Error(_) => false,
+            };
+            assert!(result)
+        }
+        _ => {
+            let result = match result.response {
+                SendFileAggregatedResponse::Cdr(_, cdr_metadata) => {
+                    assert_eq!("0", cdr_metadata.response_code);
+                    assert_eq!(Vec::<String>::new(), cdr_metadata.notes);
+                    true
+                }
+                SendFileAggregatedResponse::Ticket(_) => false,
+                SendFileAggregatedResponse::Error(_) => false,
+            };
+            assert!(result)
+        }
+    };
+}

xbuilder/tests/common/mod.rs

@@ -9,8 +9,9 @@ mod common;
 
 const BASE: &str = "tests/resources/e2e/renderer/creditnote/CreditNoteTest";
 
-#[test]
-fn credit_note() {
+#[serial_test::serial]
+#[tokio::test]
+async fn credit_note() {
     let mut credit_note = CreditNote {
         detalles: vec![
             Detalle {
@@ -29,5 +30,5 @@ fn credit_note() {
         ..credit_note_base()
     };
 
-    assert_credit_note(&mut credit_note, &format!("{BASE}/MinData_RUC.xml"));
+    assert_credit_note(&mut credit_note, &format!("{BASE}/MinData_RUC.xml")).await;
 }