You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eagle.apache.org by ja...@apache.org on 2018/02/07 07:05:46 UTC
[2/7] eagle git commit: [EAGLE-1080] Fix checkstyle errors in the
eagle-query-base module
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestBucketQuery2.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestBucketQuery2.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestBucketQuery2.java
index 2ecb9d0..e6358fd 100644
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestBucketQuery2.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestBucketQuery2.java
@@ -29,132 +29,132 @@ import java.util.List;
import java.util.Map;
public class TestBucketQuery2 {
- private static class SampleTaggedLogAPIEntity extends TaggedLogAPIEntity{
- private String description;
-
- @SuppressWarnings("unused")
- public String getDescription() {
- return description;
- }
-
- public void setDescription(String description) {
- this.description = description;
- }
- }
-
- @SuppressWarnings("unchecked")
-// @Test
- public void testBucketQuery(){
- SampleTaggedLogAPIEntity e1 = new SampleTaggedLogAPIEntity();
- e1.setTags(new HashMap<String, String>());
- e1.getTags().put("cluster", "cluster1");
- e1.getTags().put("rack", "rack123");
- e1.setDescription("this is description 1");
-
- SampleTaggedLogAPIEntity e2 = new SampleTaggedLogAPIEntity();
- e2.setTags(new HashMap<String, String>());
- e2.getTags().put("cluster", "cluster1");
- e2.getTags().put("rack", "rack123");
- e2.setDescription("this is description 2");
-
- List<String> bucketFields = new ArrayList<String>();
- bucketFields.add("cluster");
- int limit = 1;
-
- BucketQuery query1 = new BucketQuery(bucketFields, limit);
- query1.put(e1);
- query1.put(e2);
-
- Map<String, Object> map = query1.get();
-
- List<TaggedLogAPIEntity> o = (List<TaggedLogAPIEntity>)map.get("cluster1");
- Assert.assertEquals(limit, o.size());
-
- JsonFactory factory = new JsonFactory();
- ObjectMapper mapper = new ObjectMapper(factory);
- try{
- String result = mapper.writeValueAsString(map);
- System.out.println(result);
- }catch(Exception ex){
- ex.printStackTrace();
- Assert.fail("can not serialize bucket query result");
- }
-
- limit = 2;
- BucketQuery query2 = new BucketQuery(bucketFields, limit);
- query2.put(e1);
- query2.put(e2);
- Map<String, Object> map2 = query2.get();
- o = (List<TaggedLogAPIEntity>)map2.get("cluster1");
- try{
- String result = mapper.writeValueAsString(map2);
- System.out.println(result);
- }catch(Exception ex){
- ex.printStackTrace();
- Assert.fail("can not serialize bucket query result");
- }
- Assert.assertEquals(limit, o.size());
-
-
- SampleTaggedLogAPIEntity e3 = new SampleTaggedLogAPIEntity();
- e3.setTags(new HashMap<String, String>());
- e3.getTags().put("cluster", "cluster1");
- e3.getTags().put("rack", "rack124");
- e3.setDescription("this is description 3");
- bucketFields.add("rack");
- limit = 2;
- BucketQuery query3 = new BucketQuery(bucketFields, limit);
- query3.put(e1);
- query3.put(e2);
- query3.put(e3);
- Map<String, Object> map3 = query3.get();
- Map<String, Object> o3 = (Map<String, Object>)map3.get("cluster1");
- List<TaggedLogAPIEntity> o4 = (List<TaggedLogAPIEntity>)o3.get("rack124");
- Assert.assertEquals(1, o4.size());
- List<TaggedLogAPIEntity> o5 = (List<TaggedLogAPIEntity>)o3.get("rack123");
- Assert.assertEquals(o5.size(), 2);
-
- try{
- String result = mapper.writeValueAsString(map3);
- System.out.println(result);
- }catch(Exception ex){
- ex.printStackTrace();
- Assert.fail("can not serialize bucket query result");
- }
-
-
- SampleTaggedLogAPIEntity e4 = new SampleTaggedLogAPIEntity();
- e4.setTags(new HashMap<String, String>());
- e4.getTags().put("cluster", "cluster1");
- // rack is set to null
-// e4.getTags().put("rack", "rack124");
- e4.setDescription("this is description 3");
- limit = 2;
- BucketQuery query4 = new BucketQuery(bucketFields, limit);
- query4.put(e1);
- query4.put(e2);
- query4.put(e3);
- query4.put(e4);
- Map<String, Object> map4 = query4.get();
- Map<String, Object> o6 = (Map<String, Object>)map4.get("cluster1");
- List<TaggedLogAPIEntity> o7 = (List<TaggedLogAPIEntity>)o6.get("rack124");
- Assert.assertEquals(1, o7.size());
- List<TaggedLogAPIEntity> o8 = (List<TaggedLogAPIEntity>)o6.get("rack123");
- Assert.assertEquals(o8.size(), 2);
- List<TaggedLogAPIEntity> o9 = (List<TaggedLogAPIEntity>)o6.get("unassigned");
- Assert.assertEquals(o9.size(), 1);
-
- try{
- String result = mapper.writeValueAsString(map4);
- System.out.println(result);
- }catch(Exception ex){
- ex.printStackTrace();
- Assert.fail("can not serialize bucket query result");
- }
- }
-
- @Test
- public void test() {
-
- }
+ private static class SampleTaggedLogAPIEntity extends TaggedLogAPIEntity {
+ private String description;
+
+ @SuppressWarnings("unused")
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ // @Test
+ public void testBucketQuery() {
+ SampleTaggedLogAPIEntity e1 = new SampleTaggedLogAPIEntity();
+ e1.setTags(new HashMap<String, String>());
+ e1.getTags().put("cluster", "cluster1");
+ e1.getTags().put("rack", "rack123");
+ e1.setDescription("this is description 1");
+
+ SampleTaggedLogAPIEntity e2 = new SampleTaggedLogAPIEntity();
+ e2.setTags(new HashMap<String, String>());
+ e2.getTags().put("cluster", "cluster1");
+ e2.getTags().put("rack", "rack123");
+ e2.setDescription("this is description 2");
+
+ List<String> bucketFields = new ArrayList<String>();
+ bucketFields.add("cluster");
+ int limit = 1;
+
+ BucketQuery query1 = new BucketQuery(bucketFields, limit);
+ query1.put(e1);
+ query1.put(e2);
+
+ Map<String, Object> map = query1.get();
+
+ List<TaggedLogAPIEntity> o = (List<TaggedLogAPIEntity>)map.get("cluster1");
+ Assert.assertEquals(limit, o.size());
+
+ JsonFactory factory = new JsonFactory();
+ ObjectMapper mapper = new ObjectMapper(factory);
+ try {
+ String result = mapper.writeValueAsString(map);
+ System.out.println(result);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ Assert.fail("can not serialize bucket query result");
+ }
+
+ limit = 2;
+ BucketQuery query2 = new BucketQuery(bucketFields, limit);
+ query2.put(e1);
+ query2.put(e2);
+ Map<String, Object> map2 = query2.get();
+ o = (List<TaggedLogAPIEntity>)map2.get("cluster1");
+ try {
+ String result = mapper.writeValueAsString(map2);
+ System.out.println(result);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ Assert.fail("can not serialize bucket query result");
+ }
+ Assert.assertEquals(limit, o.size());
+
+
+ SampleTaggedLogAPIEntity e3 = new SampleTaggedLogAPIEntity();
+ e3.setTags(new HashMap<String, String>());
+ e3.getTags().put("cluster", "cluster1");
+ e3.getTags().put("rack", "rack124");
+ e3.setDescription("this is description 3");
+ bucketFields.add("rack");
+ limit = 2;
+ BucketQuery query3 = new BucketQuery(bucketFields, limit);
+ query3.put(e1);
+ query3.put(e2);
+ query3.put(e3);
+ Map<String, Object> map3 = query3.get();
+ Map<String, Object> o3 = (Map<String, Object>)map3.get("cluster1");
+ List<TaggedLogAPIEntity> o4 = (List<TaggedLogAPIEntity>)o3.get("rack124");
+ Assert.assertEquals(1, o4.size());
+ List<TaggedLogAPIEntity> o5 = (List<TaggedLogAPIEntity>)o3.get("rack123");
+ Assert.assertEquals(o5.size(), 2);
+
+ try {
+ String result = mapper.writeValueAsString(map3);
+ System.out.println(result);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ Assert.fail("can not serialize bucket query result");
+ }
+
+
+ SampleTaggedLogAPIEntity e4 = new SampleTaggedLogAPIEntity();
+ e4.setTags(new HashMap<String, String>());
+ e4.getTags().put("cluster", "cluster1");
+ // rack is set to null
+ // e4.getTags().put("rack", "rack124");
+ e4.setDescription("this is description 3");
+ limit = 2;
+ BucketQuery query4 = new BucketQuery(bucketFields, limit);
+ query4.put(e1);
+ query4.put(e2);
+ query4.put(e3);
+ query4.put(e4);
+ Map<String, Object> map4 = query4.get();
+ Map<String, Object> o6 = (Map<String, Object>)map4.get("cluster1");
+ List<TaggedLogAPIEntity> o7 = (List<TaggedLogAPIEntity>)o6.get("rack124");
+ Assert.assertEquals(1, o7.size());
+ List<TaggedLogAPIEntity> o8 = (List<TaggedLogAPIEntity>)o6.get("rack123");
+ Assert.assertEquals(o8.size(), 2);
+ List<TaggedLogAPIEntity> o9 = (List<TaggedLogAPIEntity>)o6.get("unassigned");
+ Assert.assertEquals(o9.size(), 1);
+
+ try {
+ String result = mapper.writeValueAsString(map4);
+ System.out.println(result);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ Assert.fail("can not serialize bucket query result");
+ }
+ }
+
+ @Test
+ public void test() {
+
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestFlatAggregator.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestFlatAggregator.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestFlatAggregator.java
index b6b9439..037e26c 100755
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestFlatAggregator.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestFlatAggregator.java
@@ -32,368 +32,382 @@ import org.slf4j.LoggerFactory;
import org.apache.eagle.log.entity.test.TestEntity;
public class TestFlatAggregator {
- private static final Logger LOG = LoggerFactory.getLogger(TestFlatAggregator.class);
- @Test
- public void testCounting(){
-
- }
-
- @Test
- public void testSummary(){
-
- }
-
- @Test
- public void testAverage(){
-
- }
-
- @Test
- public void testIterativeAggregation(){
-
- }
-
- @SuppressWarnings("serial")
- private TestEntity createEntity(final String cluster, final String datacenter, final String rack, int numHosts, long numClusters){
- TestEntity entity = new TestEntity();
- Map<String, String> tags = new HashMap<String, String>(){{
- put("cluster", cluster);
- put("datacenter", datacenter);
- put("rack", rack);
- }};
- entity.setTags(tags);
- entity.setNumHosts(numHosts);
- entity.setNumClusters(numClusters);
- return entity;
- }
-
- @Test
- public void testZeroGroupbyFieldSingleFunctionForSummary(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
-
- FlatAggregator agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 1);
- Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+
- entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 1);
- Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+
- entities[2].getNumClusters()+entities[3].getNumClusters()+entities[4].getNumClusters()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 1);
- Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(5), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testSingleGroupbyFieldSingleFunctionForSummary(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc2", "rack126", 15, 2);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts())+entities[3].getNumHosts(), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(entities[4].getNumHosts()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumClusters()+entities[4].getNumClusters()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters())+entities[3].getNumClusters(), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(entities[4].getNumClusters()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
-
- @Test
- public void testSingleGroupbyFieldSingleFunctionForCount(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc2", "rack126", 15, 2);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0), (double)(3), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(2), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(4), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(1), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testMultipleFieldsSingleFunctionForSummary(){
- TestEntity[] entities = new TestEntity[6];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- entities[5] = createEntity("cluster2", null, "rack126", 1, 3);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(3, result.size());
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1")).get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned")).get(0), (double)(entities[5].getNumHosts()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("cluster", "datacenter", "rack"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(5, result.size());
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack123")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack128")).get(0), (double)(entities[2].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack125")).get(0), (double)(entities[3].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack126")).get(0), (double)(entities[4].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned", "rack126")).get(0), (double)(entities[5].getNumHosts()), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testMultipleFieldsSingleFunctionForCount(){
- TestEntity[] entities = new TestEntity[6];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- entities[5] = createEntity("cluster2", null, "rack126", 1, 3);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(3, result.size());
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1")).get(0), (double)(3), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1")).get(0), (double)(2), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned")).get(0), (double)(1), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("cluster", "datacenter", "rack"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(5, result.size());
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack123")).get(0), (double)(2), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack128")).get(0), (double)(1), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack125")).get(0), (double)(1), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack126")).get(0), (double)(1), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned", "rack126")).get(0), (double)(1), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testSingleGroupbyFieldMultipleFunctions(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.count),
- Arrays.asList("numHosts", "*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 2);
- Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(1), (double)(3), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(1), (double)(2), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count, AggregateFunctionType.sum), Arrays.asList("*", "numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 1);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(5), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(1), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts())+entities[4].getNumHosts(), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count, AggregateFunctionType.sum, AggregateFunctionType.sum),
- Arrays.asList("*", "numHosts", "numClusters"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 1);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(5), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(1), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts())+entities[4].getNumHosts(), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("dc1")).get(2), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()+entities[3].getNumClusters())+entities[4].getNumClusters(), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testMultipleGroupbyFieldsMultipleFunctions(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
-
- FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "rack"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.count),
- Arrays.asList("numHosts", "*"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- Map<List<String>, List<Double>> result = agg.result();
- Assert.assertEquals(result.size(), 4);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack123")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack123")).get(1), (double)(2), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack128")).get(0), (double)(entities[2].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack128")).get(1), (double)(1), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack125")).get(0), (double)(entities[3].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack125")).get(1), (double)(1), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack126")).get(0), (double)(entities[4].getNumHosts()), 0.001);
- Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack126")).get(1), (double)(1), 0.001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
+ private static final Logger LOG = LoggerFactory.getLogger(TestFlatAggregator.class);
+ @Test
+ public void testCounting() {
+
+ }
+
+ @Test
+ public void testSummary() {
+
+ }
+
+ @Test
+ public void testAverage() {
+
+ }
+
+ @Test
+ public void testIterativeAggregation() {
+
+ }
+
+ @SuppressWarnings("serial")
+ private TestEntity createEntity(final String cluster, final String datacenter, final String rack, int numHosts, long numClusters) {
+ TestEntity entity = new TestEntity();
+ Map<String, String> tags = new HashMap<String, String>() {{
+ put("cluster", cluster);
+ put("datacenter", datacenter);
+ put("rack", rack);
+ }};
+ entity.setTags(tags);
+ entity.setNumHosts(numHosts);
+ entity.setNumClusters(numClusters);
+ return entity;
+ }
+
+ @Test
+ public void testZeroGroupbyFieldSingleFunctionForSummary() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+
+ FlatAggregator agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(entities[0].getNumHosts() + entities[1].getNumHosts()+
+ entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(entities[0].getNumClusters() + entities[1].getNumClusters() +
+ entities[2].getNumClusters() + entities[3].getNumClusters() + entities[4].getNumClusters()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(new ArrayList<String>()).get(0), (double)(5), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testSingleGroupbyFieldSingleFunctionForSummary() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc2", "rack126", 15, 2);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumHosts() + entities[4].getNumHosts()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()) + entities[3].getNumHosts(), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(entities[4].getNumHosts()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0),
+ (double)(entities[0].getNumClusters() + entities[1].getNumClusters() + entities[2].getNumClusters()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumClusters() + entities[4].getNumClusters()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numClusters"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0),
+ (double)(entities[0].getNumClusters() + entities[1].getNumClusters() + entities[2].getNumClusters()) + entities[3].getNumClusters(), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(entities[4].getNumClusters()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+
+ @Test
+ public void testSingleGroupbyFieldSingleFunctionForCount() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc2", "rack126", 15, 2);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0), (double)(3), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(2), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(4), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc2")).get(0), (double)(1), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testMultipleFieldsSingleFunctionForSummary() {
+ TestEntity[] entities = new TestEntity[6];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ entities[5] = createEntity("cluster2", null, "rack126", 1, 3);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(3, result.size());
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1")).get(0),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1")).get(0), (double)(entities[3].getNumHosts() + entities[4].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned")).get(0), (double)(entities[5].getNumHosts()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("cluster", "datacenter", "rack"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(5, result.size());
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack123")).get(0),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack128")).get(0), (double)(entities[2].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack125")).get(0), (double)(entities[3].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack126")).get(0), (double)(entities[4].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned", "rack126")).get(0), (double)(entities[5].getNumHosts()), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testMultipleFieldsSingleFunctionForCount() {
+ TestEntity[] entities = new TestEntity[6];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ entities[5] = createEntity("cluster2", null, "rack126", 1, 3);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(3, result.size());
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1")).get(0), (double)(3), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1")).get(0), (double)(2), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned")).get(0), (double)(1), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("cluster", "datacenter", "rack"), Arrays.asList(AggregateFunctionType.count), Arrays.asList("*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(5, result.size());
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack123")).get(0), (double)(2), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "dc1", "rack128")).get(0), (double)(1), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack125")).get(0), (double)(1), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "dc1", "rack126")).get(0), (double)(1), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "unassigned", "rack126")).get(0), (double)(1), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testSingleGroupbyFieldMultipleFunctions() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.count),
+ Arrays.asList("numHosts", "*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 2);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(0),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1")).get(1), (double)(3), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(0), (double)(entities[3].getNumHosts() + entities[4].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2")).get(1), (double)(2), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count, AggregateFunctionType.sum),
+ Arrays.asList("*", "numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(5), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(1),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()
+ + entities[3].getNumHosts()) + entities[4].getNumHosts(), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new FlatAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.count, AggregateFunctionType.sum, AggregateFunctionType.sum),
+ Arrays.asList("*", "numHosts", "numClusters"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(0), (double)(5), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(1),
+ (double)(entities[0].getNumHosts() + entities[1].getNumHosts() + entities[2].getNumHosts()
+ + entities[3].getNumHosts()) + entities[4].getNumHosts(), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("dc1")).get(2),
+ (double)(entities[0].getNumClusters() + entities[1].getNumClusters() + entities[2].getNumClusters()
+ + entities[3].getNumClusters()) + entities[4].getNumClusters(), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testMultipleGroupbyFieldsMultipleFunctions() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+
+ FlatAggregator agg = new FlatAggregator(Arrays.asList("cluster", "rack"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.count),
+ Arrays.asList("numHosts", "*"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ Map<List<String>, List<Double>> result = agg.result();
+ Assert.assertEquals(result.size(), 4);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack123")).get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack123")).get(1), (double)(2), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack128")).get(0), (double)(entities[2].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster1", "rack128")).get(1), (double)(1), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack125")).get(0), (double)(entities[3].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack125")).get(1), (double)(1), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack126")).get(0), (double)(entities[4].getNumHosts()), 0.001);
+ Assert.assertEquals(result.get(Arrays.asList("cluster2", "rack126")).get(1), (double)(1), 0.001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestGroupbyFieldComparator.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestGroupbyFieldComparator.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestGroupbyFieldComparator.java
index 5fec950..2643d98 100644
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestGroupbyFieldComparator.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestGroupbyFieldComparator.java
@@ -24,12 +24,13 @@ import org.junit.Test;
public class TestGroupbyFieldComparator {
- @Test
- public void testStringListCompare(){
- GroupbyFieldsComparator c = new GroupbyFieldsComparator();
- Assert.assertTrue(c.compare(Arrays.asList("ab"), Arrays.asList("ac"))<0);
- Assert.assertTrue(c.compare(Arrays.asList("xy"), Arrays.asList("cd"))>0);
- Assert.assertTrue(c.compare(Arrays.asList("xy"), Arrays.asList("xy"))==0);
- Assert.assertTrue(c.compare(Arrays.asList("xy", "ab"), Arrays.asList("xy", "ac"))<0);
- }
+
+ @Test
+ public void testStringListCompare() {
+ GroupbyFieldsComparator c = new GroupbyFieldsComparator();
+ Assert.assertTrue(c.compare(Arrays.asList("ab"), Arrays.asList("ac")) < 0);
+ Assert.assertTrue(c.compare(Arrays.asList("xy"), Arrays.asList("cd")) > 0);
+ Assert.assertTrue(c.compare(Arrays.asList("xy"), Arrays.asList("xy")) == 0);
+ Assert.assertTrue(c.compare(Arrays.asList("xy", "ab"), Arrays.asList("xy", "ac")) < 0);
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestHierarchicalAggregator.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestHierarchicalAggregator.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestHierarchicalAggregator.java
index b6c9212..56f70e7 100755
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestHierarchicalAggregator.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestHierarchicalAggregator.java
@@ -40,292 +40,292 @@ import org.apache.eagle.log.entity.test.TestEntity;
public class TestHierarchicalAggregator {
-private final static Logger LOG = LoggerFactory.getLogger(TestHierarchicalAggregator.class);
+ private static final Logger LOG = LoggerFactory.getLogger(TestHierarchicalAggregator.class);
- @SuppressWarnings("serial")
- private TestEntity createEntity(final String cluster, final String datacenter, final String rack, int numHosts, long numClusters){
- TestEntity entity = new TestEntity();
- Map<String, String> tags = new HashMap<String, String>(){{
- put("cluster", cluster);
- put("datacenter", datacenter);
- put("rack", rack);
- }};
- entity.setTags(tags);
- entity.setNumHosts(numHosts);
- entity.setNumClusters(numClusters);
- return entity;
- }
-
- @SuppressWarnings("serial")
- private TestEntity createEntityWithoutDatacenter(final String cluster, final String rack, int numHosts, long numClusters){
- TestEntity entity = new TestEntity();
- Map<String, String> tags = new HashMap<String, String>(){{
- put("cluster", cluster);
- put("rack", rack);
- }};
- entity.setTags(tags);
- entity.setNumHosts(numHosts);
- entity.setNumClusters(numClusters);
- return entity;
- }
+ @SuppressWarnings("serial")
+ private TestEntity createEntity(final String cluster, final String datacenter, final String rack, int numHosts, long numClusters) {
+ TestEntity entity = new TestEntity();
+ Map<String, String> tags = new HashMap<String, String>() {{
+ put("cluster", cluster);
+ put("datacenter", datacenter);
+ put("rack", rack);
+ }};
+ entity.setTags(tags);
+ entity.setNumHosts(numHosts);
+ entity.setNumClusters(numClusters);
+ return entity;
+ }
- private void writeToJson(String message, Object obj){
- JsonFactory factory = new JsonFactory();
- ObjectMapper mapper = new ObjectMapper(factory);
- try{
- String result = mapper.writeValueAsString(obj);
- LOG.info(message + ":\n" + result);
- }catch(Exception ex){
- LOG.error("Can not write json", ex);
- Assert.fail("Can not write json");
- }
- }
-
- @Test
- public void testZeroGropubyFieldHierarchicalAggregator(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- HierarchicalAggregator agg = new HierarchicalAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate", result);
- Assert.assertEquals(result.getChildren().size(), 0);
- Assert.assertEquals(result.getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ @SuppressWarnings("serial")
+ private TestEntity createEntityWithoutDatacenter(final String cluster, final String rack, int numHosts, long numClusters) {
+ TestEntity entity = new TestEntity();
+ Map<String, String> tags = new HashMap<String, String>() {{
+ put("cluster", cluster);
+ put("rack", rack);
+ }};
+ entity.setTags(tags);
+ entity.setNumHosts(numHosts);
+ entity.setNumClusters(numClusters);
+ return entity;
+ }
- // test sort by function1
- SortOption so = new SortOption();
- so.setIndex(0);
- so.setAscendant(true);
- List<SortOption> sortOptions = Arrays.asList(so);
- PostHierarchicalAggregateSort.sort(result, sortOptions);
- writeToJson("After sort" ,result);
- Assert.assertEquals(null, result.getChildren());
- Assert.assertEquals(0, result.getSortedList().size());
- Assert.assertEquals(result.getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testSingleGropubyFieldHierarchicalAggregator(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc2", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate" ,result);
- Assert.assertEquals(result.getChildren().size(), 2);
- Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
-
- // test sort by function 1
- SortOption so = new SortOption();
- so.setIndex(0);
- so.setAscendant(true);
- List<SortOption> sortOptions = Arrays.asList(so);
- PostHierarchicalAggregateSort.sort(result, sortOptions);
- writeToJson("After sort" ,result);
- Assert.assertEquals(null, result.getChildren());
- Assert.assertEquals(2, result.getSortedList().size(), 2);
- Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
- Assert.assertEquals(true, it.hasNext());
- Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
- Assert.assertEquals("cluster2", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
-
- Assert.assertEquals(true, it.hasNext());
- entry = it.next();
- Assert.assertEquals("cluster1", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new HierarchicalAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate" , result);
- Assert.assertEquals(result.getChildren().size(), 2);
- Assert.assertEquals(result.getChildren().get("dc1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("dc2").getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
-
- // test sort by function 1
- SortOption so = new SortOption();
- so.setIndex(0);
- so.setAscendant(true);
- List<SortOption> sortOptions = Arrays.asList(so);
- PostHierarchicalAggregateSort.sort(result, sortOptions);
- writeToJson("After sort" ,result);
- Assert.assertEquals(null, result.getChildren());
- Assert.assertEquals(2, result.getSortedList().size(), 2);
- Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
- Assert.assertEquals(true, it.hasNext());
- Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
- Assert.assertEquals("dc2", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
-
- Assert.assertEquals(true, it.hasNext());
- entry = it.next();
- Assert.assertEquals("dc1", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new HierarchicalAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.sum), Arrays.asList("numHosts", "numClusters"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate" , result);
- Assert.assertEquals(result.getChildren().size(), 2);
- Assert.assertEquals(2, result.getChildren().get("cluster1").getValues().size());
- Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(1), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()), 0.0001);
- Assert.assertEquals(2, result.getChildren().get("cluster2").getValues().size());
- Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(1), (double)(entities[3].getNumClusters()+entities[4].getNumClusters()), 0.0001);
-
- // test sort by function 2
- SortOption so = new SortOption();
- so.setIndex(1);
- so.setAscendant(true);
- List<SortOption> sortOptions = Arrays.asList(so);
- PostHierarchicalAggregateSort.sort(result, sortOptions);
- writeToJson("After sort" ,result);
- Assert.assertEquals(null, result.getChildren());
- Assert.assertEquals(2, result.getSortedList().size(), 2);
- Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
- Assert.assertEquals(true, it.hasNext());
- Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
- Assert.assertEquals("cluster1", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(1), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()), 0.0001);
-
- Assert.assertEquals(true, it.hasNext());
- entry = it.next();
- Assert.assertEquals("cluster2", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(1), (double)(entities[3].getNumClusters()+entities[4].getNumClusters()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
-
- @Test
- public void testMultipleGropubyFieldsHierarchicalAggregator(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc2", "rack128", 10, 0);
- entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate", result);
- Assert.assertEquals(2, result.getChildren().size());
- Assert.assertEquals(66.0, (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- Assert.assertEquals(2, result.getChildren().get("cluster1").getChildren().size());
- Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc2").getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
-
- Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
- Assert.assertEquals(1, result.getChildren().get("cluster2").getChildren().size());
- Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("dc1").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
-
- // test sort by function 2
- SortOption so = new SortOption();
- so.setIndex(0);
- so.setAscendant(true);
- List<SortOption> sortOptions = Arrays.asList(so);
- PostHierarchicalAggregateSort.sort(result, sortOptions);
- writeToJson("After sort" ,result);
- Assert.assertEquals(null, result.getChildren());
- Assert.assertEquals(2, result.getSortedList().size());
- Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
- Assert.assertEquals(true, it.hasNext());
- Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
- Assert.assertEquals("cluster2", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
-
- Assert.assertEquals(true, it.hasNext());
- entry = it.next();
- Assert.assertEquals("cluster1", entry.getKey());
- Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
-
- @Test
- public void testUnassigned(){
- TestEntity[] entities = new TestEntity[5];
- entities[0] = createEntityWithoutDatacenter("cluster1", "rack123", 12, 2);
- entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
- entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
- entities[3] = createEntityWithoutDatacenter("cluster2", "rack125", 9, 2);
- entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
- HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate", result);
- Assert.assertEquals(result.getChildren().size(), 2);
- Assert.assertEquals(result.getChildren().get("dc1").getValues().get(0), (double)(entities[1].getNumHosts()+entities[2].getNumHosts())+entities[4].getNumHosts(), 0.0001);
- Assert.assertEquals(result.getChildren().get("unassigned").getValues().get(0), (double)(entities[0].getNumHosts()+entities[3].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
-
- agg = new HierarchicalAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
- try{
- for(TestEntity e : entities){
- agg.accumulate(e);
- }
- HierarchicalAggregateEntity result = agg.result();
- writeToJson("After aggregate", result);
- Assert.assertEquals(result.getChildren().size(), 2);
- Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- Assert.assertEquals(2, result.getChildren().get("cluster1").getChildren().size());
- Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc1").getValues().get(0), (double)(entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("unassigned").getValues().get(0), (double)(entities[0].getNumHosts()), 0.0001);
-
- Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("dc1").getValues().get(0), (double)(entities[4].getNumHosts()), 0.0001);
- Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("unassigned").getValues().get(0), (double)(entities[3].getNumHosts()), 0.0001);
- }catch(Exception ex){
- LOG.error("Can not aggregate", ex);
- Assert.fail("Can not aggregate");
- }
- }
+ private void writeToJson(String message, Object obj) {
+ JsonFactory factory = new JsonFactory();
+ ObjectMapper mapper = new ObjectMapper(factory);
+ try {
+ String result = mapper.writeValueAsString(obj);
+ LOG.info(message + ":\n" + result);
+ } catch (Exception ex) {
+ LOG.error("Can not write json", ex);
+ Assert.fail("Can not write json");
+ }
+ }
+
+ @Test
+ public void testZeroGropubyFieldHierarchicalAggregator() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ HierarchicalAggregator agg = new HierarchicalAggregator(new ArrayList<String>(), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate", result);
+ Assert.assertEquals(result.getChildren().size(), 0);
+ Assert.assertEquals(result.getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+
+ // test sort by function1
+ SortOption so = new SortOption();
+ so.setIndex(0);
+ so.setAscendant(true);
+ List<SortOption> sortOptions = Arrays.asList(so);
+ PostHierarchicalAggregateSort.sort(result, sortOptions);
+ writeToJson("After sort" ,result);
+ Assert.assertEquals(null, result.getChildren());
+ Assert.assertEquals(0, result.getSortedList().size());
+ Assert.assertEquals(result.getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testSingleGropubyFieldHierarchicalAggregator() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc2", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate" ,result);
+ Assert.assertEquals(result.getChildren().size(), 2);
+ Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+
+ // test sort by function 1
+ SortOption so = new SortOption();
+ so.setIndex(0);
+ so.setAscendant(true);
+ List<SortOption> sortOptions = Arrays.asList(so);
+ PostHierarchicalAggregateSort.sort(result, sortOptions);
+ writeToJson("After sort" ,result);
+ Assert.assertEquals(null, result.getChildren());
+ Assert.assertEquals(2, result.getSortedList().size(), 2);
+ Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
+ Assert.assertEquals(true, it.hasNext());
+ Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
+ Assert.assertEquals("cluster2", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+
+ Assert.assertEquals(true, it.hasNext());
+ entry = it.next();
+ Assert.assertEquals("cluster1", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new HierarchicalAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate" , result);
+ Assert.assertEquals(result.getChildren().size(), 2);
+ Assert.assertEquals(result.getChildren().get("dc1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("dc2").getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
+
+ // test sort by function 1
+ SortOption so = new SortOption();
+ so.setIndex(0);
+ so.setAscendant(true);
+ List<SortOption> sortOptions = Arrays.asList(so);
+ PostHierarchicalAggregateSort.sort(result, sortOptions);
+ writeToJson("After sort" ,result);
+ Assert.assertEquals(null, result.getChildren());
+ Assert.assertEquals(2, result.getSortedList().size(), 2);
+ Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
+ Assert.assertEquals(true, it.hasNext());
+ Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
+ Assert.assertEquals("dc2", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
+
+ Assert.assertEquals(true, it.hasNext());
+ entry = it.next();
+ Assert.assertEquals("dc1", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new HierarchicalAggregator(Arrays.asList("cluster"), Arrays.asList(AggregateFunctionType.sum, AggregateFunctionType.sum), Arrays.asList("numHosts", "numClusters"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate" , result);
+ Assert.assertEquals(result.getChildren().size(), 2);
+ Assert.assertEquals(2, result.getChildren().get("cluster1").getValues().size());
+ Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(1), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()), 0.0001);
+ Assert.assertEquals(2, result.getChildren().get("cluster2").getValues().size());
+ Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(1), (double)(entities[3].getNumClusters()+entities[4].getNumClusters()), 0.0001);
+
+ // test sort by function 2
+ SortOption so = new SortOption();
+ so.setIndex(1);
+ so.setAscendant(true);
+ List<SortOption> sortOptions = Arrays.asList(so);
+ PostHierarchicalAggregateSort.sort(result, sortOptions);
+ writeToJson("After sort" ,result);
+ Assert.assertEquals(null, result.getChildren());
+ Assert.assertEquals(2, result.getSortedList().size(), 2);
+ Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
+ Assert.assertEquals(true, it.hasNext());
+ Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
+ Assert.assertEquals("cluster1", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(1), (double)(entities[0].getNumClusters()+entities[1].getNumClusters()+entities[2].getNumClusters()), 0.0001);
+
+ Assert.assertEquals(true, it.hasNext());
+ entry = it.next();
+ Assert.assertEquals("cluster2", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(1), (double)(entities[3].getNumClusters()+entities[4].getNumClusters()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+
+ @Test
+ public void testMultipleGropubyFieldsHierarchicalAggregator() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntity("cluster1", "dc1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc2", "rack128", 10, 0);
+ entities[3] = createEntity("cluster2", "dc1", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate", result);
+ Assert.assertEquals(2, result.getChildren().size());
+ Assert.assertEquals(66.0, (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()+entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ Assert.assertEquals(2, result.getChildren().get("cluster1").getChildren().size());
+ Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc2").getValues().get(0), (double)(entities[2].getNumHosts()), 0.0001);
+
+ Assert.assertEquals(result.getChildren().get("cluster2").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+ Assert.assertEquals(1, result.getChildren().get("cluster2").getChildren().size());
+ Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("dc1").getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+
+ // test sort by function 2
+ SortOption so = new SortOption();
+ so.setIndex(0);
+ so.setAscendant(true);
+ List<SortOption> sortOptions = Arrays.asList(so);
+ PostHierarchicalAggregateSort.sort(result, sortOptions);
+ writeToJson("After sort" ,result);
+ Assert.assertEquals(null, result.getChildren());
+ Assert.assertEquals(2, result.getSortedList().size());
+ Iterator<Map.Entry<String, HierarchicalAggregateEntity>> it = result.getSortedList().iterator();
+ Assert.assertEquals(true, it.hasNext());
+ Map.Entry<String, HierarchicalAggregateEntity> entry = it.next();
+ Assert.assertEquals("cluster2", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[3].getNumHosts()+entities[4].getNumHosts()), 0.0001);
+
+ Assert.assertEquals(true, it.hasNext());
+ entry = it.next();
+ Assert.assertEquals("cluster1", entry.getKey());
+ Assert.assertEquals(entry.getValue().getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
+
+ @Test
+ public void testUnassigned() {
+ TestEntity[] entities = new TestEntity[5];
+ entities[0] = createEntityWithoutDatacenter("cluster1", "rack123", 12, 2);
+ entities[1] = createEntity("cluster1", "dc1", "rack123", 20, 1);
+ entities[2] = createEntity("cluster1", "dc1", "rack128", 10, 0);
+ entities[3] = createEntityWithoutDatacenter("cluster2", "rack125", 9, 2);
+ entities[4] = createEntity("cluster2", "dc1", "rack126", 15, 2);
+ HierarchicalAggregator agg = new HierarchicalAggregator(Arrays.asList("datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate", result);
+ Assert.assertEquals(result.getChildren().size(), 2);
+ Assert.assertEquals(result.getChildren().get("dc1").getValues().get(0), (double)(entities[1].getNumHosts()+entities[2].getNumHosts())+entities[4].getNumHosts(), 0.0001);
+ Assert.assertEquals(result.getChildren().get("unassigned").getValues().get(0), (double)(entities[0].getNumHosts()+entities[3].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+
+ agg = new HierarchicalAggregator(Arrays.asList("cluster", "datacenter"), Arrays.asList(AggregateFunctionType.sum), Arrays.asList("numHosts"));
+ try {
+ for (TestEntity e : entities) {
+ agg.accumulate(e);
+ }
+ HierarchicalAggregateEntity result = agg.result();
+ writeToJson("After aggregate", result);
+ Assert.assertEquals(result.getChildren().size(), 2);
+ Assert.assertEquals(result.getChildren().get("cluster1").getValues().get(0), (double)(entities[0].getNumHosts()+entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ Assert.assertEquals(2, result.getChildren().get("cluster1").getChildren().size());
+ Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("dc1").getValues().get(0), (double)(entities[1].getNumHosts()+entities[2].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster1").getChildren().get("unassigned").getValues().get(0), (double)(entities[0].getNumHosts()), 0.0001);
+
+ Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("dc1").getValues().get(0), (double)(entities[4].getNumHosts()), 0.0001);
+ Assert.assertEquals(result.getChildren().get("cluster2").getChildren().get("unassigned").getValues().get(0), (double)(entities[3].getNumHosts()), 0.0001);
+ } catch (Exception ex) {
+ LOG.error("Can not aggregate", ex);
+ Assert.fail("Can not aggregate");
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestListQueryCompiler.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestListQueryCompiler.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestListQueryCompiler.java
index 10f96dc..016f77e 100644
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestListQueryCompiler.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/test/TestListQueryCompiler.java
@@ -19,24 +19,24 @@
package org.apache.eagle.query.aggregate.test;
import org.apache.eagle.query.ListQueryCompiler;
-import org.apache.eagle.query.parser.EagleQueryParseException;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TestListQueryCompiler {
- private final static Logger LOG = LoggerFactory.getLogger(TestListQueryCompiler.class);
+ private static final Logger LOG = LoggerFactory.getLogger(TestListQueryCompiler.class);
+
@Test
public void test() throws Exception {
try {
- String queryWithCondition = "TestTimeSeriesAPIEntity[@site=\"test\"]{*}";
- ListQueryCompiler compiler = new ListQueryCompiler(queryWithCondition);
- String queryWithSquareBrackets = "TestTimeSeriesAPIEntity[@condition=\"[A9BB756BFB8] Data[site=2]/(4/5)\"]{*}";
+ String queryWithCondition = "TestTimeSeriesAPIEntity[@site =\"test\"]{*}";
+ new ListQueryCompiler(queryWithCondition);
+ String queryWithSquareBrackets = "TestTimeSeriesAPIEntity[@condition =\"[A9BB756BFB8] Data[site= 2]/(4/5)\"]{*}";
new ListQueryCompiler(queryWithSquareBrackets);
String queryWithoutCondition = "TestTimeSeriesAPIEntity[]{*}";
new ListQueryCompiler(queryWithoutCondition);
- String query = "TestTimeSeriesAPIEntity[@condition=\"[A9BB756BFB8]{4/5}\"]{*}";
+ String query = "TestTimeSeriesAPIEntity[@condition =\"[A9BB756BFB8]{4/5}\"]{*}";
new ListQueryCompiler(query);
} catch (IllegalArgumentException e) {
LOG.error(e.getMessage());