public void VersionConflict()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new PersonService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
MappingId = 12,
Mapping = new MdmId {
SystemName = "Test", Identifier = "A"
},
Version = 34
};
var person = new MDM.Person();
person.AddDetails(new MDM.PersonDetails()
{
Timestamp = BitConverter.GetBytes(25L)
});
var mapping = new PersonMapping {
Person = person
};
validatorFactory.Setup(x => x.IsValid(It.IsAny <AmendMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <PersonMapping>(12)).Returns(mapping);
// Act
service.UpdateMapping(message);
}
public override bool IsValid(AmendMappingRequest request)
{
var mapping = request.Mapping;
var range = new EnergyTrading.DateRange(mapping.StartDate, mapping.EndDate);
var entity = this.repository.FindOne <TEntity>(request.EntityId) as MDM.PartyRole;
if (entity == null)
{
this.Message = string.Format(EntityNotFoundMessageTemplate, typeof(TEntity).Name, request.EntityId);
return(false);
}
var count = this.repository.FindPartyRoleOverlappingMappingCount <TMapping>(
mapping.SystemName,
mapping.Identifier,
range,
entity.PartyRoleType,
request.MappingId);
if (count > 0)
{
this.Message = string.Format(
MessageTemplate,
mapping.Identifier,
mapping.SystemName,
range.Start,
range.Finish);
return(false);
}
return(true);
}
public void NoOverlappingIndentifierShouldPass()
{
// Assert
var start = new DateTime(1999, 1, 1);
var finish = new DateTime(2020, 12, 31);
var validity = new DateRange(start, finish);
var system = new SourceSystem { Name = "Test" };
var expectedPartyRole = new PartyRole() { PartyRoleType = "PartyRole" };
var expected = new PartyRoleMapping { System = system, MappingValue = "1", Validity = validity, PartyRole = expectedPartyRole };
var list = new List<PartyRoleMapping> { expected };
var repository = new Mock<IRepository>();
repository.Setup(x => x.Queryable<PartyRoleMapping>()).Returns(list.AsQueryable());
repository.Setup(x => x.FindOne<PartyRole>(It.IsAny<int>())).Returns(expectedPartyRole);
var identifier = new EnergyTrading.Mdm.Contracts.MdmId
{
SystemName = "Test",
Identifier = "1",
StartDate = start.AddHours(-10),
EndDate = start.AddHours(-5)
};
var request = new AmendMappingRequest() { EntityId = 1, Mapping = identifier, MappingId = 1};
var rule = new PartyRoleAmendMappingNoOverlappingRule<PartyRole, PartyRoleMapping>(repository.Object);
// Act
var result = rule.IsValid(request);
// Assert
repository.Verify(x => x.FindOne<PartyRole>(It.IsAny<int>()));
Assert.IsTrue(result, "Rule failed");
}
public IHttpActionResult Put(int id, int mappingid, [IfMatch] ETag etag, [FromBody] Mapping mapping)
{
return(WebHandler(() =>
{
IEntityMapping returnedMapping = null;
var request = new AmendMappingRequest
{
EntityId = id,
MappingId = mappingid,
Mapping = mapping,
Version = etag.ToVersion()
};
using (var scope = new TransactionScope(TransactionScopeOption.Required, WriteOptions()))
{
returnedMapping = this.service.UpdateMapping(request);
scope.Complete();
}
if (returnedMapping != null)
{
notificationService.Notify(() => GetContract(id, etag.ToVersion()).Contract, service.ContractVersion,
Operation.Modified);
return new StatusCodeResultWithLocation(this.Request, HttpStatusCode.NoContent,
this.Request.RequestUri.AbsolutePath.Substring(1));
}
return NotFound();
}));
}
public void VersionConflict()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new SourceSystemService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
MappingId = 12,
Mapping = new EnergyTrading.Mdm.Contracts.MdmId { SystemName = "Test", Identifier = "A" },
Version = 34
};
var mapping = new SourceSystemMapping { SourceSystem = new Mdm.SourceSystem() { Timestamp = BitConverter.GetBytes(25L) } };
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<SourceSystemMapping>(12)).Returns(mapping);
// Act
service.UpdateMapping(message);
}
public void EntityNotFound()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new PersonService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
EntityId = 12,
Mapping = new MdmId {
SystemName = "Test", Identifier = "A"
}
};
validatorFactory.Setup(x => x.IsValid(It.IsAny <AmendMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
// Act
var candidate = service.UpdateMapping(message);
// Assert
Assert.IsNull(candidate);
}
public void OverlappingIdentifierFails()
{
// Assert
var start = new DateTime(1999, 1, 1);
var finish = new DateTime(2020, 12, 31);
var validity = new DateRange(start, finish);
var system = new SourceSystem { Name = "Test" };
var expected = new PersonMapping { System = system, MappingValue = "1", Validity = validity };
var list = new System.Collections.Generic.List<PersonMapping> { expected };
var repository = new Mock<IRepository>();
repository.Setup(x => x.Queryable<PersonMapping>()).Returns(list.AsQueryable());
var identifier = new EnergyTrading.Mdm.Contracts.MdmId
{
SystemName = "Test",
Identifier = "1",
StartDate = start.AddHours(5),
EndDate = start.AddHours(10)
};
var request = new AmendMappingRequest() { EntityId = 1, Mapping = identifier, MappingId = 1 };
var rule = new AmendMappingNoOverlappingRule<PersonMapping>(repository.Object);
// Act
var result = rule.IsValid(request);
// Assert
repository.Verify(x => x.Queryable<PersonMapping>());
Assert.IsFalse(result, "Rule failed");
}
public void ValidDetailsSaved()
{
const int mappingId = 12;
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new SourceSystemService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// NB Don't put mappingId here - service assigns it
var identifier = new MdmId {
SystemName = "Test", Identifier = "A"
};
var message = new AmendMappingRequest {
MappingId = mappingId, Mapping = identifier, Version = 34
};
var start = new DateTime(2000, 12, 31);
var finish = DateUtility.Round(SystemTime.UtcNow().AddDays(5));
var s1 = new SourceSystem {
Name = "Test"
};
var m1 = new SourceSystemMapping {
Id = mappingId, System = s1, MappingValue = "1", Version = 34UL.GetVersionByteArray(), Validity = new DateRange(start, DateUtility.MaxDate)
};
var m2 = new SourceSystemMapping {
Id = mappingId, System = s1, MappingValue = "1", Validity = new DateRange(start, finish)
};
// NB We deliberately bypasses the business logic
var entity = new MDM.SourceSystem();
m1.SourceSystem = entity;
entity.Mappings.Add(m1);
validatorFactory.Setup(x => x.IsValid(It.IsAny <AmendMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <SourceSystemMapping>(mappingId)).Returns(m1);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.MdmId, SourceSystemMapping>(identifier)).Returns(m2);
// Act
service.UpdateMapping(message);
// Assert
Assert.AreEqual(mappingId, identifier.MappingId, "Mapping identifier differs");
// Proves we have an update not an add
Assert.AreEqual(1, entity.Mappings.Count, "Mapping count differs");
// NB Don't verify result of Update - already covered by SourceSystemMappingFixture
repository.Verify(x => x.Save(entity));
repository.Verify(x => x.Flush());
}
public override bool IsValid(AmendMappingRequest amendMappingRequest)
{
var mapping = amendMappingRequest.Mapping;
var range = new EnergyTrading.DateRange(mapping.StartDate, mapping.EndDate);
var count = this.repository.FindOverlappingMappingCount <T>(mapping.SystemName, mapping.Identifier, range, amendMappingRequest.MappingId);
if (count > 0)
{
this.Message = string.Format(MessageTemplate, mapping.Identifier, mapping.SystemName, range.Start, range.Finish);
return(false);
}
return(true);
}
public void ValidDetailsSaved()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new PersonService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var identifier = new MdmId {
SystemName = "Test", Identifier = "A"
};
var message = new AmendMappingRequest {
MappingId = 12, Mapping = identifier, Version = 34
};
var start = new DateTime(2000, 12, 31);
var finish = DateUtility.Round(SystemTime.UtcNow().AddDays(5));
var s1 = new MDM.SourceSystem {
Name = "Test"
};
var m1 = new PersonMapping {
Id = 12, System = s1, MappingValue = "1", Version = 34UL.GetVersionByteArray(), Validity = new DateRange(start, DateUtility.MaxDate)
};
var m2 = new PersonMapping {
Id = 12, System = s1, MappingValue = "1", Validity = new DateRange(start, finish)
};
// NB We deliberately bypasses the business logic
var person = new MDM.Person();
m1.Person = person;
person.Mappings.Add(m1);
validatorFactory.Setup(x => x.IsValid(It.IsAny <AmendMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <PersonMapping>(12)).Returns(m1);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.MdmId, PersonMapping>(identifier)).Returns(m2);
// Act
service.UpdateMapping(message);
// Assert
// NB Don't verify result of Update - already covered by PersonMappingFixture
repository.Verify(x => x.Save(person));
repository.Verify(x => x.Flush());
}
public void OverlappingIndentifierShouldFail()
{
// Assert
var start = new DateTime(1999, 1, 1);
var finish = new DateTime(2020, 12, 31);
var validity = new DateRange(start, finish);
var system = new SourceSystem {
Name = "Test"
};
var expectedPartyRole = new PartyRole()
{
PartyRoleType = "PartyRole"
};
var expected = new PartyRoleMapping {
System = system, MappingValue = "1", Validity = validity, PartyRole = expectedPartyRole
};
var list = new List <PartyRoleMapping> {
expected
};
var repository = new Mock <IRepository>();
repository.Setup(x => x.Queryable <PartyRoleMapping>()).Returns(list.AsQueryable());
repository.Setup(x => x.FindOne <PartyRole>(It.IsAny <int>())).Returns(expectedPartyRole);
var identifier = new EnergyTrading.Mdm.Contracts.MdmId
{
SystemName = "Test",
Identifier = "1",
StartDate = start.AddHours(5),
EndDate = start.AddHours(10)
};
var request = new AmendMappingRequest()
{
EntityId = 1, Mapping = identifier, MappingId = 1
};
var rule = new PartyRoleAmendMappingNoOverlappingRule <PartyRole, PartyRoleMapping>(repository.Object);
// Act
var result = rule.IsValid(request);
// Assert
repository.Verify(x => x.FindOne <PartyRole>(It.IsAny <int>()));
Assert.IsFalse(result, "Rule failed");
}
public void OverlappingIdentifierFails()
{
// Assert
var start = new DateTime(1999, 1, 1);
var finish = new DateTime(2020, 12, 31);
var validity = new DateRange(start, finish);
var system = new SourceSystem {
Name = "Test"
};
var expected = new SourceSystemMapping {
System = system, MappingValue = "1", Validity = validity
};
var list = new System.Collections.Generic.List <SourceSystemMapping> {
expected
};
var repository = new Mock <IRepository>();
repository.Setup(x => x.Queryable <SourceSystemMapping>()).Returns(list.AsQueryable());
var identifier = new EnergyTrading.Mdm.Contracts.MdmId
{
SystemName = "Test",
Identifier = "1",
StartDate = start.AddHours(5),
EndDate = start.AddHours(10)
};
var request = new AmendMappingRequest()
{
EntityId = 1, Mapping = identifier, MappingId = 1
};
var rule = new AmendMappingNoOverlappingRule <SourceSystemMapping>(repository.Object);
// Act
var result = rule.IsValid(request);
// Assert
repository.Verify(x => x.Queryable <SourceSystemMapping>());
Assert.IsFalse(result, "Rule failed");
}
public void ValidDetailsSaved()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new PartyService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var identifier = new MdmId { SystemName = "Test", Identifier = "A" };
var message = new AmendMappingRequest { MappingId = 12, Mapping = identifier, Version = 34 };
var start = new DateTime(2000, 12, 31);
var finish = DateUtility.Round(SystemTime.UtcNow().AddDays(5));
var s1 = new MDM.SourceSystem { Name = "Test" };
var m1 = new PartyMapping { Id = 12, System = s1, MappingValue = "1", Version = 34UL.GetVersionByteArray(), Validity = new DateRange(start, DateUtility.MaxDate) };
var m2 = new PartyMapping { Id = 12, System = s1, MappingValue = "1", Validity = new DateRange(start, finish) };
// NB We deliberately bypasses the business logic
var party = new MDM.Party();
m1.Party = party;
party.Mappings.Add(m1);
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<PartyMapping>(12)).Returns(m1);
mappingEngine.Setup(x => x.Map<EnergyTrading.Mdm.Contracts.MdmId, PartyMapping>(identifier)).Returns(m2);
// Act
service.UpdateMapping(message);
// Assert
// NB Don't verify result of Update - already covered by PartyMappingFixture
repository.Verify(x => x.Save(party));
repository.Verify(x => x.Flush());
}
public void EntityNotFound()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new PartyService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
EntityId = 12,
Mapping = new MdmId { SystemName = "Test", Identifier = "A" }
};
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
// Act
var candidate = service.UpdateMapping(message);
// Assert
Assert.IsNull(candidate);
}
public void VersionConflict()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new CurveService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
MappingId = 12,
Mapping = new NexusId {
SystemName = "Test", Identifier = "A"
},
Version = 34
};
var mapping = new CurveMapping {
Curve = new MDM.Curve()
{
Timestamp = BitConverter.GetBytes(25L)
}
};
// var <%= EntityName.ToLower() %> = new MDM.<%= EntityName %>();
// <%= EntityName.ToLower() %>.AddDetails(new <%= EntityName %>Details() { Timestamp = BitConverter.GetBytes(25L) });
// var mapping = new <%= EntityName %>Mapping { <%= EntityName %> = <%= EntityName.ToLower() %> };
validatorFactory.Setup(x => x.IsValid(It.IsAny <AmendMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <CurveMapping>(12)).Returns(mapping);
// Act
service.UpdateMapping(message);
}
public void VersionConflict()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new PartyService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
MappingId = 12,
Mapping = new MdmId { SystemName = "Test", Identifier = "A" },
Version = 34
};
var party = new MDM.Party();
party.AddDetails(new PartyDetails() { Timestamp = BitConverter.GetBytes(25L) });
var mapping = new PartyMapping { Party = party };
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<PartyMapping>(12)).Returns(mapping);
// Act
service.UpdateMapping(message);
}
public void VersionConflict()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new CurveService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var message = new AmendMappingRequest
{
MappingId = 12,
Mapping = new NexusId { SystemName = "Test", Identifier = "A" },
Version = 34
};
var mapping = new CurveMapping { Curve = new MDM.Curve() { Timestamp = BitConverter.GetBytes(25L) } };
// var <%= EntityName.ToLower() %> = new MDM.<%= EntityName %>();
// <%= EntityName.ToLower() %>.AddDetails(new <%= EntityName %>Details() { Timestamp = BitConverter.GetBytes(25L) });
// var mapping = new <%= EntityName %>Mapping { <%= EntityName %> = <%= EntityName.ToLower() %> };
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<CurveMapping>(12)).Returns(mapping);
// Act
service.UpdateMapping(message);
}
public void ValidDetailsSaved()
{
const int mappingId = 12;
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new CurveService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// NB Don't put mappingId here - service assigns it
var identifier = new NexusId { SystemName = "Test", Identifier = "A" };
var message = new AmendMappingRequest { MappingId = mappingId, Mapping = identifier, Version = 34 };
var start = new DateTime(2000, 12, 31);
var finish = DateUtility.Round(SystemTime.UtcNow().AddDays(5));
var s1 = new SourceSystem { Name = "Test" };
var m1 = new CurveMapping { Id = mappingId, System = s1, MappingValue = "1", Version = BitConverter.GetBytes(34L), Validity = new DateRange(start, DateUtility.MaxDate) };
var m2 = new CurveMapping { Id = mappingId, System = s1, MappingValue = "1", Validity = new DateRange(start, finish) };
// NB We deliberately bypasses the business logic
var entity = new MDM.Curve();
m1.Curve = entity;
entity.Mappings.Add(m1);
validatorFactory.Setup(x => x.IsValid(It.IsAny<AmendMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<CurveMapping>(mappingId)).Returns(m1);
mappingEngine.Setup(x => x.Map<NexusId, CurveMapping>(identifier)).Returns(m2);
// Act
service.UpdateMapping(message);
// Assert
Assert.AreEqual(mappingId, identifier.MappingId, "Mapping identifier differs");
// Proves we have an update not an add
Assert.AreEqual(1, entity.Mappings.Count, "Mapping count differs");
// NB Don't verify result of Update - already covered by CurveMappingFixture
repository.Verify(x => x.Save(entity));
repository.Verify(x => x.Flush());
}
/// <summary>
///
/// Update an existing mapping for an entity.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public IEntityMapping UpdateMapping(AmendMappingRequest message)
{
// Raise validation exception if message request is null
if (message == null)
{
throw new ValidationException(new List <IRule>()
{
new PredicateRule <AmendMappingRequest>(p => p != null, "AmendMappingRequest should not be null.")
});
}
// Raise validation exception if message request is null TODO: this should really be in a validator, but existing validator checks overlaps and is therefore after the look up below
if (message == null)
{
throw new ValidationException(new List <IRule>()
{
new PredicateRule <AmendMappingRequest>(p => p != null, "AmendMappingRequest should not be null.")
});
}
// Raise validation exception if mapping is null TODO: this should really be in a validator
if (message.Mapping == null)
{
throw new ValidationException(new List <IRule>()
{
new PredicateRule <AmendMappingRequest>(p => p.Mapping != null, "Mapping should not be null.")
});
}
// Raise validation exception if mapping system name is null TODO: this should really be in a validator
if (message.Mapping.SystemName == null)
{
throw new ValidationException(new List <IRule>()
{
new PredicateRule <AmendMappingRequest>(p => !string.IsNullOrWhiteSpace(p.Mapping.SystemName), "Mapping System Name must not be null or an empty string")
});
}
// Get a reference to the entity we should operate against
var mapping = this.repository.FindOne <TMapping>(message.MappingId);
if (mapping == null)
{
return(null);
}
// NB Should we be comparing with the mapping version or the entity version?
if (mapping.Entity.Version != message.Version)
{
throw new VersionConflictException();
}
// Check it's ok
this.Validate(message);
// Ensure the id is on the message
message.Mapping.MappingId = message.MappingId;
// Translate from the contract
var changedMapping = this.MappingEngine.Map <MdmId, TMapping>(message.Mapping);
// Update the mapping and save
var entity = (TEntity)mapping.Entity;
entity.ProcessMapping(changedMapping);
this.repository.Save(entity);
this.repository.Flush();
searchCache.Clear();
return(mapping);
}
