2019-11-15 14:40:11 +01:00
|
|
|
package org.gcube.accounting.datamodel.validations.validators;
|
|
|
|
|
|
|
|
import java.io.BufferedReader;
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.FileReader;
|
2019-11-25 17:33:44 +01:00
|
|
|
import java.io.FilenameFilter;
|
2019-11-15 14:40:11 +01:00
|
|
|
import java.net.URL;
|
|
|
|
|
2019-11-26 11:50:31 +01:00
|
|
|
import org.gcube.accounting.aggregator.RegexRulesAggregator;
|
|
|
|
import org.gcube.accounting.datamodel.aggregation.AggregatedServiceUsageRecord;
|
|
|
|
import org.gcube.accounting.datamodel.usagerecords.ServiceUsageRecord;
|
|
|
|
import org.gcube.documentstore.exception.NotAggregatableRecordsExceptions;
|
2019-11-15 14:40:11 +01:00
|
|
|
import org.gcube.documentstore.records.DSMapper;
|
2019-11-26 11:50:31 +01:00
|
|
|
import org.gcube.testutility.ContextTest;
|
|
|
|
import org.gcube.testutility.TestUsageRecord;
|
|
|
|
import org.junit.Assert;
|
2019-11-15 14:40:11 +01:00
|
|
|
import org.junit.Test;
|
|
|
|
import org.slf4j.Logger;
|
|
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
|
|
|
|
|
|
public class TestRules {
|
|
|
|
|
|
|
|
private static final Logger logger = LoggerFactory.getLogger(TestRules.class);
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAllRules() throws Exception {
|
2019-11-25 17:33:44 +01:00
|
|
|
|
|
|
|
File rulesDirectory = getRulesDirectory();
|
|
|
|
FilenameFilter filenameFilter = new FilenameFilter() {
|
|
|
|
@Override
|
|
|
|
public boolean accept(File dir, String name) {
|
|
|
|
return name.endsWith(".json");
|
|
|
|
}
|
2019-11-15 14:40:11 +01:00
|
|
|
};
|
2019-11-25 17:33:44 +01:00
|
|
|
File[] rulesFiles = rulesDirectory.listFiles(filenameFilter);
|
2019-11-26 11:50:31 +01:00
|
|
|
RegexRulesAggregator regexRulesAggregator = RegexRulesAggregator.getInstance();
|
|
|
|
|
|
|
|
for(File rulesFile : rulesFiles) {
|
|
|
|
ObjectMapper mapper = DSMapper.getObjectMapper();
|
|
|
|
MatcherReplace matcherReplace = mapper.readValue(rulesFile, MatcherReplace.class);
|
|
|
|
regexRulesAggregator.addMatcherReplace(matcherReplace);
|
|
|
|
}
|
2019-11-15 14:40:11 +01:00
|
|
|
|
2019-11-25 17:33:44 +01:00
|
|
|
for(File rulesFile : rulesFiles) {
|
|
|
|
testRule(rulesFile);
|
2019-11-15 14:40:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-15 17:00:14 +01:00
|
|
|
public File getRulesDirectory() throws Exception {
|
|
|
|
URL logbackFileURL = TestRules.class.getClassLoader().getResource("logback-test.xml");
|
|
|
|
File logbackFile = new File(logbackFileURL.toURI());
|
|
|
|
File resourcesDirectory = logbackFile.getParentFile();
|
|
|
|
return new File(resourcesDirectory, "rules");
|
|
|
|
}
|
|
|
|
|
2019-11-26 11:50:31 +01:00
|
|
|
protected long durationWeightedAverage(int numberA, long durationA, int numberB, long durationB){
|
|
|
|
return ((numberA * durationA) + (numberB * durationB)) / (numberA + numberB);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public void initAllRules() throws Exception {
|
|
|
|
RegexRulesAggregator regexRulesAggregator = RegexRulesAggregator.getInstance();
|
|
|
|
File rulesDirectory = getRulesDirectory();
|
|
|
|
FilenameFilter filenameFilter = new FilenameFilter() {
|
|
|
|
@Override
|
|
|
|
public boolean accept(File dir, String name) {
|
|
|
|
return name.endsWith(".json");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
File[] rulesFiles = rulesDirectory.listFiles(filenameFilter);
|
|
|
|
|
|
|
|
for(File rulesFile : rulesFiles) {
|
|
|
|
ObjectMapper mapper = DSMapper.getObjectMapper();
|
|
|
|
MatcherReplace matcherReplace = mapper.readValue(rulesFile, MatcherReplace.class);
|
|
|
|
regexRulesAggregator.addMatcherReplace(matcherReplace);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-25 17:33:44 +01:00
|
|
|
public void testRule(File rulesFile) throws Exception {
|
|
|
|
logger.info("-----------------------------------------------------------------------------------------------------");
|
|
|
|
logger.info("Analisyng rule from file {}\n", rulesFile.getAbsolutePath());
|
|
|
|
File rulesDirectory = rulesFile.getParentFile();
|
2019-11-15 17:00:14 +01:00
|
|
|
|
2019-11-15 14:40:11 +01:00
|
|
|
ObjectMapper mapper = DSMapper.getObjectMapper();
|
2019-11-15 17:00:14 +01:00
|
|
|
MatcherReplace matcherReplace = mapper.readValue(rulesFile, MatcherReplace.class);
|
2019-11-15 14:40:11 +01:00
|
|
|
Replacer replacer = matcherReplace.getReplacer();
|
|
|
|
|
2019-11-26 11:50:31 +01:00
|
|
|
ServiceUsageRecord serviceUsageRecord = TestUsageRecord.createTestServiceUsageRecord();
|
|
|
|
serviceUsageRecord.setServiceClass(replacer.getServiceClass());
|
|
|
|
serviceUsageRecord.setServiceName(replacer.getServiceName());
|
|
|
|
serviceUsageRecord.setCalledMethod(replacer.getCalledMethod());
|
|
|
|
serviceUsageRecord.validate();
|
|
|
|
|
|
|
|
AggregatedServiceUsageRecord aggregated = new AggregatedServiceUsageRecord(serviceUsageRecord);
|
|
|
|
|
2019-11-25 17:33:44 +01:00
|
|
|
final String requiredMatchesFileName = rulesFile.getName().replaceAll(".json", ".csv");
|
|
|
|
File elaborationFile = new File(rulesDirectory,requiredMatchesFileName);
|
2019-11-26 11:50:31 +01:00
|
|
|
int count = 1;
|
2019-11-15 14:40:11 +01:00
|
|
|
try(BufferedReader br = new BufferedReader(new FileReader(elaborationFile))) {
|
|
|
|
for(String line; (line = br.readLine()) != null;) {
|
|
|
|
String[] splittedLine = line.split(",");
|
2019-11-26 11:50:31 +01:00
|
|
|
++count;
|
|
|
|
|
|
|
|
String serviceClass = splittedLine[0];
|
|
|
|
String serviceName = splittedLine[1];
|
|
|
|
String calledMethod = splittedLine[2];
|
|
|
|
|
|
|
|
boolean matched = matcherReplace.check(serviceClass,serviceName,calledMethod);
|
2019-11-15 14:40:11 +01:00
|
|
|
if(matched) {
|
2019-12-02 15:40:13 +01:00
|
|
|
logger.info("{} --> {},{},{}", line, replacer.getServiceClass(), replacer.getServiceName(), replacer.getCalledMethod());
|
2019-11-15 14:40:11 +01:00
|
|
|
} else {
|
|
|
|
logger.error("{} does not match {}. This MUST not occur.", line, matcherReplace.getMultiMatcher().toString());
|
2019-11-15 16:42:11 +01:00
|
|
|
throw new Exception();
|
2019-11-15 14:40:11 +01:00
|
|
|
}
|
|
|
|
|
2019-11-26 11:50:31 +01:00
|
|
|
ServiceUsageRecord sur = TestUsageRecord.createTestServiceUsageRecord();
|
|
|
|
sur.setServiceClass(serviceClass);
|
|
|
|
sur.setServiceName(serviceName);
|
|
|
|
sur.setCalledMethod(calledMethod);
|
|
|
|
sur.validate();
|
|
|
|
// logger.trace("To Be aggregated ServiceUsageRecord {}", sur);
|
|
|
|
|
|
|
|
long minInvocationTime = aggregated.getMinInvocationTime();
|
|
|
|
long maxInvocationTime = aggregated.getMaxInvocationTime();
|
|
|
|
long oldDuration = aggregated.getDuration();
|
|
|
|
long surDuration = sur.getDuration();
|
|
|
|
|
|
|
|
aggregated.aggregate(sur);
|
|
|
|
//logger.debug("Resulting Aggregated ServiceUsageRecord: {}", aggregated);
|
|
|
|
|
|
|
|
long avgDuration = durationWeightedAverage(count-1, oldDuration, 1, surDuration);
|
|
|
|
Assert.assertTrue(aggregated.getDuration() == (avgDuration));
|
|
|
|
Assert.assertTrue(aggregated.getOperationCount() == count);
|
|
|
|
|
|
|
|
if(minInvocationTime >= surDuration){
|
|
|
|
Assert.assertTrue(aggregated.getMinInvocationTime() == surDuration);
|
|
|
|
}else{
|
|
|
|
Assert.assertTrue(aggregated.getMinInvocationTime() == minInvocationTime);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(maxInvocationTime >= surDuration){
|
|
|
|
Assert.assertTrue(aggregated.getMaxInvocationTime() == maxInvocationTime);
|
|
|
|
}else{
|
|
|
|
Assert.assertTrue(aggregated.getMaxInvocationTime() == surDuration);
|
|
|
|
}
|
|
|
|
|
2019-11-15 14:40:11 +01:00
|
|
|
}
|
|
|
|
} catch(Exception e) {
|
|
|
|
throw e;
|
|
|
|
}
|
2019-11-25 17:33:44 +01:00
|
|
|
|
|
|
|
|
|
|
|
FilenameFilter filenameFilter = new FilenameFilter() {
|
|
|
|
@Override
|
|
|
|
public boolean accept(File dir, String name) {
|
|
|
|
boolean accept = name.endsWith(".csv");
|
|
|
|
return name.compareTo(requiredMatchesFileName)!=0 && accept;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
File[] elaborationFilesNoMatch = rulesDirectory.listFiles(filenameFilter);
|
|
|
|
|
|
|
|
for(File elaborationFileNoMatch : elaborationFilesNoMatch) {
|
2019-12-02 15:40:13 +01:00
|
|
|
logger.info("Comparing examples which must not match from file {}", elaborationFileNoMatch.getName());
|
2019-11-25 17:33:44 +01:00
|
|
|
try(BufferedReader br = new BufferedReader(new FileReader(elaborationFileNoMatch))) {
|
|
|
|
for(String line; (line = br.readLine()) != null;) {
|
|
|
|
String[] splittedLine = line.split(",");
|
2019-11-26 11:50:31 +01:00
|
|
|
String serviceClass = splittedLine[0];
|
|
|
|
String serviceName = splittedLine[1];
|
|
|
|
String calledMethod = splittedLine[2];
|
|
|
|
boolean matched = matcherReplace.check(serviceClass,serviceName,calledMethod);
|
2019-11-25 17:33:44 +01:00
|
|
|
if(matched) {
|
|
|
|
logger.error("{} match {} but it should NOT. This MUST not occur.", line, matcherReplace.getMultiMatcher().toString());
|
|
|
|
throw new Exception();
|
|
|
|
} else {
|
2019-12-02 15:40:13 +01:00
|
|
|
logger.trace("{} does NOT match as requested", line, replacer.getServiceClass(), replacer.getServiceName(), replacer.getCalledMethod());
|
2019-11-25 17:33:44 +01:00
|
|
|
}
|
|
|
|
|
2019-11-26 11:50:31 +01:00
|
|
|
|
|
|
|
ServiceUsageRecord sur = TestUsageRecord.createTestServiceUsageRecord();
|
|
|
|
sur.setServiceClass(serviceClass);
|
|
|
|
sur.setServiceName(serviceName);
|
|
|
|
sur.setCalledMethod(calledMethod);
|
|
|
|
sur.validate();
|
|
|
|
//logger.trace("Should not be aggregated ServiceUsageRecord {}", sur);
|
|
|
|
|
|
|
|
try {
|
|
|
|
aggregated.aggregate(sur);
|
|
|
|
throw new Exception("The record has been aggregated and it should NOT");
|
|
|
|
}catch (NotAggregatableRecordsExceptions e) {
|
|
|
|
//logger.trace("{} is not aggragable as expected", sur);
|
|
|
|
}
|
2019-11-25 17:33:44 +01:00
|
|
|
}
|
|
|
|
} catch(Exception e) {
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
logger.info("-----------------------------------------------------------------------------------------------------\n\n\n");
|
2019-11-15 14:40:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testSingleRule() throws Exception {
|
2019-11-26 11:50:31 +01:00
|
|
|
ContextTest.setContextByName(ContextTest.DEFAULT_TEST_SCOPE);
|
|
|
|
initAllRules();
|
2019-11-25 17:33:44 +01:00
|
|
|
File rulesDirectory = getRulesDirectory();
|
2019-12-02 16:01:50 +01:00
|
|
|
File rulesFile = new File(rulesDirectory, "geoanalytics-gos-ShapeManagement.json");
|
2019-11-25 17:33:44 +01:00
|
|
|
testRule(rulesFile);
|
2019-11-15 14:40:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|