metron-analytics/metron-profiler-client/src/test/java/org/apache/metron/profiler/client/HBaseProfilerClientTest.java - metron - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you under the Apache License, Version 2.0 (the
  *  "License"); you may not use this file except in compliance
  *  with the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package org.apache.metron.profiler.client;

 import org.apache.metron.hbase.mock.MockHBaseTableProvider;
 import org.apache.metron.hbase.mock.MockHTable;
 import org.apache.metron.profiler.ProfileMeasurement;
 import org.apache.metron.profiler.hbase.ColumnBuilder;
 import org.apache.metron.profiler.hbase.RowKeyBuilder;
 import org.apache.metron.profiler.hbase.SaltyRowKeyBuilder;
 import org.apache.metron.profiler.hbase.ValueOnlyColumnBuilder;
 import org.apache.metron.stellar.common.DefaultStellarStatefulExecutor;
 import org.apache.metron.stellar.common.StellarStatefulExecutor;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;

 import static org.junit.jupiter.api.Assertions.assertEquals;

 /**
  * Tests the HBaseProfilerClient.
  *
  * The naming used in this test attempts to be as similar to how the 'groupBy'
  * functionality might be used 'in the wild'.  This test involves reading and
  * writing two separate groups originating from the same Profile and Entity.
  * There is a 'weekdays' group which contains all measurements taken on weekdays.
  * There is also a 'weekend' group which contains all measurements taken on weekends.
  */
 public class HBaseProfilerClientTest {

   private static final String tableName = "profiler";
   private static final String columnFamily = "P";
   private static final long periodDuration = 15;
   private static final TimeUnit periodUnits = TimeUnit.MINUTES;
   private static final int periodsPerHour = 4;

   private HBaseProfilerClient client;
   private StellarStatefulExecutor executor;
   private MockHBaseTableProvider provider;
   private ProfileWriter profileWriter;

   @BeforeEach
   public void setup() {
     provider = new MockHBaseTableProvider();
     executor = new DefaultStellarStatefulExecutor();
     MockHBaseTableProvider.addToCache(tableName, columnFamily);

     // writes values to be read during testing
     long periodDurationMillis = periodUnits.toMillis(periodDuration);
     RowKeyBuilder rowKeyBuilder = new SaltyRowKeyBuilder();
     ColumnBuilder columnBuilder = new ValueOnlyColumnBuilder(columnFamily);
     profileWriter = new ProfileWriter(rowKeyBuilder, columnBuilder, provider, periodDurationMillis,
         tableName, null);

     client = new HBaseProfilerClient(provider, rowKeyBuilder, columnBuilder, periodDurationMillis,
         tableName, null);
   }

   @AfterEach
   public void tearDown() throws Exception {
     ((MockHTable) provider.getTable(null, tableName)).clear();
   }

   @Test
   public void Should_ReturnMeasurements_When_DataExistsForAGroup() {
     final String profile = "profile1";
     final String entity = "entity1";
     final int expectedValue = 2302;
     final int hours = 2;
     final int count = hours * periodsPerHour + 1;
     final long startTime = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(hours);

     // setup - write two groups of measurements - 'weekends' and 'weekdays'
     ProfileMeasurement prototype = new ProfileMeasurement()
             .withProfileName(profile)
             .withEntity(entity)
             .withPeriod(startTime, periodDuration, periodUnits);
     profileWriter.write(prototype, count, Arrays.asList("weekdays"), val -> expectedValue);
     profileWriter.write(prototype, count, Arrays.asList("weekends"), val -> 0);

     long end = System.currentTimeMillis();
     long start = end - TimeUnit.HOURS.toMillis(2);
     {
       //validate "weekday" results
       List<Object> groups = Arrays.asList("weekdays");
       List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, start, end, Optional.empty());
       assertEquals(count, results.size());
       results.forEach(actual -> {
         assertEquals(profile, actual.getProfileName());
         assertEquals(entity, actual.getEntity());
         assertEquals(groups, actual.getGroups());
         assertEquals(expectedValue, actual.getProfileValue());
       });
     }
     {
       //validate "weekend" results
       List<Object> groups = Arrays.asList("weekends");
       List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, start, end, Optional.empty());
       assertEquals(count, results.size());
       results.forEach(actual -> {
         assertEquals(profile, actual.getProfileName());
         assertEquals(entity, actual.getEntity());
         assertEquals(groups, actual.getGroups());
         assertEquals(0, actual.getProfileValue());
       });
     }
   }

   @Test
   public void Should_ReturnResultFromGroup_When_MultipleGroupsExist() {
     final String profile = "profile1";
     final String entity = "entity1";
     final int periodsPerHour = 4;
     final int expectedValue = 2302;
     final int hours = 2;
     final int count = hours * periodsPerHour;
     final long endTime = System.currentTimeMillis();
     final long startTime = endTime - TimeUnit.HOURS.toMillis(hours);

     // setup - write two groups of measurements - 'weekends' and 'weekdays'
     ProfileMeasurement m = new ProfileMeasurement()
             .withProfileName("profile1")
             .withEntity("entity1")
             .withPeriod(startTime, periodDuration, periodUnits);
     profileWriter.write(m, count, Arrays.asList("weekdays"), val -> expectedValue);
     profileWriter.write(m, count, Arrays.asList("weekends"), val -> 0);

     List<Object> weekdays = Arrays.asList("weekdays");
     List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, weekdays, startTime, endTime, Optional.empty());

     // should only return results from 'weekdays' group
     assertEquals(count, results.size());
     results.forEach(actual -> assertEquals(weekdays, actual.getGroups()));
   }

   @Test
   public void Should_ReturnNoResults_When_GroupDoesNotExist() {
     final String profile = "profile1";
     final String entity = "entity1";
     final int periodsPerHour = 4;
     final int expectedValue = 2302;
     final int hours = 2;
     final int count = hours * periodsPerHour;
     final long endTime = System.currentTimeMillis();
     final long startTime = endTime - TimeUnit.HOURS.toMillis(hours);

     // create two groups of measurements - one on weekdays and one on weekends
     ProfileMeasurement m = new ProfileMeasurement()
             .withProfileName("profile1")
             .withEntity("entity1")
             .withPeriod(startTime, periodDuration, periodUnits);
     profileWriter.write(m, count, Arrays.asList("weekdays"), val -> expectedValue);
     profileWriter.write(m, count, Arrays.asList("weekends"), val -> 0);

     // should return no results when the group does not exist
     List<Object> groups = Arrays.asList("does-not-exist");
     List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, startTime, endTime, Optional.empty());
     assertEquals(0, results.size());
   }

   @Test
   public void Should_ReturnNoResults_When_NoDataInStartToEnd() {
     final String profile = "profile1";
     final String entity = "entity1";
     final int hours = 2;
     int numberToWrite = hours * periodsPerHour;
     final List<Object> group = Arrays.asList("weekends");
     final long measurementTime = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(1);

     // write some data with a timestamp of s1 day ago
     ProfileMeasurement prototype = new ProfileMeasurement()
             .withProfileName("profile1")
             .withEntity("entity1")
             .withPeriod(measurementTime, periodDuration, periodUnits);
     profileWriter.write(prototype, numberToWrite, group, val -> 1000);

     // should return no results when [start,end] is long after when test data was written
     final long endFetchAt = System.currentTimeMillis();
     final long startFetchAt = endFetchAt - TimeUnit.MILLISECONDS.toMillis(30);
     List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, group, startFetchAt, endFetchAt, Optional.empty());
     assertEquals(0, results.size());
   }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package org.apache.metron.profiler.client;

	import org.apache.metron.hbase.mock.MockHBaseTableProvider;
	import org.apache.metron.hbase.mock.MockHTable;
	import org.apache.metron.profiler.ProfileMeasurement;
	import org.apache.metron.profiler.hbase.ColumnBuilder;
	import org.apache.metron.profiler.hbase.RowKeyBuilder;
	import org.apache.metron.profiler.hbase.SaltyRowKeyBuilder;
	import org.apache.metron.profiler.hbase.ValueOnlyColumnBuilder;
	import org.apache.metron.stellar.common.DefaultStellarStatefulExecutor;
	import org.apache.metron.stellar.common.StellarStatefulExecutor;
	import org.junit.jupiter.api.AfterEach;
	import org.junit.jupiter.api.BeforeEach;
	import org.junit.jupiter.api.Test;

	import java.util.Arrays;
	import java.util.List;
	import java.util.Optional;
	import java.util.concurrent.TimeUnit;

	import static org.junit.jupiter.api.Assertions.assertEquals;

	/**
	* Tests the HBaseProfilerClient.
	*
	* The naming used in this test attempts to be as similar to how the 'groupBy'
	* functionality might be used 'in the wild'. This test involves reading and
	* writing two separate groups originating from the same Profile and Entity.
	* There is a 'weekdays' group which contains all measurements taken on weekdays.
	* There is also a 'weekend' group which contains all measurements taken on weekends.
	*/
	public class HBaseProfilerClientTest {

	private static final String tableName = "profiler";
	private static final String columnFamily = "P";
	private static final long periodDuration = 15;
	private static final TimeUnit periodUnits = TimeUnit.MINUTES;
	private static final int periodsPerHour = 4;

	private HBaseProfilerClient client;
	private StellarStatefulExecutor executor;
	private MockHBaseTableProvider provider;
	private ProfileWriter profileWriter;

	@BeforeEach
	public void setup() {
	provider = new MockHBaseTableProvider();
	executor = new DefaultStellarStatefulExecutor();
	MockHBaseTableProvider.addToCache(tableName, columnFamily);

	// writes values to be read during testing
	long periodDurationMillis = periodUnits.toMillis(periodDuration);
	RowKeyBuilder rowKeyBuilder = new SaltyRowKeyBuilder();
	ColumnBuilder columnBuilder = new ValueOnlyColumnBuilder(columnFamily);
	profileWriter = new ProfileWriter(rowKeyBuilder, columnBuilder, provider, periodDurationMillis,
	tableName, null);

	client = new HBaseProfilerClient(provider, rowKeyBuilder, columnBuilder, periodDurationMillis,
	tableName, null);
	}

	@AfterEach
	public void tearDown() throws Exception {
	((MockHTable) provider.getTable(null, tableName)).clear();
	}

	@Test
	public void Should_ReturnMeasurements_When_DataExistsForAGroup() {
	final String profile = "profile1";
	final String entity = "entity1";
	final int expectedValue = 2302;
	final int hours = 2;
	final int count = hours * periodsPerHour + 1;
	final long startTime = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(hours);

	// setup - write two groups of measurements - 'weekends' and 'weekdays'
	ProfileMeasurement prototype = new ProfileMeasurement()
	.withProfileName(profile)
	.withEntity(entity)
	.withPeriod(startTime, periodDuration, periodUnits);
	profileWriter.write(prototype, count, Arrays.asList("weekdays"), val -> expectedValue);
	profileWriter.write(prototype, count, Arrays.asList("weekends"), val -> 0);

	long end = System.currentTimeMillis();
	long start = end - TimeUnit.HOURS.toMillis(2);
	{
	//validate "weekday" results
	List<Object> groups = Arrays.asList("weekdays");
	List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, start, end, Optional.empty());
	assertEquals(count, results.size());
	results.forEach(actual -> {
	assertEquals(profile, actual.getProfileName());
	assertEquals(entity, actual.getEntity());
	assertEquals(groups, actual.getGroups());
	assertEquals(expectedValue, actual.getProfileValue());
	});
	}
	{
	//validate "weekend" results
	List<Object> groups = Arrays.asList("weekends");
	List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, start, end, Optional.empty());
	assertEquals(count, results.size());
	results.forEach(actual -> {
	assertEquals(profile, actual.getProfileName());
	assertEquals(entity, actual.getEntity());
	assertEquals(groups, actual.getGroups());
	assertEquals(0, actual.getProfileValue());
	});
	}
	}

	@Test
	public void Should_ReturnResultFromGroup_When_MultipleGroupsExist() {
	final String profile = "profile1";
	final String entity = "entity1";
	final int periodsPerHour = 4;
	final int expectedValue = 2302;
	final int hours = 2;
	final int count = hours * periodsPerHour;
	final long endTime = System.currentTimeMillis();
	final long startTime = endTime - TimeUnit.HOURS.toMillis(hours);

	// setup - write two groups of measurements - 'weekends' and 'weekdays'
	ProfileMeasurement m = new ProfileMeasurement()
	.withProfileName("profile1")
	.withEntity("entity1")
	.withPeriod(startTime, periodDuration, periodUnits);
	profileWriter.write(m, count, Arrays.asList("weekdays"), val -> expectedValue);
	profileWriter.write(m, count, Arrays.asList("weekends"), val -> 0);

	List<Object> weekdays = Arrays.asList("weekdays");
	List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, weekdays, startTime, endTime, Optional.empty());

	// should only return results from 'weekdays' group
	assertEquals(count, results.size());
	results.forEach(actual -> assertEquals(weekdays, actual.getGroups()));
	}

	@Test
	public void Should_ReturnNoResults_When_GroupDoesNotExist() {
	final String profile = "profile1";
	final String entity = "entity1";
	final int periodsPerHour = 4;
	final int expectedValue = 2302;
	final int hours = 2;
	final int count = hours * periodsPerHour;
	final long endTime = System.currentTimeMillis();
	final long startTime = endTime - TimeUnit.HOURS.toMillis(hours);

	// create two groups of measurements - one on weekdays and one on weekends
	ProfileMeasurement m = new ProfileMeasurement()
	.withProfileName("profile1")
	.withEntity("entity1")
	.withPeriod(startTime, periodDuration, periodUnits);
	profileWriter.write(m, count, Arrays.asList("weekdays"), val -> expectedValue);
	profileWriter.write(m, count, Arrays.asList("weekends"), val -> 0);

	// should return no results when the group does not exist
	List<Object> groups = Arrays.asList("does-not-exist");
	List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, groups, startTime, endTime, Optional.empty());
	assertEquals(0, results.size());
	}

	@Test
	public void Should_ReturnNoResults_When_NoDataInStartToEnd() {
	final String profile = "profile1";
	final String entity = "entity1";
	final int hours = 2;
	int numberToWrite = hours * periodsPerHour;
	final List<Object> group = Arrays.asList("weekends");
	final long measurementTime = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(1);

	// write some data with a timestamp of s1 day ago
	ProfileMeasurement prototype = new ProfileMeasurement()
	.withProfileName("profile1")
	.withEntity("entity1")
	.withPeriod(measurementTime, periodDuration, periodUnits);
	profileWriter.write(prototype, numberToWrite, group, val -> 1000);

	// should return no results when [start,end] is long after when test data was written
	final long endFetchAt = System.currentTimeMillis();
	final long startFetchAt = endFetchAt - TimeUnit.MILLISECONDS.toMillis(30);
	List<ProfileMeasurement> results = client.fetch(Integer.class, profile, entity, group, startFetchAt, endFetchAt, Optional.empty());
	assertEquals(0, results.size());
	}
	}