/** @return a test for the find (by ID) method, if available and requested (may return null) */ private MethodMetadataBuilder getFindMethodTest( final MemberTypeAdditions findMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isFind() || findMethod == null || identifierAccessorMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(identifierAccessorMethod.getReturnType()); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find method for '" + entityName + "' illegally returned null for id '\" + id + \"'\", obj);"); bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Find method for '" + entityName + "' returned the incorrect identifier\", id, obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the find all method, if available and requested (may return null) */ private MethodMetadataBuilder getFindAllMethodTest( final MemberTypeAdditions findAllMethod, final MemberTypeAdditions countMethod) { if (!annotationValues.isFindAll() || findAllMethod == null || countMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findAllMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(LIST); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Too expensive to perform a find all test for '" + entityName + "', as there are \" + count + \" entries; set the findAllMaximum to exceed this value or set findAll=false on the integration test annotation to disable the test\", count < " + annotationValues.getFindAllMaximum() + ");"); bodyBuilder.appendFormalLine( "List<" + entityName + "> result = " + findAllMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find all method for '" + entityName + "' illegally returned null\", result);"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Find all method for '" + entityName + "' failed to return any data\", result.size() > 0);"); findAllMethod.copyAdditionsTo(builder, governorTypeDetails); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the find entries method, if available and requested (may return null) */ private MethodMetadataBuilder getFindEntriesMethodTest( final MemberTypeAdditions countMethod, final MemberTypeAdditions findEntriesMethod) { if (!annotationValues.isFindEntries() || countMethod == null || findEntriesMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findEntriesMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(LIST); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine("if (count > 20) count = 20;"); bodyBuilder.appendFormalLine("int firstResult = 0;"); bodyBuilder.appendFormalLine("int maxResults = (int) count;"); bodyBuilder.appendFormalLine( "List<" + entityName + "> result = " + findEntriesMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find entries method for '" + entityName + "' illegally returned null\", result);"); bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Find entries method for '" + entityName + "' returned an incorrect number of entries\", count, result.size());"); findEntriesMethod.copyAdditionsTo(builder, governorTypeDetails); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the count method, if available and requested (may return null) */ private MethodMetadataBuilder getCountMethodTest(final MemberTypeAdditions countMethod) { if (!annotationValues.isCount() || countMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(countMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Counter for '" + entityName + "' incorrectly reported there were no entries\", count > 0);"); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the persist method, if available and requested (may return null) */ private MethodMetadataBuilder getRemoveMethodTest( final MemberTypeAdditions removeMethod, final MemberTypeAdditions findMethod, final MemberTypeAdditions flushMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isRemove() || removeMethod == null || findMethod == null || identifierAccessorMethod == null) { // User does not want this method or one of its core dependencies return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(removeMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(identifierAccessorMethod.getReturnType()); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); if (isGaeSupported) { AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(transactionManager) && !"transactionManager".equals(transactionManager)) { transactionalBuilder.addStringAttribute("value", transactionManager); } transactionalBuilder.addEnumAttribute( "propagation", new EnumDetails(PROPAGATION, new JavaSymbolName("SUPPORTS"))); annotations.add(transactionalBuilder); } final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine(removeMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertNull(\"Failed to remove '" + entityName + "' with identifier '\" + id + \"'\", " + findMethod.getMethodCall() + ");"); removeMethod.copyAdditionsTo(builder, governorTypeDetails); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the persist method, if available and requested (may return null) */ private MethodMetadataBuilder getPersistMethodTest( final MemberTypeAdditions persistMethod, final MemberTypeAdditions flushMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isPersist() || persistMethod == null || identifierAccessorMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(persistMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getNewTransientEntityMethod().getMethodName().getSymbolName() + "(Integer.MAX_VALUE);"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide a new transient entity\", obj);"); if (!hasEmbeddedIdentifier) { bodyBuilder.appendFormalLine( "Assert.assertNull(\"Expected '" + entityName + "' identifier to be null\", obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); } bodyBuilder.appendFormalLine(persistMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Expected '" + entityName + "' identifier to no longer be null\", obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); persistMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the merge method, if available and requested (may return null) */ private MethodMetadataBuilder getMergeMethodTest( final MemberTypeAdditions mergeMethod, final MemberTypeAdditions findMethod, final MemberTypeAdditions flushMethod, final MethodMetadata versionAccessorMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isMerge() || mergeMethod == null || versionAccessorMethod == null || findMethod == null || identifierAccessorMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(mergeMethod.getMethodName()) + "Update"); if (governorHasMethod(methodName)) { return null; } JavaType versionType = versionAccessorMethod.getReturnType(); builder .getImportRegistrationResolver() .addImports(identifierAccessorMethod.getReturnType(), versionType); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "boolean modified = dod." + dataOnDemandMetadata.getModifyMethod().getMethodName().getSymbolName() + "(obj);"); bodyBuilder.appendFormalLine( versionAccessorMethod.getReturnType().getSimpleTypeName() + " currentVersion = obj." + versionAccessorMethod.getMethodName().getSymbolName() + "();"); String castStr = entityHasSuperclass ? "(" + entityName + ")" : ""; bodyBuilder.appendFormalLine( entityName + " merged = " + castStr + mergeMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Identifier of merged object not the same as identifier of original object\", merged." + identifierAccessorMethod.getMethodName().getSymbolName() + "(), id);"); if (JdkJavaType.isDateField(versionType)) { bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Version for '" + entityName + "' failed to increment on merge and flush directive\", (currentVersion != null && obj." + versionAccessorMethod.getMethodName().getSymbolName() + "().after(currentVersion)) || !modified);"); } else { bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Version for '" + entityName + "' failed to increment on merge and flush directive\", (currentVersion != null && obj." + versionAccessorMethod.getMethodName().getSymbolName() + "() > currentVersion) || !modified);"); } mergeMethod.copyAdditionsTo(builder, governorTypeDetails); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** Adds the JUnit and Spring type level annotations if needed */ private void addRequiredIntegrationTestClassIntroductions(final JavaType dodGovernor) { // Add an @RunWith(SpringJunit4ClassRunner) annotation to the type, if // the user did not define it on the governor directly if (MemberFindingUtils.getAnnotationOfType(governorTypeDetails.getAnnotations(), RUN_WITH) == null) { AnnotationMetadataBuilder runWithBuilder = new AnnotationMetadataBuilder(RUN_WITH); runWithBuilder.addClassAttribute( "value", "org.springframework.test.context.junit4.SpringJUnit4ClassRunner"); builder.addAnnotation(runWithBuilder); } // Add an @ContextConfiguration("classpath:/applicationContext.xml") // annotation to the type, if the user did not define it on the governor // directly if (MemberFindingUtils.getAnnotationOfType( governorTypeDetails.getAnnotations(), CONTEXT_CONFIGURATION) == null) { AnnotationMetadataBuilder contextConfigurationBuilder = new AnnotationMetadataBuilder(CONTEXT_CONFIGURATION); contextConfigurationBuilder.addStringAttribute( "locations", "classpath:/META-INF/spring/applicationContext*.xml"); builder.addAnnotation(contextConfigurationBuilder); } // Add an @Transactional, if the user did not define it on the governor // directly if (annotationValues.isTransactional() && MemberFindingUtils.getAnnotationOfType( governorTypeDetails.getAnnotations(), TRANSACTIONAL) == null) { AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(transactionManager) && !"transactionManager".equals(transactionManager)) { transactionalBuilder.addStringAttribute("value", transactionManager); } builder.addAnnotation(transactionalBuilder); } // Add the data on demand field if the user did not define it on the // governor directly FieldMetadata field = governorTypeDetails.getField(new JavaSymbolName("dod")); if (field != null) { Assert.isTrue( field.getFieldType().equals(dodGovernor), "Field 'dod' on '" + destination.getFullyQualifiedTypeName() + "' must be of type '" + dodGovernor.getFullyQualifiedTypeName() + "'"); Assert.notNull( MemberFindingUtils.getAnnotationOfType(field.getAnnotations(), AUTOWIRED), "Field 'dod' on '" + destination.getFullyQualifiedTypeName() + "' must be annotated with @Autowired"); } else { // Add the field via the ITD List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(AUTOWIRED)); FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( getId(), Modifier.PRIVATE, annotations, new JavaSymbolName("dod"), dodGovernor); builder.addField(fieldBuilder); } builder.getImportRegistrationResolver().addImport(ASSERT); }