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());
