public async Task ItShouldReturnAnInvalidResponseWhenThereIsAMatchThatHasInvalidData()
{
var message = new ChallengePermissionQuery
{
Id = "123",
Balance = "£1000",
ChallengeElement1 = "1",
ChallengeElement2 = "2"
};
var account = new Core.Models.Account
{
HashedAccountId = "ASDAS",
AccountId = 123
};
_accountRepository
.Setup(x => x.Get(message.Id, AccountFieldsSelection.PayeSchemes))
.ReturnsAsync(account);
_challengeRepository.Setup(x => x.CheckData(account, message)).ReturnsAsync(false);
var actual = await _unit.Handle(message);
_challengeRepository.Verify(x => x.CheckData(account, message));
Assert.IsNotNull(actual);
Assert.AreEqual(false, actual.IsValid);
}
//private readonly ApplicationDbContext _context;
//public AccountCreateLogic(ApplicationDbContext context)
//{
// _context = context;
//}
public void Create(string name, int pin)
{
var account = new Core.Models.Account(name, pin);
//_context.Accounts.Add(account);
//_context.SaveChanges();
}
private AccountSearchModel Map(Core.Models.Account account)
{
return(new AccountSearchModel
{
Account = account.DasAccountName,
AccountID = account.HashedAccountId,
SearchType = SearchCategory.Account,
PayeSchemeIds = account.PayeSchemes?.Select(p => p.PayeRefWithOutSlash).ToList()
});
}
public async Task <ResultModel <AccountBasic> > RegisterAccountAsync(AccountRegister accountRegister)
{
var result = new ResultModel <AccountBasic>();
try
{
var id_User = _tokenRead.GetValue("Id_User");
if (!string.IsNullOrEmpty(id_User) && int.TryParse(id_User, out int userId))
{
var account = new Core.Models.Account(accountRegister);
var valid = account.Valid();
if (valid.Success)
{
await _account.RegisterAccount(account, userId);
if (account.Id > 0)
{
await _bus.PublishForgetAsync(new AccountCommandInsert {
AccountId = account.Id
});
result.SetData(new AccountBasic
{
Active = account.Active,
Id = account.Id,
Identification = account.Identification
});
}
else
{
result.NotValid();
result.SetMessages("Não foi possíovel realizar o cadastro!");
}
}
else
{
result.NotValid();
result.SetMessages(valid.Messages);
}
}
else
{
result.NotValid();
result.SetMessages("Error Token, not found User_Id");
}
}
catch (Exception e)
{
result.NotValid(e.GetBaseException().Message);
}
return(result);
}
public async Task <bool> CheckData(Core.Models.Account record, ChallengePermissionQuery message)
{
var balance = await _accountRepository.GetAccountBalance(message.Id);
var validPayeSchemesData = CheckPayeSchemesData(record.PayeSchemes, message);
decimal messageBalance;
if (!decimal.TryParse(message.Balance.Replace("£", string.Empty), out messageBalance))
{
return(false);
}
return(Math.Truncate(balance) == Math.Truncate(Convert.ToDecimal(messageBalance)) && validPayeSchemesData);
}
public async Task ItShouldReturnFalseWhenCheckDataHasInvalidBalance()
{
var account = new Core.Models.Account
{
Transactions = new List <TransactionViewModel>
{
new TransactionViewModel {
Balance = 300m
},
new TransactionViewModel {
Balance = 700m
}
},
PayeSchemes = new List <PayeSchemeModel>
{
new PayeSchemeModel
{
AddedDate = DateTime.Today.AddMonths(-12),
Ref = "123/456789"
},
new PayeSchemeModel
{
AddedDate = DateTime.Today.AddMonths(-12),
Ref = "124/AA6789"
}
}
};
var challengePermissionQuery = new ChallengePermissionQuery
{
Id = "123",
Balance = "£Z000",
ChallengeElement1 = "1",
ChallengeElement2 = "A",
FirstCharacterPosition = 0,
SecondCharacterPosition = 4
};
var balance = 1000m;
_accountRepository.Setup(x => x.GetAccountBalance(challengePermissionQuery.Id))
.ReturnsAsync(balance);
var actual = await _unit.CheckData(account, challengePermissionQuery);
Assert.IsFalse(actual);
}
public async Task ItShouldReturnAccountInResponseIfFound()
{
var accountId = 123L;
var orgid = accountId.ToString();
var account = new Core.Models.Account {
AccountId = accountId
};
MockAccountRepository.Setup(r => r.Get(orgid, AccountFieldsSelection.None)).ReturnsAsync(account);
var actual = await Unit.Find(orgid);
Assert.IsNotNull(actual);
Assert.AreEqual(SearchResponseCodes.Success, actual.StatusCode);
Assert.IsNotNull(actual.Account);
}
private Core.Models.Account GenerateTestAccount()
{
Core.Models.Account toReturn = new Core.Models.Account
{
HashedAccountId = _accountId,
DasAccountName = "TEST",
PayeSchemes = new List <PayeSchemeModel>
{
new PayeSchemeModel
{
Ref = _actualPayeRef
}
}
};
return(toReturn);
}
public async Task ItShouldReturnNoAccountInTheResponseIfNotFound()
{
var accountId = 123L;
var orgid = accountId.ToString();
var account = new Core.Models.Account {
AccountId = accountId
};
MockAccountRepository.Setup(r => r.Get(orgid, AccountFieldsSelection.PayeSchemes))
.ReturnsAsync(null as Core.Models.Account);
var actual = await Unit.FindPayeSchemes(orgid);
Assert.IsNotNull(actual);
Assert.AreEqual(new AccountDetailOrganisationsResponse().StatusCode, actual.StatusCode);
Assert.IsNull(actual.Account);
}
public async Task ItShouldReturnAnAccountAndSuccessWhenQueryHasAMatch()
{
const string id = "123";
var account = new Core.Models.Account
{
HashedAccountId = "ASDAS",
AccountId = 123
};
_accountRepository.Setup(x =>
x.Get(id,
AccountFieldsSelection.PayeSchemes))
.ReturnsAsync(account);
var actual = await _unit.Get(id);
Assert.IsNotNull(actual);
Assert.IsNotNull(actual.Account);
Assert.AreEqual(SearchResponseCodes.Success, actual.StatusCode);
}
/// <summary>
/// Do somthing for tests.
/// </summary>
public void DeveloperFunction()
{
GameAppDelegate.Account.Scrap.MaximumValue = 1000;
GameAppDelegate.Account.Plutonium.MaximumValue = 1000;
GameAppDelegate.Account.Population.MaximumValue = 1000;
GameAppDelegate.Account.Technology.MaximumValue = 1000;
GameAppDelegate.Account.Energy.MaximumValue = 1000;
GameAppDelegate.Account.Scrap.Set(DateTime.Now, 1000, 0);
GameAppDelegate.Account.Plutonium.Set(DateTime.Now, 1000, 0);
GameAppDelegate.Account.Population.Value = 1000;
GameAppDelegate.Account.Technology.Set(DateTime.Now, 1000, 0);
GameAppDelegate.Account.Energy.Value = 1000;
var account = new Core.Models.Account(GameAppDelegate.Account.ID + 1);
new Core.Models.AccountManager().AddAccount(account);
var pos = Models.Geolocation.Instance.CurrentGamePosition;
// var posI = new Core.Models.PositionI(pos.RegionPosition, pos.CellPosition);
var actionCreate = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(pos),
Core.Models.World.Instance.DefinitionManager.GetDefinition(Core.Models.Definitions.EntityType.Headquarter),
account);
m_gameScene.WorldLayerHex.DoAction(actionCreate);
account.Scrap.MaximumValue = 10000;
account.Plutonium.MaximumValue = 10000;
account.Population.MaximumValue = 10000;
account.Technology.MaximumValue = 10000;
account.Energy.MaximumValue = 10000;
account.Scrap.Set(DateTime.Now, 10000, 0);
account.Plutonium.Set(DateTime.Now, 10000, 0);
account.Population.Value = 10000;
account.Technology.Set(DateTime.Now, 10000, 0);
account.Energy.Value = 10000;
var newPos = new Core.Models.Position(pos.RegionPosition, new Core.Models.CellPosition((int)pos.X + 2, (int)pos.Y + 2));
var actioncreate2 = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newPos),
Core.Models.World.Instance.DefinitionManager.GetDefinition(Core.Models.Definitions.EntityType.Barracks),
account);
m_gameScene.WorldLayerHex.DoAction(actioncreate2);
var actioncr = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newPos),
new Core.Models.Definitions.Definition((int)Core.Models.Definitions.EntityType.Archer),
account);
var actioncr2 = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newPos),
new Core.Models.Definitions.Definition((int)Core.Models.Definitions.EntityType.Fencer),
account);
m_gameScene.WorldLayerHex.DoAction(actioncr);
m_gameScene.WorldLayerHex.DoAction(actioncr2);
var newBorderpos = new Core.Models.Position(pos.RegionPosition, new Core.Models.CellPosition((int)pos.X - 4, (int)pos.Y));
var newBorderpos2 = new Core.Models.Position(pos.RegionPosition, new Core.Models.CellPosition((int)pos.X, (int)pos.Y - 4));
var actioncreate3 = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newBorderpos),
Core.Models.World.Instance.DefinitionManager.GetDefinition(Core.Models.Definitions.EntityType.GuardTower),
account);
m_gameScene.WorldLayerHex.DoAction(actioncreate3);
var actioncreate4 = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newBorderpos2),
Core.Models.World.Instance.DefinitionManager.GetDefinition(Core.Models.Definitions.EntityType.GuardTower),
account);
m_gameScene.WorldLayerHex.DoAction(actioncreate4);
var newLabpos = new Core.Models.Position(pos.RegionPosition, new Core.Models.CellPosition((int)newBorderpos.X - 1, (int)newBorderpos.Y));
var actioncreate5 = Helper.ActionHelper.CreateEntity(
new Core.Models.PositionI(newLabpos),
Core.Models.World.Instance.DefinitionManager.GetDefinition(Core.Models.Definitions.EntityType.Lab),
account);
m_gameScene.WorldLayerHex.DoAction(actioncreate5);
}
public IndexModel()
{
_account = new Core.Models.Account("Timo");
_account.AddBalance(12345, 50);
}
