Skip to content

Async Set Operations #20

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
NirAgai wants to merge 12 commits into
base: master
Choose a base branch
from
Open

Async Set Operations #20

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
2751569
Redis List Operations.
Apr 3, 2019
9653604
Added Script Operations.
Apr 3, 2019
c7f2cd1
Moved the lua tests to the redis tests class.
Apr 16, 2019
b7084f6
Merge remote-tracking branch 'upstream/master'
Apr 24, 2019
be1c1d4
Added a summary for a function, and removed accidental namespace.
Apr 24, 2019
1d1271d
merge from base
Nov 4, 2019
b9c0e28
Merge remote-tracking branch 'upstream/master'
Jun 17, 2020
5d58fe9
Added async set operations.
Jun 25, 2020
20ff034
Merge pull request #1 from NirAgai/feature/async-set-operations
NirAgai Jun 25, 2020
ce13360
Improved the passing of async methods to the Retry function.
Jun 28, 2020
11bac5e
Updated version.
Jun 28, 2020
9aa6f40
Merge pull request #2 from NirAgai/feature/async-set-operations
NirAgai Jun 28, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
211 changes: 210 additions & 1 deletion IntegrationTests/RedisTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace PubComp.RedisRepo.IntegrationTests
{
Expand Down Expand Up @@ -76,7 +77,7 @@ public static void Retry(Action action, int maxAttempts)
return RetryUtil.Retry(() => this.Database.KeyTimeToLive(key), 3);
}
}

#endregion

#region Test Cases
Expand Down Expand Up @@ -306,6 +307,115 @@ public void SetOperations_Double()
.OrderBy(x => x).ToList());
}

[TestMethod]
public async Task AsyncSetOperations_Double()
{
var key1 = TestContext.TestName + ".1";
var key2 = TestContext.TestName + ".2";
var key3 = TestContext.TestName + ".3";

redisContext.Delete(key1);
redisContext.Delete(key2);
redisContext.Delete(key3);

await redisContext.SetAddAsync<double>(key1, new[] { 5.0, 2.0, 1.5 });
await redisContext.SetAddAsync<double>(key1, 3.5);

CollectionAssert.AreEquivalent(
new[] { 1.5, 2.0, 3.5, 5.0 },
(await redisContext.SetGetItemsAsync(key1, RedisValueConverter.ToDouble))
.OrderBy(x => x).ToList());

await redisContext.SetAddAsync<double>(key2, new[] { 7.0, 4.0, 1.5 });
await redisContext.SetAddAsync<double>(key3, new[] { 1.5, 7.0, 3.5, 8.5 });

var actualIntersect123 = await redisContext.SetsIntersectAsync(
new[] { key1, key2, key3 }, RedisValueConverter.ToDouble);
CollectionAssert.AreEquivalent(
new[] { 1.5 },
actualIntersect123.OrderBy(x => x).ToList());

var actualUnion123 = await redisContext.SetsUnionAsync(
new[] { key1, key2, key3 }, RedisValueConverter.ToDouble);
CollectionAssert.AreEquivalent(
new[] { 1.5, 2.0, 3.5, 4.0, 5.0, 7.0, 8.5 },
actualUnion123.OrderBy(x => x).ToList());

var actualMinus123 = await redisContext.SetsDiffAsync(
new[] { key1, key2, key3 }, RedisValueConverter.ToDouble);
CollectionAssert.AreEquivalent(
new[] { 2.0, 5.0 },
actualMinus123.OrderBy(x => x).ToList());

Assert.AreEqual(4, await redisContext.SetLengthAsync(key1));
Assert.AreEqual(3, await redisContext.SetLengthAsync(key2));
Assert.AreEqual(4, await redisContext.SetLengthAsync(key3));

await redisContext.SetRemoveAsync<double>(key1, 2.0);
Assert.AreEqual(3, await redisContext.SetLengthAsync(key1));
CollectionAssert.AreEquivalent(
new[] { 1.5, 3.5, 5.0 },
(await redisContext.SetGetItemsAsync(key1, RedisValueConverter.ToDouble))
.OrderBy(x => x).ToList());

await redisContext.SetRemoveAsync<double>(key3, new[] { 2.0, 8.5, 7.0 });
Assert.AreEqual(2, await redisContext.SetLengthAsync(key3));
CollectionAssert.AreEquivalent(
new[] { 1.5, 3.5 },
(await redisContext.SetGetItemsAsync(key3, RedisValueConverter.ToDouble))
.OrderBy(x => x).ToList());

redisContext.Delete(key2);
await redisContext.SetAddAsync<double>(key2, 9.0);
Assert.AreEqual(1, await redisContext.SetLengthAsync(key2));
CollectionAssert.AreEquivalent(
new[] { 9.0 },
(await redisContext.SetGetItemsAsync(key2, RedisValueConverter.ToDouble))
.OrderBy(x => x).ToList());
}

[TestMethod]
public async Task AsyncSetOperations_Parallel()
{
var key1 = TestContext.TestName + ".1";

redisContext.Delete(key1);

var range = Enumerable.Range(1, 10).ToList();

var tasks = range.Select(i => redisContext.SetAddAsync<int>(key1, i));
await Task.WhenAll(tasks);

var set = (await redisContext.SetGetItemsAsync(key1, RedisValueConverter.ToInt))
.OrderBy(x => x).ToList();

CollectionAssert.AreEquivalent(range, set);
}


[TestMethod]
public async Task SetOperations_NullEmptyValuesParam()
{
var key1 = TestContext.TestName + ".1";

redisContext.Delete(key1);

int[] nullValues = null;
int[] emptyValues = new int[0];

Assert.ThrowsException<ArgumentNullException>(() => redisContext.SetAdd(key1, nullValues));
await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => redisContext.SetAddAsync(key1, nullValues));

