public void ExecuteGetTreatmentOnRemovedUserFromSegmentShouldReturnOff()
{
//Arrange
var client = new RedisClient(config);
var cache = new RedisSegmentCache(new RedisAdapter("localhost", "6379", ""));
//Act
var result = client.GetTreatment("c1321b21-0f70-449f-8979-b8faed67d210", "test_jw2", null);
cache.RemoveFromSegment("payed", new List <string>()
{
"c1321b21-0f70-449f-8979-b8faed67d210"
});
var result2 = client.GetTreatment("c1321b21-0f70-449f-8979-b8faed67d210", "test_jw2", null);
//Assert
Assert.IsNotNull(result);
Assert.AreEqual("on", result);
Assert.IsNotNull(result2);
Assert.AreEqual("off", result2);
//Reset Status
cache.AddToSegment("payed", new List <string>()
{
"c1321b21-0f70-449f-8979-b8faed67d210"
});
cache = null;
}
public void GetSegmentNamesTest()
{
// Arrange.
var redisAdapterMock = new Mock <IRedisAdapter>();
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
// Act & Assert.
var result = segmentCache.GetSegmentNames();
Assert.AreEqual(0, result.Count);
var segmentName = "test";
redisAdapterMock
.Setup(mock => mock.SMembers("SPLITIO.segments.registered"))
.Returns(new List <RedisValue>
{
segmentName,
$"{segmentName}-1",
$"{segmentName}-2"
}.ToArray());
result = segmentCache.GetSegmentNames();
Assert.AreEqual(3, result.Count);
Assert.IsTrue(result.Contains(segmentName));
Assert.IsTrue(result.Contains($"{segmentName}-1"));
Assert.IsTrue(result.Contains($"{segmentName}-2"));
}
public void GetSegmentKeysTest()
{
// Arrange.
var redisAdapterMock = new Mock <IRedisAdapter>();
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
var keys = new List <string> {
"abcd", "1234"
};
var segmentName = "test";
segmentCache.AddToSegment(segmentName, keys);
redisAdapterMock
.Setup(mock => mock.SMembers($"SPLITIO.segment.{segmentName}"))
.Returns(new List <RedisValue>
{
"abcd",
"1234"
}.ToArray());
// Act & Assert.
var result = segmentCache.GetSegmentKeys(segmentName);
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.Contains("abcd"));
Assert.IsTrue(result.Contains("1234"));
result = segmentCache.GetSegmentKeys("segmentName");
Assert.AreEqual(0, result.Count);
}
private void BuildRedisCache()
{
redisAdapter = new RedisAdapter(RedisHost, RedisPort, RedisPassword, RedisDatabase, RedisConnectTimeout, RedisConnectRetry, RedisSyncTimeout);
splitCache = new RedisSplitCache(redisAdapter, RedisUserPrefix);
segmentCache = new RedisSegmentCache(redisAdapter, RedisUserPrefix);
metricsCache = new RedisMetricsCache(redisAdapter, SdkMachineIP, SdkVersion, RedisUserPrefix);
impressionsCache = new RedisImpressionsCache(redisAdapter, SdkMachineIP, SdkVersion, RedisUserPrefix);
}
public void FlushTest()
{
//Arrange
var redisAdapterMock = new Mock <IRedisAdapter>();
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
segmentCache.Flush();
//Assert
redisAdapterMock.Verify(mock => mock.Flush(), Times.Once());
}
private void BuildRedisCache()
{
_redisAdapter = new RedisAdapter(_config.RedisHost, _config.RedisPort, _config.RedisPassword, _config.RedisDatabase, _config.RedisConnectTimeout, _config.RedisConnectRetry, _config.RedisSyncTimeout);
Task.Factory.StartNew(() => _redisAdapter.Connect());
_segmentCache = new RedisSegmentCache(_redisAdapter, _config.RedisUserPrefix);
_splitParser = new RedisSplitParser(_segmentCache);
_splitCache = new RedisSplitCache(_redisAdapter, _splitParser, _config.RedisUserPrefix);
_metricsCache = new RedisMetricsCache(_redisAdapter, _config.SdkMachineIP, _config.SdkVersion, _config.SdkMachineName, _config.RedisUserPrefix);
_trafficTypeValidator = new TrafficTypeValidator(_splitCache);
}
public void IsInSegmentWithInexistentSegmentTest()
{
//Arrange
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SIsMember(segmentKeyPrefix + "test", "abcd")).Returns(false);
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
var result = segmentCache.IsInSegment("test", "abcd");
//Assert
Assert.IsFalse(result);
}
public void RegisterSegmentTest()
{
//Arrange
var segmentName = "test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SAdd(It.IsAny <string>(), It.IsAny <RedisValue[]>())).Returns(1);
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
var result = segmentCache.RegisterSegment(segmentName);
//Assert
Assert.AreEqual(1, result);
}
private void BuildRedisCache()
{
_redisAdapter = new RedisAdapter(_config.RedisHost, _config.RedisPort, _config.RedisPassword, _config.RedisDatabase, _config.RedisConnectTimeout, _config.RedisConnectRetry, _config.RedisSyncTimeout, _config.TlsConfig);
Task.Factory.StartNew(() =>
{
_redisAdapter.Connect();
RecordConfigInit();
});
_segmentCache = new RedisSegmentCache(_redisAdapter, _config.RedisUserPrefix);
_splitParser = new RedisSplitParser(_segmentCache);
_splitCache = new RedisSplitCache(_redisAdapter, _splitParser, _config.RedisUserPrefix);
_trafficTypeValidator = new TrafficTypeValidator(_splitCache);
}
public void IsNotInSegmentOrRedisExceptionTest()
{
//Arrange
var segmentName = "segment_test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SIsMember(segmentKeyPrefix + segmentName, "abcd")).Returns(false);
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
var result = segmentCache.IsInSegment(segmentName, "abcd");
//Assert
Assert.IsFalse(result);
}
public void GetRegisteredSegmentTest()
{
//Arrange
var segmentName = "segment_test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SMembers(segmentsKeyPrefix + "registered")).Returns(new RedisValue[] { segmentName });
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
var result = segmentCache.GetRegisteredSegments();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(segmentName, result[0]);
}
public void GetChangeNumberWhenNotSetOrRedisExceptionTest()
{
//Arrange
var changeNumber = -1;
var segmentName = "segment_test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.Get(segmentNameKeyPrefix.Replace("{segmentname}", segmentName) + "till")).Returns("");
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
var result = segmentCache.GetChangeNumber(segmentName);
//Assert
Assert.AreEqual(changeNumber, result);
}
private void BuildRedisCache()
{
redisAdapter = new RedisAdapter(RedisHost, RedisPort, RedisPassword, RedisDatabase, RedisConnectTimeout, RedisConnectRetry, RedisSyncTimeout);
if (BlockMilisecondsUntilReady > 0 && !redisAdapter.IsConnected())
{
throw new TimeoutException($"SDK was not ready in {BlockMilisecondsUntilReady} miliseconds. Could not connect to Redis");
}
splitCache = new RedisSplitCache(redisAdapter, RedisUserPrefix);
segmentCache = new RedisSegmentCache(redisAdapter, RedisUserPrefix);
metricsCache = new RedisMetricsCache(redisAdapter, SdkMachineIP, SdkVersion, RedisUserPrefix);
impressionsCacheRedis = new RedisImpressionsCache(redisAdapter, SdkMachineIP, SdkVersion, RedisUserPrefix);
eventsCache = new RedisEventsCache(redisAdapter, SdkMachineName, SdkMachineIP, SdkVersion, RedisUserPrefix);
_trafficTypeValidator = new TrafficTypeValidator(_log, splitCache);
}
public void AddToSegmentTest()
{
//Arrange
var segmentName = "test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SAdd(It.IsAny <string>(), It.IsAny <RedisValue[]>())).Returns(1);
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
segmentCache.AddToSegment(segmentName, new List <string>()
{
"test"
});
//Assert
redisAdapterMock.Verify(mock => mock.SAdd(segmentKeyPrefix + segmentName, It.IsAny <RedisValue[]>()));
}
public void SetAndGetChangeNumberTest()
{
//Arrange
var changeNumber = 1234;
var segmentName = "segment_test";
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.Set(segmentNameKeyPrefix.Replace("{segmentname}", segmentName) + "till", changeNumber.ToString())).Returns(true);
redisAdapterMock.Setup(x => x.Get(segmentNameKeyPrefix.Replace("{segmentname}", segmentName) + "till")).Returns(changeNumber.ToString());
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
segmentCache.SetChangeNumber(segmentName, 1234);
var result = segmentCache.GetChangeNumber(segmentName);
//Assert
Assert.AreEqual(1234, result);
}
public void RemoveKeyFromSegmentTest()
{
//Arrange
var segmentName = "segment_test";
var keys = new List <string> {
"abcd"
};
var redisAdapterMock = new Mock <IRedisAdapter>();
redisAdapterMock.Setup(x => x.SRem(segmentKeyPrefix + segmentName, It.IsAny <RedisValue[]>())).Returns(1);
redisAdapterMock.Setup(x => x.SIsMember(segmentKeyPrefix + segmentName, "abcd")).Returns(false);
var segmentCache = new RedisSegmentCache(redisAdapterMock.Object);
//Act
segmentCache.RemoveFromSegment(segmentName, keys);
var result = segmentCache.IsInSegment(segmentName, keys.First());
//Assert
Assert.IsFalse(result);
}
