@Test
public void testNotProcessingInheritPropertiesForTableType() {
String tableName = "Rules void hello2(int hour)";
TableSyntaxNode resultTsn = findTable(tableName);
if (resultTsn != null) {
ITableProperties tableProperties = resultTsn.getTableProperties();
assertNotNull(tableProperties);
Map<String, Object> categoryProperties = tableProperties.getPropertiesAppliedForCategory();
assertTrue(categoryProperties.size() == 5);
// check that we have all properties from category level
assertEquals(
InheritanceLevel.CATEGORY.getDisplayName(), (String) categoryProperties.get("scope"));
assertEquals("My Category", (String) categoryProperties.get("category"));
assertEquals("newLob", (String) categoryProperties.get("lob"));
assertEquals(
UsRegionsEnum.SE.name(),
((UsRegionsEnum[]) categoryProperties.get("usregion"))[0].name());
assertEquals(
RegionsEnum.NCSA.name(), ((RegionsEnum[]) categoryProperties.get("region"))[0].name());
Map<String, Object> allProperties = tableProperties.getAllProperties();
assertEquals(
"AllProperties size is 10, ignore property 'scope' and including default properties",
8,
allProperties.size());
assertTrue(
"There is no property 'scope' applied for this table, as it can`t be defined in such table type",
!allProperties.containsKey("scope"));
} else {
fail();
}
}
private boolean isExecutableTableSyntaxNode(TableSyntaxNode tableSyntaxNode) {
return XlsNodeTypes.XLS_DT.equals(tableSyntaxNode.getNodeType())
|| XlsNodeTypes.XLS_TBASIC.equals(tableSyntaxNode.getNodeType())
|| XlsNodeTypes.XLS_METHOD.equals(tableSyntaxNode.getNodeType())
|| XlsNodeTypes.XLS_COLUMN_MATCH.equals(tableSyntaxNode.getNodeType())
|| XlsNodeTypes.XLS_SPREADSHEET.equals(tableSyntaxNode.getNodeType());
}
private void addDuplicatedMethodError(
String message, IOpenMethod method, IOpenMethod existedMethod) {
ISyntaxNode newMethodSyntaxNode = method.getInfo().getSyntaxNode();
if (newMethodSyntaxNode instanceof TableSyntaxNode) {
SyntaxNodeException error =
SyntaxNodeExceptionUtils.createError(message, newMethodSyntaxNode);
((TableSyntaxNode) newMethodSyntaxNode).addError(error);
try {
TableSyntaxNode existedMethodSyntaxNode =
(TableSyntaxNode) existedMethod.getInfo().getSyntaxNode();
if (existedMethodSyntaxNode != null) {
existedMethodSyntaxNode.addError(
SyntaxNodeExceptionUtils.createError(message, existedMethodSyntaxNode));
}
} catch (Exception ex) {
log.warn(
"Cannot get a syntax node for the method: {}",
MethodUtil.printMethod(existedMethod, new StringBuilder()),
ex);
}
addError(error);
} else {
addError(new DuplicatedMethodException(message, method));
}
}
@Override
public ValidationResult validateTables(
OpenL openl, TableSyntaxNode[] tableSyntaxNodes, IOpenClass openClass) {
ValidationResult validationResult = null;
// Group methods not TableSyntaxNodes as we may have dependent modules,
// and no sources for them,
// represented in current module. The only information about dependency
// methods contains in openClass.
//
Map<DimensionPropertiesMethodKey, List<TableSyntaxNode>> groupedMethods =
groupExecutableMethods(tableSyntaxNodes);
for (DimensionPropertiesMethodKey key : groupedMethods.keySet()) {
List<TableSyntaxNode> methodsGroup = groupedMethods.get(key);
List<TableSyntaxNode> activeExecutableMethodTable = new ArrayList<TableSyntaxNode>();
int activeTableFoundCount = 0;
for (TableSyntaxNode executableMethodTable : methodsGroup) {
if (executableMethodTable.getMember() instanceof TestSuiteMethod) {
activeTableFoundCount++;
break;
}
if (executableMethodTable.getTableProperties() != null && isActive(executableMethodTable)) {
activeExecutableMethodTable.add(executableMethodTable);
activeTableFoundCount++;
}
}
if (activeTableFoundCount > 1) {
if (validationResult == null) {
validationResult = new ValidationResult(ValidationStatus.FAIL);
}
for (TableSyntaxNode executableMethodTable : activeExecutableMethodTable) {
SyntaxNodeException exception =
SyntaxNodeExceptionUtils.createError(ODD_ACTIVE_TABLE_MESSAGE, executableMethodTable);
executableMethodTable.addError(exception);
ValidationUtils.addValidationMessage(validationResult, new OpenLErrorMessage(exception));
}
}
if (activeTableFoundCount == 0) {
if (validationResult == null) {
validationResult = new ValidationResult(ValidationStatus.SUCCESS);
}
// warning is attached to all table syntax node
for (TableSyntaxNode tsn : methodsGroup) {
ValidationUtils.addValidationMessage(
validationResult, new OpenLWarnMessage(NO_ACTIVE_TABLE_MESSAGE, tsn));
}
}
}
if (validationResult != null) {
return validationResult;
} else {
return ValidationUtils.validationSuccess();
}
}
@Test
public void testErrorParsing() {
String tableName = "Rules void hello1(int hour)";
TableSyntaxNode resultTsn = findTable(tableName);
if (resultTsn != null) {
ITableProperties tableProperties = resultTsn.getTableProperties();
assertNotNull(tableProperties);
assertEquals(5, tableProperties.getAllProperties().size());
} else {
fail();
}
}
private OpenMethodHeader addMethodHeaderToContext(
XlsModuleOpenClass module,
TableSyntaxNode tableSyntaxNode,
OpenL openl,
RulesModuleBindingContext moduleContext,
IMemberBoundNode[] children,
int index) {
try {
AExecutableNodeBinder aExecutableNodeBinder =
(AExecutableNodeBinder) getBinderFactory().get(tableSyntaxNode.getType());
IOpenSourceCodeModule source =
aExecutableNodeBinder.createHeaderSource(tableSyntaxNode, moduleContext);
OpenMethodHeader openMethodHeader =
(OpenMethodHeader) OpenLManager.makeMethodHeader(openl, source, moduleContext);
XlsBinderExecutableMethodBind xlsBinderExecutableMethodBind =
new XlsBinderExecutableMethodBind(
module, openl, tableSyntaxNode, children, index, openMethodHeader, moduleContext);
moduleContext.addBinderMethod(openMethodHeader, xlsBinderExecutableMethodBind);
return openMethodHeader;
} catch (Exception e) {
SyntaxNodeException error = SyntaxNodeExceptionUtils.createError(e, tableSyntaxNode);
processError(error, tableSyntaxNode, moduleContext);
}
return null;
}
protected void processError(
SyntaxNodeException error,
TableSyntaxNode tableSyntaxNode,
RulesModuleBindingContext moduleContext) {
tableSyntaxNode.addError(error);
BindHelper.processError(error, moduleContext);
}
private Map<DimensionPropertiesMethodKey, List<TableSyntaxNode>> groupExecutableMethods(
TableSyntaxNode[] tableSyntaxNodes) {
Map<DimensionPropertiesMethodKey, List<TableSyntaxNode>> groupedMethods =
new HashMap<DimensionPropertiesMethodKey, List<TableSyntaxNode>>();
for (TableSyntaxNode tsn : tableSyntaxNodes) {
if (tsn.getMember() instanceof ExecutableRulesMethod) {
ExecutableRulesMethod executableMethod = (ExecutableRulesMethod) tsn.getMember();
DimensionPropertiesMethodKey key = new DimensionPropertiesMethodKey(executableMethod);
if (!groupedMethods.containsKey(key)) {
groupedMethods.put(key, new ArrayList<TableSyntaxNode>());
}
groupedMethods.get(key).add(tsn);
}
}
return groupedMethods;
}
public int getNumErrors() {
int result = 0;
TableSyntaxNode table = getTableSyntaxNode();
if (table != null) {
SyntaxNodeException errors[] = table.getErrors();
if (errors != null) {
return errors.length;
}
}
Iterable<? extends ITreeElement<Object>> children = getChildren();
for (ITreeElement<Object> treeNode : children) {
if (treeNode instanceof ProjectTreeNode) {
ProjectTreeNode projectTreeNode = (ProjectTreeNode) treeNode;
result += projectTreeNode.getNumErrors();
}
}
return result;
}
private boolean isActive(TableSyntaxNode executableMethodTable) {
return Boolean.TRUE.equals(executableMethodTable.getTableProperties().getActive());
}
