public async Task <Result> Handle(CreateDamageCodeCommand request, CancellationToken cancellationToken)
{
Result result;
var id = _identifierProvider.Generate();
var damageCodeToCreate = new DamageCode(id, request.Code, request.Name, bool.Parse(request.DamagedQuantityRequired), request.Source);
damageCodeToCreate.Version = _versionProvider.Generate();
try
{
await _damageCodeWriteRepository.CreateAsync(damageCodeToCreate);
result = Result.Ok(id, damageCodeToCreate.Version);
}
catch (UniqueKeyException)
{
result = Result.Fail(new System.Collections.Generic.List <Failure>()
{
new HandlerFault()
{
Code = HandlerFaultCode.Conflict.Name,
Message = HandlerFailures.CodeSourceConflict,
Target = "code-source"
}
}
);
}
catch
{
result = Result.Fail(CustomFailures.CreateDamageCodeFailure);
}
return(result);
}
public void CreateDamageCodeShouldSucceed()
{
// Arrange
Guid id = Guid.NewGuid();
string name = "DamageCodeTest";
string source = "Belgium";
bool damagedQuantityRequired = true;
string code = "code";
// Act
var damageCode = new DamageCode(id, code, name, damagedQuantityRequired, source);
// Assert
damageCode.Name.Should().Be(name);
}
public async Task CreateShouldSucceedWhenNameIsSame()
{
//Arrange
var name = "TestName";
var DamageCode = new DamageCode(Guid.NewGuid(), "TestCode1", name, true, "TestSource1");
await _repository.CreateAsync(DamageCode);
var DamageCode2 = new DamageCode(Guid.NewGuid(), "TestCode2", name, true, "TestSource2");
//Act
Action act = () => { _repository.CreateAsync(DamageCode2).GetAwaiter().GetResult(); };
//Assert
act.Should().NotThrow();
}
// Start is called before the first frame update
void Start()
{
// --- Number of Attacker Successes --- //
// Calculate the average number of dice that come up a success.
float chanceForOneDieToBeSuccessful = GetChanceForSingleDieToBeatTargetNumber(GunTargetNumber);
float chanceForOneSuccess = 1 - Mathf.Pow(((1 - chanceForOneDieToBeSuccessful)), GunSkillDice);
float averageNumberOfAttackerSuccesses = chanceForOneDieToBeSuccessful * GunSkillDice;
Debug.Log("Attacker Chance to Get at least 1 Success against a Target Number of " + GunTargetNumber + ": " + chanceForOneSuccess);
Debug.Log("Average Number of Attacker Successes against a Target Number of " + GunTargetNumber + ": " + averageNumberOfAttackerSuccesses);
// --- Number of Defender Successes --- //
// Subtract ballistic armor from power.
int defenderTargetNumber = GunPower - TargetBallisticArmor;
float averageNumberOfDefenderSuccesses = GetChanceForSingleDieToBeatTargetNumber(defenderTargetNumber) * TargetBodyDice;
Debug.Log("Average Number of Defender Successes against a Target Number of " + defenderTargetNumber + " (GunPower minus Armor): " + averageNumberOfDefenderSuccesses);
// --- Calculate Damage Results --- //
float averageSuccesses = averageNumberOfAttackerSuccesses - averageNumberOfDefenderSuccesses;
Debug.Log("Average Successes Total (attacker == positive): " + averageSuccesses);
DamageCode finalDamageCode = GunDamageCode;
while (Mathf.Abs(averageSuccesses) > 2)
{
// Stage damage up
if (averageSuccesses > 0)
{
finalDamageCode = (finalDamageCode == DamageCode.D ? DamageCode.D : finalDamageCode + 1);
averageSuccesses -= 2;
}
// Stage damage down.
else
{
finalDamageCode = (finalDamageCode == DamageCode.NoDamage ? DamageCode.NoDamage : finalDamageCode - 1);
averageSuccesses += 2;
}
}
Debug.Log("Average Damage on Hit: " + finalDamageCode);
}
public async Task CreateShouldFailWhenCodeAndSourceSame()
{
//Arrange
var code = "TestCode";
var name = "TestName";
var source = "TestSource";
var damagedQuantityRequired = true;
var damageCode = new DamageCode(Guid.NewGuid(), code, name, damagedQuantityRequired, source);
await _repository.CreateAsync(damageCode);
var damageCode2 = new DamageCode(Guid.NewGuid(), code, name, damagedQuantityRequired, source);
//Act
Action act = () => { _repository.CreateAsync(damageCode2).GetAwaiter().GetResult(); };
//Assert
act.Should().Throw <UniqueKeyException>();
}
public static DamageCode CreateDamageCode(Guid id, string code, string name, bool DamagedQuantityRequired, string source)
{
// prepare
var writeRepository = new DamageCodeWriteRepository(new DataContext(new PersistenceConfiguration(RepositoryTestsHelper.ConnectionString)));
var readRepository = new DamageCodeReadRepository(new DataContext(new PersistenceConfiguration(RepositoryTestsHelper.ConnectionString)));
// create
var damageCode = new DamageCode(id, code, name, DamagedQuantityRequired, source);
IEnumerable <DamageCode> damageCodes = new List <DamageCode>()
{
damageCode
};
foreach (var item in damageCodes)
{
writeRepository.CreateAsync(item).GetAwaiter().GetResult();
}
// result
var result = readRepository.GetAsync(damageCode.Id).Result;
return(result);
}
public async Task CreateShouldSucceed()
{
//Arrange
var code = "TestCode";
var name = "TestName";
var source = "TestSource";
var damagedQuantityRequired = true;
var damageCode = new DamageCode(Guid.NewGuid(), code, name, damagedQuantityRequired, source);
//Act
await _repository.CreateAsync(damageCode);
//Asssert
var data = RepositoryHelper.ForDamageCode.GetDamageCodes();
data.Should().HaveCount(1);
var result = data.First();
result.Name.Should().Be(name);
result.Code.Should().Be(code);
result.Source.Should().Be(source);
}
