public AddNotificationTransactionHandlerTests()
{
var chargeCalculator = A.Fake <INotificationChargeCalculator>();
A.CallTo(() => chargeCalculator.GetValue(A <Guid> .Ignored)).Returns(TotalBillable);
transactions = new List <NotificationTransaction>();
var transactionRepository = A.Fake <INotificationTransactionRepository>();
A.CallTo(() => transactionRepository.GetTransactions(NotificationId)).Returns(transactions);
calculatorTransactions = new List <NotificationTransaction>();
var calculatorRepository = A.Fake <INotificationTransactionRepository>();
A.CallTo(() => calculatorRepository.GetTransactions(NotificationId)).Returns(calculatorTransactions);
context.ShipmentInfos.Add(new TestableShipmentInfo {
NotificationId = NotificationId
});
assessment = new NotificationAssessment(NotificationId);
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.NotificationReceived, assessment);
context.NotificationAssessments.Add(assessment);
context.NotificationApplications.Add(new TestableNotificationApplication {
Id = NotificationId
});
var assessmentRepository = A.Fake <INotificationAssessmentRepository>();
A.CallTo(() => assessmentRepository.GetByNotificationId(NotificationId)).Returns(assessment);
handler = new AddNotificationTransactionHandler(context, new Transaction(assessmentRepository, transactionRepository, new NotificationTransactionCalculator(calculatorRepository, chargeCalculator)));
}
public NotificationTransportRouteTests()
{
this.transportRoute = new TransportRoute(Guid.Empty);
guids = new List <Guid>
{
new Guid("D8DB53F9-D3CB-498D-B044-7A67B94EE4E4"),
new Guid("1D3A7A18-F345-4201-81AA-8FC8A4029F4E"),
new Guid("596E6BE3-D0C1-4C17-AF75-BFCDBD972627"),
new Guid("208EA94D-638B-4724-9272-DF1383FF9452"),
new Guid("DEDAA6F6-CA6D-486E-B0B8-254A477E697F"),
new Guid("4C7EEA30-510E-45BD-8DBB-3EC1AF5E563A"),
new Guid("8B87B87D-43D0-4BBE-8E2C-8EC84C983A42"),
new Guid("40E44905-4CDE-4470-8E8B-527EE65C65DC"),
new Guid("58E18F1C-5A4A-4E2E-869F-72D9C1512FE8")
};
countries = guids.Select(g => CountryFactory.Create(g)).ToList();
transitStates = new List <TransitState>();
for (int i = 0; i < countries.Count - 1; i++)
{
var c = countries[i];
transitStates.Add(new TransitState(c,
CompetentAuthorityFactory.Create(guids[i], c),
EntryOrExitPointFactory.Create(guids[i], c),
EntryOrExitPointFactory.Create(guids[i + 1], c), i + 1));
ObjectInstantiator <TransitState> .SetProperty(x => x.Id, guids[i], transitStates[i]);
}
this.validator = A.Fake <ITransportRouteValidator>();
}
public virtual IList <T> ToObjects <T>(DataRow[] dataRows,
IDataTypeConverter dataTypeConverter,
ExtendedPropertyInfo[] mappings,
DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
var dbNullConverter = GetDbNullConverter(settings);
var objectList = new T[dataRows.Length];
for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++)
{
var returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var mapping in mappings)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex],
mapping.PropertyInfo.PropertyType,
settings,
dbNullConverter);
mapping.PropertyInfo.SetValue(returnObject, value);
}
objectList[rowIndex] = returnObject;
}
return(objectList);
}
private PricingStructure GetPricingStructure()
{
var pricingStructure = ObjectInstantiator <PricingStructure> .CreateNew();
ObjectInstantiator <PricingStructure> .SetProperty(x => x.CompetentAuthority, UKCompetentAuthority.England, pricingStructure);
var activity = A.Fake <Activity>();
ObjectInstantiator <Activity> .SetProperty(x => x.TradeDirection, TradeDirection.Export, activity);
ObjectInstantiator <Activity> .SetProperty(x => x.NotificationType, NotificationType.Recovery, activity);
ObjectInstantiator <Activity> .SetProperty(x => x.IsInterim, false, activity);
ObjectInstantiator <PricingStructure> .SetProperty(x => x.Activity, activity, pricingStructure);
var shipmentQuantityRange = A.Fake <ShipmentQuantityRange>();
ObjectInstantiator <ShipmentQuantityRange> .SetProperty(x => x.RangeFrom, LowerRange, shipmentQuantityRange);
ObjectInstantiator <ShipmentQuantityRange> .SetProperty(x => x.RangeTo, UpperRange, shipmentQuantityRange);
ObjectInstantiator <PricingStructure> .SetProperty(x => x.ShipmentQuantityRange, shipmentQuantityRange, pricingStructure);
ObjectInstantiator <PricingStructure> .SetProperty(x => x.Price, NotificationPrice, pricingStructure);
return(pricingStructure);
}
public async Task NotificationNotConsented_Throws()
{
ObjectInstantiator <ImportNotificationAssessment> .SetProperty(x => x.Status,
ImportNotificationStatus.FileClosed, assessment);
await Assert.ThrowsAsync <InvalidOperationException>(() => factory.Create(notificationId, 1, shipmentDate, null));
}
private void Client_SpawnGameObject(ClientBase sender, SpawnGameObject packet)
{
Console.WriteLine(packet);
//To avoid duplicates and possibly infinite spawn loop.
if (gameObjects.ContainsKey(packet.UID))
{
return;
}
GameObject gameObject = ObjectInstantiator.Instantiate((Objects)packet.ObjType);
gameObject.name = packet.name;
gameObject.UID = packet.UID;
if (packet.parentUID == 0)
{
world.AddChild(gameObject, false);
}
else
{
gameObjects[packet.parentUID].AddChild(gameObject, false); //TODO: It errors here with gameObjects[packet.parentUID] not existing, but it happens randomly
}
gameObjects[gameObject.UID] = gameObject;
//TODO: MOVE THIS CODE ELSEWHERE
Game1.worldActionScript.SetVariable(new string[] { gameObject.name }, new Dictionary <string, object>());
Game1.worldActionScript.SetVariable(new string[] { gameObject.name, "object" }, gameObject);
}
private void Client_SpawnGameObject(ClientBase sender, SpawnGameObject packet)
{
//To avoid duplicates and possibly infinite spawn loop.
//TODO: Restrict the amount of temp ids.
if (gameObjects.ContainsKey(packet.UID))
{
return; //Send back an error.
}
if (!clientObjectIdsToServerObjectIds.ContainsKey(sender))
{
clientObjectIdsToServerObjectIds.Add(sender, new Dictionary <int, int>());
}
Dictionary <int, int> clientToServerIds = clientObjectIdsToServerObjectIds[sender];
GameObject gameObject = ObjectInstantiator.Instantiate((Objects)packet.ObjType);
gameObject.UID = GenerateFreeId();
clientToServerIds[packet.UID] = gameObject.UID;
sender.Send(new ChangeGameObjectUID()
{
oldUID = packet.UID, newUID = gameObject.UID
});
if (packet.parentUID == 0)
{
world.AddChild(gameObject);
}
else
{
gameObjects[clientToServerIds[packet.parentUID]].AddChild(gameObject);
}
}
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
ConcurrentBag <T> objectList = new ConcurrentBag <T>();
var dbNullConverter = new DbNullConverter(settings);
Parallel.For(0, dataRows.Length, (rowIndex) =>
{
T returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var mapping in mappings)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex], mapping.PropertyInfo.PropertyType, settings, dbNullConverter);
mapping.PropertyInfo.SetValue(returnObject, value);
}
objectList.Add(returnObject);
});
return(objectList.ToList());
}
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
List <T> objectList = new List <T>(capacity: dataRows.Length);
var dbNullConverter = new DbNullConverter(settings);
IEnumerable <DelegateColumnMapping <T> > delegates = GetDelegatesForType <T>(mappings);
for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++)
{
T returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var setterDelegate in delegates)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][setterDelegate.ExtendedPropertyInfo.ColumnIndex], setterDelegate.ExtendedPropertyInfo.PropertyInfo.PropertyType, settings, dbNullConverter);
setterDelegate.SetterDelegate(returnObject, value);
}
objectList.Add(returnObject);
}
return(objectList);
}
public async Task GetNotificationAssessmentByIdChecksAuthorization()
{
var notification = NotificationApplicationFactory.Create(userId, NotificationType.Recovery,
UKCompetentAuthority.England, 20181);
context.NotificationApplications.Add(notification);
context.SaveChanges();
var notificationId = notification.Id;
var assessment = new NotificationAssessment(notificationId);
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.NotificationReceived, assessment);
context.NotificationAssessments.Add(assessment);
context.SaveChanges();
var repository = new NotificationAssessmentRepository(context,
notificationApplicationAuthorization);
await repository.GetByNotificationId(notificationId);
A.CallTo(() => notificationApplicationAuthorization.EnsureAccessAsync(notificationId)).MustHaveHappened();
context.DeleteOnCommit(assessment);
await context.SaveChangesAsync();
context.DeleteOnCommit(notification);
await context.SaveChangesAsync();
}
private Country GetTestCountry(Guid id)
{
var country = ObjectInstantiator <Country> .CreateNew();
ObjectInstantiator <Country> .SetProperty(x => x.Id, id, country);
return(country);
}
public void HasShipped_MovementSubmitted_ShipmentDateInFuture_ReturnsFalse()
{
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
ObjectInstantiator <Movement> .SetProperty(x => x.Date, AfterFrozenTime, movement);
Assert.False(movement.HasShipped);
}
public void HasShipped_MovementSubmitted_ShipmentDateInPast_ReturnsTrue()
{
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
ObjectInstantiator <Movement> .SetProperty(x => x.Date, BeforeFrozenTime, movement);
Assert.True(movement.HasShipped);
}
private Domain.ImportNotificationAssessment.ImportNotificationAssessment CreateNotificationAssessment(Guid notificationApplicationId, ImportNotificationStatus status)
{
var assessment = new Domain.ImportNotificationAssessment.ImportNotificationAssessment(notificationApplicationId);
ObjectInstantiator <Domain.ImportNotificationAssessment.ImportNotificationAssessment> .SetProperty(n => n.Status, status, assessment);
return(assessment);
}
private CompetentAuthority GetTestCompetentAuthority(Country country)
{
var competentAuthority = ObjectInstantiator <CompetentAuthority> .CreateNew();
ObjectInstantiator <CompetentAuthority> .SetProperty(x => x.Country, country, competentAuthority);
return(competentAuthority);
}
public MovementOperationReceiptTests()
{
var notification = new NotificationApplication(Guid.NewGuid(), NotificationType.Recovery, UKCompetentAuthority.England, 0);
movement = new Movement(1, notification.Id);
ObjectInstantiator <Movement> .SetProperty(x => x.Date, MovementDate, movement);
ObjectInstantiator <Movement> .SetProperty(x => x.Units, ShipmentQuantityUnits.Kilograms, movement);
}
public async Task PaymentMadeButPaymentIncomplete_PaymentReceivedDateNull()
{
ObjectInstantiator <NotificationDates> .SetProperty(x => x.PaymentReceivedDate, existingDate, assessment.Dates);
var incompletePayment = GetAddNotificationTransaction(existingDate, 50.00m, null);
await handler.HandleAsync(incompletePayment);
Assert.Null(context.NotificationAssessments.Single().Dates.PaymentReceivedDate);
}
public async Task PaymentComplete_PaymentReceivedDateSet_UpdatesDateToAssessment()
{
ObjectInstantiator <NotificationDates> .SetProperty(x => x.PaymentReceivedDate, existingDate, assessment.Dates);
var paymentComplete = GetAddNotificationTransaction(NewDate, TotalBillable, null);
await handler.HandleAsync(paymentComplete);
Assert.Equal(NewDate, context.NotificationAssessments.Single().Dates.PaymentReceivedDate);
}
public void SetCommencementDateUpdatesStatusToInAssessment()
{
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.NotificationReceived, notificationAssessment);
ObjectInstantiator <NotificationDates> .SetProperty(x => x.PaymentReceivedDate, receivedDate, notificationAssessment.Dates);
notificationAssessment.Commenced(commencementDate, nameOfOfficer);
Assert.Equal(NotificationStatus.InAssessment, notificationAssessment.Status);
}
public void SetCommencementDate_NameOfOfficerCantBeEmpty()
{
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.NotificationReceived, notificationAssessment);
ObjectInstantiator <NotificationDates> .SetProperty(x => x.PaymentReceivedDate, receivedDate, notificationAssessment.Dates);
Action setCommencementDate = () => notificationAssessment.Commenced(commencementDate, string.Empty);
Assert.Throws <ArgumentException>("nameOfOfficer", setCommencementDate);
}
public async Task Handler_NotificationHasExitCustomsOffice_ReturnsAllData()
{
ObjectInstantiator <TransportRoute> .SetProperty(x => x.ExitCustomsOffice, exitCustomsOffice, transport);
var result = await handler.HandleAsync(new GetExitCustomsOfficeAddDataByNotificationId(NotificationId));
Assert.Equal(1, result.Countries.Count);
Assert.Equal(exitCustomsOffice.Name, result.CustomsOfficeData.Name);
Assert.NotNull(result.CustomsOffices);
}
private ImportNotification CreateImportNotification(NotificationType notificationType, Guid importNotificationId)
{
var instance = ObjectInstantiator <ImportNotification> .CreateNew();
EntityHelper.SetEntityId(instance, importNotificationId);
ObjectInstantiator <ImportNotification> .SetProperty(x => x.NotificationType, notificationType,
instance);
return(instance);
}
public void CanSetCommencementDateWhenReceived_SetsNameOfOfficer()
{
SetNotificationStatus(NotificationStatus.NotificationReceived);
ObjectInstantiator <NotificationDates> .SetProperty(x => x.PaymentReceivedDate, receivedDate, notificationAssessment.Dates);
notificationAssessment.Commenced(commencementDate, nameOfOfficer);
Assert.Equal(nameOfOfficer, notificationAssessment.Dates.NameOfOfficer);
}
public SetNotificationReceivedDateHandlerTests()
{
context = new TestIwsContext();
assessment = new NotificationAssessment(notificationId);
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.Submitted, assessment);
context.NotificationAssessments.Add(assessment);
handler = new SetNotificationReceivedDateHandler(context);
message = new SetNotificationReceivedDate(notificationId, notificationReceivedDate);
}
public async Task MovementStatusNotSubmitted_Throws(MovementStatus status)
{
var movement = new Movement(1, NotificationId, Today, AnyGuid);
ObjectInstantiator <Movement> .SetProperty(x => x.Status, status, movement);
var validDate = Today.AddDays(3);
await Assert.ThrowsAsync <MovementDateException>(() =>
updatedDateValidator.EnsureDateValid(movement, validDate));
}
private static FinancialGuaranteeCollection GetFinancialGuarantee(FinancialGuaranteeStatus status)
{
var collection = new FinancialGuaranteeCollection(NotificationId);
var fg = collection.AddFinancialGuarantee(Today);
ObjectInstantiator <FinancialGuarantee> .SetProperty(f => f.ActiveLoadsPermitted, 2, fg);
ObjectInstantiator <FinancialGuarantee> .SetProperty(f => f.Status, status, fg);
return(collection);
}
public async Task DateChangedRaisesEvent()
{
var movement = new Movement(1, NotificationId, Today, userId);
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
var newDate = Today.AddDays(5);
await movement.UpdateDate(newDate, validator);
Assert.NotNull(movement.Events.OfType <MovementDateChangeEvent>().SingleOrDefault());
}
public async Task DateUpdates()
{
var movement = new Movement(1, NotificationId, Today, userId);
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
var newDate = Today.AddDays(13);
await movement.UpdateDate(newDate, validator);
Assert.Equal(newDate, movement.Date);
}
public async Task Date10WorkingsDaysGreaterThanOriginalDate_Throws()
{
var movement = new Movement(1, NotificationId, Today, AnyGuid);
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
//10 workings days after 1 Jan 2015 is 14 calendar days (only counting weekends)...
var newDate = Today.AddDays(15);
await Assert.ThrowsAsync <MovementDateOutOfRangeOfOriginalDateException>(() =>
updatedDateValidator.EnsureDateValid(movement, newDate));
}
public async Task ValidDate_DoesNotThrow()
{
var movement = new Movement(1, NotificationId, Today, AnyGuid);
ObjectInstantiator <Movement> .SetProperty(x => x.Status, MovementStatus.Submitted, movement);
var validDate = Today.AddDays(3);
await updatedDateValidator.EnsureDateValid(movement, validDate);
// No assert required
}
