From f443c081fea86cf57f1d4f9267a3493e358da599 Mon Sep 17 00:00:00 2001 From: dmurat Date: Thu, 4 Nov 2010 01:40:05 +0100 Subject: [PATCH] GRAILS-6584 - Fixed - Allow reuse of constrains in commands --- .../grails/validation/AbstractConstraint.java | 4 + .../ConstrainedPropertyBuilder.java | 111 +++- .../groovy/grails/validation/Constraint.java | 2 + ...ainedPropertyBuiderForCommandsTests.groovy | 513 ++++++++++++++++++ 4 files changed, 625 insertions(+), 5 deletions(-) create mode 100644 src/test/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuiderForCommandsTests.groovy diff --git a/src/java/org/codehaus/groovy/grails/validation/AbstractConstraint.java b/src/java/org/codehaus/groovy/grails/validation/AbstractConstraint.java index af8aab158b6..b2a90e79615 100644 --- a/src/java/org/codehaus/groovy/grails/validation/AbstractConstraint.java +++ b/src/java/org/codehaus/groovy/grails/validation/AbstractConstraint.java @@ -79,6 +79,10 @@ public void setParameter(Object constraintParameter) { this.constraintParameter = constraintParameter; } + public Object getParameter() { + return this.constraintParameter; + } + protected void checkState() { Assert.hasLength(constraintPropertyName, "Property 'propertyName' must be set on the constraint"); Assert.notNull(constraintOwningClass, "Property 'owningClass' must be set on the constraint"); diff --git a/src/java/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuilder.java b/src/java/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuilder.java index b731e5ee7c5..ebbad6a9a61 100644 --- a/src/java/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuilder.java +++ b/src/java/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuilder.java @@ -18,12 +18,20 @@ import groovy.lang.MissingMethodException; import groovy.util.BuilderSupport; -import java.util.Collections; -import java.util.HashMap; +import java.beans.PropertyDescriptor; import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.ArrayList; +import java.util.Collections; import org.codehaus.groovy.grails.commons.ClassPropertyFetcher; +import org.codehaus.groovy.grails.commons.GrailsApplication; +import org.codehaus.groovy.grails.commons.GrailsDomainClass; +import org.codehaus.groovy.grails.commons.DomainClassArtefactHandler; +import org.codehaus.groovy.grails.web.servlet.mvc.GrailsWebRequest; import org.springframework.beans.InvalidPropertyException; +import org.springframework.web.context.request.RequestContextHolder; /** * Builder used as a delegate within the "constraints" closure of GrailsDomainClass instances . @@ -38,6 +46,7 @@ public class ConstrainedPropertyBuilder extends BuilderSupport { private Class targetClass; private ClassPropertyFetcher classPropertyFetcher; private static final String SHARED_CONSTRAINT = "shared"; + private static final String IMPORT_FROM_CONSTRAINT = "importFrom"; public ConstrainedPropertyBuilder(Object target) { this(target.getClass()); @@ -70,8 +79,10 @@ protected Object createNode(Object name, Map attributes) { } if (cp.getPropertyType() == null) { - GrailsUtil.warn("Property [" + cp.getPropertyName() + "] not found in domain class " + - targetClass.getName() + "; cannot apply constraints: " + attributes); + if (!IMPORT_FROM_CONSTRAINT.equals(name)) { + GrailsUtil.warn("Property [" + cp.getPropertyName() + "] not found in domain class " + + targetClass.getName() + "; cannot apply constraints: " + attributes); + } return cp; } @@ -102,6 +113,7 @@ protected Object createNode(Object name, Map attributes) { } } } + return cp; } catch(InvalidPropertyException ipe) { @@ -112,7 +124,96 @@ protected Object createNode(Object name, Map attributes) { @SuppressWarnings("rawtypes") @Override protected Object createNode(Object name, Map attributes, Object value) { - throw new MissingMethodException((String)name,targetClass,new Object[]{ attributes,value}); + if (IMPORT_FROM_CONSTRAINT.equals(name) && (value instanceof Class)) { + return handleImportFrom(attributes, (Class) value); + } + else { + throw new MissingMethodException((String)name,targetClass,new Object[]{ attributes,value}); + } + } + + @SuppressWarnings("unchecked") + private Object handleImportFrom(Map attributes, Class importFromClazz) { + GrailsWebRequest grailsWebRequest = (GrailsWebRequest) RequestContextHolder.currentRequestAttributes(); + if (grailsWebRequest == null) { + String message = + "Web request can't be found. Importing constraints is only allowed FROM domain classes TO " + + "command classes in running Grails application."; + throw new IllegalArgumentException(message); + } + + GrailsApplication grailsApplication = grailsWebRequest.getAttributes().getGrailsApplication(); + GrailsDomainClass importFromGrailsDomainClazz = + (GrailsDomainClass) grailsApplication.getArtefact( + DomainClassArtefactHandler.TYPE, importFromClazz.getName()); + + if (importFromGrailsDomainClazz == null) { + String message = + "Class '" + importFromClazz.getName() + "' is not a domain class. Importing constraints is only " + + "allowed FROM domain classes TO command classes."; + throw new IllegalArgumentException(message); + } + + Map importFromConstrainedProperties = importFromGrailsDomainClazz.getConstrainedProperties(); + + PropertyDescriptor[] targetPropertyDescriptorArray = classPropertyFetcher.getPropertyDescriptors(); + + List toBeIncludedPropertyNamesParam = (List) attributes.get("include"); + List toBeExcludedPropertyNamesParam = (List) attributes.get("exclude"); + + List resultingPropertyNames = new ArrayList(); + for (PropertyDescriptor targetPropertyDescriptor : targetPropertyDescriptorArray) { + String targetPropertyName = targetPropertyDescriptor.getName(); + + if (toBeIncludedPropertyNamesParam == null) { + resultingPropertyNames.add(targetPropertyName); + } + else if (isListOfRegexpsContainsString(toBeIncludedPropertyNamesParam, targetPropertyName)) { + resultingPropertyNames.add(targetPropertyName); + } + + if (toBeExcludedPropertyNamesParam != null + && isListOfRegexpsContainsString(toBeExcludedPropertyNamesParam, targetPropertyName)) { + resultingPropertyNames.remove(targetPropertyName); + } + } + + resultingPropertyNames.remove("class"); + resultingPropertyNames.remove("metaClass"); + + for (String targetPropertyName : resultingPropertyNames) { + ConstrainedProperty importFromConstrainedProperty = + (ConstrainedProperty) importFromConstrainedProperties.get(targetPropertyName); + + if (importFromConstrainedProperty != null) { + // Map importFromConstrainedPropertyAttributes = importFromConstrainedProperty.getAttributes(); + // createNode(targetPropertyName, importFromConstrainedPropertyAttributes); + Map importFromConstrainedPropertyAttributes = new HashMap(); + for (Constraint importFromAppliedConstraint : importFromConstrainedProperty.getAppliedConstraints()) { + String importFromAppliedConstraintName = importFromAppliedConstraint.getName(); + Object importFromAppliedConstraintParameter = importFromAppliedConstraint.getParameter(); + importFromConstrainedPropertyAttributes.put( + importFromAppliedConstraintName, importFromAppliedConstraintParameter); + } + + createNode(targetPropertyName, importFromConstrainedPropertyAttributes); + } + } + + return null; + } + + private boolean isListOfRegexpsContainsString(List listOfStrings, String stringToMatch) { + boolean result = false; + + for (String listElement:listOfStrings) { + if (stringToMatch.matches(listElement)) { + result = true; + break; + } + } + + return result; } @Override diff --git a/src/java/org/codehaus/groovy/grails/validation/Constraint.java b/src/java/org/codehaus/groovy/grails/validation/Constraint.java index 470ef865952..4d114f63a2b 100644 --- a/src/java/org/codehaus/groovy/grails/validation/Constraint.java +++ b/src/java/org/codehaus/groovy/grails/validation/Constraint.java @@ -51,6 +51,8 @@ public interface Constraint extends MessageSourceAware { */ void setParameter(Object parameter); + Object getParameter(); + /** * The class the constraint applies to * diff --git a/src/test/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuiderForCommandsTests.groovy b/src/test/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuiderForCommandsTests.groovy new file mode 100644 index 00000000000..53d40b1628b --- /dev/null +++ b/src/test/org/codehaus/groovy/grails/validation/ConstrainedPropertyBuiderForCommandsTests.groovy @@ -0,0 +1,513 @@ +package org.codehaus.groovy.grails.validation + +import org.codehaus.groovy.grails.web.servlet.mvc.AbstractGrailsControllerTests +import org.codehaus.groovy.grails.web.plugins.support.WebMetaUtils + +/** + * Tests constraints building specific for command objects + */ +class ConstrainedPropertyBuiderForCommandsTests extends AbstractGrailsControllerTests { + protected void onSetUp() { + parseDomainTestClasses() + } + + private void parseDomainTestClasses() { + gcl.parseClass(''' + class Person { + Long id + Long version + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + firstName(nullable:false, blank:false, maxSize:30) + lastName(nullable:false, blank:false, maxSize:50) + middleName(nullable:true, blank:false, notEqual:"myMiddleName") + telephone(nullable:true, blank:false, matches:"123123") + email(nullable:true, blank:false, email:true) + } + }''') + } + + private void parseCommandTestClasses() { + gcl.parseClass(''' + class PersonAllConstraintsNoNormalConstraintsCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person + } + }''') + + gcl.parseClass(''' + class PersonSomeConstraintsNoNormalConstraintsCommand { + String firstName + String lastName + + static constraints = { + importFrom Person + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsWithNormalConstraintsFirstCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + firstName(nullable:true, blank:true, maxSize:10) + lastName(nullable:true, blank:true, maxSize:20) + email(nullable:false, blank:true, email:true) + + importFrom Person + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsWithNormalConstraintsLastCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person + + firstName(nullable:true, blank:true, maxSize:10) + lastName(nullable:true, blank:true, maxSize:20) + email(nullable:false, blank:true, email:true) + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsNoNormalConstraintsIncludingCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person, include:["firstName", "lastName"] + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsNoNormalConstraintsExcludingCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person, exclude:["firstName", "lastName"] + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsNoNormalConstraintsIncludingByRegexpCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person, include:[".*Name"] + } + }''') + + gcl.parseClass(''' + class PersonAllConstraintsNoNormalConstraintsIncludingExcludingByRegexpCommand { + String firstName + String lastName + String middleName + String telephone + String email + + static constraints = { + importFrom Person, include:[".*Name"], exclude:["m.*Name"] + } + }''') + } + + public void testImportFrom_AllConstraints_ConstraintsExist() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsNoNormalConstraintsCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(5, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("email")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("email")) + } + + public void testImportFrom_AllConstraints_Validation() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsNoNormalConstraintsCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + personCommand.firstName = "firstName" + personCommand.lastName = "lastName" + personCommand.validate() + + assertFalse(personCommand.hasErrors()) + + personCommand.clearErrors() + personCommand.firstName = null + personCommand.validate() + + assertTrue(personCommand.hasErrors()) + assertEquals(1, personCommand.getErrors().getErrorCount()) + assertEquals(1, personCommand.getErrors().getFieldErrors("firstName").size()) + assertNull(personCommand.getErrors().getFieldErrors("firstName")[0].getRejectedValue()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + + person.firstName = "firstName" + person.lastName = "lastName" + person.validate() + + assertFalse(person.hasErrors()) + + person.clearErrors() + person.firstName = null + person.validate() + + assertTrue(person.hasErrors()) + assertEquals(1, person.getErrors().getErrorCount()) + assertEquals(1, person.getErrors().getFieldErrors("firstName").size()) + assertNull(person.getErrors().getFieldErrors("firstName")[0].getRejectedValue()) + } + + public void testImportFrom_SomeConstraints_ConstraintsExist() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonSomeConstraintsNoNormalConstraintsCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(2, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("firstName")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("firstName")) + assertNotNull(person.getConstraints().get("email")) + } + + public void testImportFrom_SomeConstraints_Validation() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonSomeConstraintsNoNormalConstraintsCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + personCommand.firstName = "firstName" + personCommand.lastName = "lastName" + personCommand.validate() + + assertFalse(personCommand.hasErrors()) + + personCommand.clearErrors() + personCommand.firstName = null + personCommand.validate() + + assertTrue(personCommand.hasErrors()) + assertEquals(1, personCommand.getErrors().getErrorCount()) + assertEquals(1, personCommand.getErrors().getFieldErrors("firstName").size()) + assertNull(personCommand.getErrors().getFieldErrors("firstName")[0].getRejectedValue()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + + person.firstName = "firstName" + person.lastName = "lastName" + person.email = "someemail@some.net" + person.validate() + + assertFalse(person.hasErrors()) + + person.clearErrors() + person.email = "wrongEmail" + person.validate() + + assertTrue(person.hasErrors()) + assertEquals(1, person.getErrors().getErrorCount()) + assertEquals(1, person.getErrors().getFieldErrors("email").size()) + assertEquals("wrongEmail", person.getErrors().getFieldErrors("email")[0].getRejectedValue()) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_NormalConstraintsFirst() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsWithNormalConstraintsFirstCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(5, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("telephone")) + + assertEquals(30, personCommand.getConstraints().get("firstName").getAppliedConstraint("maxSize").getParameter()) + assertEquals(50, personCommand.getConstraints().get("lastName").getAppliedConstraint("maxSize").getParameter()) + assertEquals( + "123123", + personCommand.getConstraints().get("telephone").getAppliedConstraint("matches").getParameter()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("telephone")) + + assertEquals(30, person.getConstraints().get("firstName").getAppliedConstraint("maxSize").getParameter()) + assertEquals(50, person.getConstraints().get("lastName").getAppliedConstraint("maxSize").getParameter()) + assertEquals("123123", person.getConstraints().get("telephone").getAppliedConstraint("matches").getParameter()) + } + + public void testImportFrom_AllConstraints_Validation_NormalConstraintsFirst() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsWithNormalConstraintsFirstCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + personCommand.firstName = "firstName" + personCommand.lastName = "lastName" + personCommand.validate() + + assertFalse(personCommand.hasErrors()) + + personCommand.clearErrors() + personCommand.firstName = null + personCommand.lastName = null + personCommand.validate() + + assertTrue(personCommand.hasErrors()) + assertEquals(2, personCommand.getErrors().getErrorCount()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + + person.firstName = "firstName" + person.lastName = "lastName" + person.email = "someemail@some.net" + person.validate() + + assertFalse(person.hasErrors()) + + person.clearErrors() + person.firstName = null + person.email = "wrongEmail" + person.validate() + + assertTrue(person.hasErrors()) + assertEquals(2, person.getErrors().getErrorCount()) + assertEquals(1, person.getErrors().getFieldErrors("firstName").size()) + assertNull(person.getErrors().getFieldErrors("firstName")[0].getRejectedValue()) + assertEquals(1, person.getErrors().getFieldErrors("email").size()) + assertEquals("wrongEmail", person.getErrors().getFieldErrors("email")[0].getRejectedValue()) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_NormalConstraintsLast() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsWithNormalConstraintsLastCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(5, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("telephone")) + + assertEquals(10, personCommand.getConstraints().get("firstName").getAppliedConstraint("maxSize").getParameter()) + assertEquals(20, personCommand.getConstraints().get("lastName").getAppliedConstraint("maxSize").getParameter()) + assertEquals( + "123123", + personCommand.getConstraints().get("telephone").getAppliedConstraint("matches").getParameter()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("telephone")) + + assertEquals(30, person.getConstraints().get("firstName").getAppliedConstraint("maxSize").getParameter()) + assertEquals(50, person.getConstraints().get("lastName").getAppliedConstraint("maxSize").getParameter()) + assertEquals("123123", person.getConstraints().get("telephone").getAppliedConstraint("matches").getParameter()) + } + + public void testImportFrom_AllConstraints_Validation_NormalConstraintsLast() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsWithNormalConstraintsLastCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + personCommand.firstName = null + personCommand.lastName = null + personCommand.email = "someemail@some.net" + personCommand.validate() + + assertFalse(personCommand.hasErrors()) + + personCommand.clearErrors() + personCommand.firstName = null + personCommand.lastName = null + personCommand.email = "wrongEmail" + personCommand.validate() + + assertTrue(personCommand.hasErrors()) + assertEquals(1, personCommand.getErrors().getErrorCount()) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + + person.firstName = "firstName" + person.lastName = "lastName" + person.email = "someemail@some.net" + person.validate() + + assertFalse(person.hasErrors()) + + person.clearErrors() + person.firstName = null + person.email = "wrongEmail" + person.validate() + + assertTrue(person.hasErrors()) + assertEquals(2, person.getErrors().getErrorCount()) + assertEquals(1, person.getErrors().getFieldErrors("firstName").size()) + assertNull(person.getErrors().getFieldErrors("firstName")[0].getRejectedValue()) + assertEquals(1, person.getErrors().getFieldErrors("email").size()) + assertEquals("wrongEmail", person.getErrors().getFieldErrors("email")[0].getRejectedValue()) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_Including() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsNoNormalConstraintsIncludingCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(2, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("firstName")) + assertNull(personCommand.getConstraints().get("email")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("firstName")) + assertNotNull(person.getConstraints().get("email")) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_Excluding() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsNoNormalConstraintsExcludingCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(3, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNull(personCommand.getConstraints().get("firstName")) + assertNull(personCommand.getConstraints().get("lastName")) + assertNotNull(personCommand.getConstraints().get("email")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("firstName")) + assertNotNull(person.getConstraints().get("email")) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_IncludingByRegexp() { + parseCommandTestClasses() + def personCommandClazz = gcl.loadClass("PersonAllConstraintsNoNormalConstraintsIncludingByRegexpCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(3, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("firstName")) + assertNotNull(personCommand.getConstraints().get("lastName")) + assertNotNull(personCommand.getConstraints().get("middleName")) + assertNull(personCommand.getConstraints().get("email")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("firstName")) + assertNotNull(person.getConstraints().get("email")) + } + + public void testImportFrom_AllConstraints_ConstraintsExist_IncludingExcludingByRegexp() { + parseCommandTestClasses() + def personCommandClazz = + gcl.loadClass("PersonAllConstraintsNoNormalConstraintsIncludingExcludingByRegexpCommand") + + WebMetaUtils.enhanceCommandObject(appCtx, personCommandClazz) + def personCommand = personCommandClazz.newInstance() + + assertNotNull(personCommand.getConstraints()) + assertEquals(2, personCommand.getConstraints().size()) + assertNull(personCommand.getConstraints().get("importFrom")) + assertNotNull(personCommand.getConstraints().get("firstName")) + assertNotNull(personCommand.getConstraints().get("lastName")) + assertNull(personCommand.getConstraints().get("middleName")) + assertNull(personCommand.getConstraints().get("email")) + + // Now check that everything is ok with domain class + def person = gcl.loadClass("Person").newInstance() + assertNotNull(person.getConstraints()) + assertEquals(5, person.getConstraints().size()) + assertNull(person.getConstraints().get("importFrom")) + assertNotNull(person.getConstraints().get("firstName")) + assertNotNull(person.getConstraints().get("email")) + } +}