diff --git a/RedisStudyTest/RedisHashStudyTest.cs b/RedisStudyTest/RedisHashStudyTest.cs
index dd5b1a8..08fb3d5 100644
--- a/RedisStudyTest/RedisHashStudyTest.cs
+++ b/RedisStudyTest/RedisHashStudyTest.cs
@@ -18,18 +18,19 @@ namespace RedisStudyTest
/// <summary>
/// Redis Hash 类型测试
/// </summary>
+ [Trait("RedisHash", "All")]
public class RedisHashStudyTest : IDisposable
{
#region 初始化
private readonly ITestOutputHelper testOutput;
private IDatabase redisDatabase = null;
- private RedisHashStudy hashStudy = null;
- private List<Student> students;
+ private RedisHashStudy redisHashStudy = null;
+ private List<Student> defaultStudentList;
private Student defaultStudent = null;
- private string preHashKey = "RedisStudy:Student:";
- private string defaultHashKey = "";
- private int keyExpireSeconds = 20;
+ private string preStudentHashKey = "RedisStudy:Student:";
+ private string defaultStudentHashKey = "";
+ private int keyDefaultExpireSeconds = 20;
/// <summary>
/// 构造
@@ -39,7 +40,7 @@ namespace RedisStudyTest
this.testOutput = output;
redisDatabase = RedisHelper.GetRedisDatabase();
- hashStudy = new RedisHashStudy();
+ redisHashStudy = new RedisHashStudy();
defaultStudent = new Student()
{
Id = 1,
@@ -47,9 +48,9 @@ namespace RedisStudyTest
Age = 18
};
- defaultHashKey = preHashKey + defaultStudent.Id;
+ defaultStudentHashKey = preStudentHashKey + defaultStudent.Id;
- students = new List<Student>()
+ defaultStudentList = new List<Student>()
{
new Student()
{
@@ -82,6 +83,8 @@ namespace RedisStudyTest
Age = 55
},
};
+
+ //删理默认学生
DeleteExitsStudents();
}
#endregion
@@ -90,6 +93,7 @@ namespace RedisStudyTest
/// <summary>
/// xUnit输出信息 测试
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact(DisplayName = "HashSet 输出信息测试")]
public void HashSetOutputTest()
{
@@ -100,72 +104,74 @@ namespace RedisStudyTest
/// <summary>
/// 参数异常 测试
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact(DisplayName = "HashSet 异常测试")]
public void HashSetExceptionTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
+ string redisKey = preStudentHashKey + defaultStudent.Id;
//参数异常测试
- Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet(string.Empty, null));
- Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet("", null));
- Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet(preHashKey + "-1", null));
- Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet(preHashKey + "-1", new HashEntry[] { }));
+ Assert.Throws<ArgumentNullException>(() => redisHashStudy.HashSet(string.Empty, null));
+ Assert.Throws<ArgumentNullException>(() => redisHashStudy.HashSet("", null));
+ Assert.Throws<ArgumentNullException>(() => redisHashStudy.HashSet(preStudentHashKey + "-1", null));
+ Assert.Throws<ArgumentNullException>(() => redisHashStudy.HashSet(preStudentHashKey + "-1", new HashEntry[] { }));
}
/// <summary>
/// 参数 When 测试
/// </summary>
- [Trait("HashSet", "When")]
+ [Trait("RedisHash", "HashSet")]
[Fact(DisplayName = "HashSet When参数测试")]
public void HashSetWhenTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
+ string redisKey = preStudentHashKey + defaultStudent.Id;
//当前上下文不能使用： When.Exists
- var id_When_NotExists_No = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
+ var id_When_NotExists_No = redisHashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
Assert.True(id_When_NotExists_No);
- var id_When_NotExists_Yes = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
+ var id_When_NotExists_Yes = redisHashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
Assert.False(id_When_NotExists_Yes);
- var id_When_Always_Exists = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.Always);
+ var id_When_Always_Exists = redisHashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.Always);
Assert.False(id_When_Always_Exists);
- var id_When_Always_NotExists = hashStudy.HashSet(redisKey, "Id4", defaultStudent.Id + 1, When.Always);
+ var id_When_Always_NotExists = redisHashStudy.HashSet(redisKey, "Id4", defaultStudent.Id + 1, When.Always);
Assert.True(id_When_Always_NotExists);
}
/// <summary>
/// 添加一个默认学生 测试
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact]
public void HashSetAddStudentTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
var studentEntries = new HashEntry[]
{
- new HashEntry("Id",1),
+ new HashEntry("Id",defaultStudent.Id),
new HashEntry("Name",defaultStudent.Name),
new HashEntry("Age",defaultStudent.Age),
};
//插入Sudent
- var addHash = hashStudy.HashSet(redisKey, studentEntries, CommandFlags.None);
+ var addHash = redisHashStudy.HashSet(defaultStudentHashKey, studentEntries, CommandFlags.None);
Assert.True(addHash);
//设置过期
- redisDatabase.KeyExpire(redisKey, TimeSpan.FromSeconds(keyExpireSeconds));
+ redisDatabase.KeyExpire(defaultStudentHashKey, TimeSpan.FromSeconds(keyDefaultExpireSeconds));
}
/// <summary>
/// 添加一组初始化设置的学生 测试
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact]
public void HashSetAddGroupStudentTest()
{
- foreach (var temp in students)
+ foreach (var temp in defaultStudentList)
{
- string redisKey = preHashKey + temp.Id;
+ string redisKey = preStudentHashKey + temp.Id;
var studentEntries = new HashEntry[]
{
new HashEntry("Id", temp.Id),
@@ -174,34 +180,35 @@ namespace RedisStudyTest
};
//插入Sudent
- var addStudent = hashStudy.HashSet(redisKey, studentEntries);
+ var addStudent = redisHashStudy.HashSet(redisKey, studentEntries);
Assert.True(addStudent);
//设置过期
- redisDatabase.KeyExpire(redisKey, TimeSpan.FromSeconds(keyExpireSeconds));
+ redisDatabase.KeyExpire(redisKey, TimeSpan.FromSeconds(keyDefaultExpireSeconds));
}
//清理删除
- foreach (var temp in students)
+ foreach (var temp in defaultStudentList)
{
- redisDatabase.KeyDelete(preHashKey + temp.Id);
+ redisDatabase.KeyDelete(preStudentHashKey + temp.Id);
}
}
/// <summary>
/// 设置一个哈希字段 测试
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact]
public void HashSetHashfieldTest()
{
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
- Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Id", defaultStudent.Id));
+ Assert.False(redisHashStudy.HashSet(defaultStudentHashKey, "Id", defaultStudent.Id));
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Name", defaultStudent.Name));
- Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Name", defaultStudent.Name));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Name", defaultStudent.Name));
+ Assert.False(redisHashStudy.HashSet(defaultStudentHashKey, "Name", defaultStudent.Name));
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Age", defaultStudent.Age));
- Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Age", defaultStudent.Age));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Age", defaultStudent.Age));
+ Assert.False(redisHashStudy.HashSet(defaultStudentHashKey, "Age", defaultStudent.Age));
}
/// <summary>
@@ -210,8 +217,8 @@ namespace RedisStudyTest
[Fact]
public void HashSetGroupHashfieldTest()
{
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
- Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id + 1));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Id", defaultStudent.Id));
+ Assert.False(redisHashStudy.HashSet(defaultStudentHashKey, "Id", defaultStudent.Id + 1));
var entrys = new HashEntry[]
{
@@ -225,18 +232,19 @@ namespace RedisStudyTest
new HashEntry("Age", defaultStudent.Age+1),
};
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, entrys));
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, entrys2));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, entrys));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, entrys2));
}
/// <summary>
/// 特例测试：给key为空的哈希 设置字段
/// 结 果：添加或更新操作能成功，但是字段值插入不进去。
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact]
public void HashSetForEmptyKeyTest()
{
- Assert.True(hashStudy.HashSet(string.Empty, "Name", "wanggaofeng"));
+ Assert.True(redisHashStudy.HashSet(string.Empty, "Name", "wanggaofeng"));
redisDatabase.KeyDelete(string.Empty);
}
@@ -244,13 +252,14 @@ namespace RedisStudyTest
/// 特例测试：给字段名为空串的哈希 设置字段
/// 结 果：添加或更新操作正常，只是字段键名为""
/// </summary>
+ [Trait("RedisHash", "HashSet")]
[Fact]
public void HashSetForEmptyFieldTest()
{
- Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "", defaultStudent.Id));
- Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "", defaultStudent.Id + 1));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "", defaultStudent.Id));
+ Assert.False(redisHashStudy.HashSet(defaultStudentHashKey, "", defaultStudent.Id + 1));
- redisDatabase.KeyDelete(preHashKey + defaultStudent.Id);
+ redisDatabase.KeyDelete(defaultStudentHashKey);
}
#endregion
@@ -264,10 +273,8 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementExceptionTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
- Assert.True(hashStudy.HashSet(redisKey, "Name", "wanggaofeng"));
- Assert.Throws<RedisServerException>(() => hashStudy.HashDecrement(redisKey, "Name", 1));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Name", "wanggaofeng"));
+ Assert.Throws<RedisServerException>(() => redisHashStudy.HashDecrement(defaultStudentHashKey, "Name", 1));
}
/// <summary>
@@ -277,13 +284,11 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementHashKeyTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//Key不存在，先创建哈希表，再添加值为0的字段，然后执行自减操作
- Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Id", 1));
+ Assert.Equal(-1, redisHashStudy.HashDecrement(defaultStudentHashKey, "Id", 1));
//存在，直接自减
- Assert.Equal(-1, hashStudy.HashGet(redisKey, "Id"));
+ Assert.Equal(-1, redisHashStudy.HashGet(defaultStudentHashKey, "Id"));
}
/// <summary>
@@ -293,11 +298,9 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementHashFieldTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//字段不存在，则创建之
- Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Age", 1));
- Assert.Equal(-1, hashStudy.HashGet(redisKey, "Age"));
+ Assert.Equal(-1, redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", 1));
+ Assert.Equal(-1, redisHashStudy.HashGet(defaultStudentHashKey, "Age"));
}
/// <summary>
@@ -306,10 +309,8 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementMinusTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//自减负数时，则自增
- Assert.Equal(2, hashStudy.HashDecrement(redisKey, "Age", -2));
+ Assert.Equal(2, redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", -2));
}
/// <summary>
@@ -318,12 +319,10 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementByIntTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//字段减少1
- Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Age", 1));
+ Assert.Equal(-1, redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", 1));
//字段减少2
- Assert.Equal(-3, hashStudy.HashDecrement(redisKey, "Age", 2));
+ Assert.Equal(-3, redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", 2));
}
/// <summary>
@@ -333,15 +332,13 @@ namespace RedisStudyTest
[Fact]
public void HashDecrementByDoubleTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//新字段时，可以用相等比较
- var dec = hashStudy.HashDecrement(redisKey, "Age", 2.1);
+ var dec = redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", 2.1);
var absDec = Math.Abs(-2.1 - dec);
Assert.Equal(0, absDec);
//已经存在的，浮点数，不使用相等比较，而改用两值相差一定的小范围
- dec = hashStudy.HashDecrement(redisKey, "Age", 2.5);
+ dec = redisHashStudy.HashDecrement(defaultStudentHashKey, "Age", 2.5);
absDec = Math.Abs(-4.6 - dec);
Assert.True(absDec < 0.01);
}
@@ -357,10 +354,8 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementExceptionTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
- Assert.True(hashStudy.HashSet(redisKey, "Name", "wanggaofeng"));
- Assert.Throws<RedisServerException>(() => hashStudy.HashIncrement(redisKey, "Name", 1));
+ Assert.True(redisHashStudy.HashSet(defaultStudentHashKey, "Name", "wanggaofeng"));
+ Assert.Throws<RedisServerException>(() => redisHashStudy.HashIncrement(defaultStudentHashKey, "Name", 1));
}
/// <summary>
@@ -370,11 +365,9 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementHashKeyTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//Key不存在，先创建哈希表，再添加值为0的字段，然后执行自减操作
- Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Id", 1));
- Assert.Equal(1, hashStudy.HashGet(redisKey, "Id"));
+ Assert.Equal(1, redisHashStudy.HashIncrement(defaultStudentHashKey, "Id", 1));
+ Assert.Equal(1, redisHashStudy.HashGet(defaultStudentHashKey, "Id"));
}
/// <summary>
@@ -384,11 +377,9 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementHashFieldTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//字段不存在，则创建之
- Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Age", 1));
- Assert.Equal(1, hashStudy.HashGet(redisKey, "Age"));
+ Assert.Equal(1, redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", 1));
+ Assert.Equal(1, redisHashStudy.HashGet(defaultStudentHashKey, "Age"));
}
/// <summary>
@@ -397,10 +388,8 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementMinusTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//自增负数时，则自减
- Assert.Equal(-2, hashStudy.HashIncrement(redisKey, "Age", -2));
+ Assert.Equal(-2, redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", -2));
}
/// <summary>
@@ -409,12 +398,10 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementByIntTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//字段减少1
- Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Age", 1));
+ Assert.Equal(1, redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", 1));
//字段减少2
- Assert.Equal(3, hashStudy.HashIncrement(redisKey, "Age", 2));
+ Assert.Equal(3, redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", 2));
}
/// <summary>
@@ -424,15 +411,13 @@ namespace RedisStudyTest
[Fact]
public void HashIncrementByDoubleTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
//新字段时，可以用相等比较
- var dec = hashStudy.HashIncrement(redisKey, "Age", 2.1);
+ var dec = redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", 2.1);
var absDec = Math.Abs(2.1 - dec);
Assert.Equal(0, absDec);
//已经存在的，浮点数，不使用相等比较，而改用两值相差一定的小范围
- dec = hashStudy.HashIncrement(redisKey, "Age", 2.5);
+ dec = redisHashStudy.HashIncrement(defaultStudentHashKey, "Age", 2.5);
absDec = Math.Abs(4.6 - dec);
Assert.True(absDec < 0.01);
}
@@ -445,19 +430,18 @@ namespace RedisStudyTest
[Fact]
public void HashGetAllTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
var studentEntries = new HashEntry[]
{
- new HashEntry("Id",1),
+ new HashEntry("Id",defaultStudent.Id),
new HashEntry("Name",defaultStudent.Name),
new HashEntry("Age",defaultStudent.Age),
};
//插入Sudent
- var addHash = hashStudy.HashSet(redisKey, studentEntries);
+ var addHash = redisHashStudy.HashSet(defaultStudentHashKey, studentEntries);
Assert.True(addHash);
- var entries = hashStudy.HashGetAll(redisKey);
+ var entries = redisHashStudy.HashGetAll(defaultStudentHashKey);
Assert.NotNull(entries);
@@ -481,8 +465,7 @@ namespace RedisStudyTest
[Fact]
public void HashGetNotKkeyTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
- var result = hashStudy.HashGet(redisKey, "Id");
+ var result = redisHashStudy.HashGet(defaultStudentHashKey, "Id");
Assert.False(result.HasValue);
}
@@ -493,24 +476,39 @@ namespace RedisStudyTest
[Fact]
public void HashGetNotHashfieldTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
-
- hashStudy.HashIncrement(redisKey, "Id", 1);
+ redisHashStudy.HashIncrement(defaultStudentHashKey, "Id", 1);
- var result = hashStudy.HashGet(redisKey, "Name");
+ var result = redisHashStudy.HashGet(defaultStudentHashKey, "Name");
Assert.False(result.HasValue);
}
[Fact]
- public void HashGetTest()
+ public void HashGetOneFieldTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
AddDefaultStudent();
- Assert.Equal(1, hashStudy.HashGet(redisKey, "Id"));
- Assert.Equal(defaultStudent.Name, hashStudy.HashGet(redisKey, "Name"));
- Assert.Equal(defaultStudent.Age, hashStudy.HashGet(redisKey, "Age"));
+ Assert.Equal(1, redisHashStudy.HashGet(defaultStudentHashKey, "Id"));
+ Assert.Equal(defaultStudent.Name, redisHashStudy.HashGet(defaultStudentHashKey, "Name", CommandFlags.None));
+ Assert.Equal(defaultStudent.Age, redisHashStudy.HashGet(defaultStudentHashKey, "Age", CommandFlags.None));
+ }
+
+ [Fact]
+ public void HashGetGroupFieldTest()
+ {
+ AddDefaultStudent();
+
+ RedisValue[] hashFields = new RedisValue[]
+ {
+ "Id",
+ "Name",
+ "Age",
+ };
+
+ RedisValue[] resultValues = redisHashStudy.HashGet(defaultStudentHashKey, hashFields, CommandFlags.None);
+ Assert.Contains(defaultStudent.Id, resultValues);
+ Assert.Contains(defaultStudent.Name, resultValues);
+ Assert.Contains(defaultStudent.Age, resultValues);
}
#endregion
@@ -523,7 +521,7 @@ namespace RedisStudyTest
[Fact]
public void HashKeysNotKeyTest()
{
- RedisValue[] keys = hashStudy.HashKeys(defaultHashKey);
+ RedisValue[] keys = redisHashStudy.HashKeys(defaultStudentHashKey);
Assert.NotNull(keys);
Assert.Empty(keys);
@@ -538,7 +536,7 @@ namespace RedisStudyTest
{
AddDefaultStudent();
- RedisValue[] keys = hashStudy.HashKeys(defaultHashKey);
+ RedisValue[] keys = redisHashStudy.HashKeys(defaultStudentHashKey);
Assert.NotEmpty(keys);
Assert.Contains("Id", keys);
@@ -554,7 +552,7 @@ namespace RedisStudyTest
[Fact]
public void HashValuesNotKeyTest()
{
- RedisValue[] keys = hashStudy.HashValues(defaultHashKey);
+ RedisValue[] keys = redisHashStudy.HashValues(defaultStudentHashKey);
Assert.NotNull(keys);
Assert.Empty(keys);
@@ -569,7 +567,7 @@ namespace RedisStudyTest
{
AddDefaultStudent();
- RedisValue[] values = hashStudy.HashValues(defaultHashKey);
+ RedisValue[] values = redisHashStudy.HashValues(defaultStudentHashKey);
Assert.NotEmpty(values);
Assert.Contains(defaultStudent.Id, values);
@@ -587,8 +585,7 @@ namespace RedisStudyTest
[Fact]
public void HashLengthNotKeyTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
- var result = hashStudy.HashLength(redisKey);
+ var result = redisHashStudy.HashLength(defaultStudentHashKey);
Assert.Equal(0, result);
}
@@ -599,10 +596,9 @@ namespace RedisStudyTest
[Fact]
public void HashLengthTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
AddDefaultStudent();
- var result = hashStudy.HashLength(redisKey);
+ var result = redisHashStudy.HashLength(defaultStudentHashKey);
Assert.Equal(3, result);
}
@@ -615,9 +611,9 @@ namespace RedisStudyTest
/// 哈希不存在时，HashScan
/// </summary>
[Fact]
- public void HashScanNotKey()
+ public void HashScanNotKeyTest()
{
- var hashEntrys= hashStudy.HashScan(defaultHashKey);
+ var hashEntrys = redisHashStudy.HashScan(defaultStudentHashKey, "*", 20, CommandFlags.None);
var num = hashEntrys.Count();
Assert.Equal(0, num);
@@ -626,6 +622,48 @@ namespace RedisStudyTest
Assert.Empty(entryList);
}
+
+ /// <summary>
+ /// 简单测试，有单独测试类详细测试
+ /// </summary>
+ [Fact]
+ public void HashScanTest()
+ {
+ //插入多列hash
+ List<HashEntry> hashEntries = new List<HashEntry>();
+ for (int i=1;i<=100; i++)
+ {
+ hashEntries.Add(new HashEntry("Field"+i,i));
+ }
+ redisHashStudy.HashSet(defaultStudentHashKey, hashEntries.ToArray());
+
+ var hashFieldScan = redisHashStudy.HashScan(defaultStudentHashKey);
+
+ Assert.Equal(100, hashFieldScan.Count());
+
+ var scanTake = hashFieldScan.Skip(10).Take(10).ToList();
+ Assert.Equal(10, scanTake.Count());
+
+ //删除hash
+ redisDatabase.KeyDelete(defaultStudentHashKey);
+
+ }
+
+ [Fact]
+ public void HashScan2Test()
+ {
+ //插入多列hash
+ List<HashEntry> hashEntries = new List<HashEntry>();
+ for (int i = 1; i <= 100; i++)
+ {
+ hashEntries.Add(new HashEntry("Field" + i, i));
+ }
+ redisHashStudy.HashSet(defaultStudentHashKey, hashEntries.ToArray());
+
+ var hashFieldScan = redisHashStudy.HashScan(defaultStudentHashKey, "*", 20, 0, 0, CommandFlags.None);
+
+ Assert.Equal(100, hashFieldScan.Count());
+ }
#endregion
#region HashExists
@@ -635,20 +673,19 @@ namespace RedisStudyTest
[Fact]
public void HashExists()
{
- string redisKey = preHashKey + defaultStudent.Id;
var studentEntries = new HashEntry[]
{
- new HashEntry("Id",1),
+ new HashEntry("Id",defaultStudent.Id),
new HashEntry("Name",defaultStudent.Name),
};
//插入Sudent
- var addHash = hashStudy.HashSet(redisKey, studentEntries);
+ var addHash = redisHashStudy.HashSet(defaultStudentHashKey, studentEntries);
Assert.True(addHash);
- Assert.True(hashStudy.HashExists(redisKey, "Id"));
- Assert.True(hashStudy.HashExists(redisKey, "Name"));
- Assert.False(hashStudy.HashExists(redisKey, "Age"));
+ Assert.True(redisHashStudy.HashExists(defaultStudentHashKey, "Id"));
+ Assert.True(redisHashStudy.HashExists(defaultStudentHashKey, "Name"));
+ Assert.False(redisHashStudy.HashExists(defaultStudentHashKey, "Age"));
}
#endregion
@@ -660,8 +697,7 @@ namespace RedisStudyTest
[Fact]
public void HashDeleteNotKeyTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
- var hashDeleteResult = hashStudy.HashDelete(redisKey, "FieldFirst");
+ var hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, "FieldFirst");
Assert.False(hashDeleteResult);
}
@@ -672,31 +708,47 @@ namespace RedisStudyTest
[Fact]
public void HashDeleteNotFieldTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
- hashStudy.HashIncrement(redisKey, "Id",1);
+ redisHashStudy.HashIncrement(defaultStudentHashKey, "Id",1);
- var hashDeleteResult = hashStudy.HashDelete(redisKey, "Name");
+ var hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, "Name");
Assert.False(hashDeleteResult);
}
/// <summary>
- /// 删除哈希字段
+ /// 删除哈希一个字段
/// </summary>
[Fact]
public void HashDeleteTest()
{
- string redisKey = preHashKey + defaultStudent.Id;
AddDefaultStudent();
- var hashDeleteResult = hashStudy.HashDelete(redisKey, "Id");
+ var hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, "Id");
Assert.True(hashDeleteResult);
- hashDeleteResult = hashStudy.HashDelete(redisKey, "Name");
+ hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, "Name", CommandFlags.None);
Assert.True(hashDeleteResult);
- hashDeleteResult = hashStudy.HashDelete(redisKey, "Age");
+ hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, "Age", CommandFlags.None);
Assert.True(hashDeleteResult);
}
+
+ /// <summary>
+ /// 删除一组哈希字段
+ /// </summary>
+ [Fact]
+ public void HashDeleteGroupFieldTest()
+ {
+ AddDefaultStudent();
+
+ RedisValue[] delValues = new RedisValue[]
+ {
+ "Id",
+ "Name",
+ "Age",
+ };
+ var hashDeleteResult = redisHashStudy.HashDelete(defaultStudentHashKey, delValues, CommandFlags.None);
+ Assert.Equal(3,hashDeleteResult);
+ }
#endregion
#region HashKeyDelete
@@ -707,7 +759,7 @@ namespace RedisStudyTest
[Fact]
public void KeyDeleteTest()
{
- Assert.False(redisDatabase.KeyDelete(preHashKey + "-2000"));
+ Assert.False(redisDatabase.KeyDelete(preStudentHashKey + "-2000"));
}
#endregion
@@ -728,22 +780,21 @@ namespace RedisStudyTest
{
if (defaultStudent != null)
{
- redisDatabase.KeyDelete(preHashKey + defaultStudent.Id);
+ redisDatabase.KeyDelete(preStudentHashKey + defaultStudent.Id);
}
}
private void AddDefaultStudent()
{
- string redisKey = preHashKey + defaultStudent.Id;
var studentEntries = new HashEntry[]
{
- new HashEntry("Id",1),
+ new HashEntry("Id",defaultStudent.Id),
new HashEntry("Name",defaultStudent.Name),
new HashEntry("Age",defaultStudent.Age),
};
//插入Sudent
- var addHash = hashStudy.HashSet(redisKey, studentEntries);
+ var addHash = redisHashStudy.HashSet(defaultStudentHashKey, studentEntries);
}
#endregion
}
diff --git a/RedisStudyTest/RedisLockStudyTest.cs b/RedisStudyTest/RedisLockStudyTest.cs
index 5b1c87d..fb602a3 100644
--- a/RedisStudyTest/RedisLockStudyTest.cs
+++ b/RedisStudyTest/RedisLockStudyTest.cs
@@ -13,6 +13,7 @@ using Xunit;
namespace RedisStudyTest
{
+ [Trait("RedisLock", "All")]
public class RedisLockStudyTest
{
private IDatabase redisDatabase;
diff --git a/RedisStudyTest/RedisServerStudyTest.cs b/RedisStudyTest/RedisServerStudyTest.cs
index d0dd741..02522c3 100644
--- a/RedisStudyTest/RedisServerStudyTest.cs
+++ b/RedisStudyTest/RedisServerStudyTest.cs
@@ -12,6 +12,7 @@ using Xunit;
namespace RedisStudyTest
{
+ [Trait("RedisServer", "All")]
public class RedisServerStudyTest
{
private IServer redisServer;
diff --git a/RedisStudyTest/RedisSortSetStudyTest.cs b/RedisStudyTest/RedisSortSetStudyTest.cs
index 45453a2..ef23cbf 100644
--- a/RedisStudyTest/RedisSortSetStudyTest.cs
+++ b/RedisStudyTest/RedisSortSetStudyTest.cs
@@ -14,6 +14,7 @@ using RedisStuy;
namespace RedisStudyTest
{
+ [Trait("RedisSortSet", "All")]
public class RedisSortSetStudyTest : IDisposable
{
private IDatabase redisDatabase = null;
diff --git a/RedisStuy/RedisHashStudy.cs b/RedisStuy/RedisHashStudy.cs
index 76b7f5d..d35b9d4 100644
--- a/RedisStuy/RedisHashStudy.cs
+++ b/RedisStuy/RedisHashStudy.cs
@@ -167,23 +167,10 @@ namespace RedisStuy
throw new ArgumentNullException("hashFields", "参数hashFields.Length ");
}
-
- bool result = false;
- try
- {
- redisDatabase.HashSet(key, hashFields, flags);
- result = true;
- }
- catch (ArgumentNullException argumentNullException)
- {
- throw argumentNullException;
- }
- catch (Exception baseException)
- {
- throw baseException;
- }
- return result;
+ redisDatabase.HashSet(key, hashFields, flags);
+
+ return true;
}
/// <summary>
diff --git a/RedisStuy/RedisScanStudy.cs b/RedisStuy/RedisScanStudy.cs
new file mode 100644
index 0000000..97b46d0
--- /dev/null
+++ b/RedisStuy/RedisScanStudy.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RedisStuy
+{
+ /// <summary>
+ /// Scan命令学习：包括Scan SScan HScan ZScan
+ /// Scan命令比较特殊，并且此组命令相似，所以放在一起单独学习
+ /// </summary>
+ public class RedisScanStudy
+ {
+
+ }
+}
diff --git a/RedisStuy/RedisStuy.csproj b/RedisStuy/RedisStuy.csproj
index 46c8600..3ceb585 100644
--- a/RedisStuy/RedisStuy.csproj
+++ b/RedisStuy/RedisStuy.csproj
@@ -50,6 +50,7 @@
<Compile Include="RedisListStudy.cs" />
<Compile Include="RedisDatabaseStudy.cs" />
<Compile Include="RedisLockStudy.cs" />
+ <Compile Include="RedisScanStudy.cs" />
<Compile Include="RedisSetStudy.cs" />
<Compile Include="RedisSortSetStudy.cs" />
<Compile Include="RedisTransactionStudy.cs" />