public async Task SeenHashShouldReturnStoredMessage()
{
var hash = "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae";
var dto = new HashDto()
{
Hash = hash,
Value = "foo"
};
var repo = new Mock <IServiceRepository>();
repo.Setup(r => r.HashExistsAsync(hash)).ReturnsAsync(true);
repo.Setup(r => r.FindHashAsync(hash)).ReturnsAsync(dto);
var mapper = this.GetConfiguredMapper();
var logger = Mock.Of <ILogger <MessageController> >();
var controller = new MessageController(repo.Object, mapper, logger);
var response = await controller.GetMessage(hash);
var objectResult = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsType <MessageResponseModel>(objectResult.Value);
Assert.Equal("foo", result.Message);
}
public override void SetRangeInHash(string key, IEnumerable <KeyValuePair <string, string> > keyValuePairs)
{
Guard.ArgumentNotNull(key, "key");
Guard.ArgumentNotNull(keyValuePairs, "keyValuePairs");
foreach (var kvp in keyValuePairs)
{
var local = kvp;
QueueCommand(() =>
{
var hash = _data.GetEnumeration <HashDto>().SingleOrDefault(h => h.Key == key && h.Field == local.Key);
if (hash == null)
{
hash = new HashDto
{
Id = AutoIncrementIdGenerator.GenerateId(typeof(HashDto)),
Key = key,
Field = local.Key
};
_data.Create(hash);
}
hash.Value = local.Value;
});
}
}
public void ExpireHash_SetsHashExpirationData()
{
var hash1 = new HashDto {
Key = "Hash1"
};
_database.JobGraph.InsertOne(hash1);
var hash2 = new HashDto {
Key = "Hash2"
};
_database.JobGraph.InsertOne(hash2);
Commit(x => x.ExpireHash(hash1.Key, TimeSpan.FromDays(1)));
var testHash1 = GetTestHash(_database, hash1.Key);
Assert.True(DateTime.UtcNow.AddMinutes(-1) < testHash1.ExpireAt &&
testHash1.ExpireAt <= DateTime.UtcNow.AddDays(1));
var testHash2 = GetTestHash(_database, hash2.Key);
Assert.Null(testHash2.ExpireAt);
}
public void PersistHash_OfGivenKey_ClearsTheHashExpirationData()
{
// ARRANGE
var hash1 = new HashDto {
Key = "Hash1", ExpireAt = DateTimeOffset.UtcNow
};
var hash2 = new HashDto {
Key = "Hash2", ExpireAt = DateTimeOffset.UtcNow
};
_realm.Write(() =>
{
_realm.Add(hash1);
_realm.Add(hash2);
});
// ACT
_transaction.PersistHash(hash1.Key);
_transaction.Commit();
// ASSERT
var testSet1 = _realm.Find <HashDto>(hash1.Key);
Assert.Null(testSet1.ExpireAt);
var testSet2 = _realm.Find <HashDto>(hash2.Key);
Assert.NotNull(testSet2.ExpireAt);
}
public void GetAllEntriesFromHash_ReturnsAllKeysAndTheirValues()
{
var hash1 = new HashDto("some-hash");
hash1.Fields.Add(new FieldDto("Key1", "Value1"));
hash1.Fields.Add(new FieldDto("Key2", "Value2"));
var hash2 = new HashDto("another-hash");
hash2.Fields.Add(new FieldDto("Key3", "Value3"));
var realm = _storage.GetRealm();
realm.Write(() =>
{
realm.Add(hash1);
realm.Add(hash2);
});
// Act
var result = _connection.GetAllEntriesFromHash("some-hash");
// Assert
Assert.NotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("Value1", result["Key1"]);
Assert.AreEqual("Value2", result["Key2"]);
}
public void GetValueFromHash_ReturnsValue_OfAGivenField()
{
var realm = _storage.GetRealm();
var hash1 = new HashDto("hash-1");
hash1.Fields.Add(new FieldDto("field-1", "1"));
var hash2 = new HashDto("hash-2");
hash2.Fields.Add(new FieldDto("field-2", "2"));
var hash3 = new HashDto("hash-3");
hash3.Fields.Add(new FieldDto("field-1", "3"));
realm.Write(() =>
{
realm.Add(hash1);
realm.Add(hash2);
realm.Add(hash3);
});
// Act
var result = _connection.GetValueFromHash("hash-1", "field-1");
// Assert
Assert.AreEqual("1", result);
}
public Task AddHashAsync(HashDto dto)
{
this._logger.LogInformation(
"Adding a new hash entry for message {0} with value {1}.",
dto.Value,
dto.Hash);
this._context.Hashes.Add(dto);
return(Task.CompletedTask);
}
public override string GetValueFromHash(string key, string name)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
HashDto result = AsyncHelper.RunSync(() => _database.Hash
.Find(Builders <HashDto> .Filter.Eq(_ => _.Key, key) & Builders <HashDto> .Filter.Eq(_ => _.Field, name))
.FirstOrDefaultAsync());
return(result != null ? result.Value : null);
}
public JsonResult Login([FromBody] HashDto dto)
{
object ret = null;
HeaderModel header = null;
string[] roles = null;
if (!String.IsNullOrEmpty(dto?.hash))
{
header = SQLData.GetHeaderByNonce(dto.hash);
roles = header.SelfProfile?.Roles.Split(',') ?? new string[] { "User" };
ret = new { id = header?.HeaderId, roles = roles };
}
if (header != null)
{
var cookieOptions = new CookieOptions()
{
Path = "/",
HttpOnly = false,
Expires = DateTimeOffset.UtcNow.AddDays(int.Parse(_configuration["JwtExpireDays"]))
//SameSite = SameSiteMode.None,
//Domain = "localhost",
//Secure = false
};
Response.Cookies.Append("authtoken",
GenerateJwtToken(header.HeaderId, roles),
cookieOptions);
//else
//throw new ApplicationException("INVALID_LOGIN_ATTEMPT");
//TODO: implement errorhandling middleware, concerning 500s and nginx route errors as well
ViewBag.User = header.HeaderId;
ViewBag.Roles = header.SelfProfile.Roles;
}
return(new JsonResult(ret));
}
public async Task <HeaderViewModel> Validate([FromBody] HashDto dto)
{
if (_user.IsAuthenticated)
{
ViewBag.User = _user.User; ViewBag.Roles = _user.Roles;
}
HeaderModel header = SQLData.GetHeaderById(dto.hash);
UserProfileModel validatorProfile = SQLData.GetProfileById(_user.User);
header.ValidatorUuid = validatorProfile.Id;
header.ValidatorName = validatorProfile.Name;
if (String.IsNullOrEmpty(header.ValidatorLegitimationId) || String.IsNullOrEmpty(header.IssuerUuid))
{
header.IssuerUuid = validatorProfile.Id;
header.IssuerName = validatorProfile.Name;
}
header.ValidationCounter = "1";
string contractAddress = _configuration["ethContractAddress"];
string abi = _configuration["ethAbi"];
string senderAddress = _configuration["ethSenderAddress"];
string senderPrimaryKey = _configuration["ethSenderPK"];
string ethNode = _configuration["ethNode"];
Ethereum eth = new Ethereum(contractAddress, abi, senderAddress, senderPrimaryKey, ethNode);
header = await eth.SendToNetwork(header);
SQLData.UpdateHeader(header);
header = SQLData.GetHeaderWithImageById(header.HeaderId);
return(new HeaderViewModel(header, _configuration));
}
public void PersistHash_ClearsTheHashExpirationData()
{
ConnectionUtils.UseConnection(database =>
{
var hash1 = new HashDto {
Key = "Hash1", Value = "value1", ExpireAt = DateTime.UtcNow
};
database.StateData.InsertOne(hash1);
var hash2 = new HashDto {
Key = "Hash2", Value = "value2", ExpireAt = DateTime.UtcNow
};
database.StateData.InsertOne(hash2);
Commit(database, x => x.PersistHash(hash1.Key));
var testHash1 = GetTestHash(database, hash1.Key);
Assert.Null(testHash1.ExpireAt);
var testHash2 = GetTestHash(database, hash2.Key);
Assert.NotNull(testHash2.ExpireAt);
});
}
public void ExpireHash_SetsHashExpirationData()
{
ConnectionUtils.UseConnection(database =>
{
var hash1 = new HashDto {
Key = "Hash1", Value = "value1"
};
database.StateData.InsertOne(hash1);
var hash2 = new HashDto {
Key = "Hash2", Value = "value2"
};
database.StateData.InsertOne(hash2);
Commit(database, x => x.ExpireHash(hash1.Key, TimeSpan.FromDays(1)));
var testHash1 = GetTestHash(database, hash1.Key);
Assert.True(DateTime.UtcNow.AddMinutes(-1) < testHash1.ExpireAt && testHash1.ExpireAt <= DateTime.UtcNow.AddDays(1));
var testHash2 = GetTestHash(database, hash2.Key);
Assert.Null(testHash2.ExpireAt);
});
}
public void PersistHash_ClearsTheHashExpirationData()
{
UseConnection(database =>
{
var hash1 = new HashDto {
Key = "Hash1", Value = "value1", ExpireAt = database.GetServerTimeUtc()
};
database.Hash.InsertOne(hash1);
var hash2 = new HashDto {
Key = "Hash2", Value = "value2", ExpireAt = database.GetServerTimeUtc()
};
database.Hash.InsertOne(hash2);
Commit(database, x => x.PersistHash(hash1.Key));
var testHash1 = GetTestHash(database, hash1.Key);
Assert.Null(testHash1.ExpireAt);
var testHash2 = GetTestHash(database, hash2.Key);
Assert.NotNull(testHash2.ExpireAt);
});
}
public async Task <HashDto> Remove(string arg,
bool force = false)
{
var cid = await DfsService.BlockApi.RemoveAsync(arg, true, Cancel);
var dto = new HashDto();
if (cid == null && !force)
{
dto.Hash = arg;
dto.Error = "block not found";
}
else if (cid == null)
{
return(null);
}
else
{
dto.Hash = cid;
}
return(dto);
}
public void PersistHash_ClearsTheHashExpirationData()
{
var hash1 = new HashDto {
Key = "Hash1", ExpireAt = DateTime.UtcNow
};
_database.JobGraph.InsertOne(hash1);
var hash2 = new HashDto {
Key = "Hash2", ExpireAt = DateTime.UtcNow
};
_database.JobGraph.InsertOne(hash2);
Commit(x => x.PersistHash(hash1.Key));
var testHash1 = GetTestHash(_database, hash1.Key);
Assert.Null(testHash1.ExpireAt);
var testHash2 = GetTestHash(_database, hash2.Key);
Assert.NotNull(testHash2.ExpireAt);
}
