public void CheckThatCanBeParsedTest()
{
// Arrange
object parameter = null;
int seed = 1337;
int loopCount = 100;
GuidGenerator gg = new GuidGenerator();
List <bool> parseWasOk = new List <bool>();
// Act
var shouldBeValidResult = gg.Init(parameter, seed);
for (int i = 0; i < loopCount; i++)
{
var generateResult = gg.Generate(parameter: null, wantedOutput: null);
gg.NextStep();
parseWasOk.Add(Guid.TryParse((string)generateResult.result, out _));
}
// Assert
Assert.IsTrue(shouldBeValidResult.success, "Init should have been successful");
Assert.AreEqual(parseWasOk.Count, parseWasOk.Where(item => item == true).Count(), "All of the results should be true");
}
public override BaseResult Calculate(CancellationToken cancellationToken)
{
if (_guids == null)
{
_guids = _guidGenerator.Generate(_guidCount);
}
var maxCommonStrings = new List <string>();
if (_guids.Count < 3)
{
return(new FindMaxCommonSequenceResult(_guids, maxCommonStrings));
}
var strGuids = _guids.Select(x => x.ToString().Replace("-", String.Empty));
foreach (var comb in strGuids.Combinations(MinGuidsCountWithMaxCommonSubstrings))
{
cancellationToken.ThrowIfCancellationRequested();
var currentMaxCommonSubstrings = comb.MaxCommonSubstrings();
maxCommonStrings.AddRange(currentMaxCommonSubstrings);
maxCommonStrings = maxCommonStrings.Where(x => x.Length == maxCommonStrings.Max(y => y.Length)).Distinct().ToList();
}
return(new FindMaxCommonSequenceResult(_guids, maxCommonStrings));
}
public void SeedTest()
{
// Arrange
int seed1 = 1337;
int seed2 = 13370;
int rounds = 100;
GuidGenerator gg1 = new GuidGenerator();
GuidGenerator gg2 = new GuidGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <object> gene2Objects = new List <object>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = gg1.Init(null, seed1);
var shouldBeValidInitResult2 = gg2.Init(null, seed2);
for (int i = 0; i < rounds; i++)
{
var genResult1 = gg1.Generate();
var genResult2 = gg2.Generate();
gene1Objects.Add(genResult1.result);
gene2Objects.Add(genResult2.result);
gg1.NextStep();
gg2.NextStep();
}
CollectionAssert.AreNotEqual(gene1Objects, gene2Objects);
}
public async Task <(string token, string refreshToken)> LoginAsync(string username, string password)
{
var userInDB = await repositoryWrapper.User.GetUserAsync(username);
if (userInDB == null)
{
return(null, null);
}
if (!VerifyPasswordHash(password, userInDB.PasswordHash, userInDB.PasswordSalt))
{
return(null, null);
}
var accessToken = new Token()
{
AccessToken = GenerateJSONWebToken(userInDB),
AccessTokenExpiry = DateTime.Now.AddMinutes(60),
refreshToken = GuidGenerator.Generate(),
refreshTokenExpiry = DateTime.Now.AddMinutes(65),
UserId = userInDB.Id
};
repositoryWrapper.Token.AddToken(accessToken);
var saveStatus = await repositoryWrapper.Complete();
return(GenerateJSONWebToken(userInDB), GuidGenerator.Generate());
}
public void If_Uppercase_True_Then_Result_Should_Be_All_Uppercase()
{
var hyphenated = GuidGenerator.Generate(true, true);
var nonHyphenated = GuidGenerator.Generate(false, true);
Assert.AreEqual(hyphenated, hyphenated.ToUpper());
Assert.AreEqual(nonHyphenated, nonHyphenated.ToUpper());
}
public void If_Hyphens_True_Then_Result_Should_Contain_Hyphens()
{
var uppercase = GuidGenerator.Generate(true, true);
var lowercase = GuidGenerator.Generate(true, false);
Assert.AreNotEqual(uppercase, uppercase.Replace("-", ""));
Assert.AreNotEqual(lowercase, lowercase.Replace("-", ""));
}
public void GenerateNoGroupingTest()
{
// Arrange
string parameter = "JOINED"; // Disables grouping
int seed = 1337;
int loopCount = 100;
GuidGenerator gg = new GuidGenerator();
List <string> guids = new List <string>();
List <bool> successList = new List <bool>();
// Act
var shouldBeValidResult = gg.Init(parameter, seed);
var generated1 = gg.Generate(parameter);
var generated2 = gg.Generate(parameter); // Same step should provide same result
for (int i = 0; i < loopCount; i++)
{
gg.NextStep();
var generateResult = gg.Generate(parameter: null, wantedOutput: null);
successList.Add(generateResult.success);
guids.Add((string)generateResult.result);
}
// Assert
Assert.IsTrue(shouldBeValidResult.success, "Init should have been successful");
Assert.AreEqual(generated1.result, generated2.result, "Both generates should have same results since NextStep has not been called between them");
CollectionAssert.DoesNotContain(successList, false, "All generates should have been successful");
CollectionAssert.AllItemsAreUnique(guids, "In theory every GUID should be unique");
foreach (string guid in guids)
{
Assert.AreEqual(0, guid.Count(c => c == GuidGenerator.groupSeparator), "Every GUID should have 0 group separators");
}
}
public Task Invoke(HttpContext context)
{
if (context.Request.Headers.TryGetValue("X-RequestFreeGuid", out var correlationId))
{
context.Response.OnStarting(() =>
{
context.Response.Headers.Add("X-FreeGUID", _generator.Generate());
return(Task.CompletedTask);
});
}
return(_next(context));
}
public void GenerateWorks(Guid value, string expected)
{
// Arrange
var random = new Mock <IRandomNumber>();
var x = random.Setup(x => x.Next()).Returns(value);
var sut = new GuidGenerator(random.Object);
// Act
var result = sut.Generate();
// assert
Assert.Equal(expected, result);
}
private async Task <Token> WriteToDB(int userId, Token TokenInDB)
{
var userInDB = await repositoryWrapper.User.GetUserByIDAsync(userId, false);
await repositoryWrapper.Token.DeleteTokenAsync(TokenInDB.refreshToken);
var accessToken = new Token()
{
AccessToken = GenerateJSONWebToken(userInDB),
AccessTokenExpiry = DateTime.Now.AddMinutes(7),
refreshToken = GuidGenerator.Generate(),
refreshTokenExpiry = DateTime.Now.AddMinutes(20),
UserId = userInDB.Id
};
repositoryWrapper.Token.AddToken(accessToken);
return(accessToken);
}
private async void Tmr_Tick(object sender, EventArgs e)
{/*
* if (LatestRa3 == null)
* return;
*
* var ra3Connections = Utility.Networking.GetAllTCPConnections()
* .Where(connection => connection.owningPid == LatestRa3.Id);
*
* foreach (var mibTcprowOwnerPid in ra3Connections)
* {
* Console.WriteLine(mibTcprowOwnerPid.RemoteAddress.ToString());
* }*/
// _processWatcher.CheckProcesses();
// Sample Code...
string guid = await GuidGenerator.Generate();
await PutReport("http://127.0.0.1:1337/report", guid);
}
private Task HandleExceptionAsync(HttpContext ctx, Exception ex, ApiExceptionOptions opts)
{
var error = new ApiError
{
Id = GuidGenerator.Generate(),
StatusCode = (short)HttpStatusCode.InternalServerError,
Title = "Internal Server Error"
};
opts.AddResponseDetails?.Invoke(ctx, ex, error);
var innerExMessage = GetInnerMostExceptionMessage(ex);
loggerManager.LogError($"{error.ToString()} \n{innerExMessage}");
var result = JsonConvert.SerializeObject(error);
// ctx.Response.AddApplicationError(error.Title);
ctx.Response.ContentType = "application/json";
ctx.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(ctx.Response.WriteAsync(error.ToString()));
}
public override void OnResultExecuting(ResultExecutingContext context)
{
context.HttpContext.Response.Headers.Add(_name, new[] { _guidGenerator.Generate(), _instantGuid.ToString() });
base.OnResultExecuting(context);
}
public void ShouldGenerateGuidCorrectly()
{
var result = _guidGenerator.Generate();
Guid.TryParse(result, out _).Should().BeTrue();
}
public object GenerateFor(PropertyInfo property)
{
return(GuidGenerator.Generate());
}
