public OperationExecutionAggregate ToDomain()
{
return(OperationExecutionAggregate.Restore(
ETag,
State,
Result,
StartMoment,
ActiveTransactionIdGenerationMoment,
ActiveTransactionStartMoment,
TransactionExecutionRepeatRequestMoment,
ActiveTransactionClearingMoment,
TransactionFinishMoment,
FinishMoment,
OperationId,
FromAddress,
Outputs
.Select(x => x.ToDomain())
.ToArray(),
AssetId,
IncludeFee,
BlockchainType,
BlockchainAssetId,
EndpointsConfiguration,
ActiveTransactionId,
ActiveTransactionNumber,
TransactionOutputs?
.Select(o => o.ToDomain())
.ToArray(),
TransactionBlock,
TransactionFee,
TransactionHash,
Error,
RebuildConfirmationResult));
}
public void Test_One_To_Many_Execution_To_Failure()
{
// Arrange
var switcher = OperationExecutionStateSwitcherBuilder.Build();
var aggregate = OperationExecutionAggregate.Start
(
Guid.NewGuid(),
"",
new []
{
new TransactionOutputValueType("1", 1.0m),
new TransactionOutputValueType("2", 2.0m),
},
"",
false,
"",
"",
OperationExecutionEndpointsConfiguration.OneToOne
);
// Act / Assert
Assert.Equal(OperationExecutionState.Started, aggregate.State);
Assert.True(switcher.Switch(aggregate, new ActiveTransactionIdGeneratedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.ActiveTransactionIdGenerated, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionStartedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.TransactionExecutionInProgress, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionFailedEvent
{
ErrorCode = TransactionExecutionResult.UnknownError,
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.Failed, aggregate.State);
Assert.True(switcher.Switch(aggregate, new OperationExecutionFailedEvent()));
Assert.Equal(OperationExecutionState.NotifiedAboutEnding, aggregate.State);
}
public void Test_Simple_Execution_To_Completion()
{
// Arrange
var switcher = OperationExecutionStateSwitcherBuilder.Build();
var aggregate = OperationExecutionAggregate.Start
(
Guid.NewGuid(),
"",
new [] { new TransactionOutputValueType("", 0) },
"",
false,
"",
"",
OperationExecutionEndpointsConfiguration.OneToOne
);
// Act / Assert
Assert.Equal(OperationExecutionState.Started, aggregate.State);
Assert.True(switcher.Switch(aggregate, new ActiveTransactionIdGeneratedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.ActiveTransactionIdGenerated, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionStartedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.TransactionExecutionInProgress, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionCompletedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.Completed, aggregate.State);
Assert.True(switcher.Switch(aggregate, new OperationExecutionCompletedEvent()));
Assert.Equal(OperationExecutionState.NotifiedAboutEnding, aggregate.State);
}
// ReSharper restore MemberCanBePrivate.Global
#endregion
#region Conversion
public static OperationExecutionEntity FromDomain(OperationExecutionAggregate aggregate)
{
return(new OperationExecutionEntity
{
ETag = aggregate.Version,
PartitionKey = AggregateKeysBuilder.BuildPartitionKey(aggregate.OperationId),
RowKey = AggregateKeysBuilder.BuildRowKey(aggregate.OperationId),
State = aggregate.State,
Result = aggregate.Result,
StartMoment = aggregate.StartMoment,
ActiveTransactionIdGenerationMoment = aggregate.ActiveTransactionIdGenerationMoment,
ActiveTransactionStartMoment = aggregate.ActiveTransactionStartMoment,
TransactionExecutionRepeatRequestMoment = aggregate.TransactionExecutionRepeatRequestMoment,
ActiveTransactionClearingMoment = aggregate.ActiveTransactionClearingMoment,
TransactionFinishMoment = aggregate.TransactionFinishMoment,
FinishMoment = aggregate.FinishMoment,
OperationId = aggregate.OperationId,
BlockchainType = aggregate.BlockchainType,
FromAddress = aggregate.FromAddress,
Outputs = aggregate.Outputs
.Select(TransactionOutputEntity.FromDomain)
.ToArray(),
AssetId = aggregate.AssetId,
IncludeFee = aggregate.IncludeFee,
BlockchainAssetId = aggregate.BlockchainAssetId,
EndpointsConfiguration = aggregate.EndpointsConfiguration,
ActiveTransactionId = aggregate.ActiveTransactionId,
ActiveTransactionNumber = aggregate.ActiveTransactionNumber,
TransactionOutputs = aggregate.TransactionOutputs?
.Select(TransactionOutputEntity.FromDomain)
.ToArray(),
TransactionBlock = aggregate.TransactionBlock,
TransactionFee = aggregate.TransactionFee,
TransactionHash = aggregate.TransactionHash,
Error = aggregate.Error,
RebuildConfirmationResult = aggregate.RebuildConfirmationResult
});
}
public Task SaveAsync(OperationExecutionAggregate aggregate)
{
return(_aggregateRepository.SaveAsync(aggregate));
}
public void Test_Execution_With_Double_Transaction_Repeat_To_Failure()
{
// Arrange
var switcher = OperationExecutionStateSwitcherBuilder.Build();
var aggregate = OperationExecutionAggregate.Start
(
Guid.NewGuid(),
"",
new [] { new TransactionOutputValueType("", 0) },
"",
false,
"",
"",
OperationExecutionEndpointsConfiguration.OneToOne
);
// Act / Assert
Assert.Equal(OperationExecutionState.Started, aggregate.State);
Assert.True(switcher.Switch(aggregate, new ActiveTransactionIdGeneratedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.ActiveTransactionIdGenerated, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionStartedEvent
{
TransactionNumber = 1
}));
Assert.Equal(OperationExecutionState.TransactionExecutionInProgress, aggregate.State);
foreach (var transactionNumber in Enumerable.Range(2, 2))
{
Assert.True(switcher.Switch(aggregate, new TransactionExecutionRepeatRequestedEvent
{
ErrorCode = TransactionExecutionResult.RebuildingIsRequired,
TransactionNumber = transactionNumber - 1
}));
Assert.Equal(OperationExecutionState.TransactionExecutionRepeatRequested, aggregate.State);
Assert.True(switcher.Switch(aggregate, new ActiveTransactionClearedEvent
{
TransactionNumber = transactionNumber - 1
}));
Assert.Equal(OperationExecutionState.ActiveTransactionCleared, aggregate.State);
Assert.True(switcher.Switch(aggregate, new ActiveTransactionIdGeneratedEvent
{
TransactionNumber = transactionNumber
}));
Assert.Equal(OperationExecutionState.ActiveTransactionIdGenerated, aggregate.State);
Assert.True(switcher.Switch(aggregate, new TransactionExecutionStartedEvent
{
TransactionNumber = transactionNumber
}));
Assert.Equal(OperationExecutionState.TransactionExecutionInProgress, aggregate.State);
}
Assert.True(switcher.Switch(aggregate, new TransactionExecutionFailedEvent
{
ErrorCode = TransactionExecutionResult.UnknownError,
TransactionNumber = 3
}));
Assert.Equal(OperationExecutionState.Failed, aggregate.State);
Assert.True(switcher.Switch(aggregate, new OperationExecutionFailedEvent()));
Assert.Equal(OperationExecutionState.NotifiedAboutEnding, aggregate.State);
}
