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));
}
