| /******************************************************************************* |
| * Copyright (c) 2007 BEA Systems, Inc and others |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * BEA Systems, Inc - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.j2ee.classpath.tests; |
| |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.jst.j2ee.classpath.tests.util.ClasspathDependencyTestUtil; |
| import org.eclipse.jst.j2ee.classpathdep.UpdateClasspathAttributeUtil; |
| import org.eclipse.jst.j2ee.dependency.tests.util.DependencyCreationUtil; |
| import org.eclipse.jst.j2ee.dependency.tests.util.DependencyUtil; |
| import org.eclipse.jst.j2ee.dependency.tests.util.ProjectUtil; |
| import org.eclipse.jst.j2ee.internal.common.classpath.J2EEComponentClasspathContainer; |
| import org.eclipse.wst.common.componentcore.ComponentCore; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualResource; |
| |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| |
| /** |
| * Tests validation rules for classpath component dependencies. |
| */ |
| public class ClasspathDependencyValidationTests extends AbstractTests { |
| |
| private ClasspathDependencyValidationTests(final String name) { |
| super(name); |
| } |
| |
| public static Test suite(){ |
| final TestSuite suite = new TestSuite(); |
| suite.setName("Classpath Component Dependency Validation Tests" ); |
| suite.addTest(new ClasspathDependencyValidationTests("testSourceEntryRule")); |
| suite.addTest(new ClasspathDependencyValidationTests("testProjectEntryRule")); |
| suite.addTest(new ClasspathDependencyValidationTests("testDuplicateClassFolderRule")); |
| suite.addTest(new ClasspathDependencyValidationTests("testNonWebNonExportedRule")); |
| //suite.addTest(new ClasspathDependencyValidationTests("testDuplicateArchiveNamesRule")); |
| suite.addTest(new ClasspathDependencyValidationTests("testRootMappingNonEARWARRefRule")); |
| suite.addTest(new ClasspathDependencyValidationTests("testInvalidContainerRules")); |
| suite.addTest(new ClasspathDependencyValidationTests("testNonTaggedExportedClassesRule")); |
| |
| return suite; |
| } |
| //SourceEntry=Invalid classpath component dependency {0}. Source entries not supported. |
| public void testSourceEntryRule() throws Exception { |
| final IProject project = ProjectUtil.createUtilityProject("TestUtil", "TestEAR", true); |
| ClasspathDependencyTestUtil.verifyNoValidationError(project); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| |
| IClasspathEntry[] entries = javaProject.getRawClasspath(); |
| IClasspathEntry src = null; |
| for (int i = 0; i < entries.length; i++) { |
| if (entries[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { |
| src = entries[i]; |
| break; |
| } |
| } |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), src); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyError(project); |
| |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, project.getName(), src); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencyError(project); |
| } |
| |
| //ProjectClasspathEntry=Invalid classpath component dependency {0}. Project entries not supported. |
| public void testProjectEntryRule() throws Exception { |
| final IProject utilProject = ProjectUtil.createUtilityProject("TestUtil", "TestEAR"); |
| final IProject webProject = ProjectUtil.createWebProject("TestWeb", "TestEAR", true); |
| final IJavaProject webJavaProject = JavaCore.create(webProject); |
| final IVirtualComponent webComp = ComponentCore.createComponent(webProject); |
| |
| final IClasspathEntry entry = JavaCore.newProjectEntry(utilProject.getFullPath()); |
| ClasspathDependencyTestUtil.addEntryToCP(webJavaProject, entry); |
| |
| DependencyUtil.waitForValidationJobs(webProject); |
| ClasspathDependencyTestUtil.verifyNoValidationError(webProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(webJavaProject); |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(webJavaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(webComp); |
| |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, webProject.getName(), entry); |
| |
| DependencyUtil.waitForValidationJobs(webProject); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyError(webProject); |
| |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, webProject.getName(), entry); |
| |
| DependencyUtil.waitForValidationJobs(webProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencyError(webProject); |
| } |
| |
| //DuplicateClassFolderEntry |
| public void testDuplicateClassFolderRule() throws Exception { |
| final IProject project = ProjectUtil.createUtilityProject("TestUtil", "TestEAR", true); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| final IPath classFolderPath = project.getFullPath().append(ClasspathDependencyTestUtil.TEST3_BIN_PATH); |
| |
| // create a library classpath entry |
| ClasspathDependencyTestUtil.addLibraryEntry(javaProject, classFolderPath, true); |
| |
| // link via the component file |
| comp.getRootFolder().createLink(ClasspathDependencyTestUtil.TEST3_BIN_PATH, IVirtualResource.FORCE, null); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoValidationError(project); |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| |
| IClasspathEntry[] entries = javaProject.getRawClasspath(); |
| IClasspathEntry lib = null; |
| for (int i = 0; i < entries.length; i++) { |
| if (entries[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) { |
| lib = entries[i]; |
| break; |
| } |
| } |
| |
| // Mark that cp entry for publish/export |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), lib); |
| |
| final Set entryPaths = Collections.singleton(classFolderPath); |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyClasspathAttributes(javaProject, entryPaths); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyError(project); |
| |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, project.getName(), lib); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencyError(project); |
| } |
| |
| //NonWebNonExported=Invalid classpath component dependency {0}. Classpath component dependencies for non-web projects must be exported. |
| public void testNonWebNonExportedRule() throws Exception { |
| final IProject project = ProjectUtil.createUtilityProject("TestUtil", "TestEAR", true); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| |
| ClasspathDependencyTestUtil.addLibraryEntry(javaProject, ClasspathDependencyTestUtil.TEST3_JAR_PATH, false); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoValidationError(project); |
| final Set entryPaths = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR_PATH); |
| List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(javaProject, entryPaths); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| |
| IClasspathEntry entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), entry); |
| |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyClasspathAttributes(javaProject, entryPaths); |
| final Set archiveNames = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR); |
| ClasspathDependencyTestUtil.verifyClasspathDependencies(comp, archiveNames); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyMarker(project); |
| } |
| |
| //DuplicateArchiveName=Invalid classpath component dependency {0}. The project contains another classpath component dependency the same archive name. |
| public void testDuplicateArchiveNamesRule() throws Exception { |
| final IProject webProject = ProjectUtil.createWebProject("TestWeb", "TestEAR"); |
| final IJavaProject webJavaProject = JavaCore.create(webProject); |
| final IProject util1 = ProjectUtil.createUtilityProject("TestUtil1", "TestEAR"); |
| DependencyCreationUtil.createWebLibDependency(webProject, util1); |
| final IJavaProject utilJava1 = JavaCore.create(util1); |
| final IVirtualComponent utilComp1 = ComponentCore.createComponent(util1); |
| final IProject util2 = ProjectUtil.createUtilityProject("TestUtil2", "TestEAR"); |
| DependencyCreationUtil.createWebLibDependency(webProject, util2); |
| final IVirtualComponent utilComp2 = ComponentCore.createComponent(util2); |
| final IJavaProject utilJava2 = JavaCore.create(util2); |
| final IProject util3 = ProjectUtil.createUtilityProject("TestUtil3", "TestEAR", true); |
| DependencyCreationUtil.createWebLibDependency(webProject, util3); |
| final IVirtualComponent utilComp3 = ComponentCore.createComponent(util3); |
| final IJavaProject utilJava3 = JavaCore.create(util3); |
| ClasspathDependencyTestUtil.addLibraryEntry(utilJava1, ClasspathDependencyTestUtil.TEST3_JAR_PATH, true); |
| ClasspathDependencyTestUtil.addLibraryEntry(utilJava2, ClasspathDependencyTestUtil.TEST3_JAR_PATH, true); |
| ClasspathDependencyTestUtil.addLibraryEntry(utilJava3, ClasspathDependencyTestUtil.TEST3_JAR_OTHER_LOCATION_PATH, true); |
| final Set entryPaths = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR_PATH); |
| final Set otherEntryPaths = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR_OTHER_LOCATION_PATH); |
| final Set archiveNames = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR); |
| |
| |
| // add the dependency attribute to util1 and util2 (these point to the same jar so won't |
| // generate a validation error) |
| List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(utilJava1, entryPaths); |
| IClasspathEntry entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, util1.getName(), entry); |
| ClasspathDependencyTestUtil.verifyClasspathDependencies(utilComp1, archiveNames); |
| entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(utilJava2, entryPaths); |
| entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, util2.getName(), entry); |
| ClasspathDependencyTestUtil.verifyClasspathDependencies(utilComp2, archiveNames); |
| |
| // no validation error on the EAR or Web |
| DependencyUtil.waitForValidationJobs(webProject); |
| IProject earProject = ProjectUtil.getProject("TestEAR"); |
| ClasspathDependencyTestUtil.verifyNoValidationError(earProject); |
| ClasspathDependencyTestUtil.verifyNoValidationError(webProject); |
| |
| // add the dependency attribute to util3 |
| entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(utilJava3, otherEntryPaths); |
| entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, util3.getName(), entry); |
| ClasspathDependencyTestUtil.verifyClasspathDependencies(utilComp3, archiveNames); |
| |
| // will have a validation error on the EAR and on the Web |
| DependencyUtil.waitForValidationJobs(webProject); |
| DependencyUtil.waitForValidationJobs(earProject); |
| ClasspathDependencyTestUtil.verifyValidationError(webProject); |
| ClasspathDependencyTestUtil.verifyValidationError(earProject); |
| |
| // remove dependency attribute from util3 |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, util3.getName(), entry); |
| |
| // will have no validation errors on the EAR and on the Web |
| DependencyUtil.waitForValidationJobs(webProject); |
| DependencyUtil.waitForValidationJobs(earProject); |
| ClasspathDependencyTestUtil.verifyNoValidationError(webProject); |
| ClasspathDependencyTestUtil.verifyNoValidationError(earProject); |
| } |
| |
| //RootMappingNonEARWARRef=Non-web projects must be referenced by an EAR or a WAR to use classpath component dependencies. |
| public void testRootMappingNonEARWARRefRule() throws Exception { |
| final IProject project = ProjectUtil.createUtilityProject("TestUtil", null, true); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| |
| ClasspathDependencyTestUtil.addLibraryEntry(javaProject, ClasspathDependencyTestUtil.TEST3_JAR_PATH, true); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoValidationError(project); |
| final Set entryPaths = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR_PATH); |
| List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(javaProject, entryPaths); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| IClasspathEntry entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), entry); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyMarker(project); |
| |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyClasspathAttributes(javaProject, entryPaths); |
| final Set archiveNames = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR); |
| ClasspathDependencyTestUtil.verifyClasspathDependencies(comp, archiveNames); |
| |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, project.getName(), entry); |
| |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| } |
| |
| //EarLibrariesContainer=Invalid classpath component dependency {0}. The EAR Libraries classpath container cannot be exposed. |
| //WebAppLibrariesContainer=Invalid classpath component dependency {0}. The Web App Libraries classpath container cannot be exposed. |
| //RuntimeClasspathContainer=Invalid classpath component dependency {0}. Server Runtime classpath containers cannot be exposed. |
| //JREContainer=Invalid classpath component dependency {0}. JRE classpath containers cannot be exposed. |
| public void testInvalidContainerRules() throws Exception { |
| final IProject project = ProjectUtil.createWebProject("TestWeb", "TestEAR", true); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoValidationError(project); |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| |
| IClasspathEntry earLibContainer = null; |
| IClasspathEntry webAppLibContainer = null; |
| IClasspathEntry jreContainer = null; |
| IClasspathEntry[] rawCP = javaProject.getRawClasspath(); |
| for (int i = 0; i < rawCP.length; i++) { |
| if (rawCP[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER) { |
| final IPath path = rawCP[i].getPath(); |
| if (path.equals(J2EEComponentClasspathContainer.CONTAINER_PATH)) { |
| earLibContainer = rawCP[i]; |
| } else if (path.segment(0).equals("org.eclipse.jst.j2ee.internal.web.container")) { |
| webAppLibContainer = rawCP[i]; |
| } else if (path.segment(0).equals(JavaRuntime.JRE_CONTAINER)) { |
| jreContainer = rawCP[i]; |
| } |
| } |
| } |
| |
| // XXX Encountering sporadic JUnit problems trying to wait for and verify results of validator |
| // the ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject) will need to be |
| // sufficient for now: the results of that call are computed by calling the validator |
| |
| // try adding the Ear Libraries container |
| //testInvalidContainer(javaProject, earLibContainer); |
| |
| // try adding the Web App Libraries container |
| //testInvalidContainer(javaProject, webAppLibContainer); |
| |
| // try adding the JRE container |
| //testInvalidContainer(javaProject, jreContainer); |
| } |
| |
| private void testInvalidContainer(final IJavaProject javaProject, final IClasspathEntry entry) throws Exception { |
| IProject project = javaProject.getProject(); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), entry); |
| ClasspathDependencyTestUtil.verifyClasspathAttributes(javaProject, Collections.singleton(entry.getPath())); |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyError(project); |
| UpdateClasspathAttributeUtil.removeDependencyAttribute(null, project.getName(), entry); |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencyError(project); |
| } |
| |
| //NonTaggedExportedClasses=Classpath entry {0} will not be exported or published. Runtime ClassNotFoundExceptions may result. |
| public void testNonTaggedExportedClassesRule() throws Exception { |
| final IProject project = ProjectUtil.createUtilityProject("TestUtil", "TestEAR", true); |
| final IJavaProject javaProject = JavaCore.create(project); |
| final IVirtualComponent comp = ComponentCore.createComponent(project); |
| |
| ClasspathDependencyTestUtil.addLibraryEntry(javaProject, ClasspathDependencyTestUtil.TEST3_JAR_PATH, true); |
| |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyClasspathDependencyMarker(project); |
| final Set entryPaths = Collections.singleton(ClasspathDependencyTestUtil.TEST3_JAR_PATH); |
| List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(javaProject, entryPaths); |
| ClasspathDependencyTestUtil.verifyNoClasspathAttributes(javaProject); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencies(comp); |
| IClasspathEntry entry = (IClasspathEntry) entries.get(0); |
| UpdateClasspathAttributeUtil.addDependencyAttribute(null, project.getName(), entry); |
| |
| ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(javaProject); |
| ClasspathDependencyTestUtil.verifyClasspathAttributes(javaProject, entryPaths); |
| DependencyUtil.waitForValidationJobs(project); |
| ClasspathDependencyTestUtil.verifyNoClasspathDependencyMarker(project); |
| } |
| |
| } |
