/// <summary>
/// Returns the URI for NextPageLink
/// </summary>
/// <param name="baseUri">BaseUri for nextlink. It should be request URI for top level resource and navigation link for nested resource.</param>
/// <param name="pageSize">Maximum number of records in the set of partial results for a resource.</param>
/// <param name="instance">Instance based on which SkipToken value will be generated.</param>
/// <param name="context">Serializer context</param>
/// <returns>Returns the URI for NextPageLink. If a null object is passed for the instance, resorts to the default paging mechanism of using $skip and $top.</returns>
public override Uri GenerateNextPageLink(Uri baseUri, int pageSize, Object instance, ODataSerializerContext context)
{
if (context == null)
{
return(null);
}
if (pageSize <= 0)
{
return(null);
}
Func <object, string> skipTokenGenerator = null;
IList <OrderByNode> orderByNodes = null;
ExpandedReferenceSelectItem expandedItem = context.CurrentSelectItem as ExpandedReferenceSelectItem;
IEdmModel model = context.Model;
DefaultQuerySettings settings = context.QueryContext.DefaultQuerySettings;
if (settings.EnableSkipToken)
{
if (expandedItem != null)
{
// Handle Delta resource; currently not value based.
if (DeltaHelper.IsDeltaOfT(context.ExpandedResource.GetType()))
{
return(GetNextPageHelper.GetNextPageLink(baseUri, pageSize));
}
if (expandedItem.OrderByOption != null)
{
orderByNodes = OrderByNode.CreateCollection(expandedItem.OrderByOption);
}
skipTokenGenerator = (obj) =>
{
return(GenerateSkipTokenValue(obj, model, orderByNodes));
};
return(GetNextPageHelper.GetNextPageLink(baseUri, pageSize, instance, skipTokenGenerator));
}
if (context.QueryOptions != null && context.QueryOptions.OrderBy != null)
{
orderByNodes = context.QueryOptions.OrderBy.OrderByNodes;
}
skipTokenGenerator = (obj) =>
{
return(GenerateSkipTokenValue(obj, model, orderByNodes));
};
}
return(GetNextPageHelper.GetNextPageLink(baseUri, pageSize, instance, skipTokenGenerator));
}
public void IsDeltaResourceSet_Returns_BooleanAsExpected()
{
// Arrange & Act & Assert
Assert.False(DeltaHelper.IsDeltaResourceSet(null));
Assert.False(DeltaHelper.IsDeltaResourceSet(42));
Assert.True(DeltaHelper.IsDeltaResourceSet(new DeltaSet <DeltaHelperTests>()));
IEdmEntityType entityType = new Mock <IEdmEntityType>().Object;
Assert.True(DeltaHelper.IsDeltaResourceSet(new EdmChangedObjectCollection(entityType)));
}
public void DeltasDao_Deltas_Should_Be_Convertible()
{
var previousHash = _hashProvider.ComputeMultiHash(Encoding.UTF8.GetBytes("previousHash"));
var original = DeltaHelper.GetDelta(_hashProvider, previousHash);
var messageDao = original.ToDao <Delta, DeltaDao>(_mapperProvider);
var reconverted = messageDao.ToProtoBuff <DeltaDao, Delta>(_mapperProvider);
original.Should().Be(reconverted);
}
public BadDeltas()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var noPreviousHash = new Delta {
PreviousDeltaDfsHash = new byte[0].ToByteString()
};
var noMerkleRoot = DeltaHelper.GetDelta(hashProvider, merkleRoot: new byte[0]);
AddRow(noMerkleRoot, typeof(InvalidDataException));
AddRow(noPreviousHash, typeof(InvalidDataException));
AddRow(null as Delta, typeof(ArgumentNullException));
}
private Delta CreateAndExpectDeltaFromCache(MultiHash hash)
{
var delta = DeltaHelper.GetDelta(_hashProvider);
_deltaCache.TryGetOrAddConfirmedDelta(Arg.Is(hash), out Arg.Any <Delta>())
.Returns(ci =>
{
ci[1] = delta;
return(true);
});
return(delta);
}
public void When_receiving_no_voterid_should_log_and_not_hit_the_cache()
{
var elector = new DeltaElector(_cache, _deltaProducersProvider, _reputationManager, _logger);
elector.OnNext(new FavouriteDeltaBroadcast
{
Candidate = DeltaHelper.GetCandidateDelta(HashProvider)
});
_cache.DidNotReceiveWithAnyArgs().TryGetValue(Arg.Any <object>(), out Arg.Any <object>());
_cache.DidNotReceiveWithAnyArgs().CreateEntry(Arg.Any <object>());
}
ConstructionProducingSubscription_Should_Trigger_BuildDeltaCandidate_On_Construction_Producing_Phase()
{
var builtCandidate = DeltaHelper.GetCandidateDelta(_hashProvider);
_deltaBuilder.BuildCandidateDelta(Arg.Any <Cid>()).Returns(builtCandidate);
_cycleEventProvider.MovePastNextPhase(PhaseName.Construction);
_deltaBuilder.Received(1).BuildCandidateDelta(
Arg.Is <Cid>(b => b == PreviousDeltaBytes));
_deltaHub.Received(1).BroadcastCandidate(Arg.Is(builtCandidate));
}
public void TryReadDeltaFromDfs_Should_Return_True_When_Hash_Found_On_Dfs_And_Delta_Is_Valid()
{
var cid = _hashProvider.ComputeUtf8MultiHash("good hash").CreateCid();
var matchingDelta = DeltaHelper.GetDelta(_hashProvider);
_dfs.ReadAsync(cid, CancellationToken.None)
.Returns(matchingDelta.ToByteArray().ToMemoryStream());
var found = _dfsReader.TryReadDeltaFromDfs(cid, out var delta, CancellationToken.None);
found.Should().BeTrue();
delta.Should().Be(matchingDelta);
}
public void TryReadDeltaFromDfs_Should_Pass_Cancellation_Token()
{
var cid = _hashProvider.ComputeUtf8MultiHash("good hash").CreateCid();
var cancellationToken = new CancellationToken();
var matchingDelta = DeltaHelper.GetDelta(_hashProvider);
_dfs.ReadAsync(cid, CancellationToken.None)
.Returns(matchingDelta.ToByteArray().ToMemoryStream());
_dfsReader.TryReadDeltaFromDfs(cid, out _, CancellationToken.None);
_dfs.Received(1)?.ReadAsync(Arg.Is(cid), Arg.Is(cancellationToken));
}
public void FavouriteDeltaBroadcastDao_FavouriteDeltaBroadcast_Should_Be_Convertible()
{
var original = new FavouriteDeltaBroadcast
{
Candidate = DeltaHelper.GetCandidateDelta(_hashProvider, producerId: PeerIdHelper.GetPeerId("not me")),
VoterId = PeerIdHelper.GetPeerId("test")
};
var contextDao = original.ToDao <FavouriteDeltaBroadcast, FavouriteDeltaBroadcastDao>(_mapperProvider);
var reconverted =
contextDao.ToProtoBuff <FavouriteDeltaBroadcastDao, FavouriteDeltaBroadcast>(_mapperProvider);
reconverted.Should().Be(original);
}
public void When_candidate_is_produced_by_unexpected_producer_should_log_and_return_without_hitting_the_cache()
{
var candidateFromUnknownProducer = DeltaHelper.GetCandidateDelta(_hashProvider,
producerId: PeerIdHelper.GetPeerId("unknown_producer"));
_voter = new DeltaVoter(_cache, _producersProvider, _peerSettings, _logger);
_voter.OnNext(candidateFromUnknownProducer);
_logger.Received(1).Error(Arg.Is <Exception>(e => e is KeyNotFoundException),
Arg.Any <string>(), Arg.Any <CandidateDeltaBroadcast>());
_cache.DidNotReceiveWithAnyArgs().TryGetValue(Arg.Any <object>(), out Arg.Any <object>());
_cache.DidNotReceiveWithAnyArgs().CreateEntry(Arg.Any <object>());
}
public void OnNext_Should_Still_Get_Called_After_HandleBroadcast_Failure()
{
var testScheduler = new TestScheduler();
var candidateDeltaMessages = Enumerable.Repeat(DeltaHelper.GetCandidateDelta(_hashProvider), 10).ToArray();
var messageStream = MessageStreamHelper.CreateStreamWithMessages(testScheduler, candidateDeltaMessages);
using (var observer = new FailingBroadCastObserver(Substitute.For <ILogger>()))
{
observer.StartObserving(messageStream);
testScheduler.Start();
observer.Counter.Should().Be(10);
}
}
private Dictionary <Cid, Delta> BuildChainedDeltas(int chainSize)
{
var chainedDeltas = Enumerable.Range(0, chainSize + 1).ToDictionary(
i => _hashProvider.ComputeUtf8MultiHash(i.ToString()).CreateCid(),
i =>
{
var previousHash = _hashProvider.ComputeUtf8MultiHash((i - 1).ToString()).CreateCid();
var delta = DeltaHelper.GetDelta(_hashProvider, previousHash);
return(delta);
});
_output.WriteLine("chain is:");
_output.WriteLine(string.Join(Environment.NewLine,
chainedDeltas.Select((c, i) =>
$"{i}: current {c.Key} | previous {c.Value.PreviousDeltaDfsHash.ToByteArray().ToCid()}")));
return(chainedDeltas);
}
public void When_voter_not_a_producer_should_not_save_vote()
{
var favourite = DeltaHelper.GetFavouriteDelta(_hashProvider);
_deltaProducersProvider
.GetDeltaProducersFromPreviousDelta(Arg.Any <Cid>())
.Returns(new List <PeerId> {
PeerIdHelper.GetPeerId("the only known producer")
});
var elector = new DeltaElector(_cache, _deltaProducersProvider, _reputationManager, _logger);
elector.OnNext(favourite);
_deltaProducersProvider.Received(1)
.GetDeltaProducersFromPreviousDelta(Arg.Is <Cid>(h =>
favourite.Candidate.PreviousDeltaDfsHash.Equals(h.ToArray().ToByteString())));
_cache.DidNotReceiveWithAnyArgs().TryGetValue(default, out _);
private IList <int> ExtractRpmIndexes(
PsaParameterData rpmDataSet, int valueBase)
{
IList <int> result = new List <int>();
for (int i = 0; i < rpmDataSet.Values.Count; i++)
{
double value;
double.TryParse(rpmDataSet.Values[i], NumberStyles.Float,
CultureInfo.InvariantCulture, out value);
if (DeltaHelper.GetDeltaPercentage(value,
valueBase) <= RpmDifferencePercentage)
{
result.Add(i);
}
}
return(result);
}
public void TryReadDeltaFromDfs_Should_Return_False_When_Hash_Found_On_Dfs_And_Delta_Is_Not_Valid()
{
var cid = _hashProvider.ComputeUtf8MultiHash("good hash").CreateCid();
var matchingDelta = DeltaHelper.GetDelta(_hashProvider);
matchingDelta.PreviousDeltaDfsHash = ByteString.Empty;
new Action(() => matchingDelta.IsValid()).Should()
.Throw <InvalidDataException>("otherwise this test is useless");
_dfs.ReadAsync(cid, CancellationToken.None)
.Returns(matchingDelta.ToByteArray().ToMemoryStream());
var found = _dfsReader.TryReadDeltaFromDfs(cid, out var delta, CancellationToken.None);
found.Should().BeFalse();
delta.Should().BeNull();
}
CampaigningProductionSubscription_Should_Trigger_TryGetFavouriteDelta_On_Campaigning_Producing_Phase()
{
var favourite = DeltaHelper.GetFavouriteDelta(_hashProvider);
_deltaVoter.TryGetFavouriteDelta(Arg.Any <Cid>(), out Arg.Any <FavouriteDeltaBroadcast>())
.Returns(ci =>
{
ci[1] = favourite;
return(true);
});
_cycleEventProvider.MovePastNextPhase(PhaseName.Campaigning);
_deltaVoter.Received(1).TryGetFavouriteDelta(
Arg.Is <Cid>(b => b == PreviousDeltaBytes),
out Arg.Any <FavouriteDeltaBroadcast>());
_deltaHub.Received(1).BroadcastFavouriteCandidateDelta(Arg.Is(favourite));
}
public void TryGetDelta_Should_Not_Hit_The_Dfs_Or_Store_Delta_When_Delta_Is_In_Cache()
{
_memoryCache.ClearReceivedCalls(); // needed because of the CreateEntry call from the DeltaCache .ctor
var deltaFromCache = DeltaHelper.GetDelta(_hashProvider);
var cid = CidHelper.CreateCid(_hashProvider.ComputeUtf8MultiHash("abc"));
_memoryCache.TryGetValue(Arg.Is(cid.Hash), out Arg.Any <Delta>())
.Returns(ci =>
{
ci[1] = deltaFromCache;
return(true);
});
var found = _deltaCache.TryGetOrAddConfirmedDelta(cid.Hash, out var delta);
delta.Should().Be(deltaFromCache);
found.Should().BeTrue();
_dfsReader.DidNotReceiveWithAnyArgs().TryReadDeltaFromDfs(default, out _);
public BadFavouritesData()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
Add(null, typeof(ArgumentNullException));
Add(new FavouriteDeltaBroadcast(), typeof(InvalidDataException));
Add(new FavouriteDeltaBroadcast
{
Candidate = new CandidateDeltaBroadcast
{
Hash = ByteUtil.GenerateRandomByteArray(32).ToByteString(),
ProducerId = PeerIdHelper.GetPeerId("unknown_producer")
},
VoterId = PeerIdHelper.GetPeerId("candidate field is invalid")
}, typeof(InvalidDataException));
Add(new FavouriteDeltaBroadcast
{
Candidate = DeltaHelper.GetCandidateDelta(hashProvider)
}, typeof(InvalidDataException));
}
public void When_candidates_not_in_cache_should_create_or_update_a_previous_hash_entry()
{
using (var realCache = new MemoryCache(new MemoryCacheOptions()))
{
_voter = new DeltaVoter(realCache, _producersProvider, _peerSettings, _logger);
var candidate1 = DeltaHelper.GetCandidateDelta(
_hashProvider,
_previousDeltaHash,
producerId: _producerIds.First());
var candidate1CacheKey = DeltaVoter.GetCandidateCacheKey(candidate1);
var candidate2 = DeltaHelper.GetCandidateDelta(
_hashProvider,
_previousDeltaHash,
producerId: _producerIds.Last());
var candidate2CacheKey = DeltaVoter.GetCandidateCacheKey(candidate2);
var previousDeltaCacheKey = DeltaVoter.GetCandidateListCacheKey(candidate1);
_voter.OnNext(candidate1);
realCache.TryGetValue(candidate1CacheKey,
out ScoredCandidateDelta retrievedCandidate1).Should().BeTrue();
retrievedCandidate1.Candidate.ProducerId.Should().Be(_producerIds.First());
realCache.TryGetValue(previousDeltaCacheKey,
out ConcurrentBag <string> retrievedCandidateList).Should().BeTrue();
retrievedCandidateList.Should().BeEquivalentTo(candidate1CacheKey);
_voter.OnNext(candidate2);
realCache.TryGetValue(candidate2CacheKey,
out ScoredCandidateDelta retrievedCandidate2).Should().BeTrue();
retrievedCandidate2.Candidate.ProducerId.Should().Be(_producerIds.Last());
realCache.TryGetValue(previousDeltaCacheKey,
out ConcurrentBag <string> retrievedUpdatedCandidateList).Should().BeTrue();
retrievedUpdatedCandidateList.Should().BeEquivalentTo(candidate1CacheKey, candidate2CacheKey);
}
}
public void When_receiving_known_favourite_should_not_store_in_cache()
{
using (var realCache = new MemoryCache(new MemoryCacheOptions()))
{
var favourite = DeltaHelper.GetFavouriteDelta(_hashProvider);
var candidateListKey = DeltaElector.GetCandidateListCacheKey(favourite);
AddVoterAsExpectedProducer(favourite.VoterId);
var elector = new DeltaElector(realCache, _deltaProducersProvider, _reputationManager, _logger);
elector.OnNext(favourite);
elector.OnNext(favourite);
realCache.TryGetValue(candidateListKey, out IDictionary <FavouriteDeltaBroadcast, bool> retrieved)
.Should().BeTrue();
retrieved.Keys.Count.Should().Be(1);
retrieved.Should().ContainKey(favourite);
}
}
public void When_receiving_new_valid_favourite_should_store_in_cache()
{
var favourite = DeltaHelper.GetFavouriteDelta(_hashProvider);
var candidateListKey = DeltaElector.GetCandidateListCacheKey(favourite);
AddVoterAsExpectedProducer(favourite.VoterId);
var elector = new DeltaElector(_cache, _deltaProducersProvider, _reputationManager, _logger);
var addedEntry = Substitute.For <ICacheEntry>();
_cache.CreateEntry(Arg.Is <string>(s => s.Equals(candidateListKey)))
.Returns(addedEntry);
elector.OnNext(favourite);
_cache.Received(1).TryGetValue(Arg.Is <string>(s => s.Equals(candidateListKey)), out Arg.Any <object>());
_cache.Received(1).CreateEntry(Arg.Is <string>(s => s.Equals(candidateListKey)));
var addedValue = addedEntry.Value;
addedValue.Should().BeAssignableTo <IDictionary <FavouriteDeltaBroadcast, bool> >();
((IDictionary <FavouriteDeltaBroadcast, bool>)addedValue).Should().ContainKey(favourite);
}
