public async Task TestGetAllPagination()
{
using var kvl = KVLite.CreateInMemory();
var entryCount = 1024;
var entries = Enumerable
.Range(0, entryCount)
.Select(x => createKVP(x, "value"));
await kvl.Add(entries);
var keys = entries
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
await foreach (var k in kvl.Get().Batch(10).Take(2))
{
await foreach (var res in k)
{
var key = Encoding.UTF8.GetString(res.Key);
keys.Remove(key);
Assert.AreEqual("value", Encoding.UTF8.GetString(res.Value));
}
}
Assert.AreEqual(entryCount - 20, keys.Count);
}
public async Task TestUpdate()
{
var kvl = KVLite.CreateInMemory();
var value = Encoding.UTF8.GetBytes("value");
var newValue = Encoding.UTF8.GetBytes("newValue");
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Add(key, value);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Update(key, newValue);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
var res = await kvl.Get(key);
Assert.IsTrue(res.IsSome);
Assert.AreEqual("newValue", Encoding.UTF8.GetString(res.Head()));
}
}
public async Task TestGetAll()
{
var kvl = KVLite.CreateInMemory();
var entryCount = 1024;
var entries = Enumerable
.Range(0, entryCount)
.Select(x => createKVP(x, "value"));
await kvl.Add(entries);
var keys = entries
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
var counter = 0;
await foreach (var res in kvl.Get())
{
Interlocked.Increment(ref counter);
var key = Encoding.UTF8.GetString(res.Key);
keys.Remove(key);
Assert.AreEqual("value", Encoding.UTF8.GetString(res.Value));
}
Assert.AreEqual(0, keys.Count);
Assert.AreEqual(counter, entryCount);
}
public async Task TestDelete()
{
var kvl = KVLite.CreateJsonInMemory();
var value = JsonSerializer.Serialize(new { hello = "value" });
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Add(key, value);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Delete(key);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
}
public async Task TestGetRR()
{
var kvl = KVLite.CreateInMemory();
var entries = Enumerable
.Range(0, 1000)
.Select(x => createKVP(x, "value"));
await kvl.Add(entries);
var keys = entries
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
var counter = 0;
await foreach (var res in kvl.GetRR(true))
{
counter++;
var key = Encoding.UTF8.GetString(res.Key);
keys.Remove(key);
Assert.AreEqual("value", Encoding.UTF8.GetString(res.Value));
}
Assert.AreEqual(1000, counter);
Assert.AreEqual(0, keys.Count);
}
public async Task TestUpdate()
{
var kvl = KVLite.CreateJsonInMemory();
var value = JsonSerializer.Serialize(new { hello = "value" });
var newValue = JsonSerializer.Serialize(new { hello = "newValue" });
var entries = Enumerable
.Range(0, 1000)
.Select(x => createKVP(x, value));
await kvl.Add(entries);
var newEntries = Enumerable
.Range(0, 1000)
.Select(x => createKVP(x, newValue));
await kvl.Update(newEntries);
var keys = entries
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
await foreach (var res in kvl.Get())
{
var key = Encoding.UTF8.GetString(res.Key);
keys.Remove(key);
Assert.AreEqual(newValue, res.Value);
}
Assert.AreEqual(0, keys.Count);
}
public async Task TestUpdate()
{
var kvl = KVLite.CreateJsonInMemory();
var value = JsonSerializer.Serialize(new { hello = "value" });
var newValue = JsonSerializer.Serialize(new { hello = "newValue" });
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Add(key, value);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Update(key, newValue);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
var res = await kvl.Get(key);
Assert.AreEqual(newValue, res);
}
}
public async Task TestDeleteNonExisting()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
await kvl.Delete(key);
}
public async Task TestDeleteNonExisting()
{
var kvl = KVLite.CreateInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = Encoding.UTF8.GetBytes("value");
await kvl.Delete(key);
}
public async Task TestGetNonExisting()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
public async Task TestUpdateNonExisting()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
await kvl.Update(key, value);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
public async Task TestUpdateNonExisting()
{
var kvl = KVLite.CreateInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = Encoding.UTF8.GetBytes("value");
var newValue = Encoding.UTF8.GetBytes("newValue");
await kvl.Update(key, newValue);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
public async Task TestAdd()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
await kvl.Add(key, value);
var res = await kvl.Get(key);
Assert.AreEqual(value, res);
}
public async Task TestAdd()
{
var kvl = KVLite.CreateJsonInMemory();
var run = Enumerable.Range(0, 10)
.Select(x => lifecycle(kvl, x));
await Task.WhenAll(run);
var count = await kvl.Get().CountAsync();
Assert.AreEqual(0, count);
}
public async Task TestAdd()
{
var kvl = KVLite.CreateInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = Encoding.UTF8.GetBytes("value");
await kvl.Add(key, value);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsSome);
Assert.AreEqual("value", Encoding.UTF8.GetString(res.Head()));
}
public async Task TestDelete()
{
var kvl = KVLite.CreateInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = Encoding.UTF8.GetBytes("value");
await kvl.Add(key, value);
await kvl.Delete(key);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
public async Task TestAddSameKeyTwiceWithDifferentValue()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value1 = JsonSerializer.Serialize(new { hello = "value1" });
var value2 = JsonSerializer.Serialize(new { hello = "value2" });
await kvl.Add(key, value1);
await kvl.Add(key, value2);
var res = await kvl.Get(key);
Assert.AreEqual(value1, res);
}
public async Task TestCountWithComparison(Compare comp, int expected)
{
var kvl = KVLite.CreateJsonInMemory();
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
var value = JsonSerializer.Serialize(new { hello = i });
await kvl.Add(key, value);
}
var count = await kvl.Count("$.hello", comp, 500);
Assert.AreEqual(expected, count);
}
public async Task TestCount()
{
var kvl = KVLite.CreateJsonInMemory();
var value = JsonSerializer.Serialize(new { hello = "value" });
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key{i}");
await kvl.Add(key, value);
}
var count = await kvl.Count();
Assert.AreEqual(1000, count);
}
public async Task TestInsertIntoArray()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = new [] { 1, 2, 3 } });
await kvl.Add(key, value);
await kvl.Insert(key, "$.hello[#]", 4);
var res = await kvl.Get(key);
var expected = JsonSerializer.Serialize(new { hello = new [] { 1, 2, 3, 4 } });
Assert.AreEqual(expected, res);
}
public async Task TestAddSameKeyTwiceWithDifferentValue()
{
var kvl = KVLite.CreateInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value1 = Encoding.UTF8.GetBytes("value1");
var value2 = Encoding.UTF8.GetBytes("value2");
await kvl.Add(key, value1);
await kvl.Add(key, value2);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsSome);
Assert.AreEqual("value1", Encoding.UTF8.GetString(res.Head()));
}
public async Task TestRemove()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value", world = "value" });
await kvl.Add(key, value);
await kvl.Remove(key, "$.world");
var res = await kvl.Get(key);
var expected = JsonSerializer.Serialize(new { hello = "value" });
Assert.AreEqual(expected, res);
}
public async Task TestSetDoesOverwrite()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
var newValue = JsonSerializer.Serialize("newValue");
await kvl.Add(key, value);
await kvl.Set(key, "$.hello", newValue);
var res = await kvl.Get(key);
var expected = JsonSerializer.Serialize(new { hello = "newValue" });
Assert.AreEqual(expected, res);
}
public async Task TestMultiThreadedTransactionOnSameKeyOneThrows()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
var arrayValues = Enumerable.Range(0, 100);
await kvl.Add(key, value);
var tasks = arrayValues
.Select(trxFunc);
var t = await Assert.ThrowsExceptionAsync <Exception>(() => Task.WhenAll(tasks));
var res = await kvl.Get(key);
var element = JsonDocument.Parse(res.Head()).RootElement;
var prop = element
.EnumerateObject()
.Find(x => x.Name == "world").Head();
var values = arrayValues.ToHashSet();
foreach (var i in prop.Value.EnumerateArray())
{
values.Remove(i.GetInt32());
}
Assert.AreEqual(1, values.Count);
async Task trxFunc(int i)
{
if (i == 50)
{
throw new Exception("Boom");
}
using var trx = await kvl.BeginTransactionAsync(key);
await kvl.Insert(key, "$.world", "[]");
await kvl.Insert(key, "$.world[#]", i);
await trx.CommitAsync();
}
}
public async Task TestRollbackTransaction()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
var value2 = JsonSerializer.Serialize("value");
await kvl.Add(key, value);
using var trx = await kvl.BeginTransactionAsync(key);
await kvl.Insert(key, "$.world", value2);
await trx.RollbackAsync();
var res = await kvl.Get(key);
Assert.AreEqual(value, res);
}
public async Task TestAdd()
{
var kvl = KVLite.CreateJsonInMemory();
Parallel.ForEach(Enumerable.Range(0, 100), async x => {
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key-{x}-{i}");
var value = JsonSerializer.Serialize(new { hello = "value" });
await kvl.Add(key, value);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key-{x}-{i}");
await kvl.Insert(key, "$.world", "value");
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key-{x}-{i}");
await kvl.Insert(key, "$.world", "value");
var res = await kvl.Get(key);
var expected = JsonSerializer.Serialize(new { hello = "value", world = "value" });
Assert.AreEqual(expected, res);
}
for (var i = 0; i < 1000; i++)
{
var key = Encoding.UTF8.GetBytes($"key-{x}-{i}");
await kvl.Delete(key);
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
});
var count = await kvl.Get().CountAsync();
Assert.AreEqual(0, count);
}
public async Task TestDelete()
{
var kvl = KVLite.CreateJsonInMemory();
var value = JsonSerializer.Serialize(new { hello = "value" });
var entries = Enumerable
.Range(0, 1000)
.Select(x => createKVP(x, value));
await kvl.Add(entries);
var keys = entries.Select(x => x.Key);
await kvl.Delete(keys);
foreach (var key in keys)
{
var res = await kvl.Get(key);
Assert.IsTrue(res.IsNone);
}
}
public async Task TestDisposeRollsBack()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
await kvl.Add(key, value);
using (var trx = await kvl.BeginTransactionAsync(key))
{
await kvl.Insert(key, "$.world", "[0]");
await kvl.Insert(key, "$.world[#]", 1);
await kvl.Insert(key, "$.world[#]", 2);
}
var res = await kvl.Get(key);
Assert.AreEqual(value, res);
}
public async Task TestMulitpleInsertsPerTransaction()
{
var kvl = KVLite.CreateJsonInMemory();
var key = Encoding.UTF8.GetBytes("key");
var value = JsonSerializer.Serialize(new { hello = "value" });
using var trx = await kvl.BeginTransactionAsync(key);
await kvl.Add(key, value);
await kvl.Set(key, "$.world", "[0]");
await kvl.Insert(key, "$.world[#]", 1);
await kvl.Set(key, "$.world[#]", 2);
await trx.CommitAsync();
var expected = JsonSerializer.Serialize(new { hello = "value", world = new [] { 0, 1, 2 } });
var res = await kvl.Get(key);
Assert.AreEqual(expected, res);
}
public async Task TestGetByComparison(int entryCount, bool random)
{
var kvl = KVLite.CreateJsonInMemory();
var valueTrue = JsonSerializer.Serialize(new { done = true });
var valueFalse = JsonSerializer.Serialize(new { done = false });
var rnd = new Random(Guid.NewGuid().GetHashCode());
var entries = Enumerable
.Range(0, entryCount)
.Select(x =>
{
var value = random
? rnd.Next(0, 100) > 50
? valueTrue : valueFalse
: x < entryCount / 2
? valueTrue : valueFalse;
var key = Encoding.UTF8.GetBytes($"key{x}");
return(new KeyValuePair <byte[], string>(key, value));
}).ToList();
await kvl.Add(entries);
var groups = entries.GroupBy(x => x.Value.Contains("true"));
var trueKeys = groups
.Where(x => x.Key)
.First()
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
var falseKeys = groups
.Where(x => !x.Key)
.First()
.Select(x => Encoding.UTF8.GetString(x.Key))
.ToHashSet();
var trueCount = trueKeys.Count;
var falseCount = falseKeys.Count;
var counter = 0;
var hs = new HashSet <string>();
await foreach (var res in kvl.Get <string, bool>("$.done", Compare.EQ, true))
{
Interlocked.Increment(ref counter);
var key = Encoding.UTF8.GetString(res.Key);
trueKeys.Remove(key);
hs.Add(key);
Assert.AreEqual(valueTrue, res.Value);
}
await foreach (var res in kvl.Get <string, bool>("$.done", Compare.NE, true))
{
Interlocked.Increment(ref counter);
var key = Encoding.UTF8.GetString(res.Key);
falseKeys.Remove(key);
hs.Add(key);
Assert.AreEqual(valueFalse, res.Value);
}
Assert.AreEqual(hs.Count, entryCount);
Assert.AreEqual(0, trueKeys.Count);
Assert.AreEqual(counter, entryCount);
}
