UnifiedJedisTDigestCommandsTest.java
package redis.clients.jedis.mocked.unified;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.sameInstance;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.bloom.TDigestMergeParams;
public class UnifiedJedisTDigestCommandsTest extends UnifiedJedisMockedTestBase {
@Test
public void testTdigestAdd() {
String key = "testTDigest";
double[] values = { 1.0, 2.0, 3.0 };
String expectedResponse = "OK";
when(commandObjects.tdigestAdd(key, values)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestAdd(key, values);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestAdd(key, values);
}
@Test
public void testTdigestByRank() {
String key = "testTDigest";
long[] ranks = { 1, 2 };
List<Double> expectedResponse = Arrays.asList(0.1, 0.2);
when(commandObjects.tdigestByRank(key, ranks)).thenReturn(listDoubleCommandObject);
when(commandExecutor.executeCommand(listDoubleCommandObject)).thenReturn(expectedResponse);
List<Double> result = jedis.tdigestByRank(key, ranks);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listDoubleCommandObject);
verify(commandObjects).tdigestByRank(key, ranks);
}
@Test
public void testTdigestByRevRank() {
String key = "testTDigest";
long[] ranks = { 1, 2 };
List<Double> expectedResponse = Arrays.asList(9.9, 9.8);
when(commandObjects.tdigestByRevRank(key, ranks)).thenReturn(listDoubleCommandObject);
when(commandExecutor.executeCommand(listDoubleCommandObject)).thenReturn(expectedResponse);
List<Double> result = jedis.tdigestByRevRank(key, ranks);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listDoubleCommandObject);
verify(commandObjects).tdigestByRevRank(key, ranks);
}
@Test
public void testTdigestCDF() {
String key = "testTDigest";
double[] values = { 0.5, 0.9 };
List<Double> expectedResponse = Arrays.asList(0.1, 0.95);
when(commandObjects.tdigestCDF(key, values)).thenReturn(listDoubleCommandObject);
when(commandExecutor.executeCommand(listDoubleCommandObject)).thenReturn(expectedResponse);
List<Double> result = jedis.tdigestCDF(key, values);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listDoubleCommandObject);
verify(commandObjects).tdigestCDF(key, values);
}
@Test
public void testTdigestCreate() {
String key = "testTDigest";
String expectedResponse = "OK";
when(commandObjects.tdigestCreate(key)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestCreate(key);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestCreate(key);
}
@Test
public void testTdigestCreateWithCompression() {
String key = "testTDigest";
int compression = 100;
String expectedResponse = "OK";
when(commandObjects.tdigestCreate(key, compression)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestCreate(key, compression);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestCreate(key, compression);
}
@Test
public void testTdigestInfo() {
String key = "testTDigest";
Map<String, Object> expectedResponse = new HashMap<>();
expectedResponse.put("compression", 100);
expectedResponse.put("capacity", 1000);
expectedResponse.put("merged_nodes", 500);
expectedResponse.put("unmerged_nodes", 50);
expectedResponse.put("total_compressions", 10);
when(commandObjects.tdigestInfo(key)).thenReturn(mapStringObjectCommandObject);
when(commandExecutor.executeCommand(mapStringObjectCommandObject)).thenReturn(expectedResponse);
Map<String, Object> result = jedis.tdigestInfo(key);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(mapStringObjectCommandObject);
verify(commandObjects).tdigestInfo(key);
}
@Test
public void testTdigestMax() {
String key = "testTDigest";
double expectedResponse = 10.0;
when(commandObjects.tdigestMax(key)).thenReturn(doubleCommandObject);
when(commandExecutor.executeCommand(doubleCommandObject)).thenReturn(expectedResponse);
double result = jedis.tdigestMax(key);
assertThat(result, equalTo(expectedResponse));
verify(commandExecutor).executeCommand(doubleCommandObject);
verify(commandObjects).tdigestMax(key);
}
@Test
public void testTdigestMerge() {
String destinationKey = "destTDigest";
String[] sourceKeys = { "sourceTDigest1", "sourceTDigest2" };
String expectedResponse = "OK";
when(commandObjects.tdigestMerge(destinationKey, sourceKeys)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestMerge(destinationKey, sourceKeys);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestMerge(destinationKey, sourceKeys);
}
@Test
public void testTdigestMergeWithParams() {
TDigestMergeParams mergeParams = new TDigestMergeParams().compression(200);
String destinationKey = "destTDigest";
String[] sourceKeys = { "sourceTDigest1", "sourceTDigest2" };
String expectedResponse = "OK";
when(commandObjects.tdigestMerge(mergeParams, destinationKey, sourceKeys)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestMerge(mergeParams, destinationKey, sourceKeys);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestMerge(mergeParams, destinationKey, sourceKeys);
}
@Test
public void testTdigestMin() {
String key = "testTDigest";
double expectedResponse = 0.1;
when(commandObjects.tdigestMin(key)).thenReturn(doubleCommandObject);
when(commandExecutor.executeCommand(doubleCommandObject)).thenReturn(expectedResponse);
double result = jedis.tdigestMin(key);
assertThat(result, equalTo(expectedResponse));
verify(commandExecutor).executeCommand(doubleCommandObject);
verify(commandObjects).tdigestMin(key);
}
@Test
public void testTdigestQuantile() {
String key = "testTDigest";
double[] quantiles = { 0.1, 0.5, 0.9 };
List<Double> expectedResponse = Arrays.asList(1.0, 2.0, 3.0);
when(commandObjects.tdigestQuantile(key, quantiles)).thenReturn(listDoubleCommandObject);
when(commandExecutor.executeCommand(listDoubleCommandObject)).thenReturn(expectedResponse);
List<Double> result = jedis.tdigestQuantile(key, quantiles);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listDoubleCommandObject);
verify(commandObjects).tdigestQuantile(key, quantiles);
}
@Test
public void testTdigestRank() {
String key = "testTDigest";
double[] values = { 1.0, 2.0 };
List<Long> expectedResponse = Arrays.asList(10L, 20L);
when(commandObjects.tdigestRank(key, values)).thenReturn(listLongCommandObject);
when(commandExecutor.executeCommand(listLongCommandObject)).thenReturn(expectedResponse);
List<Long> result = jedis.tdigestRank(key, values);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listLongCommandObject);
verify(commandObjects).tdigestRank(key, values);
}
@Test
public void testTdigestReset() {
String key = "testTDigest";
String expectedResponse = "OK";
when(commandObjects.tdigestReset(key)).thenReturn(stringCommandObject);
when(commandExecutor.executeCommand(stringCommandObject)).thenReturn(expectedResponse);
String result = jedis.tdigestReset(key);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(stringCommandObject);
verify(commandObjects).tdigestReset(key);
}
@Test
public void testTdigestRevRank() {
String key = "testTDigest";
double[] values = { 1.0, 2.0 };
List<Long> expectedResponse = Arrays.asList(90L, 80L);
when(commandObjects.tdigestRevRank(key, values)).thenReturn(listLongCommandObject);
when(commandExecutor.executeCommand(listLongCommandObject)).thenReturn(expectedResponse);
List<Long> result = jedis.tdigestRevRank(key, values);
assertThat(result, sameInstance(expectedResponse));
verify(commandExecutor).executeCommand(listLongCommandObject);
verify(commandObjects).tdigestRevRank(key, values);
}
@Test
public void testTdigestTrimmedMean() {
String key = "testTDigest";
double lowCutQuantile = 0.1;
double highCutQuantile = 0.9;
double expectedResponse = 5.0;
when(commandObjects.tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile)).thenReturn(doubleCommandObject);
when(commandExecutor.executeCommand(doubleCommandObject)).thenReturn(expectedResponse);
double result = jedis.tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile);
assertThat(result, equalTo(expectedResponse));
verify(commandExecutor).executeCommand(doubleCommandObject);
verify(commandObjects).tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile);
}
}