Assert.AreEqual(0, redisContext.SetAdd(key1, emptyValues));
Assert.AreEqual(0, await redisContext.SetAddAsync(key1, emptyValues));

Assert.ThrowsException<ArgumentNullException>(() => redisContext.SetRemove(key1, nullValues));
await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => redisContext.SetRemoveAsync(key1, nullValues));

Assert.AreEqual(0, redisContext.SetRemove(key1, emptyValues));
Assert.AreEqual(0, await redisContext.SetRemoveAsync(key1, emptyValues));
}

[TestMethod]
public void SetDeleteMany()
{
Expand Down Expand Up @@ -694,18 +804,40 @@ public void TestAddToRedisSet()
ValidateSetResults(key, new[] { "a", "b", "c", "bar" });
}

[TestMethod]
public async Task TestAddToRedisSetAsync()
{
const string key = "k1";
var values = new[] { "bar", "bar", "a", "b", "c" };

await redisContext.AddToSetAsync(key, values);

await ValidateSetResultsAsync(key, new[] { "a", "b", "c", "bar" });
}

[TestMethod]
public void TestSetContainsTrue()
{
TestSetContains("a", "a", true);
}

[TestMethod]
public async Task TestSetContainsTrueAsync()
{
await TestSetContainsAsync("a", "a", true);
}

[TestMethod]
public void TestSetContainsFalse()
{
TestSetContains("a", "b", false);
}

[TestMethod]
public async Task TestSetContainsFalseAsync()
{
await TestSetContainsAsync("a", "b", false);
}

[TestMethod]
public void TestCountSetMembers()
Expand All @@ -718,6 +850,17 @@ public void TestCountSetMembers()
Assert.AreEqual(4, redisContext.CountSetMembers(key));
}

[TestMethod]
public async Task TestCountSetMembersAsync()
{
const string key = "k2";
var values = new[] { "bar", "bar", "a", "b", "c", "a", "b" };

await redisContext.AddToSetAsync(key, values);

Assert.AreEqual(4, await redisContext.CountSetMembersAsync(key));
}

[TestMethod]
public void TestSetsDiff()
{
Expand All @@ -734,6 +877,22 @@ public void TestSetsDiff()
CollectionAssert.AreEquivalent(new[] { "c", "d", "e" }, results);
}

[TestMethod]
public async Task TestSetsDiffAsync()
{
const string key1 = "testSetDiff1";
var values1 = new[] { "a", "b", "c", "d", "e" };

const string key2 = "testSetDiff2";
var values2 = new[] { "a", "b", };

await redisContext.AddToSetAsync(key1, values1);
await redisContext.AddToSetAsync(key2, values2);

var results = await redisContext.GetSetsDifferenceAsync(new[] { key1, key2 });
CollectionAssert.AreEquivalent(new[] { "c", "d", "e" }, results);
}

[TestMethod]
public void TestSetsUnion()
{
Expand All @@ -750,6 +909,22 @@ public void TestSetsUnion()
CollectionAssert.AreEquivalent(new[] { "a", "b", "c" }, results);
}

[TestMethod]
public async Task TestSetsUnionAsync()
{
const string key1 = "TestSetsUnion1";
var values1 = new[] { "a", "c" };

const string key2 = "TestSetsUnion2";
var values2 = new[] { "a", "b" };

await redisContext.AddToSetAsync(key1, values1);
await redisContext.AddToSetAsync(key2, values2);

var results = await redisContext.UnionSetsAsync(new[] { key1, key2 });
CollectionAssert.AreEquivalent(new[] { "a", "b", "c" }, results);
}

[TestMethod]
public void TestSetsIntersect()
{
Expand All @@ -766,12 +941,34 @@ public void TestSetsIntersect()
CollectionAssert.AreEquivalent(new[] { "a" }, results);
}

[TestMethod]
public async Task TestSetsIntersectAsync()
{
const string key1 = "TestSetsIntersect1";
var values1 = new[] { "a", "c" };

const string key2 = "TestSetsIntersect2";
var values2 = new[] { "a", "b" };

await redisContext.AddToSetAsync(key1, values1);
await redisContext.AddToSetAsync(key2, values2);

var results = await redisContext.IntersectSetsAsync(new[] { key1, key2 });
CollectionAssert.AreEquivalent(new[] { "a" }, results);
}

private void ValidateSetResults(string key, string[] expected)
{
var valuesFromRedis = redisContext.GetSetMembers(key);
CollectionAssert.AreEquivalent(expected, valuesFromRedis);
}

private async Task ValidateSetResultsAsync(string key, string[] expected)
{
var valuesFromRedis = await redisContext.GetSetMembersAsync(key);
CollectionAssert.AreEquivalent(expected, valuesFromRedis);
}

public void TestSetContains(string valueToAdd, string searchForValue, bool expected)
{
const string key = "testSetContains";
Expand All @@ -784,6 +981,18 @@ public void TestSetContains(string valueToAdd, string searchForValue, bool expec
Assert.AreEqual(expected, setContains);
}

public async Task TestSetContainsAsync(string valueToAdd, string searchForValue, bool expected)
{
const string key = "testSetContains";
var values = new[] { "foo", "bar" };

await redisContext.AddToSetAsync(key, values);
await redisContext.AddToSetAsync(key, new[] { valueToAdd });

var setContains = await redisContext.SetContainsAsync(key, searchForValue);
Assert.AreEqual(expected, setContains);
}

#endregion

#region Redis Hashes
Expand Down
Loading