public async Task AccountDataRequestTest(int nonce, Type excpectedException) { context.AppState.State = ApplicationState.Ready; var accountWrapper = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair); var order = new AccountDataRequest { Account = accountWrapper.Account.Id, RequestId = nonce, AccountWrapper = accountWrapper }; var envelope = order.CreateEnvelope(); envelope.Sign(TestEnvironment.Client1KeyPair); if (!context.IsAlpha) { var quantum = new RequestQuantum { Apex = context.QuantumStorage.CurrentApex + 1, RequestEnvelope = envelope, Timestamp = DateTime.UtcNow.Ticks }; envelope = quantum.CreateEnvelope(); envelope.Sign(TestEnvironment.AlphaKeyPair); } var res = await AssertQuantumHandling(envelope, excpectedException); if (excpectedException == null) { Assert.IsInstanceOf <Models.AccountDataResponse>(res); } }
//[TestMethod()] public void GetMailTest() { var getMail = "https://localhost:5001/api/Mailer/GetMail"; var addMail = "https://localhost:5001/api/Account/CreateAccount"; var randMail = Guid.NewGuid().ToString(); var randAccount = Guid.NewGuid().ToString(); var mailDataRequest = new MailDataRequest() { Mail = randMail, AccountName = randAccount, GroupId = 0 }; var accountDataRequest = new AccountDataRequest() { AccountName = randAccount, Email = randMail }; var request = this.CreateRequest <MailDataRequest>(Method.GET, mailDataRequest); var client = new RestClient(getMail); var response = client.Execute(request); Assert.IsTrue(response.Content.Length == 0); client.BaseUrl = new Uri(addMail); request = this.CreateRequest <AccountDataRequest>(Method.POST, accountDataRequest); client.Execute(request); client.BaseUrl = new Uri(getMail); request = this.CreateRequest <MailDataRequest>(Method.GET, mailDataRequest); response = client.Execute(request); Assert.IsTrue(response.Content.Length > 0); }
public async Task AccountRequestRateLimitTest(KeyPair clientKeyPair, int?requestLimit) { context.AppState.State = ApplicationState.Ready; var account = context.AccountStorage.GetAccount(clientKeyPair); if (requestLimit.HasValue) { //TODO: replace it with quantum var effect = new RequestRateLimitUpdateEffect { Account = account.Id, AccountWrapper = account, RequestRateLimits = new RequestRateLimits { HourLimit = (uint)requestLimit.Value, MinuteLimit = (uint)requestLimit.Value } }; var effectProcessor = new RequestRateLimitUpdateEffectProcessor(effect, context.Constellation.RequestRateLimits); effectProcessor.CommitEffect(); } var clientConnection = new AlphaWebSocketConnection(context, new FakeWebSocket(), "127.0.0.1") { ClientPubKey = clientKeyPair, ConnectionState = ConnectionState.Ready, Account = account }; var minuteLimit = (account.Account.RequestRateLimits ?? context.Constellation.RequestRateLimits).MinuteLimit; var minuteIterCount = minuteLimit + 1; for (var i = 0; i < minuteIterCount; i++) { var envelope = new AccountDataRequest { Account = account.Account.Id, RequestId = i + 1 }.CreateEnvelope(); envelope.Sign(clientKeyPair); using var writer = new XdrBufferWriter(); var inMessage = envelope.ToIncomingMessage(writer); if (i + 1 > minuteLimit) { await AssertMessageHandling(clientConnection, inMessage, typeof(TooManyRequestsException)); } else { await AssertMessageHandling(clientConnection, inMessage); } } }
public IActionResult Login([FromBody] AccountDataRequest req) { var result = AccountBL.Login(req); if (result) { return(Ok(this.GetToken())); } else { return(Ok("Błędne dane logowania")); } }
public bool Login(AccountDataRequest req) { var accountData = AccountRepository.GetAll(); var query = from model in accountData where model.AccountName == req.AccountName select new { model.AccountName }; if (query.ToList().Count > 0) { return(true); } else { return(false); } }
public async Task AccountRequestRateLimitTest(KeyPair clientKeyPair, int?requestLimit) { context.AppState.State = ApplicationState.Ready; var account = context.AccountStorage.GetAccount(clientKeyPair); if (requestLimit.HasValue) { account.Account.RequestRateLimits = new RequestRateLimits { HourLimit = (uint)requestLimit.Value, MinuteLimit = (uint)requestLimit.Value } } ; var minuteLimit = (account.Account.RequestRateLimits ?? context.Constellation.RequestRateLimits).MinuteLimit; var minuteIterCount = minuteLimit + 1; for (var i = 0; i < minuteIterCount; i++) { var envelope = new AccountDataRequest { Account = account.Account.Id, RequestId = i + 1, AccountWrapper = account }.CreateEnvelope(); envelope.Sign(clientKeyPair); if (!context.IsAlpha) { var quantum = new RequestQuantum { Apex = context.QuantumStorage.CurrentApex + 1, RequestEnvelope = envelope, Timestamp = DateTime.UtcNow.Ticks }; envelope = quantum.CreateEnvelope(); envelope.Sign(TestEnvironment.AlphaKeyPair); } if (i + 1 > minuteLimit) { await AssertQuantumHandling(envelope, typeof(TooManyRequestsException)); } else { await AssertQuantumHandling(envelope, null); } } }
public bool CreateAccount(AccountDataRequest req) { try { AccountRepository.Insert(new AccountModel() { AccountName = req.AccountName }); EmailAddressRepository.Insert(new EmailAddressModel() { Email = req.Email, AccountName = req.AccountName, GroupId = null }); return(true); } catch (Exception) { return(false); } }
public async Task AccountDataRequestTest(ConnectionState state, Type excpectedException) { Global.AppState.State = ApplicationState.Ready; var clientConnection = new AlphaWebSocketConnection(new FakeWebSocket(), "127.0.0.1") { ClientPubKey = TestEnvironment.Client1KeyPair.PublicKey, ConnectionState = state }; var account = Global.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair); var envelope = new AccountDataRequest { Account = account.Account.Id, RequestId = 1 }.CreateEnvelope(); envelope.Sign(TestEnvironment.Client1KeyPair); await AssertMessageHandling(clientConnection, envelope, excpectedException); }
public async Task AccountDataRequestTest(ConnectionState state, Type excpectedException) { context.AppState.State = ApplicationState.Ready; var clientConnection = new AlphaWebSocketConnection(context, new FakeWebSocket(), "127.0.0.1") { ClientPubKey = TestEnvironment.Client1KeyPair.PublicKey, ConnectionState = state }; var account = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair); var envelope = new AccountDataRequest { Account = account.Account.Id, RequestId = 1 }.CreateEnvelope(); envelope.Sign(TestEnvironment.Client1KeyPair); using var writer = new XdrBufferWriter(); var inMessage = envelope.ToIncomingMessage(writer); await AssertMessageHandling(clientConnection, inMessage, excpectedException); }
public IActionResult CreateAccount([FromBody] AccountDataRequest req) { var result = AccountBL.CreateAccount(req); return(Ok(result)); }
public async Task AlphaRestartWithQuantaDelayTest(bool invalidHash, bool invalidClientSignature, bool invalidAlphaSignature) { var environment = new IntegrationTestEnvironment(); await environment.PrepareConstellation(1, 3); var lastApex = environment.AlphaWrapper.Context.QuantumStorage.CurrentApex; var lastHash = environment.AlphaWrapper.Context.QuantumStorage.LastQuantumHash; var clientPk = environment.Clients.First(); var client = environment.AlphaWrapper.Context.AccountStorage.GetAccount(clientPk); //wait while all auditors will process all available quanta await environment.AssertConstellationApex(lastApex, TimeSpan.FromSeconds(5)); //generate quantum that will not be processed by Alpha var request = new AccountDataRequest { Account = client.Id, RequestId = DateTime.UtcNow.Ticks, AccountWrapper = client } .CreateEnvelope() .Sign(clientPk); var quantum = new RequestQuantum { Apex = lastApex + 1, PrevHash = lastHash, RequestEnvelope = request, Timestamp = DateTime.UtcNow.Ticks }; var quantumEnvelope = quantum .CreateEnvelope(); var result = await environment.ProcessQuantumIsolated(quantumEnvelope); quantum.EffectsHash = result.effectsHash; quantumEnvelope.Sign(environment.AlphaWrapper.Settings.KeyPair); await environment.AlphaWrapper.Shutdown(); await Task.WhenAll(environment.AuditorWrappers.Select(a => IntegrationTestEnvironmentExtensions.AssertState(a.Startup, ApplicationState.Running, TimeSpan.FromSeconds(10)))); //handle quantum await Task.WhenAll(environment.AuditorWrappers.Select(a => { var rawQuantum = quantumEnvelope.ToByteArray(); var auditorsQuantum = XdrConverter.Deserialize <MessageEnvelope>(rawQuantum); return(a.Context.QuantumHandler.HandleAsync(auditorsQuantum)); })); //change quantum environment.AuditorWrappers.ForEach(a => { a.Context.QuantumStorage.GetQuantaBacth(lastApex + 1, 1, out var quanta); var quantum = quanta.First(); if (invalidHash) { ((Quantum)quantum.Message).Timestamp = DateTime.UtcNow.Ticks; } if (invalidClientSignature) { var request = (RequestQuantum)quantum.Message; request.RequestEnvelope.Signatures.Clear(); request.RequestEnvelope.Sign(KeyPair.Random()); } if (invalidAlphaSignature) { quantum.Signatures.Clear(); quantum.Sign(KeyPair.Random()); } }); await environment.AlphaWrapper.Run(); var expectedState = invalidHash || invalidClientSignature || invalidAlphaSignature ? ApplicationState.Failed : ApplicationState.Ready; await IntegrationTestEnvironmentExtensions.AssertState(environment.AlphaWrapper.Startup, expectedState, TimeSpan.FromSeconds(30)); if (expectedState == ApplicationState.Failed) { return; } await Task.WhenAll(environment.AuditorWrappers.Select(a => IntegrationTestEnvironmentExtensions.AssertState(a.Startup, ApplicationState.Ready, TimeSpan.FromSeconds(10)))); await environment.AssertConstellationApex(lastApex + 1, TimeSpan.FromSeconds(5)); }