public void Throw_InvalidOperationException_If_Amount_Is_Lesser_Than_OverdraftLimit() { Assert.Throws <InvalidOperationException>(() => { var balance = Balance.Create(-600m); }); }
public void Bank_statement_should_have_separator_after_credit() { var transaction = Transaction.Create(new Credit(1000)); var bankStatement = transaction.BankStatement(Balance.Create(500)); Compare(bankStatement, "01/01/2016 || 1000.00 ||"); }
public void Debit_Bank_statement_should_not_have_any_credit_information() { var transaction = Transaction.Create(new Debit(1000)); var bankStatement = transaction.BankStatement(Balance.Create(500)); Compare(bankStatement, "01/01/2016 || || 1000.00 ||"); }
public void Create_Itself_From_Money() { var money = new Money(123); var balance = Balance.Create(money); Assert.AreEqual(money.Value, balance.Value); }
public void Bank_statement_should_have_balance_at_the_end() { var transaction = Transaction.Create(new Debit(1000)); var bankStatement = transaction.BankStatement(Balance.Create(2500)); Compare(bankStatement, "01/01/2016 || || 1000.00 || 2500.00"); }
public void Bank_statement_should_begin_with_today() { var transaction = Transaction.Create(new Credit(1000)); var bankStatement = transaction.BankStatement(Balance.Create(500)); Compare(bankStatement, "01/01/2016 "); }
public void EncodingTest() { var accountId = new AccountId(); accountId.Create("0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"); var balance = new Balance(); balance.Create(100); var callArguments = new GenericExtrinsicCall("", "", accountId, balance); switch (Constants.AddressVersion) { case 0: Assert.AreEqual("D43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101", Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure)); break; case 1: Assert.AreEqual("FFD43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101", Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure)); break; case 2: Assert.AreEqual("00D43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101", Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure)); break; } }
public void Throw_InvalidOperationException_If_Amount_Have_More_Than_Two_Decimal_Points() { Assert.Throws <InvalidOperationException>(() => { var balance = Balance.Create(0.001m); }); }
public void Credit_Bank_statement_should_be_displayed_after_date() { var transaction = Transaction.Create(new Credit(1000)); var bankStatement = transaction.BankStatement(Balance.Create(500)); Compare(bankStatement, "01/01/2016 || 1000.00"); }
public void Create_Account_With_Balance() { BankAccount bankAccount = BankAccount.CreateBankAccountWithBalance(Balance.Create(123)); var actualBalance = bankAccount.Balance; Assert.AreEqual(Balance.Create(123), actualBalance); }
internal Balance GetBalance() { return(Balance.Create( currency, decimal.Round(decimal.Parse(balanceAvailable.ToString()), 2), decimal.Round(decimal.Parse(balanceCurrent.ToString()), 2), Util.EpochTimeMillis(), new List <TypedBalance>())); }
private DateTimeOffset[] GetOccurredOns() { var accountCreatedWithBalance = new AccountCreatedWithBalance(Balance.Create(123m)); var accountCreatedWithEmptyBalance = new AccountCreatedWithEmptyBalance(); var depositedMoney = new DepositedMoney(new Money(123m)); var withdrawnMoney = new WithdrawnMoney(new Money(123m)); return(new[] { accountCreatedWithBalance.OccurredOn, accountCreatedWithEmptyBalance.OccurredOn, depositedMoney.OccurredOn, withdrawnMoney.OccurredOn }); }
public void Initialize_Balance() { var balance = Balance.Create(123m); var accountCreatedWithBalance = new AccountCreatedWithBalance(balance); var actual = accountCreatedWithBalance.Balance; Assert.AreEqual(balance, actual); }
public void Configure(EntityTypeBuilder <Account> builder) { builder.ToTable("Accounts", "account"); builder.HasKey(p => p.Id); builder.HasOne(p => p.Client).WithMany(p => p.Accounts); builder.Property(p => p.Iban).HasColumnType("nvarchar(34)"); builder.Property(p => p.Balance).HasConversion(p => p.Value, p => Balance.Create(p)); builder.HasMany(p => p.Transactions).WithOne(p => p.Account); }
public void Withdraw_Money() { var money = new Money(100m); var balance = Balance.Create(300m); var newBalance = balance.Withdraw(money); var actual = newBalance.Value; Assert.AreEqual(balance.Value - money.Value, actual); }
public void Have_Overriden_Equality_Members() { var balance1 = Balance.Create(123m); var balance2 = Balance.Create(123m); var balance3 = Balance.Create(122m); Assert.IsTrue(balance1 == balance2); Assert.IsTrue(balance2.Equals(balance1)); Assert.IsTrue(balance1 != balance3); Assert.IsTrue(!balance3.Equals(balance2)); }
public void Have_Zero_As_StoredEventVersion_After_Initialization() { var bankAccount1 = BankAccount.CreateEmptyBankAccount(); var bankAccount2 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123)); var actual1 = bankAccount1.StoredEventVersion; var actual2 = bankAccount2.StoredEventVersion; Assert.AreEqual(default(int), actual1); Assert.AreEqual(default(int), actual2); }
public void Deposit_Money() { BankAccount bankAccount = BankAccount.CreateEmptyBankAccount(); var money = new Money(123); bankAccount.Deposit(money); var actualBalance = bankAccount.Balance; Assert.AreEqual(Balance.Create(money), actualBalance); }
public void Withdraw_Money() { BankAccount bankAccount = BankAccount.CreateEmptyBankAccount(); var money = new Money(123); bankAccount.Withdraw(money); var actualBalance = bankAccount.Balance; Assert.AreEqual(Balance.Create(-123), actualBalance); }
public void MogwaiBiosTest() { var mogwaiBiosStr = "0x0b1b9f0f79a9e3971baf6188ed98623284f1c3bb275883602164b7097789523f000000000881f7a106cc0f747e85deedaf2946297ebacbe008a7a4887c334448fcc4c4888c00000000000000000000000000000000010426df010000"; var mogwaiBiosA = new MogwaiBios(); mogwaiBiosA.Create(mogwaiBiosStr); var mogwaiBiosB = new MogwaiBios(); var id = new Hash(); id.Create(mogwaiBiosA.Id.Value); Assert.AreEqual("0x0B1B9F0F79A9E3971BAF6188ED98623284F1C3BB275883602164B7097789523F", mogwaiBiosA.Id.Value); var state = new U32(); state.Create(mogwaiBiosA.State.Value); Assert.AreEqual(0, mogwaiBiosA.State.Value); var metaXy = new Vec <U8Arr16>(); metaXy.Create(mogwaiBiosA.MetaXy.Bytes); Assert.AreEqual(2, mogwaiBiosA.MetaXy.Value.Count); Assert.AreEqual("0x0881F7A106CC0F747E85DEEDAF2946297EBACBE008A7A4887C334448FCC4C4888C", Utils.Bytes2HexString(mogwaiBiosA.MetaXy.Bytes)); Assert.AreEqual("0x81F7A106CC0F747E85DEEDAF2946297E", Utils.Bytes2HexString(metaXy.Value[0].Bytes)); var intrinsic = new Balance(); intrinsic.Create(mogwaiBiosA.Intrinsic.Value); var level = new U8(); level.Create(mogwaiBiosA.Level.Value); var phases = new Vec <BlockNumber>(); phases.Create(mogwaiBiosA.Phases.Bytes); var adaptations = new Vec <Hash>(); adaptations.Create(mogwaiBiosA.Adaptations.Bytes); mogwaiBiosB.Create(id, state, metaXy, intrinsic, level, phases, adaptations); Assert.AreEqual(mogwaiBiosB.Id.Value, mogwaiBiosA.Id.Value); Assert.AreEqual(mogwaiBiosB.State.Value, mogwaiBiosA.State.Value); Assert.AreEqual(mogwaiBiosB.MetaXy.Value[0].Bytes, mogwaiBiosA.MetaXy.Value[0].Bytes); Assert.AreEqual(mogwaiBiosB.Intrinsic.Value, mogwaiBiosA.Intrinsic.Value); Assert.AreEqual(mogwaiBiosB.Level.Value, mogwaiBiosA.Level.Value); Assert.AreEqual(mogwaiBiosB.Phases.Value[0].Bytes, mogwaiBiosA.Phases.Value[0].Bytes); Assert.AreEqual(mogwaiBiosB.Adaptations.Value, mogwaiBiosA.Adaptations.Value); }
public static GenericExtrinsicCall BalanceTransfer(string address, BigInteger balanceAmount) { var accountId = new AccountId(); accountId.Create(Utils.GetPublicKeyFrom(address)); var balance = new Balance(); balance.Create(balanceAmount); return(BalanceTransfer(accountId, balance)); }
public void BalanceTest() { var balance1 = new Balance(); balance1.Create("0x518fd3f9a8503a4f7e00000000000000"); Assert.AreEqual("2329998717451725147985", balance1.Value.ToString()); var balance2 = new Balance(); balance2.Create(Utils.HexToByteArray("518fd3f9a8503a4f7e00000000000000")); Assert.AreEqual("2329998717451725147985", balance2.Value.ToString()); }
public void Update_DomainEventVersion_On_Every_Mutation() { var bankAccount1 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123)); var bankAccount2 = BankAccount.CreateEmptyBankAccount(); bankAccount2.Deposit(new Money(1)); bankAccount2.Withdraw(new Money(3)); var actual1 = bankAccount1.DomainEventVersion; var actual2 = bankAccount2.DomainEventVersion; Assert.AreEqual(1, actual1); Assert.AreEqual(3, actual2); }
public void Initialize_Identity() { BankAccount bankAccount1 = BankAccount.CreateEmptyBankAccount(); BankAccount bankAccount2 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123)); BankAccount bankAccount3 = BankAccount.ReconstructBankAccount(new BankAccountSnapshot(1, 23, Guid.NewGuid()), new List <DomainEvent>()); var actual1 = bankAccount1.Id; var actual2 = bankAccount2.Id; var actual3 = bankAccount3.Id; Assert.AreNotEqual(default(Guid), actual1); Assert.AreNotEqual(default(Guid), actual2); Assert.AreNotEqual(default(Guid), actual3); }
public void Store_Event_For_Every_Mutation() { var bankAccountWithBalance = BankAccount.CreateBankAccountWithBalance(Balance.Create(123)); var bankAccount = BankAccount.CreateEmptyBankAccount(); bankAccount.Deposit(new Money(1)); bankAccount.Withdraw(new Money(3)); var actualBankAccountWithBalanceEvent = bankAccountWithBalance.Changes[0]; var actualEmptyBankAccountEvent = bankAccount.Changes[0]; var actualDepositEvent = bankAccount.Changes[1]; var actualWithdrawEvent = bankAccount.Changes[2]; Assert.IsInstanceOf <AccountCreatedWithBalance>(actualBankAccountWithBalanceEvent); Assert.IsInstanceOf <AccountCreatedWithEmptyBalance>(actualEmptyBankAccountEvent); Assert.IsInstanceOf <DepositedMoney>(actualDepositEvent); Assert.IsInstanceOf <WithdrawnMoney>(actualWithdrawEvent); }
public void MogwaiStructTest() { var mogwaiStructStr = "0x89ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec889ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec871000000000000000000000000000000000000000000000000"; var mogwaiStructA = new MogwaiStruct(); mogwaiStructA.Create(mogwaiStructStr); var mogwaiStructB = new MogwaiStruct(); var id = new Hash(); id.Create(mogwaiStructA.Id.Value); var dna = new Hash(); dna.Create(mogwaiStructA.Dna.Value); var genesis = new BlockNumber(); genesis.Create(mogwaiStructA.Genesis.Value); var price = new Balance(); price.Create(mogwaiStructA.Price.Value); var gen = new U32(); gen.Create(mogwaiStructA.Gen.Value); var rarity = new EnumType <RarityType>(); rarity.Create(mogwaiStructA.Rarity.Bytes); mogwaiStructB.Create(id, dna, genesis, price, gen, rarity); Assert.AreEqual(mogwaiStructB.Id.Value, mogwaiStructA.Id.Value); Assert.AreEqual(mogwaiStructB.Dna.Value, mogwaiStructA.Dna.Value); Assert.AreEqual(mogwaiStructB.Genesis.Value, mogwaiStructA.Genesis.Value); Assert.AreEqual(mogwaiStructB.Price.Value, mogwaiStructA.Price.Value); Assert.AreEqual(mogwaiStructB.Gen.Value, mogwaiStructA.Gen.Value); Assert.AreEqual(mogwaiStructB.Rarity.Value, mogwaiStructA.Rarity.Value); }
public void Reconstruct_Itself_From_Snapshot_And_Non_Empty_List_Of_Domain_Events() { var bankAccount = BankAccount.CreateEmptyBankAccount(); bankAccount.Deposit(new Money(100)); bankAccount.Deposit(new Money(100)); bankAccount.Deposit(new Money(100)); var snapshot = bankAccount.Snapshot(); var reconstructedAccount = BankAccount.ReconstructBankAccount(snapshot, new List <DomainEvent> { new WithdrawnMoney(new Money(100)), new WithdrawnMoney(new Money(100)) }); Assert.AreEqual(Balance.Create(new Money(100)), reconstructedAccount.Balance); Assert.AreEqual(0, reconstructedAccount.Changes.Count); Assert.AreEqual(reconstructedAccount.DomainEventVersion, reconstructedAccount.StoredEventVersion); }
public void Create_Itself_From_Decimal_Value() { var balance = Balance.Create(123m); Assert.AreEqual(123m, balance.Value); }
public BankAccount() { _balance = Balance.Create(0); }
public async Task <WalletResult> PayoutToUser <T>(RequestContext <T> requestContext, GameResult gr, BonusExtraInfo bei, bool isEndGame, string debitTrxId = "") { using (logger.BeginScope(new Dictionary <string, object> { ["SessionKey"] = requestContext.UserSession.SessionKey, ["UserId"] = requestContext.UserSession.UserId, ["GameKey"] = requestContext.GameKey, ["Platform"] = requestContext.Platform, ["GameTransactionId"] = gr.TransactionId, ["Amount"] = gr.Win, ["CurrentRoundId"] = gr.RoundId, ["WalletReference"] = bei.BetId, })) { logger.LogInformation("Payout to user"); if (gr.RoundId <= 0) { var msg = String.Format("RoundID can not be zero or less than zero, please always set RoundID to GameResult. Current value is {0}", gr.RoundId); throw new ArgumentException(msg, "RoundID"); } if (isEndGame && gr.RoundId > 0) { logger.LogDebug($"[WIN:ENDGAME] BetId:{bei.BetId} RoundId:{gr.RoundId}"); } gr.Balance = Balance.Create(0); var user = requestContext.UserSession.User; var game = requestContext.Game; WalletResult result; try { var wallet = await userService.GetWallet(requestContext.UserSession); result = await wallet.Credit(gr.Win, game.Id, gr.TransactionId, 0, gr.RoundId, bei.BetId, (int)gr.PlatformType, debitTrxId, gr.TransactionId.ToString(), isEndGame); if (result.Balance <= 0) { var x = await wallet.GetBalance(game.Id, (int)gr.PlatformType); result.Balance = x.IsError ? 0m : x.Value; } gr.ExchangeRate = result.ExchangeRate; } catch (Exception ex) { gr.ErrorSource = ErrorSource.Wallet; logger.LogError(ex, $"[WIN:CREDIT] UserId:{user.Id} GameId:{game.Id} TransactionId:{gr.TransactionId} BetId:{bei.BetId} RoundId:{gr.RoundId} Message:{ex.Message}"); throw; } if (!gr.ExchangeRate.HasValue) { gr.ExchangeRate = 1; } gr.Balance = Balance.Create(result.Balance); return(result); } }