public void TestFullConstructorWithValidValues()
{
// ARRANGE
Guid paramId = Guid.NewGuid();
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
DateTime paramTimeStamp = DateTime.Now;
const string paramUsername = "******";
Guid paramCorrelationId = Guid.NewGuid();
IList <IAuditDetail> paramAuditDetails = new List <IAuditDetail>();
// ACT
IAuditHeaderWithAuditDetails auditHeaderWithAuditDetails = new AuditHeaderWithAuditDetails(
id: paramId,
auditEvent: paramAuditEvent,
timeStamp: paramTimeStamp,
username: paramUsername,
correlationId: paramCorrelationId,
auditDetails: paramAuditDetails);
// ASSERT
Assert.AreNotEqual(Guid.Empty, auditHeaderWithAuditDetails.Id);
Assert.AreEqual(paramId, auditHeaderWithAuditDetails.Id);
Assert.AreEqual(paramAuditEvent, auditHeaderWithAuditDetails.AuditEvent);
Assert.AreEqual(paramTimeStamp, auditHeaderWithAuditDetails.TimeStamp);
Assert.AreEqual(paramUsername, auditHeaderWithAuditDetails.Username);
Assert.AreNotEqual(Guid.Empty, auditHeaderWithAuditDetails.CorrelationId);
Assert.AreEqual(paramCorrelationId, auditHeaderWithAuditDetails.CorrelationId);
Assert.AreSame(paramAuditDetails, auditHeaderWithAuditDetails.AuditDetails);
}
public void TestShortConstructorWithValidValues()
{
// ARRANGE
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
const string paramUsername = "******";
Guid paramCorrelationId = Guid.NewGuid();
// ACT
IAuditHeaderWithAuditDetails auditHeaderWithAuditDetails = new AuditHeaderWithAuditDetails(
auditEvent: paramAuditEvent,
username: paramUsername,
correlationId: paramCorrelationId);
// ASSERT
double seconds = (DateTime.Now - auditHeaderWithAuditDetails.TimeStamp).TotalSeconds;
Assert.AreNotEqual(Guid.Empty, auditHeaderWithAuditDetails.Id);
Assert.AreEqual(paramAuditEvent, auditHeaderWithAuditDetails.AuditEvent);
Assert.IsTrue(seconds >= 0 && seconds <= 5);
Assert.AreEqual(paramUsername, auditHeaderWithAuditDetails.Username);
Assert.AreNotEqual(Guid.Empty, auditHeaderWithAuditDetails.CorrelationId);
Assert.AreEqual(paramCorrelationId, auditHeaderWithAuditDetails.CorrelationId);
Assert.IsNotNull(auditHeaderWithAuditDetails.AuditDetails);
Assert.AreEqual(0, auditHeaderWithAuditDetails.AuditDetails.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditHeaderWithAuditDetails"/> class.
/// </summary>
/// <param name="auditEvent">Audit Event.</param>
/// <param name="username">Username.</param>
/// <param name="correlationId">Correlation Id.</param>
public AuditHeaderWithAuditDetails(
EAuditEvent auditEvent,
string username,
Guid correlationId)
: base(auditEvent, username, correlationId)
{
this.AuditDetails = new List <IAuditDetail>();
Validate(this);
}
/// <inheritdoc />
public Task CreateOrganisationAsync(
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
return(OrganisationHelper.CreateOrganisationAsync(
logger: this.logger,
data: this.data,
who: who,
auditEvent: auditEvent,
organisation: organisation));
}
public void TestEmptyUsernameThrowsException()
{
// ARRANGE
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
Guid paramCorrelationId = Guid.NewGuid();
// ACT
_ = new AuditHeader(
auditEvent: paramAuditEvent,
username: string.Empty,
correlationId: paramCorrelationId);
}
/// <inheritdoc />
public Task CreateAsync(
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
if (who == null)
{
throw new ArgumentNullException(nameof(who));
}
if (organisation == null)
{
throw new ArgumentNullException(nameof(organisation));
}
return(CreateOrganisationInternalAsync());
async Task CreateOrganisationInternalAsync()
{
this.logger.LogTrace(
"ENTRY {Method}(who, organisation) {@Who} {@Organisation}",
nameof(this.CreateAsync),
who,
organisation);
try
{
IAuditHeaderWithAuditDetails auditHeader = await this.data.BeginTransactionAsync(
who, auditEvent)
.ConfigureAwait(false);
await this.data.Organisation.CreateAsync(
who : who,
auditHeader : auditHeader,
organisation : organisation)
.ConfigureAwait(false);
await this.data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction(who);
throw;
}
this.logger.LogTrace(
"EXIT {Method}(who) {@Who}",
nameof(this.CreateAsync),
who);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditHeaderWithAuditDetails"/> class.
/// </summary>
/// <param name="id">Audit Header Id.</param>
/// <param name="auditEvent">Audit Event.</param>
/// <param name="timeStamp">Time Stamp.</param>
/// <param name="auditDetails">Audit Details.</param>
/// <param name="username">Username.</param>
/// <param name="correlationId">Correlation Id.</param>
public AuditHeaderWithAuditDetails(
Guid id,
EAuditEvent auditEvent,
DateTime timeStamp,
IList <IAuditDetail> auditDetails,
string username,
Guid correlationId)
: base(id, auditEvent, timeStamp, username, correlationId)
{
this.AuditDetails = auditDetails;
Validate(this);
}
public void TestLongUsernameThrowsException()
{
// ARRANGE
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
string paramUsername = new string('x', 500);
Guid paramCorrelationId = Guid.NewGuid();
// ACT
_ = new AuditHeader(
auditEvent: paramAuditEvent,
username: paramUsername,
correlationId: paramCorrelationId);
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditHeaderDto"/> class.
/// </summary>
/// <param name="id">Audit Header Id.</param>
/// <param name="auditEvent">Audit Event.</param>
/// <param name="timeStamp">Time Stamp.</param>
/// <param name="auditDetails">Audit Details.</param>
/// <param name="username">Username.</param>
/// <param name="correlationId">Correlation Id.</param>
public AuditHeaderDto(
Guid id,
EAuditEvent auditEvent,
DateTime timeStamp,
string username,
Guid correlationId,
IList <AuditDetailDto> auditDetails)
{
this.Id = id;
this.AuditEvent = auditEvent;
this.TimeStamp = timeStamp;
this.Username = username;
this.CorrelationId = correlationId;
this.AuditDetails = auditDetails;
}
public void TestEmptyAuditHeaderIdThrowsException()
{
// ARRANGE
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
DateTime paramTimeStamp = DateTime.Now;
const string paramUsername = "******";
Guid paramCorrelationId = Guid.NewGuid();
// ACT
_ = new AuditHeader(
id: Guid.Empty,
auditEvent: paramAuditEvent,
timeStamp: paramTimeStamp,
username: paramUsername,
correlationId: paramCorrelationId);
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditHeader"/> class.
/// </summary>
/// <param name="auditEvent">Audit Event.</param>
/// <param name="username">Username.</param>
/// <param name="correlationId">Correlation Id.</param>
public AuditHeader(
EAuditEvent auditEvent,
string username,
Guid correlationId)
{
this.Id = Guid.NewGuid();
this.AuditEvent = auditEvent;
this.TimeStamp = DateTime.Now;
this.Username = username;
this.CorrelationId = correlationId;
if (this.GetType() == typeof(AuditHeader))
{
Validate(this);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditHeader"/> class.
/// </summary>
/// <param name="id">Audit Header Id.</param>
/// <param name="auditEvent">Audit Event.</param>
/// <param name="timeStamp">Time Stamp.</param>
/// <param name="username">Username.</param>
/// <param name="correlationId">Correlation Id.</param>
public AuditHeader(
Guid id,
EAuditEvent auditEvent,
DateTime timeStamp,
string username,
Guid correlationId)
{
this.Id = id;
this.AuditEvent = auditEvent;
this.TimeStamp = timeStamp;
this.Username = username;
this.CorrelationId = correlationId;
if (this.GetType() == typeof(AuditHeader))
{
Validate(this);
}
}
/// <summary>
/// Creates the organisation asynchronous.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="data">Data Layer.</param>
/// <param name="who">Who details.</param>
/// <param name="auditEvent">Audit event.</param>
/// <param name="organisation">Organisation to create.</param>
/// <returns>NOTHING.</returns>
internal static async Task CreateOrganisationAsync(
ILogger <VirtualBridgeService> logger,
IVirtualBridgeData data,
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
logger.LogTrace(
"ENTRY {Method}(who, organisation) {@who} {@organisation}",
nameof(CreateOrganisationAsync),
who,
organisation);
try
{
IAuditHeaderWithAuditDetails auditHeader =
await data.BeginTransactionAsync(who, auditEvent)
.ConfigureAwait(false);
await data.Organisation.CreateAsync(
who : who,
auditHeader : auditHeader,
organisation : organisation)
.ConfigureAwait(false);
await data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
data.RollbackTransaction(who);
throw;
}
logger.LogTrace(
"EXIT {Method}(who) {@who}",
nameof(CreateOrganisationAsync),
who);
}
public void Test_Basic_Constructor()
{
// ARRANGE
Guid paramId = Guid.NewGuid();
const EAuditEvent paramAuditEvent = EAuditEvent.OrganisationMaintenance;
DateTime paramTimeStamp = DateTime.Now;
const string paramUsername = "******";
Guid paramCorrelationId = Guid.NewGuid();
IList <AuditDetailDto> paramAuditDetails = new List <AuditDetailDto>
{
new AuditDetailDto(
id: Guid.NewGuid(),
auditHeaderId: paramId,
tableName: "TableName",
columnName: "ColumnName",
recordId: Guid.NewGuid(),
oldValue: "old value",
newValue: "new value",
databaseAction: EDatabaseAction.Update)
};
// ACT
AuditHeaderDto auditHeaderDto = new AuditHeaderDto(
id: paramId,
auditEvent: paramAuditEvent,
timeStamp: paramTimeStamp,
username: paramUsername,
correlationId: paramCorrelationId,
auditDetails: paramAuditDetails);
// ASSERT
Assert.AreEqual(paramId, auditHeaderDto.Id);
Assert.AreEqual(paramAuditEvent, auditHeaderDto.AuditEvent);
Assert.AreEqual(paramTimeStamp, auditHeaderDto.TimeStamp);
Assert.AreEqual(paramUsername, auditHeaderDto.Username);
Assert.AreEqual(paramCorrelationId, auditHeaderDto.CorrelationId);
Assert.AreSame(paramAuditDetails, auditHeaderDto.AuditDetails);
}
/// <inheritdoc />
public Task <IAuditHeaderWithAuditDetails> BeginTransactionAsync(
IWho who,
EAuditEvent auditEvent)
{
if (who == null)
{
throw new ArgumentNullException(nameof(who));
}
return(BeginTransactionInternalAsync());
async Task <IAuditHeaderWithAuditDetails> BeginTransactionInternalAsync()
{
this.logger.LogTrace(
"ENTRY {Method}(who, auditEvent) {@Who} {@AuditEvent}",
nameof(this.BeginTransactionAsync),
who,
auditEvent);
await this.context.Database.BeginTransactionAsync()
.ConfigureAwait(false);
AuditHeaderWithAuditDetails auditHeader = new AuditHeaderWithAuditDetails(
auditEvent: auditEvent,
username: "******",
correlationId: who.CorrelationId);
this.logger.LogTrace(
"EXIT {Method}(who, auditHeader) {@Who} {@AuditHeader}",
nameof(this.BeginTransactionAsync),
who,
auditHeader);
return(auditHeader);
}
}
