コード例 #1
0
ファイル: TransactionTest.cs プロジェクト: mtikoian/Gameplan
        public void Test_Transaction_DeleteTransactionLineItemMapping()
        {
            // From the test Data
            const int    testTacticId      = 2079;
            const int    testLineItemId    = 301;
            const int    testTransactionId = 75;
            const double testAmount        = 300.10;

            // Create a Line Item Mapping
            List <TransactionLineItemMapping> tlimList = new List <TransactionLineItemMapping>();

            tlimList.Add(new TransactionLineItemMapping {
                TransactionId = testTransactionId, LineItemId = testLineItemId, Amount = testAmount
            });
            _transaction.SaveTransactionToLineItemMapping(testClientId, tlimList, testUserId);

            // Verify its created
            List <LineItemsGroupedByTactic> groupedLineItems = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);

            LineItemsGroupedByTactic ligbt = groupedLineItems.Find(item => item.TacticId == testTacticId);

            Assert.IsNotNull(ligbt);
            LinkedLineItem lineItem = ligbt.LineItems.Find(item => item.LineItemId == testLineItemId);

            Assert.IsNotNull(lineItem);

            // Test deleting line item mapping with invalid clientId. MUST Be run before actually deleting the line item.
            _transaction.DeleteTransactionLineItemMapping(testOtherClientId, lineItem.LineItemMapping.TransactionLineItemMappingId);

            // Verify not deleted
            groupedLineItems = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);
            ligbt            = groupedLineItems.Find(item => item.TacticId == testTacticId);
            Assert.IsNotNull(ligbt);
            lineItem = ligbt.LineItems.Find(item => item.LineItemId == testLineItemId);
            Assert.IsNotNull(lineItem);

            // Test deleting line item mapping
            _transaction.DeleteTransactionLineItemMapping(testClientId, lineItem.LineItemMapping.TransactionLineItemMappingId);

            // Verify its deleted.
            groupedLineItems = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);

            ligbt = groupedLineItems.Find(item => item.TacticId == testTacticId);
            // If there is no LineItemsGroupedByTactic entry, no mappings were found so the delete worked. However, if there is
            // a LineItemGroupedByTactic, then we need to verify the specific line item is not mapped (others could be mapped).
            if (ligbt != null)
            {
                lineItem = ligbt.LineItems.Find(item => item.LineItemId == testLineItemId);
                Assert.IsNull(lineItem);
            }
        }
コード例 #2
0
ファイル: TransactionTest.cs プロジェクト: mtikoian/Gameplan
        public void Test_Transaction_SaveTransactionToLineItemMapping()
        {
            const int testTransactionId = 120;
            const int testTacticId      = 2077;

            int[]        testLineItemIds              = new int[] { 297, 298 };
            double[]     testMappingAmounts           = new double[] { 300.10, 100.10 };
            const int    testModifiedLineItemId       = 297;
            const double testModifiedMappingAmount    = 400.4;
            const int    testNewLineItemId            = 296;
            const double testNewMappingAmount         = 500.5;
            const int    testOtherClientTransactionId = 214;
            const int    testOtherClientLineItemId    = 1810;

            // Test Create line item
            List <TransactionLineItemMapping> tlimList = new List <TransactionLineItemMapping>();

            for (int ndx = 0; ndx < testLineItemIds.Length; ndx++)
            {
                tlimList.Add(new TransactionLineItemMapping {
                    TransactionId = testTransactionId, LineItemId = testLineItemIds[ndx], Amount = testMappingAmounts[ndx]
                });
            }

            _transaction.SaveTransactionToLineItemMapping(testClientId, tlimList, testUserId);

            // Verify they are added
            List <LineItemsGroupedByTactic> ligbtList = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);

            LineItemsGroupedByTactic ligbt = ligbtList.Find(item => item.TacticId == testTacticId);

            Assert.IsNotNull(ligbt);

            for (int ndx = 0; ndx < testLineItemIds.Length; ndx++)
            {
                LinkedLineItem li = ligbt.LineItems.Find(item => item.LineItemId == testLineItemIds[ndx]);
                Assert.IsNotNull(li);
                Assert.AreEqual(testMappingAmounts[ndx], li.LineItemMapping.Amount);
            }


            // Test Update line item AND Test Create and Update in same list
            tlimList = new List <TransactionLineItemMapping>();
            // Update
            LinkedLineItem lineItem = ligbt.LineItems.Find(item => item.LineItemId == testModifiedLineItemId);

            lineItem.LineItemMapping.Amount = testModifiedMappingAmount;
            tlimList.Add(lineItem.LineItemMapping);
            // New item
            tlimList.Add(new TransactionLineItemMapping {
                TransactionId = testTransactionId, LineItemId = testNewLineItemId, Amount = testNewMappingAmount
            });
            _transaction.SaveTransactionToLineItemMapping(testClientId, tlimList, testUserId);

            ligbtList = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);
            ligbt     = ligbtList.Find(item => item.TacticId == testTacticId);
            lineItem  = ligbt.LineItems.Find(item => item.LineItemId == testModifiedLineItemId);
            Assert.AreEqual(testModifiedMappingAmount, lineItem.LineItemMapping.Amount);
            lineItem = ligbt.LineItems.Find(item => item.LineItemId == testNewLineItemId);
            Assert.AreEqual(testNewMappingAmount, lineItem.LineItemMapping.Amount);

            // Clean up line item mappings
            ligbtList = _transaction.GetLinkedLineItemsForTransaction(testClientId, testTransactionId);
            ligbt     = ligbtList.Find(item => item.TacticId == testTacticId);
            List <int> lineItemIdsToDelete = new List <int>(testLineItemIds);

            lineItemIdsToDelete.Add(testNewLineItemId);
            foreach (int lineItemId in lineItemIdsToDelete)
            {
                LinkedLineItem li = ligbt.LineItems.Find(item => item.LineItemMapping.LineItemId == lineItemId);
                _transaction.DeleteTransactionLineItemMapping(testClientId, li.LineItemMapping.TransactionLineItemMappingId);
            }

            // Test with clientId that doesn't match transaction
            tlimList = new List <TransactionLineItemMapping>();
            tlimList.Add(new TransactionLineItemMapping {
                TransactionId = testOtherClientTransactionId, LineItemId = testLineItemIds[0], Amount = testMappingAmounts[0]
            });
            _transaction.SaveTransactionToLineItemMapping(testClientId, tlimList, testUserId);

            List <Models.TransactionLineItemMapping> lineItemMappings = GetTransactionLineItem(testOtherClientTransactionId, testLineItemIds[0]);

            Assert.AreEqual(0, lineItemMappings.Count);

            // Test with clientId that doesn't match line item
            tlimList = new List <TransactionLineItemMapping>();
            tlimList.Add(new TransactionLineItemMapping {
                TransactionId = testTransactionId, LineItemId = testOtherClientLineItemId, Amount = testMappingAmounts[0]
            });
            _transaction.SaveTransactionToLineItemMapping(testClientId, tlimList, testUserId);
            lineItemMappings = GetTransactionLineItem(testTransactionId, testOtherClientLineItemId);
            Assert.AreEqual(0, lineItemMappings.Count);
        }