bundles/org.eclipse.vorto.fbeditor.tests/src/org/eclipse/vorto/fbeditor/tests/validator/FbValidatorTest.xtend

/*******************************************************************************
 * Copyright (c) 2014 Bosch Software Innovations GmbH and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 *
 * The Eclipse Public License is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * The Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 * Bosch Software Innovations GmbH - Please refer to git log
 *
 *******************************************************************************/
 package org.eclipse.vorto.fbeditor.tests.validator

import org.eclipse.vorto.fbeditor.FunctionblockStandaloneSetup
import org.eclipse.vorto.fbeditor.validation.FunctionblockValidator
import org.eclipse.vorto.fbeditor.internal.validation.SystemMessage
import org.eclipse.vorto.functionblock.ConstraintIntervalType
import org.eclipse.vorto.functionblock.FunctionblockFactory
import org.eclipse.vorto.functionblock.PrimitiveType
import org.eclipse.xtext.junit4.AbstractXtextTests
import org.eclipse.xtext.junit4.validation.ValidatorTester
import org.junit.Test

class FbValidatorTest extends AbstractXtextTests {
	
	private ValidatorTester<FunctionblockValidator> tester;
	
	def override void setUp() throws Exception {
		super.setUp();
		with(FunctionblockStandaloneSetup);
		var validator = get(FunctionblockValidator);
		tester = new ValidatorTester<FunctionblockValidator>(validator, getInjector());
	}
	
	@Test
	def test_Duplicated_Entity() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		
		var entity1 = FunctionblockFactory.eINSTANCE.createEntity();
		entity1.setName("abc");
		
		var entity2 = FunctionblockFactory.eINSTANCE.createEntity();
		entity2.setName("abc");
		
		fbmodel.getElements().add(entity1);
		fbmodel.getElements().add(entity2);
		
