@Test
public void testLoadNull() {
initializeExpectedProject(1);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(null);
replay(resourceManager);
assertNull(resourceManager.get(PROJECT_INFO.projectId()));
}
private IFile createManifest(IProject project, IProgressMonitor monitor, PomParser bizPom) {
String manifestTemplate = ResourceHelper.content(templateRoot + "MANIFEST.MF");
String bizClientJar = "lib/" + bizPom.getArtifactId() + "-client.jar";
String manifest =
String.format(manifestTemplate, pi.getProjectName(), pi.getProjectId(), bizClientJar);
IFolder metaInf = project.getFolder("META-INF");
return EclipseHelper.createFile("MANIFEST.MF", metaInf, manifest, monitor);
}
@Test
public void testGet() {
initializeExpectedProject(1);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(expectedProject);
replay(resourceManager);
Project loadedProject = resourceManager.get(PROJECT_INFO.projectId());
assertEquals(expectedProject, loadedProject);
}
private IFile createGuidesign(IProject project, IProgressMonitor monitor) {
IFolder resourceFolder = (IFolder) project.findMember("src/main/resources");
String modelTemplate = ResourceHelper.content(templateRoot + "model.guidesign");
String path =
"platform:/resource/" + pi.getBusinessProjectId() + "/src/main/resources/model.btdesign";
String model =
String.format(
modelTemplate, path, pi.getProjectName().replace(" ", ""), resolveBusinessAppName());
return EclipseHelper.createFile("model.guidesign", resourceFolder, model, monitor);
}
@Test
public final void testGetProjectInfo() throws FailedToLoadProjectInfoException {
// TEST
final ProjectInfo projectInfo = Utils.getProjectInfo(Utils.class, "/auction-common.properties");
// VERIFY
assertThat(projectInfo.getName()).isEqualTo("Axon Auction Example - Common");
assertThat(projectInfo.getVersion()).isNotEmpty();
assertThat(projectInfo.getBuildTimestamp()).isNotNull();
}
@Test
public void testReload() {
initializeExpectedProject(2);
ProjectInfo newInfo = PROJECT_INFO.toBuilder().addLabel("k3", "v3").build();
Project expectedProject =
new Project(serviceMockReturnsOptions, new ProjectInfo.BuilderImpl(newInfo));
expect(resourceManager.options()).andReturn(mockOptions);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(expectedProject);
replay(resourceManager);
initializeProject();
Project newProject = project.reload();
assertEquals(expectedProject, newProject);
}
/**
* Treat the file specially if it represents a metadata file, which includes: - project
* description file (.project) - project preferences files (*.prefs)
*
* <p>This method is called whenever it is discovered that a file has been modified (added,
* removed, or changed).
*/
public void updateMetadataFiles() throws CoreException {
int count = path.segmentCount();
String name = path.segment(1);
// is this a project description file?
if (count == 2 && name.equals(IProjectDescription.DESCRIPTION_FILE_NAME)) {
Project project = (Project) getProject();
project.updateDescription();
// Discard stale project natures on ProjectInfo
ProjectInfo projectInfo = (ProjectInfo) project.getResourceInfo(false, true);
projectInfo.discardNatures();
return;
}
// check to see if we are in the .settings directory
if (count == 3 && EclipsePreferences.DEFAULT_PREFERENCES_DIRNAME.equals(name)) {
ProjectPreferences.updatePreferences(this);
return;
}
}
@Test
public void testUndelete() {
initializeExpectedProject(1);
expect(resourceManager.options()).andReturn(mockOptions);
resourceManager.undelete(PROJECT_INFO.projectId());
replay(resourceManager);
initializeProject();
project.undelete();
}
@Test
public void testReloadNull() {
initializeExpectedProject(1);
expect(resourceManager.options()).andReturn(mockOptions);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(null);
replay(resourceManager);
Project reloadedProject =
new Project(resourceManager, new ProjectInfo.BuilderImpl(PROJECT_INFO)).reload();
assertNull(reloadedProject);
}
private IFile createPom(IProject project, IProgressMonitor monitor, PomParser bizPom)
throws CoreException {
String pomTemplate = ResourceHelper.content(templateRoot + "pom.xml");
String pom =
String.format(
pomTemplate,
bizPom.getGroupId(),
bizPom.getParentArtifactId(),
bizPom.getVersion(),
pi.getProjectId(),
bizPom.getArtifactId());
return EclipseHelper.createFile("pom.xml", project, pom, monitor);
}
protected IStatus run(IProgressMonitor monitor) {
IValidatorOutput output = null;
try {
output = createOutput();
for (Iterator i = byProject.entrySet().iterator(); i.hasNext(); ) {
Map.Entry entry = (Map.Entry) i.next();
final IProject project = (IProject) entry.getKey();
final ProjectInfo info = (ProjectInfo) entry.getValue();
invokeValidationFor(
output,
DLTKCore.create(project),
info.elementsToArray(),
info.resourcesToArray(),
monitor);
}
} finally {
if (output != null) {
output.close();
}
}
return Status.OK_STATUS;
}
private IProject createProject(IProgressMonitor monitor) {
Set<String> refs = new HashSet<String>();
refs.add("org.eclipse.ui");
refs.add("org.eclipse.core.runtime");
refs.add("org.eclipse.core.resources");
refs.add("org.eclipse.ui.ide");
refs.add("org.eclipse.jdt.core");
IProject project =
EclipseHelper.createRichClientProject(
pi.getProjectId(), Collections.<IProject>emptyList(), refs, monitor, getShell());
monitor.worked(1);
return project;
}
/**
* Get the runtime value of an expression. <br>
* <li><b>"current" </b> points to the current project object.
* <li>Characters in '' will keep there original string value.
* <li>Other tokens will be treated as property key of current project. <br>
* <br>
* e.g: "utest.report.base.dir, '/', current.projectName" will be split into three tokens:
* Runtime value for "utest.report.base.dir" will be retrieved from current project, '/' will
* keep its original value, while "current.projectName" will be the current project name.
*
* @param info
* @param key
* @return
*/
private String getRuntimeValue(ProjectInfo info, String key) {
final String CURRENT_KEY = "current"; // $NON-NLS-1$
if (key.startsWith(CURRENT_KEY)) {
// e.g:
// projectInfo.getAttribute( "projectName" )
// projectInfo.getAttribute( "baseDir" )
return info.getValue(key.substring(CURRENT_KEY.length() + 1));
} else if (key.startsWith("'") && key.endsWith("'")) // $NON-NLS-1$//$NON-NLS-2$
{
return key.substring(1, key.length() - 1);
} else return getProject().getProperty(key);
}
@Override
protected void execute(IProgressMonitor monitor)
throws CoreException, InvocationTargetException, InterruptedException {
try {
monitor.beginTask("Creating project " + pi.getProjectName(), 2);
IProject project = createProject(monitor);
if (project == null) {
return;
}
PomParser bizPom = parseBizPom();
createWorkflow(project, monitor);
IFile fileToOpen = createGuidesign(project, monitor);
createGeneratorProperties(project, monitor, bizPom);
createSpecialCasesXpt(project, monitor);
createSpecialCasesExt(project, monitor);
createBuildProperties(project, monitor, bizPom);
createPom(project, monitor, bizPom);
createManifest(project, monitor, bizPom);
createSpringHandlers(project, monitor);
createSpringSchemas(project, monitor);
createIcons(project, monitor);
openFile(monitor, fileToOpen);
monitor.worked(1);
} catch (final RuntimeException e) {
PluginLog.logError(e);
Display.getDefault()
.asyncExec(
new Runnable() {
@Override
public void run() {
String message = "Problem when creating rich client project: " + e.getMessage();
IStatus status =
PluginLog.createStatus(IStatus.ERROR, IStatus.CANCEL, e.getMessage(), e);
ErrorDialog.openError(
Display.getCurrent().getActiveShell(),
"Rich client project wizard",
message,
status);
}
});
}
}
private String parseFileContent(String fileName) throws CoreException {
// TODO we should use the project path instead of its name, but
// don't know how to do that
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IProject bizProj = workspace.getRoot().getProject(pi.getBusinessProjectId());
IFile bizFile = bizProj.getFile(fileName);
if (!bizFile.exists()) {
throw new RuntimeException("Missing " + fileName + " in business tier project: " + bizFile);
}
BufferedReader bizReader;
try {
bizReader =
new BufferedReader(new InputStreamReader(bizFile.getContents(), bizFile.getCharset()));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e.getMessage(), e);
}
return ResourceHelper.content(bizReader);
}
/**
* Execute all nestedTasks.
*
* @throws BuildException if one of the nested tasks fails.
*/
public void execute() throws BuildException {
Object o = getProject().getReference(refID);
ProjectList list;
if (o instanceof ProjectList) {
list = (ProjectList) o;
} else {
log(
"ForEach only support one ProjectList reference!", //$NON-NLS-1$
Project.MSG_ERR);
throw new BuildException("ForEach only support one ProjectList reference!"); // $NON-NLS-1$
}
for (int i = 0; i < list.getCount(); i++) {
ProjectInfo projectInfo = list.getProject(i);
// register dynamic property
for (int j = 0; j < dynamicProperties.size(); j++) {
DynamicProperty property = (DynamicProperty) dynamicProperties.get(j);
getDynamicValue(projectInfo, property);
}
// ================= Add Build Listeners
// ============================
DefaultLogger logger = null;
if (loggerPath != null) {
File loggerPathDir = new File(loggerPath);
if (!loggerPathDir.exists()) loggerPathDir.mkdir();
if (!loggerPathDir.isDirectory())
throw new BuildException(
"loggerPath attribute should reference to a directory."); //$NON-NLS-1$
// Add INFO level logger.
logger = new DefaultLogger();
PrintStream str = null;
try {
String fileName =
projectInfo.getValue("projectName") + "_log.txt"; // $NON-NLS-1$//$NON-NLS-2$
str =
new PrintStream(
new FileOutputStream(new File(loggerPathDir, fileName), true),
true); //$NON-NLS-1$
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
logger.setMessageOutputLevel(Project.MSG_INFO);
logger.setErrorPrintStream(str);
logger.setOutputPrintStream(str);
getProject().addBuildListener(logger);
}
// ================= End of adding Build Listeners
// ============================
for (Enumeration e = nestedTasks.elements(); e.hasMoreElements(); ) {
Task nestedTask = (Task) e.nextElement();
try {
nestedTask.perform();
getProject().setProperty(failurePropertyName, TASK_STATUS_PASS); // $NON-NLS-1$
} catch (BuildException ex) {
log(
"Execution error on task: ["
+ nestedTask.getTaskName()
+ "] message: "
+ ex.toString(),
Project.MSG_WARN); // $NON-NLS-1$ //$NON-NLS-2$
// Check for Ant execution, check to see whether the
// individual project
// failed on itself or failed on dependencies.
if ("Ant".equalsIgnoreCase(nestedTask.getTaskName())) // $NON-NLS-1$
{
if (isThisProjectError(ex)) {
getProject().setProperty(failurePropertyName, TASK_STATUS_FAIL); // $NON-NLS-1$
log("Project failed on itself: ", Project.MSG_ERR); // $NON-NLS-1$
} else {
getProject().setProperty(failurePropertyName, TASK_STATUS_FAIL_ON_DEPENDENCY);
log("Project failed on dependencies:", Project.MSG_WARN); // $NON-NLS-1$ //$NON-NLS-2$
}
}
if (failOnError) {
throw ex;
}
log("Continue execution.", Project.MSG_INFO); // $NON-NLS-1$
}
}
// Remove Build Listener.
if (logger != null) getProject().removeBuildListener(logger);
}
}
public class ProjectTest {
private static final String PROJECT_ID = "project-id";
private static final String NAME = "myProj";
private static final Map<String, String> LABELS = ImmutableMap.of("k1", "v1", "k2", "v2");
private static final Long PROJECT_NUMBER = 123L;
private static final Long CREATE_TIME_MILLIS = 123456789L;
private static final ProjectInfo.State STATE = ProjectInfo.State.DELETE_REQUESTED;
private static final ProjectInfo PROJECT_INFO =
ProjectInfo.builder(PROJECT_ID)
.name(NAME)
.labels(LABELS)
.projectNumber(PROJECT_NUMBER)
.createTimeMillis(CREATE_TIME_MILLIS)
.state(STATE)
.build();
private static final Identity USER = Identity.user("*****@*****.**");
private static final Identity SERVICE_ACCOUNT =
Identity.serviceAccount("*****@*****.**");
private static final Policy POLICY =
Policy.builder()
.addIdentity(ProjectRole.OWNER.value(), USER)
.addIdentity(ProjectRole.EDITOR.value(), SERVICE_ACCOUNT)
.build();
private ResourceManager serviceMockReturnsOptions = createStrictMock(ResourceManager.class);
private ResourceManagerOptions mockOptions = createMock(ResourceManagerOptions.class);
private ResourceManager resourceManager;
private Project expectedProject;
private Project project;
@Before
public void setUp() {
resourceManager = createStrictMock(ResourceManager.class);
}
@After
public void tearDown() throws Exception {
verify(resourceManager);
}
private void initializeExpectedProject(int optionsCalls) {
expect(serviceMockReturnsOptions.options()).andReturn(mockOptions).times(optionsCalls);
replay(serviceMockReturnsOptions);
expectedProject =
new Project(serviceMockReturnsOptions, new ProjectInfo.BuilderImpl(PROJECT_INFO));
}
private void initializeProject() {
project = new Project(resourceManager, new ProjectInfo.BuilderImpl(PROJECT_INFO));
}
@Test
public void testToBuilder() {
initializeExpectedProject(4);
replay(resourceManager);
compareProjects(expectedProject, expectedProject.toBuilder().build());
}
@Test
public void testBuilder() {
expect(resourceManager.options()).andReturn(mockOptions).times(7);
replay(resourceManager);
Project.Builder builder =
new Project.Builder(new Project(resourceManager, new ProjectInfo.BuilderImpl("wrong-id")));
Project project =
builder
.projectId(PROJECT_ID)
.name(NAME)
.labels(LABELS)
.projectNumber(PROJECT_NUMBER)
.createTimeMillis(CREATE_TIME_MILLIS)
.state(STATE)
.build();
assertEquals(PROJECT_ID, project.projectId());
assertEquals(NAME, project.name());
assertEquals(LABELS, project.labels());
assertEquals(PROJECT_NUMBER, project.projectNumber());
assertEquals(CREATE_TIME_MILLIS, project.createTimeMillis());
assertEquals(STATE, project.state());
assertEquals(resourceManager.options(), project.resourceManager().options());
assertNull(project.parent());
ResourceId parent = new ResourceId("id", "type");
project =
project
.toBuilder()
.clearLabels()
.addLabel("k3", "v3")
.addLabel("k4", "v4")
.removeLabel("k4")
.parent(parent)
.build();
assertEquals(PROJECT_ID, project.projectId());
assertEquals(NAME, project.name());
assertEquals(ImmutableMap.of("k3", "v3"), project.labels());
assertEquals(PROJECT_NUMBER, project.projectNumber());
assertEquals(CREATE_TIME_MILLIS, project.createTimeMillis());
assertEquals(STATE, project.state());
assertEquals(resourceManager.options(), project.resourceManager().options());
assertEquals(parent, project.parent());
}
@Test
public void testGet() {
initializeExpectedProject(1);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(expectedProject);
replay(resourceManager);
Project loadedProject = resourceManager.get(PROJECT_INFO.projectId());
assertEquals(expectedProject, loadedProject);
}
@Test
public void testReload() {
initializeExpectedProject(2);
ProjectInfo newInfo = PROJECT_INFO.toBuilder().addLabel("k3", "v3").build();
Project expectedProject =
new Project(serviceMockReturnsOptions, new ProjectInfo.BuilderImpl(newInfo));
expect(resourceManager.options()).andReturn(mockOptions);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(expectedProject);
replay(resourceManager);
initializeProject();
Project newProject = project.reload();
assertEquals(expectedProject, newProject);
}
@Test
public void testLoadNull() {
initializeExpectedProject(1);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(null);
replay(resourceManager);
assertNull(resourceManager.get(PROJECT_INFO.projectId()));
}
@Test
public void testReloadNull() {
initializeExpectedProject(1);
expect(resourceManager.options()).andReturn(mockOptions);
expect(resourceManager.get(PROJECT_INFO.projectId())).andReturn(null);
replay(resourceManager);
Project reloadedProject =
new Project(resourceManager, new ProjectInfo.BuilderImpl(PROJECT_INFO)).reload();
assertNull(reloadedProject);
}
@Test
public void testResourceManager() {
initializeExpectedProject(1);
replay(resourceManager);
assertEquals(serviceMockReturnsOptions, expectedProject.resourceManager());
}
@Test
public void testDelete() {
initializeExpectedProject(1);
expect(resourceManager.options()).andReturn(mockOptions);
resourceManager.delete(PROJECT_INFO.projectId());
replay(resourceManager);
initializeProject();
project.delete();
}
@Test
public void testUndelete() {
initializeExpectedProject(1);
expect(resourceManager.options()).andReturn(mockOptions);
resourceManager.undelete(PROJECT_INFO.projectId());
replay(resourceManager);
initializeProject();
project.undelete();
}
@Test
public void testReplace() {
initializeExpectedProject(2);
Project expectedReplacedProject = expectedProject.toBuilder().addLabel("k3", "v3").build();
expect(resourceManager.options()).andReturn(mockOptions).times(2);
expect(resourceManager.replace(anyObject(Project.class))).andReturn(expectedReplacedProject);
replay(resourceManager);
initializeProject();
Project newProject =
new Project(resourceManager, new ProjectInfo.BuilderImpl(expectedReplacedProject));
Project actualReplacedProject = newProject.replace();
compareProjectInfos(expectedReplacedProject, actualReplacedProject);
}
@Test
public void testGetPolicy() {
expect(resourceManager.options()).andReturn(mockOptions).times(1);
expect(resourceManager.getPolicy(PROJECT_ID)).andReturn(POLICY);
replay(resourceManager);
initializeProject();
assertEquals(POLICY, project.getPolicy());
}
@Test
public void testReplacePolicy() {
expect(resourceManager.options()).andReturn(mockOptions).times(1);
expect(resourceManager.replacePolicy(PROJECT_ID, POLICY)).andReturn(POLICY);
replay(resourceManager);
initializeProject();
assertEquals(POLICY, project.replacePolicy(POLICY));
}
@Test
public void testTestPermissions() {
List<Boolean> response = ImmutableList.of(true, true);
String getPermission = "resourcemanager.projects.get";
String deletePermission = "resourcemanager.projects.delete";
expect(resourceManager.options()).andReturn(mockOptions).times(1);
expect(
resourceManager.testPermissions(
PROJECT_ID, ImmutableList.of(getPermission, deletePermission)))
.andReturn(response);
replay(resourceManager);
initializeProject();
assertEquals(
response, project.testPermissions(ImmutableList.of(getPermission, deletePermission)));
}
private void compareProjects(Project expected, Project value) {
assertEquals(expected, value);
compareProjectInfos(expected, value);
assertEquals(expected.resourceManager().options(), value.resourceManager().options());
}
private void compareProjectInfos(ProjectInfo expected, ProjectInfo value) {
assertEquals(expected.projectId(), value.projectId());
assertEquals(expected.name(), value.name());
assertEquals(expected.labels(), value.labels());
assertEquals(expected.projectNumber(), value.projectNumber());
assertEquals(expected.createTimeMillis(), value.createTimeMillis());
assertEquals(expected.state(), value.state());
assertEquals(expected.parent(), value.parent());
}
}
private void compareProjectInfos(ProjectInfo expected, ProjectInfo value) {
assertEquals(expected.projectId(), value.projectId());
assertEquals(expected.name(), value.name());
assertEquals(expected.labels(), value.labels());
assertEquals(expected.projectNumber(), value.projectNumber());
assertEquals(expected.createTimeMillis(), value.createTimeMillis());
assertEquals(expected.state(), value.state());
assertEquals(expected.parent(), value.parent());
}
public DotClassPathFile(ProjectInfo project) {
super(project.getProject().getFile(".classpath"));
this.project = project;
}
private static List<String> update(
ProjectInfo project,
List<String> lines,
Set<ProjectInfo> projectDeps,
List<Dependency> deps) {
lines = new ArrayList<String>(lines);
if (lines.isEmpty()) {
lines.add("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
lines.add("<classpath>");
lines.add("</classpath>");
}
for (Dependency dep : deps) {
if (dep.jar.trim().equals("")) continue;
int line = indexOfLineContaining(lines, dep.jar);
if (line != -1) {
lines.remove(line);
}
}
for (int i = lines.size() - 1; i >= 0; i--) {
if (lines.get(i).contains("from=\"sbt\"")) {
lines.remove(i);
}
}
int line = indexOfLineContaining(lines, "</classpath>");
if (line < 0) {
line = lines.size();
}
boolean scalaContainer = indexOfLineContaining(lines, "SCALA_CONTAINER") != -1;
scalaContainer = true; // always skip scala library
TreeMap<String, Dependency> sortedDeps = new TreeMap<String, Dependency>();
for (Dependency dep : deps) {
sortedDeps.put(dep.name, dep);
}
for (Dependency dep : sortedDeps.values()) {
if (scalaContainer && dep.name.equals("scala-library")) continue;
lines.add(
line++,
"\t<classpathentry from=\"sbt\" kind=\"lib\" path=\""
+ dep.jar.trim()
+ "\""
+ (!dep.srcJar.trim().isEmpty() ? " sourcepath=\"" + dep.srcJar.trim() + "\"" : "")
+ "/>");
}
for (ProjectInfo dep : projectDeps) {
lines.add(
line++,
"\t<classpathentry from=\"sbt\" combineaccessrules=\"false\" kind=\"src\" path=\"/"
+ dep.getProject().getName()
+ "\"/>");
}
if (indexOfLineContaining(lines, "kind=\"con\"") < 0) {
// lines.add(line++, "\t<classpathentry kind=\"con\"
// path=\"org.eclipse.jdt.launching.JRE_CONTAINER\"/>");
}
if (indexOfLineContaining(lines, "kind=\"output\"") < 0) {
lines.add(line++, "\t<classpathentry from=\"sbt\" kind=\"output\" path=\"target/classes\"/>");
}
@SuppressWarnings("unchecked")
List<String>[] sourcePaths =
new List[] {
project.getSourceDirectories(),
project.getResourceDirectories(),
project.getTestSourceDirectories(),
project.getTestResourceDirectories()
};
for (List<String> paths : sourcePaths) {
for (String path : paths) {
if (project.getProject().getFolder(path).exists()) {
if (indexOfLineContaining(lines, path) < 0) {
lines.add(
line++, "\t<classpathentry from=\"sbt\" kind=\"src\" path=\"" + path + "\"/>");
}
}
}
}
return lines;
}
