public void GetInventoryTotalWithBatchesAcrossMultiplePurchaseOrders()
{
int expectedQuantity = 5;
ReceivedBatch batch = SetupReceivedBatch();
batch.Quantity = 1;
batch.PONumber = 11111;
batch.ColorName = "White";
batch.BatchNumber = "872891111111";
inventorySource.AddReceivedBatchToInventory(batch);
batch.PONumber = 22222;
batch.ColorName = "White";
batch.BatchNumber = "872891111111";
inventorySource.AddReceivedBatchToInventory(batch);
batch.ColorName = "Yellow";
batch.BatchNumber = "872892222222";
inventorySource.AddReceivedBatchToInventory(batch);
batch.ColorName = "Black";
batch.BatchNumber = "872893333333";
inventorySource.AddReceivedBatchToInventory(batch);
batch.PONumber = 33333;
batch.ColorName = "Black";
batch.BatchNumber = "87289333333";
inventorySource.AddReceivedBatchToInventory(batch);
Assert.AreEqual(expectedQuantity, inventorySource.TotalInventoryCount);
}
public ReceivedPurchaseOrderEditorViewModel(
EditablePurchaseOrder purchaseOrder,
IColorList colorList,
IBatchNumberValidator batchNumberValidator,
IBatchOperatorSource operatorSource,
IActiveInventorySource inventorySource,
IReceivedBatchSource receivedBatchSource,
IImplementedBatchSource implementedBatchSource
)
{
this.purchaseOrder = purchaseOrder;
this.operatorSource = operatorSource;
this.inventorySource = inventorySource;
this.receivedBatchSource = receivedBatchSource;
this.implementedBatchSource = implementedBatchSource;
receivedBatches = new ObservableCollection <ReceivedBatch>();
ReceivedBatch = new ReceivedBatch();
ImportPurchaseOrderInformation();
UpdateReceivedBatchCommand = new UpdatePurchaseOrderReceivingRecordCommand(this);
UpdatePurchaseOrderCommand = new UpdatePurchaseOrderHeaderCommand(this);
DeleteReceivingRecordCommand = new DeletePurchaseOrderReceivingRecordCommand(this);
ReceivedBatchSelectionChanged = new ReceivedBatchForEditingSelectionChangedCommand(this);
UpdateText = "Save Item";
this.colorList = colorList;
this.batchNumberValidator = batchNumberValidator;
SelectedColorIndex = 0;
ReceivedBatchesSelectedIndex = -1;
}
public void AddingRecordWithBatchNumberThatIsSimilarToAnotherBatchOfDifferentColorWillNotCommitToReceivingLedger()
{
int expectedLedgerCount = 1;
InjectTwoOperatorsIntoRepository();
SetupValidReceivedBatchInViewModel();
ReceivedBatch receivedBatch = new ReceivedBatch(
"White",
viewModel.BatchNumber,
DateTime.Now,
1,
55555,
operatorSource.FindBatchOperator(1)
);
receivingSource.SaveReceivedBatch(receivedBatch);
viewModel.ColorSelectionComboBoxIndex = 2;
viewModel.BatchNumber = "872880501302";
viewModel.Quantity = "1";
AddReceivedBatchToSessionLedger();
command.Execute(null);
Assert.AreEqual(expectedLedgerCount, receivingSource.ReceivedBatchRepository.Count);
}
public void FindingAllBatchesBySpecificBatchNumber()
{
int expectedCount = 2;
ReceivedBatch targetBatch = helper.GetUniqueBatch1();
ReceivedBatch paddingBatch = helper.GetUniqueBatch2();
for (int i = 0; i < 5; i++)
{
targetBatch.ActivityDate = DateTime.Today.AddDays(i);
targetBatch.Quantity = i;
targetBatch.PONumber = targetBatch.PONumber + i;
if (i % 2 == 0)
{
receivedBatchSource.SaveReceivedBatch(paddingBatch);
}
else
{
receivedBatchSource.SaveReceivedBatch(targetBatch);
}
}
ObservableCollection <ReceivedBatch> batches;
batches = receivedBatchSource.GetReceivedBatchesByBatchNumber(targetBatch.BatchNumber);
Assert.AreEqual(expectedCount, batches.Count);
}
public void FindingMultipleRecordsOfSpecificBatchInHaystackOfBatches()
{
int expectedCount = 2;
string targetBatch = receivedBatch.BatchNumber;
ReceivedBatch paddingBatch = receivedBatchHelper.GetUniqueBatch2();
for (int i = 0; i < 5; i++)
{
DateTime newDate = DateTime.Today.AddDays(i);
receivedBatch.ActivityDate = newDate;
paddingBatch.ActivityDate = newDate;
if (i % 2 == 0)
{
inventorySource.AddReceivedBatchToInventory(paddingBatch);
implementedBatchSource.AddBatchToImplementationLedger(paddingBatch.BatchNumber, newDate, batchOperator);
}
else
{
inventorySource.AddReceivedBatchToInventory(receivedBatch);
implementedBatchSource.AddBatchToImplementationLedger(receivedBatch.BatchNumber, newDate, batchOperator);
}
}
ObservableCollection <LoggedBatch> batches = implementedBatchSource.GetImplementedBatchesByBatchNumber(targetBatch);
Assert.AreEqual(expectedCount, batches.Count);
}
public ReceivedBatch GetBatchWithSpecificDate(DateTime dateCriteria)
{
ReceivedBatch batch = GetUniqueBatch1();
batch.ActivityDate = dateCriteria;
return(batch);
}
public void FindingAllBatchByInclusiveDateRangeThatIgnoresTimeOfDay()
{
int expectedCount = 3;
DateTime startDate = new DateTime(2019, 5, 29, 7, 15, 00);
DateTime endDate = startDate.AddDays(5);
ReceivedBatch inRangeBatch1 = helper.GetBatchWithSpecificDate(startDate);
ReceivedBatch inRangeBatch2 = helper.GetBatchWithSpecificDate(startDate.AddDays(2));
ReceivedBatch inRangeBatch3 = helper.GetBatchWithSpecificDate(startDate.AddDays(4));
ReceivedBatch outOfRangeBatch1 = helper.GetBatchWithSpecificDate(startDate.AddDays(-1));
ReceivedBatch outOfRangeBatch2 = helper.GetBatchWithSpecificDate(endDate.AddDays(1));
List <ReceivedBatch> receivables = new List <ReceivedBatch>
{
outOfRangeBatch1, inRangeBatch1, inRangeBatch2, inRangeBatch3, outOfRangeBatch2
};
foreach (ReceivedBatch batch in receivables)
{
receivedBatchSource.SaveReceivedBatch(batch);
}
ObservableCollection <ReceivedBatch> found = receivedBatchSource.GetReceivedBatchesWithinDateRange(startDate, endDate);
Assert.AreEqual(expectedCount, found.Count);
}
public void CreateReceivedPurchaseOrderFromExistingData()
{
ReceivedBatch received = helper.GetBatchWithSpecificDate(new DateTime(2019, 7, 4));
int expectedPONumber = received.PONumber;
DateTime expectedActivityDate = received.ActivityDate;
BatchOperator expectedBatchOperator = received.ReceivingOperator;
int expectedCount = 3;
string expectedDateDisplay = "July 4, 2019";
ObservableCollection <ReceivedBatch> receivedBatches = new ObservableCollection <ReceivedBatch>()
{
received, received, received
};
ReceivedPurchaseOrder receivedPO = new ReceivedPurchaseOrder(
expectedPONumber,
expectedActivityDate,
expectedBatchOperator,
receivedBatches
);
Assert.AreEqual(expectedPONumber, receivedPO.PONumber);
Assert.AreEqual(expectedActivityDate, receivedPO.ActivityDate);
Assert.AreEqual(expectedDateDisplay, receivedPO.DisplayDate);
Assert.AreSame(expectedBatchOperator, receivedPO.ReceivingOperator);
Assert.AreEqual(expectedCount, receivedPO.ReceivedBatches.Count);
}
List <IEntity> ProcessReceivedBatches(SQLiteDataReader reader)
{
Dictionary <int, Entity <BatchOperator> > batchOperatorEntities = GetBatchOperatorEntities();
List <IEntity> entities = new List <IEntity>();
if (reader.HasRows)
{
while (reader.Read())
{
int batchOperatorId = reader.GetInt32(6);
ReceivedBatch receivedBatch = new ReceivedBatch(
reader.GetString(1),
reader.GetString(2),
DateTime.ParseExact(reader.GetString(3), "yyyy-MM-dd HH:mm:ss", null),
reader.GetInt32(4),
reader.GetInt32(5),
batchOperatorEntities[batchOperatorId].NativeModel
);
Entity <ReceivedBatch> entity = new Entity <ReceivedBatch>(reader.GetInt32(0), receivedBatch);
entities.Add(entity);
}
}
return(entities);
}
public void UpdatingReceivedBatchAtIdWithIncreaseInQuanityWillUpdateInventoryCorrectly()
{
int expectedQuantityBefore = 3;
int expectedQuantityAfter = 5;
string batchNumber = "872890302902";
BatchOperator batchOperator = new BatchOperator("Jane", "Doe");
ReceivedBatch firstBatch = new ReceivedBatch(
"White", batchNumber, new DateTime(2019, 9, 16), 1, 44614, batchOperator
);
ReceivedBatch secondBatch = new ReceivedBatch(
"White", batchNumber, new DateTime(2019, 9, 23), 2, 44663, batchOperator
);
receivedBatchSource.SaveReceivedBatch(firstBatch);
receivedBatchSource.SaveReceivedBatch(secondBatch);
Assert.AreEqual(expectedQuantityBefore, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).Quantity);
EditablePurchaseOrder edited = receivedBatchSource.GetPurchaseOrderForEditing(44663);
edited.ReceivedBatches[0].Quantity = 4;
receivedBatchSource.UpdateReceivedBatch(edited.GetReceivedBatchMappedSystemId(0), edited.ReceivedBatches[0]);
Assert.AreEqual(expectedQuantityAfter, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).Quantity);
}
public ReceivedBatch GetBatchWithSpecificPO(int poNumber)
{
ReceivedBatch batch = GetUniqueBatch1();
batch.PONumber = poNumber;
return(batch);
}
void AssertSameReceivedBatchData(ReceivedBatch expected, ReceivedBatch actual)
{
Assert.AreEqual(expected.ColorName, actual.ColorName);
Assert.AreEqual(expected.BatchNumber, actual.BatchNumber);
Assert.AreEqual(StripDateTimeFluff(expected.ActivityDate), StripDateTimeFluff(actual.ActivityDate));
Assert.AreEqual(expected.Quantity, actual.Quantity);
Assert.AreEqual(expected.PONumber, actual.PONumber);
Assert.AreEqual(expected.ReceivingOperator.FullName, actual.ReceivingOperator.FullName);
}
public void SaveReceivedBatch(ReceivedBatch receivedBatch)
{
Entity <ReceivedBatch> entity = new Entity <ReceivedBatch>(receivedBatch);
ITransaction adder = new AddReceivedBatchToReceivingLedgerTransaction(entity, sqliteStore);
adder.Execute();
inventorySource.AddReceivedBatchToInventory(receivedBatch);
UpdateRepositoryAndMappings();
}
void ReceiveFiveBatchesOfTheSameBatchIntoInventory(ReceivedBatch receivedBatch)
{
receivedBatch.Quantity = 3;
receivedBatchSource.SaveReceivedBatch(receivedBatch);
receivedBatch.Quantity = 2;
receivedBatch.ActivityDate = receivedBatch.ActivityDate.AddDays(7);
receivedBatchSource.SaveReceivedBatch(receivedBatch);
}
string SetupValidDataSourceStateForProperPopulationOfHistoryGridsAndReturnTargetBatchNumber()
{
ReceivedBatch receivedBatch = receivedBatchHelper.GetBatchWithSpecificDate(DateTime.Today);
ReceiveFiveBatchesOfTheSameBatchIntoInventory(receivedBatch);
ImplementAllButOneBatch(receivedBatch.BatchNumber);
return(receivedBatch.BatchNumber);
}
protected string SetupInventoryStateAndReceiveSingleBatchAndReturnBatchNumber()
{
ReceivedBatch batch = SetupReceivedBatchWithQuantityOfTwo();
SetupInventoryStateToImplementBatch();
implementedBatchSource.AddBatchToImplementationLedger(batch.BatchNumber, DateTime.Now, batch.ReceivingOperator);
return(batch.BatchNumber);
}
public void AddingReceivedBatchToActiveInventory()
{
int expectedCount = 1;
ReceivedBatch batch = SetupReceivedBatch();
inventorySource.AddReceivedBatchToInventory(batch);
Assert.AreEqual(expectedCount, inventorySource.CurrentInventory.Count);
}
public void AddingReceivedBatchesWithSameBatchNumbersAreMerged()
{
int expectedCount = 1;
ReceivedBatch batch = SetupReceivedBatch();
inventorySource.AddReceivedBatchToInventory(batch);
inventorySource.AddReceivedBatchToInventory(batch);
Assert.AreEqual(expectedCount, inventorySource.CurrentInventory.Count);
}
public void PopulateSelectedReceivedRecord()
{
ReceivedBatch selectedBatch = GetReceivedBatchFromSelectedRecordAtIndex(ReceivedBatchesSelectedIndex);
ReceivedBatch.ColorName = selectedBatch.ColorName;
BatchNumber = selectedBatch.BatchNumber;
Quantity = selectedBatch.Quantity.ToString();
SetSelectedColorIndex(ReceivedBatch.ColorName);
UpdateText = "Update Item";
}
public void SavingReceivedBatchAlsoUpdatesActiveInventoryWithNewRecord()
{
ReceivedBatch batch = helper.GetUniqueBatch1();
string batchNumber = batch.BatchNumber;
receivedBatchSource.SaveReceivedBatch(batch);
InventoryBatch stored = inventorySource.FindInventoryBatchByBatchNumber(batchNumber);
Assert.AreEqual(batchNumber, stored.BatchNumber);
}
public void SavingReceivedBatchResultsInNewReceivedBatchAtLatestId()
{
int targetCollectionId = 0;
ReceivedBatch batch = helper.GetUniqueBatch1();
receivedBatchSource.SaveReceivedBatch(batch);
ReceivedBatch stored = receivedBatchSource.ReceivedBatchRepository[targetCollectionId];
AssertSameReceivedBatchData(batch, stored);
}
public void SavingReceivedBatchAndRetreivingFromIdResultsInTheSameBatchInfo()
{
int targetCollectionId = 0;
ReceivedBatch batch = helper.GetUniqueBatch1();
receivedBatchSource.SaveReceivedBatch(batch);
int targetId = receivedBatchSource.ReceivedBatchIdMappings[targetCollectionId];
ReceivedBatch found = receivedBatchSource.FindReceivedBatchById(targetId);
AssertSameReceivedBatchData(batch, found);
}
public void CreatedReceivedPurchaseOrderWithAnEmptySetOfReceivedBatches()
{
int expectedCount = 0;
ReceivedBatch received = helper.GetUniqueBatch1();
ReceivedPurchaseOrder receivedPO = new ReceivedPurchaseOrder(
received.PONumber,
received.ActivityDate,
received.ReceivingOperator
);
Assert.AreEqual(expectedCount, receivedPO.ReceivedBatches.Count);
}
Entity <ReceivedBatch> CreateUpdatedEntityFromOriginal(Entity <ReceivedBatch> original, ReceivedBatch updated)
{
ReceivedBatch updatedBatch = new ReceivedBatch(
updated.ColorName,
updated.BatchNumber,
updated.ActivityDate,
updated.Quantity,
updated.PONumber,
updated.ReceivingOperator
);
return(new Entity <ReceivedBatch>(original.SystemId, updatedBatch));
}
public void CommandCanNotExecuteIfOperatorBelongsToImplementedBatch()
{
ReceivedBatchTestHelper helper = new ReceivedBatchTestHelper(operatorSource);
BatchOperatorTestHelper operatorHelper = new BatchOperatorTestHelper(operatorSource);
ReceivedBatch receivedBatch = helper.GetUniqueBatch1();
BatchOperator implementingOperator = operatorHelper.GetJohnDoeOperator();
receivedBatchSource.SaveReceivedBatch(receivedBatch);
implementedBatchSource.AddBatchToImplementationLedger(receivedBatch.BatchNumber, DateTime.Now, operatorSource.FindBatchOperator(2));
viewModel.SelectedBatchOperatorFromListBoxIndex = 1;
Assert.False(command.CanExecute(null));
}
public void FindAllBatchesBySpecificDate()
{
int expectedCount = 1;
DateTime targetDate = DateTime.Today;
ReceivedBatch inRangeBatch = helper.GetBatchWithSpecificDate(targetDate);
ReceivedBatch outOfRangeBatch = helper.GetBatchWithSpecificDate(targetDate.AddDays(1));
receivedBatchSource.SaveReceivedBatch(outOfRangeBatch);
receivedBatchSource.SaveReceivedBatch(inRangeBatch);
ObservableCollection <ReceivedBatch> found = receivedBatchSource.GetReceivedBatchesbySpecificDate(targetDate);
Assert.AreEqual(expectedCount, found.Count);
}
public void FindSpecificBatchFromMultipleBatchesInActiveInventory()
{
ReceivedBatch paddingBatch = SetupReceivedBatch();
ReceivedBatch targetBatch = SetupReceivedBatch();
targetBatch.BatchNumber = "872894501202";
inventorySource.AddReceivedBatchToInventory(paddingBatch);
inventorySource.AddReceivedBatchToInventory(targetBatch);
InventoryBatch found = inventorySource.FindInventoryBatchByBatchNumber(targetBatch.BatchNumber);
Assert.AreEqual(targetBatch.BatchNumber, found.BatchNumber);
}
public void AddingReceivedBatchesWithDifferentBatchNumbersCreatedDifferentEntries()
{
int expectedCount = 2;
ReceivedBatch batch = SetupReceivedBatch();
batch.BatchNumber = "872891203202";
inventorySource.AddReceivedBatchToInventory(batch);
batch.BatchNumber = "872890802305";
inventorySource.AddReceivedBatchToInventory(batch);
Assert.AreEqual(expectedCount, inventorySource.CurrentInventory.Count);
}
public void CommandWillExecuteIfViewIsSetAndCanShowItselfAndARetrievedRecordIsSet()
{
int targetPO = 11111;
ReceivedBatch receivedBatch = helper.GetBatchWithSpecificPO(targetPO);
BatchOperator batchOperator = receivedBatch.ReceivingOperator;
operatorSource.SaveOperator(batchOperator);
receivedBatchSource.SaveReceivedBatch(receivedBatch);
viewModel.PurchaseOrderEditorViewer = new PassableIViewTestStub();
viewModel.SpecificPONumber = targetPO.ToString();
viewModel.FetchReceivingRecordsByPONumber();
Assert.True(command.CanExecute(null));
}
public void ExecutedCommandWillCallIViewShowViewMethod()
{
int targetPO = 11111;
ReceivedBatch receivedBatch = helper.GetBatchWithSpecificPO(targetPO);
BatchOperator batchOperator = receivedBatch.ReceivingOperator;
operatorSource.SaveOperator(batchOperator);
receivedBatchSource.SaveReceivedBatch(receivedBatch);
viewModel.PurchaseOrderEditorViewer = new IViewTestStub();
viewModel.SpecificPONumber = targetPO.ToString();
viewModel.FetchReceivingRecordsByPONumber();
Assert.DoesNotThrow(() => command.Execute(null));
}
