Update test cases

Author: jmbrunskill

server/service/src/invoice_line/stock_out_line/set_prescribed_quantity/mod.rs

@@ -137,11 +137,12 @@ fn update_prescribed_quantity(
 mod test {
     use repository::{
         mock::{
-            mock_item_a, mock_prescription_picked, mock_stock_line_a, mock_store_a, MockData,
-            MockDataInserts,
+            mock_item_a, mock_item_b, mock_prescription_picked, mock_stock_line_a,
+            mock_stock_line_b, mock_store_a, MockData, MockDataInserts,
         },
         test_db::setup_all_with_data,
-        InvoiceLineRow, InvoiceLineType,
+        EqualFilter, InvoiceLineFilter, InvoiceLineRepository, InvoiceLineRow,
+        InvoiceLineRowRepository, InvoiceLineType,
     };
     use util::inline_init;
 
@@ -151,7 +152,7 @@ mod test {
 
     fn mock_prescription_unallocated_invoice_line() -> InvoiceLineRow {
         InvoiceLineRow {
-            id: "test_invoice_line".to_string(),
+            id: "unallocated_invoice_line".to_string(),
             invoice_id: mock_prescription_picked().id,
             item_name: mock_item_a().name,
             item_code: mock_item_a().code,
@@ -165,7 +166,7 @@ mod test {
 
     fn mock_prescription_invoice_line_a() -> InvoiceLineRow {
         InvoiceLineRow {
-            id: "existing_stock_invoice_line".to_string(),
+            id: "existing_stock_invoice_line_a".to_string(),
             invoice_id: mock_prescription_picked().id,
             item_name: mock_item_a().name,
             item_code: mock_item_a().code,
@@ -179,34 +180,34 @@ mod test {
 
     fn mock_prescription_invoice_line_b() -> InvoiceLineRow {
         InvoiceLineRow {
-            id: "existing_stock_invoice_line".to_string(),
+            id: "existing_stock_invoice_line_b".to_string(),
             invoice_id: mock_prescription_picked().id,
             item_name: mock_item_a().name,
             item_code: mock_item_a().code,
             item_link_id: mock_item_a().id,
             r#type: InvoiceLineType::StockOut,
-            stock_line_id: Some(mock_stock_line_a().id),
+            stock_line_id: Some(mock_stock_line_b().id),
             ..Default::default()
         }
     }
 
     fn mock_prescription_invoice_line_c() -> InvoiceLineRow {
         InvoiceLineRow {
-            id: "existing_stock_invoice_line".to_string(),
+            id: "existing_stock_invoice_line_c".to_string(),
             invoice_id: mock_prescription_picked().id,
             item_name: mock_item_a().name,
             item_code: mock_item_a().code,
             item_link_id: mock_item_a().id,
             r#type: InvoiceLineType::StockOut,
-            stock_line_id: Some(mock_stock_line_a().id),
+            stock_line_id: Some(mock_stock_line_b().id), // TODO: should be different stock line ideally
             ..Default::default()
         }
     }
 
     #[actix_rt::test]
-    async fn set_prescribed_quantity_no_item_line() {
+    async fn set_prescribed_quantity_no_stock_line() {
         let (_, _, connection_manager, _) = setup_all_with_data(
-            "set_prescribed_quantity_no_item_line",
+            "set_prescribed_quantity_no_stock_line",
             MockDataInserts::all(),
             inline_init(|r: &mut MockData| {
                 r.invoice_lines = vec![mock_prescription_unallocated_invoice_line()]
@@ -220,39 +221,75 @@ mod test {
             .unwrap();
         let service = service_provider.invoice_line_service;
 
+        let new_prescribed_quantity = 20.0;
+
         let result = service.set_prescribed_quantity(
             &context,
             SetPrescribedQuantity {
                 invoice_id: mock_prescription_unallocated_invoice_line().invoice_id,
                 item_id: mock_prescription_unallocated_invoice_line().item_link_id,
-                prescribed_quantity: 10.0,
+                prescribed_quantity: new_prescribed_quantity,
             },
         );
 
         assert!(result.is_ok());
 
-        let invoice_line = result.unwrap();
+        let repo = InvoiceLineRowRepository::new(&context.connection);
+
+        let invoice_line = repo
+            .find_one_by_id(&mock_prescription_unallocated_invoice_line().id)
+            .unwrap()
+            .unwrap();
 
         assert_eq!(
-            invoice_line.invoice_line_row.invoice_id,
+            invoice_line.invoice_id,
             mock_prescription_unallocated_invoice_line().invoice_id
         );
         assert_eq!(
-            invoice_line.invoice_line_row.item_link_id,
+            invoice_line.item_link_id,
             mock_prescription_unallocated_invoice_line().item_link_id
         );
         assert_eq!(
-            invoice_line.invoice_line_row.item_code,
+            invoice_line.item_code,
             mock_prescription_unallocated_invoice_line().item_code
         );
         assert_eq!(
-            invoice_line.invoice_line_row.item_name,
+            invoice_line.item_name,
             mock_prescription_unallocated_invoice_line().item_name
         );
+        assert_eq!(
+            invoice_line.prescribed_quantity,
+            Some(new_prescribed_quantity)
+        );
+
+        let line_repo = InvoiceLineRepository::new(&context.connection);
+
+        let filter = InvoiceLineFilter::new().invoice_id(EqualFilter::equal_to(
+            &mock_prescription_unallocated_invoice_line().invoice_id,
+        ));
+        let line_count = line_repo.count(Some(filter.clone())).unwrap();
+        assert_eq!(line_count, 1);
+
+        // Check a new line gets created if one doesn't exist yet...
+        let result = service.set_prescribed_quantity(
+            &context,
+            SetPrescribedQuantity {
+                invoice_id: mock_prescription_unallocated_invoice_line().invoice_id,
+                item_id: mock_item_b().id,
+                prescribed_quantity: new_prescribed_quantity,
+            },
+        );
+
+        assert!(result.is_ok());
+        let invoice_line = result.unwrap();
+
         assert_eq!(
             invoice_line.invoice_line_row.prescribed_quantity,
-            mock_prescription_unallocated_invoice_line().prescribed_quantity
+            Some(new_prescribed_quantity)
         );
+
+        let line_count = line_repo.count(Some(filter.clone())).unwrap();
+        assert_eq!(line_count, 2);
     }
 
     #[actix_rt::test]
@@ -276,12 +313,14 @@ mod test {
             .unwrap();
         let service = service_provider.invoice_line_service;
 
+        let new_prescribed_quantity = 55.0;
+
         let result = service.set_prescribed_quantity(
             &context,
             SetPrescribedQuantity {
                 invoice_id: mock_prescription_invoice_line_a().invoice_id,
                 item_id: mock_prescription_invoice_line_a().item_link_id,
-                prescribed_quantity: 55.0,
+                prescribed_quantity: new_prescribed_quantity,
             },
         );
 
@@ -294,26 +333,27 @@ mod test {
             invoice_line.invoice_line_row.invoice_id,
             mock_prescription_invoice_line_a().invoice_id
         );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_link_id,
-            mock_prescription_invoice_line_a().item_link_id
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_code,
-            mock_prescription_invoice_line_a().item_code
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_name,
-            mock_prescription_invoice_line_a().item_name
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.prescribed_quantity,
-            Some(55.0)
-        );
 
         // doesn't update invoice lines that doesn't have prescribed quantity initially
-        assert_eq!(mock_prescription_invoice_line_b().prescribed_quantity, None);
-        assert_eq!(mock_prescription_invoice_line_c().prescribed_quantity, None);
+        let line_row_repo = InvoiceLineRowRepository::new(&context.connection);
+        let line_a = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_a().id)
+            .unwrap()
+            .unwrap();
+        assert_eq!(line_a.prescribed_quantity, Some(new_prescribed_quantity));
+        let line_b = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_b().id)
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(line_b.prescribed_quantity, None);
+
+        let line_c = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_c().id)
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(line_c.prescribed_quantity, None);
     }
 
     #[actix_rt::test]
@@ -338,43 +378,46 @@ mod test {
             .unwrap();
         let service = service_provider.invoice_line_service;
 
+        let new_prescribed_quantity = 15.0;
+
         let result = service.set_prescribed_quantity(
             &context,
             SetPrescribedQuantity {
                 invoice_id: mock_prescription_unallocated_invoice_line().invoice_id,
                 item_id: mock_prescription_unallocated_invoice_line().item_link_id,
-                prescribed_quantity: 10.0,
+                prescribed_quantity: new_prescribed_quantity,
             },
         );
 
         assert!(result.is_ok());
 
-        let invoice_line = result.unwrap();
+        let line_row_repo = InvoiceLineRowRepository::new(&context.connection);
 
-        // updates invoice line
-        assert_eq!(
-            invoice_line.invoice_line_row.invoice_id,
-            mock_prescription_invoice_line_a().invoice_id
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_link_id,
-            mock_prescription_invoice_line_a().item_link_id
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_code,
-            mock_prescription_invoice_line_a().item_code
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.item_name,
-            mock_prescription_invoice_line_a().item_name
-        );
-        assert_eq!(
-            invoice_line.invoice_line_row.prescribed_quantity,
-            Some(10.0)
-        );
+        // Check that the first allocated line gets the prescribed quantity
+        let line_a = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_a().id)
+            .unwrap()
+            .unwrap();
+        assert_eq!(line_a.prescribed_quantity, Some(new_prescribed_quantity));
 
-        // doesn't update invoice lines that doesn't have prescribed quantity initially
-        assert_eq!(mock_prescription_invoice_line_b().prescribed_quantity, None);
-        assert_eq!(mock_prescription_invoice_line_c().prescribed_quantity, None);
+        // Check other lines don't have the prescribed quantity
+        let line_b = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_b().id)
+            .unwrap()
+            .unwrap();
+        assert_eq!(line_b.prescribed_quantity, None);
+
+        let line_c = line_row_repo
+            .find_one_by_id(&mock_prescription_invoice_line_c().id)
+            .unwrap()
+            .unwrap();
+        assert_eq!(line_c.prescribed_quantity, None);
+
+        // Check that the unallocated line is deleted
+        let result = service
+            .get_invoice_line(&context, &mock_prescription_unallocated_invoice_line().id)
+            .unwrap();
+
+        assert!(result.is_none());
     }
 }