#137 — Create Comprehensive Tests for Date Range Filtering

contracts/shade/src/components/invoice.rs

@@ -1,3 +1,25 @@
+pub fn finalize_invoice(env: &Env, merchant_address: &Address, invoice_id: u64) {
+    merchant_address.require_auth();
+    let mut invoice: Invoice = env
+        .storage()
+        .persistent()
+        .get(&DataKey::Invoice(invoice_id))
+        .unwrap_or_else(|| panic_with_error!(env, ContractError::InvoiceNotFound));
+    if invoice.merchant_id != env
+        .storage()
+        .persistent()
+        .get::<_, u64>(&DataKey::MerchantId(merchant_address.clone()))
+        .unwrap()
+    {
+        panic_with_error!(env, ContractError::NotAuthorized);
+    }
+    if invoice.status != InvoiceStatus::Draft {
+        panic_with_error!(env, ContractError::InvalidInvoiceStatus);
+    }
+    invoice.status = InvoiceStatus::Pending;
+    env.storage().persistent().set(&DataKey::Invoice(invoice_id), &invoice);
+    // Optionally emit an event for finalization
+}
 use crate::components::{access_control, admin, merchant, signature_util};
 use crate::errors::ContractError;
 use crate::events;
@@ -42,7 +64,7 @@ pub fn create_invoice(
         description: description.clone(),
         amount,
         token: token.clone(),
-        status: InvoiceStatus::Pending,
+        status: InvoiceStatus::Draft,
         merchant_id,
         payer: None,
         date_created: env.ledger().timestamp(),
@@ -130,7 +152,7 @@ pub fn create_invoice_signed(
         description: description.clone(),
         amount,
         token: token.clone(),
-        status: InvoiceStatus::Pending,
+        status: InvoiceStatus::Draft,
         merchant_id,
         payer: None,
         date_created: env.ledger().timestamp(),
@@ -211,6 +233,10 @@ pub fn get_invoices(env: &Env, filter: InvoiceFilter) -> Vec<Invoice> {
             .get::<_, Invoice>(&DataKey::Invoice(i))
         {
             let mut matches = true;
+            // Hide Draft invoices unless explicitly filtering for Draft
+            if filter.status.is_none() && invoice.status == InvoiceStatus::Draft {
+                continue;
+            }
             if let Some(status) = filter.status {
                 if invoice.status as u32 != status {
                     matches = false;
@@ -324,6 +350,9 @@ pub fn refund_invoice_partial(env: &Env, invoice_id: u64, amount: i128) {
 
 pub fn pay_invoice(env: &Env, payer: &Address, invoice_id: u64) -> i128 {
     let invoice = get_invoice(env, invoice_id);
+    if invoice.status == InvoiceStatus::Draft {
+        panic_with_error!(env, ContractError::InvalidInvoiceStatus);
+    }
     if invoice.status != InvoiceStatus::Pending && invoice.status != InvoiceStatus::PartiallyPaid {
         panic_with_error!(env, ContractError::InvalidInvoiceStatus);
     }
@@ -342,6 +371,9 @@ pub fn pay_invoice_partial(env: &Env, payer: &Address, invoice_id: u64, amount:
     }
 
     let mut invoice = get_invoice(env, invoice_id);
+    if invoice.status == InvoiceStatus::Draft {
+        panic_with_error!(env, ContractError::InvalidInvoiceStatus);
+    }
 
     if let Some(expires_at) = invoice.expires_at {
         if env.ledger().timestamp() >= expires_at {

contracts/shade/src/events.rs

@@ -117,6 +117,27 @@ pub fn publish_invoice_created_event(
     .publish(env);
 }
 
+#[contractevent]
+pub struct InvoiceFinalizedEvent {
+    pub invoice_id: u64,
+    pub merchant: Address,
+    pub timestamp: u64,
+}
+
+pub fn publish_invoice_finalized_event(
+    env: &Env,
+    invoice_id: u64,
+    merchant: Address,
+    timestamp: u64,
+) {
+    InvoiceFinalizedEvent {
+        invoice_id,
+        merchant,
+        timestamp,
+    }
+    .publish(env);
+}
+
 #[contractevent]
 pub struct InvoiceRefundedEvent {
     pub invoice_id: u64,

contracts/shade/src/interface.rs

@@ -42,6 +42,7 @@ pub trait ShadeTrait {
         signature: BytesN<64>,
     ) -> u64;
     fn get_invoice(env: Env, invoice_id: u64) -> Invoice;
+    fn finalize_invoice(env: Env, merchant: Address, invoice_id: u64);
     fn refund_invoice(env: Env, merchant: Address, invoice_id: u64);
     fn set_merchant_key(env: Env, merchant: Address, key: BytesN<32>);
     fn get_merchant_key(env: Env, merchant: Address) -> BytesN<32>;

contracts/shade/src/shade.rs

@@ -148,6 +148,11 @@ impl ShadeTrait for Shade {
         invoice_component::get_invoice(&env, invoice_id)
     }
 
+    fn finalize_invoice(env: Env, merchant: Address, invoice_id: u64) {
+        pausable_component::assert_not_paused(&env);
+        invoice_component::finalize_invoice(&env, &merchant, invoice_id);
+    }
+
     fn refund_invoice(env: Env, merchant: Address, invoice_id: u64) {
         pausable_component::assert_not_paused(&env);
         invoice_component::refund_invoice(&env, &merchant, invoice_id);

contracts/shade/src/tests/mod.rs

@@ -18,3 +18,4 @@ pub mod test_refund;
 pub mod test_signatures;
 pub mod test_subscription;
 pub mod test_upgrade;
+pub mod test_invoice_date_filtering;

contracts/shade/src/tests/test_admin_payment.rs

@@ -60,6 +60,10 @@ fn test_invoice_state_validation() {
 
     // Verify initial state
     let invoice = client.get_invoice(&invoice_id);
+    assert_eq!(invoice.status, InvoiceStatus::Draft);
+
+    client.finalize_invoice(&merchant, &invoice_id);
+    let invoice = client.get_invoice(&invoice_id);
     assert_eq!(invoice.status, InvoiceStatus::Pending);
     assert_eq!(invoice.payer, None);
     assert_eq!(invoice.date_paid, None);
@@ -98,7 +102,9 @@ fn test_multiple_invoices_independent() {
             .set(&DataKey::Invoice(id_2), &inv_2);
     });
 
-    // Verify first is still Pending
+    // Verify first is still Draft
+    assert_eq!(client.get_invoice(&id_1).status, InvoiceStatus::Draft);
+    client.finalize_invoice(&merchant, &id_1);
     assert_eq!(client.get_invoice(&id_1).status, InvoiceStatus::Pending);
     assert_eq!(client.get_invoice(&id_2).status, InvoiceStatus::Paid);
 }
@@ -165,5 +171,6 @@ fn test_contract_pause_and_unpause() {
         &token,
         &None,
     );
+    client.finalize_invoice(&merchant, &invoice_id);
     assert!(invoice_id > 0);
 }