public async Task Can_add_async()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderDepositApprovalMongoRepository(database);
DepositApproval depositApproval = BuildDummyDepositApproval();
await repo.AddAsync(depositApproval);
}
public async Task get_deposit_approvals_should_return_approvals()
{
var query = new GetConsumerDepositApprovals();
var approval = new DepositApproval(Keccak.Zero, TestItem.KeccakA, "test", "kyc",
TestItem.AddressA, TestItem.AddressB, 1);
_consumerService.GetDepositApprovalsAsync(query)
.Returns(PagedResult <DepositApproval> .Create(new[] { approval }, 1, 1, 1, 1));
var result = await _rpc.ndm_getConsumerDepositApprovals(query);
await _consumerService.Received().GetDepositApprovalsAsync(query);
result.Data.Should().NotBeNull();
result.Data.Items.Should().NotBeNull();
result.Data.Items.Should().ContainSingle();
result.Data.Page.Should().Be(1);
result.Data.Results.Should().Be(1);
result.Data.TotalPages.Should().Be(1);
result.Data.TotalResults.Should().Be(1);
result.Data.IsEmpty.Should().BeFalse();
var rpcApproval = result.Data.Items.Single();
rpcApproval.Id.Should().Be(approval.Id);
rpcApproval.AssetId.Should().Be(approval.AssetId);
rpcApproval.AssetName.Should().Be(approval.AssetName);
rpcApproval.Kyc.Should().Be(approval.Kyc);
rpcApproval.Consumer.Should().Be(approval.Consumer);
rpcApproval.Provider.Should().Be(approval.Provider);
rpcApproval.Timestamp.Should().Be(approval.Timestamp);
}
private Task AddOrUpdateAsync(DepositApproval depositApproval)
{
Serialization.Rlp.Rlp rlp = _rlpDecoder.Encode(depositApproval);
_database.Set(depositApproval.Id, rlp.Bytes);
return(Task.CompletedTask);
}
private Task AddOrUpdateAsync(DepositApproval depositApproval)
{
var rlp = RlpObjectDecoder.Encode(depositApproval);
_database.Set(depositApproval.Id, rlp.Bytes);
return(Task.CompletedTask);
}
public async Task Update_to_pending_will_be_ignored()
{
DepositApproval updateToPending = new DepositApproval(_confirmedApproval.Id, _confirmedApproval.AssetId, _confirmedApproval.AssetName, _confirmedApproval.Kyc, _confirmedApproval.Consumer, _confirmedApproval.Provider, _confirmedApproval.Timestamp, DepositApprovalState.Pending);
await _service.UpdateAsync(new DepositApproval[] { updateToPending }, _providerAddress);
var result = await _service.BrowseAsync(new GetConsumerDepositApprovals());
result.Items.Where(i => i.State == DepositApprovalState.Pending).Should().HaveCount(1);
}
public async Task Can_browse()
{
IMongoDatabase database = MongoForTest.TempDb.GetDatabase();
var repo = new ConsumerDepositApprovalMongoRepository(database);
DepositApproval depositApproval = BuildDummyDepositApproval();
await repo.AddAsync(depositApproval);
await repo.BrowseAsync(new GetConsumerDepositApprovals());
}
public async Task Update_unknown_will_be_ignored()
{
DepositApproval unknown = new DepositApproval(Keccak.Compute("unknown"), _pendingApproval.AssetId, _pendingApproval.AssetName, _pendingApproval.Kyc, _pendingApproval.Consumer, _pendingApproval.Provider, _pendingApproval.Timestamp, DepositApprovalState.Confirmed);
await _service.UpdateAsync(new DepositApproval[] { unknown }, _providerAddress);
var result = await _service.BrowseAsync(new GetConsumerDepositApprovals());
result.Items.Should().HaveCount(3);
}
public async Task Update_to_confirm_will_proceed_without_errors()
{
DepositApproval updateToConfirm = new DepositApproval(_pendingApproval.Id, _pendingApproval.AssetId, _pendingApproval.AssetName, _pendingApproval.Kyc, _pendingApproval.Consumer, _pendingApproval.Provider, _pendingApproval.Timestamp, DepositApprovalState.Confirmed);
await _service.UpdateAsync(new DepositApproval[] { updateToConfirm }, _providerAddress);
var result = await _service.BrowseAsync(new GetConsumerDepositApprovals());
result.Items.Where(i => i.State == DepositApprovalState.Confirmed).Should().HaveCount(2);
}
public async Task Update_get(DepositApproval approval)
{
IDb db = new MemDb();
ConsumerDepositApprovalRocksRepository repository = new ConsumerDepositApprovalRocksRepository(db, new DepositApprovalDecoder());
await repository.UpdateAsync(approval);
DepositApproval retrieved = await repository.GetAsync(approval.Id);
retrieved.Should().BeEquivalentTo(approval);
}
public DepositApprovalForRpc(DepositApproval depositApproval)
{
HeaderId = depositApproval.HeaderId;
HeaderName = depositApproval.HeaderName;
Kyc = depositApproval.Kyc;
Consumer = depositApproval.Consumer;
Provider = depositApproval.Provider;
Timestamp = depositApproval.Timestamp;
State = depositApproval.State.ToString().ToLowerInvariant();
}
public async Task Can_get_by_id()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderDepositApprovalMongoRepository(database);
DepositApproval depositApproval = BuildDummyDepositApproval();
await repo.AddAsync(depositApproval);
DepositApproval result = await repo.GetAsync(depositApproval.Id);
result.Should().BeEquivalentTo(depositApproval);
}
private static DepositApproval BuildDummyDepositApproval()
{
DepositApproval depositApproval = new DepositApproval(
TestItem.KeccakB,
"asset_name",
"kyc", TestItem.AddressA,
TestItem.AddressB,
1,
DepositApprovalState.Rejected);
return(depositApproval);
}
public async Task Can_browse_with_query_and_pagination()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderDepositApprovalMongoRepository(database);
DepositApproval depositApproval = BuildDummyDepositApproval();
await repo.AddAsync(depositApproval);
GetProviderDepositApprovals query = new GetProviderDepositApprovals();
query.Consumer = depositApproval.Consumer;
query.OnlyPending = true;
query.DataAssetId = depositApproval.AssetId;
query.Page = 0;
query.Results = 10;
await repo.BrowseAsync(query);
}
public void Setup()
{
INdmPeer peer = Substitute.For <INdmPeer>();
peer.ProviderAddress.Returns(_providerAddress);
_providerId = TestItem.PublicKeyB;
peer.NodeId.Returns(_providerId);
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "name");
DataAsset newPendingAsset = new DataAsset(_newPendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset pendingAsset = new DataAsset(_pendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset rejectedAsset = new DataAsset(_rejectedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset confirmedAsset = new DataAsset(_confirmedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DepositsInMemoryDb db = new DepositsInMemoryDb();
ProviderInMemoryRepository providerRepository = new ProviderInMemoryRepository(db);
_cdaRepo = new ConsumerDepositApprovalInMemoryRepository();
_ndmNotifier = Substitute.For <INdmNotifier>();
ConsumerNotifier notifier = new ConsumerNotifier(_ndmNotifier);
DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance);
dataAssetService.AddDiscovered(newPendingAsset, peer);
dataAssetService.AddDiscovered(pendingAsset, peer);
dataAssetService.AddDiscovered(rejectedAsset, peer);
dataAssetService.AddDiscovered(confirmedAsset, peer);
_providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance);
_providerService.Add(peer);
_service = new DepositApprovalService(dataAssetService, _providerService, _cdaRepo, Timestamper.Default, notifier, LimboLogs.Instance);
_confirmedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_confirmedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _confirmedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Confirmed);
_pendingApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_pendingAssetId), Rlp.Encode(_consumerAddress)).Bytes), _pendingAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Pending);
_rejectedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_rejectedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _rejectedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Rejected);
_cdaRepo.AddAsync(_confirmedApproval);
_cdaRepo.AddAsync(_pendingApproval);
_cdaRepo.AddAsync(_rejectedApproval);
}
public Task <PagedResult <DepositApproval> > BrowseAsync(GetConsumerDepositApprovals query)
{
if (query is null)
{
return(Task.FromResult(PagedResult <DepositApproval> .Empty));
}
var depositApprovalsBytes = _database.GetAll();
if (depositApprovalsBytes.Length == 0)
{
return(Task.FromResult(PagedResult <DepositApproval> .Empty));
}
var depositApprovals = new DepositApproval[depositApprovalsBytes.Length];
for (var i = 0; i < depositApprovalsBytes.Length; i++)
{
depositApprovals[i] = Decode(depositApprovalsBytes[i]);
}
var filteredDepositApprovals = depositApprovals.AsEnumerable();
if (!(query.DataAssetId is null))
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.AssetId == query.DataAssetId);
}
if (!(query.Provider is null))
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.Provider == query.Provider);
}
if (query.OnlyPending)
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.State == DepositApprovalState.Pending);
}
return(Task.FromResult(filteredDepositApprovals.OrderByDescending(a => a.Timestamp).Paginate(query)));
}
public Task <PagedResult <DepositApproval> > BrowseAsync(GetConsumerDepositApprovals query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
byte[][] depositApprovalsBytes = _database.GetAllValues().ToArray();
if (depositApprovalsBytes.Length == 0)
{
return(Task.FromResult(PagedResult <DepositApproval> .Empty));
}
DepositApproval[] depositApprovals = new DepositApproval[depositApprovalsBytes.Length];
for (int i = 0; i < depositApprovalsBytes.Length; i++)
{
depositApprovals[i] = Decode(depositApprovalsBytes[i]);
}
IEnumerable <DepositApproval> filteredDepositApprovals = depositApprovals.AsEnumerable();
if (!(query.DataAssetId is null))
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.AssetId == query.DataAssetId);
}
if (!(query.Provider is null))
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.Provider == query.Provider);
}
if (query.OnlyPending)
{
filteredDepositApprovals = filteredDepositApprovals.Where(a => a.State == DepositApprovalState.Pending);
}
return(Task.FromResult(filteredDepositApprovals.OrderByDescending(a => a.Timestamp).ToArray().Paginate(query)));
}
public Task UpdateAsync(DepositApproval depositApproval) => DepositApprovals.ReplaceOneAsync(a => a.Id == depositApproval.Id, depositApproval);
public Task AddAsync(DepositApproval depositApproval) => DepositApprovals.InsertOneAsync(depositApproval);
public Task UpdateAsync(DepositApproval depositApproval) => AddOrUpdateAsync(depositApproval);
public async Task <Keccak?> RequestAsync(Keccak assetId, Address consumer, string kyc)
{
if (_logger.IsInfo)
{
_logger.Info($"Requesting a deposit approval for data asset: '{assetId}', consumer: '{consumer}'...");
}
var dataAsset = _dataAssetService.GetDiscovered(assetId);
if (dataAsset is null)
{
if (_logger.IsError)
{
_logger.Error($"Data asset: '{assetId}' was not found.");
}
return(null);
}
if (string.IsNullOrWhiteSpace(kyc))
{
if (_logger.IsError)
{
_logger.Error("KYC cannot be empty.");
}
return(null);
}
if (kyc.Length > MaxKycChars)
{
if (_logger.IsError)
{
_logger.Error($"Invalid KYC (over {MaxKycChars} chars).");
}
return(null);
}
var providerPeer = _providerService.GetPeer(dataAsset.Provider.Address);
if (providerPeer is null)
{
if (_logger.IsError)
{
_logger.Error($"Provider for address: '{dataAsset.Provider.Address}' was not found.");
}
return(null);
}
var id = Keccak.Compute(Rlp.Encode(Rlp.Encode(assetId), Rlp.Encode(consumer)).Bytes);
var approval = await _depositApprovalRepository.GetAsync(id);
if (approval is null)
{
approval = new DepositApproval(id, assetId, dataAsset.Name, kyc, consumer,
dataAsset.Provider.Address, _timestamper.EpochSeconds, DepositApprovalState.Pending);
await _depositApprovalRepository.AddAsync(approval);
}
providerPeer.SendRequestDepositApproval(assetId, consumer, kyc);
if (_logger.IsInfo)
{
_logger.Info($"Requested a deposit approval for data asset: '{assetId}', consumer: '{consumer}'.");
}
return(id);
}