		tester.validator().checkDuplicateEntityName(entity1);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_ENTITY_NAME);
	}
	
	@Test
	def test_Duplicated_OperationName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		
		var op1=FunctionblockFactory.eINSTANCE.createOperation();
		op1.setMethodName("on");
		
		var op2=FunctionblockFactory.eINSTANCE.createOperation();
		op2.setMethodName("on");
		
		fbmodel.getFeatures().add(op1);
		fbmodel.getFeatures().add(op2);
		
		tester.validator().checkDuplicateOperation(op1);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_METHOD_NAME);
	}
	
	@Test
	def test_Duplicated_ParameterName() {
		
		var operation = FunctionblockFactory.eINSTANCE.createOperation();
		
		var param1= FunctionblockFactory.eINSTANCE.createPrimitiveParam()
		param1.setParamName("ABB");
		
		var param2= FunctionblockFactory.eINSTANCE.createPrimitiveParam();
		param2.setParamName("ABB");

		operation.getParams().add(param1);
		operation.getParams().add(param2);
		
		tester.validator().checkDuplicateParameter(operation);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_PARAMETER_NAME);
	}
	
	
	@Test
	def test_Duplicated_Feature() {
		var fbFeature = FunctionblockFactory.eINSTANCE.createFBFeature();
		
		var feature = FunctionblockFactory.eINSTANCE.createProperty();
		feature.setPropName("Test");
		
		var feature2 = FunctionblockFactory.eINSTANCE.createProperty();
		feature2.setPropName("Test");
		
		fbFeature.properties.add(feature);
		fbFeature.properties.add(feature2);
		
		tester.validator().checkProperty(feature);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_PROPERTY_NAME);
	}
	
	@Test
	def test_EntityName_CamelCase() {
		var entity = FunctionblockFactory.eINSTANCE.createEntity();
		entity.setName("abc");
		
		tester.validator().checkEntityName(entity);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENTITYNAME_INVALID_CAMELCASE);
	}
	
	@Test
	def test_EntityName_SuffixReply() {
		var entity = FunctionblockFactory.eINSTANCE.createEntity();
		entity.setName("AbcReply");
		
		tester.validator().checkEntityName(entity);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENTITYNAME_SUFFIX_REPLY);
	}
	
	@Test
	def test_EntityName_SuffixReply_JustReply() {
		var entity = FunctionblockFactory.eINSTANCE.createEntity();
		entity.setName("Reply");
		
		tester.validator().checkEntityName(entity);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENTITYNAME_SUFFIX_REPLY);
	}
	
	@Test
	def test_FBName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		
		fbmodel.setName("fame")
		
		tester.validator().checkFunctionBlockName(fbmodel);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_FBNAME_INVALID);
	}
	
	@Test
	def test_Property_Name_SuffixTS(){
		var property = FunctionblockFactory.eINSTANCE.createProperty();
		property.setPropName("sodaTS")
		
		tester.validator().checkPropertyName(property)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_PROPNAME_SUFFIX_TS);
	}
	
	@Test
	def test_Property_Name_Suffixts(){
		var feature = FunctionblockFactory.eINSTANCE.createProperty();
		feature.setPropName("products")
		
		tester.validator().checkPropertyName(feature)
		tester.diagnose().assertOK()
	}
	
	@Test
	def test_OperationName_Same_EntityName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		var op1=FunctionblockFactory.eINSTANCE.createOperation();
		var ent = FunctionblockFactory.eINSTANCE.createEntity()
		
		op1.setMethodName("transAction");
		ent.setName("TransAction")
		
		fb.features.add(op1)
		fbmodel.elements.add(ent)
		fbmodel.setFunctionblock(fb);
		
		tester.validator().checkOpNameAgainstEntityName(op1)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_OPERATION_SAME_ENTITYNAME);
	}
	
	@Test
	def test_OperationName_Same_EnumName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		var op1=FunctionblockFactory.eINSTANCE.createOperation();
		var ent = FunctionblockFactory.eINSTANCE.createEnum()
		
		op1.setMethodName("transAction");
		ent.setName("TransAction")
		
		fb.features.add(op1)
		fbmodel.enums.add(ent)
		fbmodel.setFunctionblock(fb);
		
		tester.validator().checkOpNameAgainstEntityName(op1)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_OPERATION_SAME_ENUMNAME);
	}
	
	@Test
	def test_OperationName_Diff_EnumName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		var op1=FunctionblockFactory.eINSTANCE.createOperation();
		var ent = FunctionblockFactory.eINSTANCE.createEnum()
		
		op1.setMethodName("transActionz");
		ent.setName("TransAction")
		
		fb.features.add(op1)
		fbmodel.enums.add(ent)
		fbmodel.setFunctionblock(fb);
		
		tester.validator().checkOpNameAgainstEntityName(op1)
		tester.diagnose().assertOK
	}
	
	@Test
	def test_OperationName_Same_EntityName_Multiple_Op() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		var op1=FunctionblockFactory.eINSTANCE.createOperation();
		var op2=FunctionblockFactory.eINSTANCE.createOperation();
		var ent = FunctionblockFactory.eINSTANCE.createEntity()
		var ent1 = FunctionblockFactory.eINSTANCE.createEntity()
		
		op1.setMethodName("transAction");
		op2.setMethodName("action");
		ent.setName("TransAction")
		ent1.setName("Trans");
		
		fb.features.add(op1)
		fb.features.add(op2)
		fbmodel.elements.add(ent)
		fbmodel.elements.add(ent1)
		fbmodel.setFunctionblock(fb);
		
		tester.validator().checkOpNameAgainstEntityName(op1)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_OPERATION_SAME_ENTITYNAME);
	}
	
	@Test
	def test_Duplicated_Constraint() {
		var feature = FunctionblockFactory.eINSTANCE.createPrimitiveProperty();
				
		feature.type = PrimitiveType.STRING
		
		var constraint1 = FunctionblockFactory.eINSTANCE.createConstraint();
		constraint1.type = ConstraintIntervalType.STRLEN
		feature.constraints.add(constraint1)
		
		var constraint2 = FunctionblockFactory.eINSTANCE.createConstraint();
		constraint2.type = ConstraintIntervalType.STRLEN
		feature.constraints.add(constraint2)
		
		tester.validator().checkDuplicatedConstraint(feature);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_CONSTRAINT);
	}
	
	@Test
	def test_FuncBlock_Version_Valid(){
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb.version = "1.1.1-RC"
		
		tester.validator().checkVersionPattern(fb)
		tester.diagnose().assertOK
		
		var fb1 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb1.version = "1.1.1"
		
		tester.validator().checkVersionPattern(fb1)
		tester.diagnose().assertOK
		
		var fb2 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb2.version = "11.11.11"
		
		tester.validator().checkVersionPattern(fb2)
		tester.diagnose().assertOK
	}
	
	@Test
	def test_FuncBlock_Version_Invalid(){
		var fb = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb.version = "1.1"
		
		tester.validator().checkVersionPattern(fb)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_VERSION_PATTERN);
		
		var fb1 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb1.version = "1."
		
		tester.validator().checkVersionPattern(fb1)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_VERSION_PATTERN);
		
		var fb2 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb2.version = "1"
		
		tester.validator().checkVersionPattern(fb2)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_VERSION_PATTERN);
		
		var fb3 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb3.version = "1.1-RC"
		
		tester.validator().checkVersionPattern(fb3)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_VERSION_PATTERN);
		
		var fb4 = FunctionblockFactory.eINSTANCE.createFunctionBlock();
		fb4.version = "1-RC"
		
		tester.validator().checkVersionPattern(fb4)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_VERSION_PATTERN);
	}
	
	@Test
	def test_Duplicated_Enum() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		
		var enum1 = FunctionblockFactory.eINSTANCE.createEnum();
		enum1.setName("Abc");
		
		var enum2 = FunctionblockFactory.eINSTANCE.createEnum();
		enum2.setName("Abc");
		
		fbmodel.getEnums().add(enum1);
		fbmodel.getEnums().add(enum2);
		
		tester.validator().checkDuplicateEnumName(enum1);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_ENUM_NAME);
	}
	
	@Test
	def test_Enum_Name() {
		
		var enum1 = FunctionblockFactory.eINSTANCE.createEnum();
		enum1.setName("abc");
		
		tester.validator().checkEnumName(enum1);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENUMNAME_INVALID_CAMELCASE);
		
		var enum2 = FunctionblockFactory.eINSTANCE.createEnum();
		enum2.setName("Abc");
		
		tester.validator().checkEnumName(enum2);
		tester.diagnose().assertOK
	}
	
	@Test
	def test_Duplicated_Literal() {
		var enum1 = FunctionblockFactory.eINSTANCE.createEnum();
		enum1.setName("Abc");
		
		var literal1 = FunctionblockFactory.eINSTANCE.createEnumLiteral
		var literal2 = FunctionblockFactory.eINSTANCE.createEnumLiteral
		
		literal1.literal = "green"
		literal2.literal = "green"
		
		enum1.enums.add(literal1)
		enum1.enums.add(literal2)
		
		tester.validator().checkDuplicatedLiteral(enum1)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_DUPLICATED_ENUM_LITERAL);
	}
	
	@Test
	def test_EntityName_Same_EnumName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var enm = FunctionblockFactory.eINSTANCE.createEnum()
		var ent = FunctionblockFactory.eINSTANCE.createEntity()
		
		ent.setName("TransAction")
		enm.setName("TransAction")
		
		fbmodel.elements.add(ent)
		fbmodel.enums.add(enm)
		
		tester.validator().checkEnumNameAgainstEntityName(enm)
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENTITY_SAME_ENUMNAME);
	}
	
	@Test
	def test_EntityName_Diff_EnumName() {
		var fbmodel = FunctionblockFactory.eINSTANCE.createFunctionblockModel();
		var enm = FunctionblockFactory.eINSTANCE.createEnum()
		var ent = FunctionblockFactory.eINSTANCE.createEntity()
		
		ent.setName("TransAction")
		enm.setName("TransActionZ")
		
		fbmodel.elements.add(ent)
		fbmodel.enums.add(enm)
		
		tester.validator().checkEnumNameAgainstEntityName(enm)
		tester.diagnose().assertOK
	}
	
	@Test
	def test_Enum_Empty_Literal() {
		
		var enum1 = FunctionblockFactory.eINSTANCE.createEnum();
		enum1.setName("Abc");
		
		tester.validator().checkEnum(enum1);
		tester.diagnose().assertErrorContains(SystemMessage.ERROR_ENUM_CANNOT_BE_EMPTY);
		
		var lit = FunctionblockFactory.eINSTANCE.createEnumLiteral;
		lit.setLiteral("test")
		
		enum1.enums.add(lit)
		
		tester.validator().checkEnumName(enum1);
		tester.diagnose().assertOK
		
	}
	
}