/// <inheritdoc />
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var contentHashListWithDeterminism = (ContentHashListWithDeterminism)value;
var contentHashList = contentHashListWithDeterminism.ContentHashList;
var determinism = contentHashListWithDeterminism.Determinism;
writer.WriteStartObject();
if (contentHashList.HasPayload)
{
writer.WritePropertyName(PayloadFieldName);
serializer.Serialize(
writer,
HexUtilities.BytesToHex(contentHashList.Payload.ToList()));
}
writer.WritePropertyName(DeterminismFieldName);
serializer.Serialize(writer, determinism.Guid.ToString());
writer.WritePropertyName(ExpirationUtcFieldName);
serializer.Serialize(writer, determinism.ExpirationUtc.ToBinary());
writer.WritePropertyName(HashesFieldName);
var hashes = contentHashList.Hashes.Select(hash => hash.SerializeReverse()).ToList();
serializer.Serialize(writer, hashes, typeof(List <string>));
writer.WriteEndObject();
}
public void StrongFingerprintToRedisKey()
{
var sfp = StrongFingerprint.Random();
var key = _serializer.ToRedisKey(sfp);
var expected =
sfp.WeakFingerprint +
RedisSerializer.RedisValueSeparator +
sfp.Selector.ContentHash +
RedisSerializer.RedisValueSeparator +
HexUtilities.BytesToHex(sfp.Selector.Output);
Assert.Equal(expected, key);
}
/// <inheritdoc />
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var strongFingerprint = (StrongFingerprint)value;
writer.WriteStartObject();
writer.WritePropertyName(WeakFingerprintFieldName);
serializer.Serialize(
writer,
HexUtilities.BytesToHex(strongFingerprint.WeakFingerprint.ToByteArray()));
writer.WritePropertyName(SelectorFieldName);
_selectorConverter.WriteJson(writer, strongFingerprint.Selector, serializer);
writer.WriteEndObject();
}
public void NullContentHashListWithDeterminismToRedisValue()
{
var d = CacheDeterminism.None;
var chlwd = new ContentHashListWithDeterminism(null, d);
var redisValue = _serializer.ToRedisValue(chlwd);
var expected =
HexUtilities.BytesToHex(d.Serialize()) +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator;
Assert.Equal(expected, redisValue);
}
public void BytesToHexBasics()
{
string hex = HexUtilities.BytesToHex(new byte[0]);
Assert.Equal(string.Empty, hex);
hex =
HexUtilities.BytesToHex(new byte[]
{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F });
Assert.Equal("0102030405060708090A0B0C0D0E0F", hex);
hex = HexUtilities.BytesToHex(new byte[] { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF });
Assert.Equal("0123456789ABCDEF", hex);
}
/// <inheritdoc />
public RedisValue ToRedisValue(ContentHashListWithDeterminism hashList)
{
var determinismBytes = HexUtilities.BytesToHex(hashList.Determinism.Serialize());
if (hashList.ContentHashList == null)
{
return(determinismBytes + RedisValueSeparator + RedisValueSeparator + RedisValueSeparator + RedisValueSeparator);
}
var hashListValue = RedisValueExistsSemaphore + RedisValueSeparator + hashList.ContentHashList.Serialize();
var payloadValue = hashList.ContentHashList.HasPayload
? RedisValueExistsSemaphore + RedisValueSeparator + HexUtilities.BytesToHex(hashList.ContentHashList.Payload.ToList())
: RedisValueSeparator;
return(determinismBytes + RedisValueSeparator + hashListValue + RedisValueSeparator + payloadValue);
}
public void EmptyContentHashListWithDeterminismToRedisValue()
{
var chl = ContentHashList.Random(contentHashCount: 0);
var d = CacheDeterminism.None;
var chlwd = new ContentHashListWithDeterminism(chl, d);
var redisValue = _serializer.ToRedisValue(chlwd);
var expected =
HexUtilities.BytesToHex(d.Serialize()) +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueExistsSemaphore +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator;
Assert.Equal(expected, redisValue);
}
public void ContentHashListWithDeterminismToRedisValue()
{
var chl = ContentHashList.Random();
var d = CacheDeterminism.ViaCache(CacheDeterminism.NewCacheGuid(), DateTime.UtcNow);
var chlwd = new ContentHashListWithDeterminism(chl, d);
var redisValue = _serializer.ToRedisValue(chlwd);
var expected =
HexUtilities.BytesToHex(d.Serialize()) +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueExistsSemaphore +
RedisSerializer.RedisValueSeparator +
chl.Serialize() +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueSeparator;
Assert.Equal(expected, redisValue);
}
/// <inheritdoc />
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var selector = (Selector)value;
writer.WriteStartObject();
if (selector.Output != null)
{
writer.WritePropertyName(OutputFieldName);
serializer.Serialize(
writer,
HexUtilities.BytesToHex(selector.Output.ToList()));
}
writer.WritePropertyName(ContentHashFieldName);
serializer.Serialize(writer, selector.ContentHash.SerializeReverse());
writer.WriteEndObject();
}
public void ContentHashListWithDeterminismWithPayloadToRedisValue()
{
var chl = ContentHashList.Random(payload: ThreadSafeRandom.GetBytes(3));
var d = CacheDeterminism.None;
var chlwd = new ContentHashListWithDeterminism(chl, d);
var redisValue = _serializer.ToRedisValue(chlwd);
var expected =
HexUtilities.BytesToHex(d.Serialize()) +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueExistsSemaphore +
RedisSerializer.RedisValueSeparator +
chl.Serialize() +
RedisSerializer.RedisValueSeparator +
RedisSerializer.RedisValueExistsSemaphore +
RedisSerializer.RedisValueSeparator +
HexUtilities.BytesToHex(chl.Payload.ToList());
Assert.Equal(expected, redisValue);
}
public string ToHexString(bool hexPrefix = true)
{
return(HexUtilities.BytesToHex(addressBytes, hexPrefix));
}
/// <summary>
/// Serialize
/// </summary>
private static string Serialize(Selector selector)
{
return(selector.ContentHash.Serialize() + RedisValueSeparator + HexUtilities.BytesToHex(selector.Output));
}
public void SelectorsToRedisValues()
{
var selectors = Enumerable.Range(0, 3).Select(_ => Selector.Random()).ToList();
var redisValues = _serializer.ToRedisValues(selectors);
var expected = selectors.Select(selector =>
selector.ContentHash.Serialize() + RedisSerializer.RedisValueSeparator + HexUtilities.BytesToHex(selector.Output)).ToArray();
redisValues.Should().Equal(expected);
}
public void HexToBytesNull()
{
string result = HexUtilities.BytesToHex(null);
Assert.Equal("(null)", result);
}
/// <inheritdoc />
public override string ToString()
{
var hex = Output != null?HexUtilities.BytesToHex(Output) : string.Empty;
return($"ContentHash=[{ContentHash}], Output=[{hex}]");
}