protected @Override void setUp() throws Exception {
MockLookup.setLayersAndInstances(TestUtil.testProjectFactory());
ProjectManager.getDefault().reset();
FileOwnerQuery.reset();
scratch = TestUtil.makeScratchDir(this);
projdir = scratch.createFolder("my-project");
projdir.createFolder("testproject");
randomfile = scratch.createData("randomfile");
projfile = projdir.createData("projfile");
FileObject projsubdir = projdir.createFolder("projsubdir");
projfile2 = projsubdir.createData("projfile2");
subprojdir = projdir.createFolder("subproject");
subprojdir.createFolder("testproject");
subprojfile = subprojdir.createData("subprojfile");
scratch.createFolder("external1").createFolder("subdir").createData("file");
scratch.createFolder("external2").createFolder("subdir").createData("file");
scratch.createFolder("external3").createFolder("subproject").createFolder("testproject");
p = ProjectManager.getDefault().findProject(projdir);
assertNotNull("found a project successfully", p);
// make jar:file:/.../projdir/foo.jar!/zipfile/zippedfile
FileObject foojar = TestFileUtils.writeZipFile(projdir, "foo.jar", "zipdir/zippedfile:");
FileObject foojarRoot = FileUtil.getArchiveRoot(foojar);
assertNotNull("have an archive in " + foojar, foojarRoot);
zippedfile = foojarRoot.getFileObject("zipdir/zippedfile");
assertNotNull("zippedfile found in it", zippedfile);
hashedFile = TestFileUtils.writeZipFile(projdir, ".#webapp.jar.1.45", "zipdir/zippedfile:");
foojarRoot = FileUtil.getArchiveRoot(hashedFile);
assertNotNull("have an archive in " + hashedFile, foojarRoot);
hashedFile = foojarRoot.getFileObject("zipdir/zippedfile");
}
public void buildScenes(String targetPath) {
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
String srcPath =
projectManager.getCurrentWorkingPath()
+ "/"
+ projectManager.currentProjectVO.projectName
+ "/scenes";
FileHandle scenesDirectoryHandle = Gdx.files.absolute(srcPath);
File fileTarget = new File(targetPath + "/" + scenesDirectoryHandle.name());
try {
FileUtils.copyDirectory(scenesDirectoryHandle.file(), fileTarget);
} catch (IOException e) {
e.printStackTrace();
}
// copy project dt
try {
FileUtils.copyFile(
new File(
projectManager.getCurrentWorkingPath()
+ "/"
+ projectManager.currentProjectVO.projectName
+ "/project.dt"),
new File(targetPath + "/project.dt"));
} catch (IOException e) {
e.printStackTrace();
}
}
public void testExternalOwner() throws Exception {
FileObject ext1 = scratch.getFileObject("external1");
FileObject extfile1 = ext1.getFileObject("subdir/file");
assertEquals("no owner yet", null, FileOwnerQuery.getOwner(extfile1));
FileOwnerQuery.markExternalOwner(ext1, p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
assertEquals("now have an owner", p, FileOwnerQuery.getOwner(extfile1));
assertEquals("even for the projdir", p, FileOwnerQuery.getOwner(ext1));
assertEquals("but not for something else", null, FileOwnerQuery.getOwner(scratch));
FileObject ext2 = scratch.getFileObject("external2");
FileObject extfile2 = ext2.getFileObject("subdir/file");
assertEquals("no owner yet", null, FileOwnerQuery.getOwner(extfile2));
Project p2 = ProjectManager.getDefault().findProject(subprojdir);
FileOwnerQuery.markExternalOwner(ext2, p2, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
assertEquals("now have an owner", p2, FileOwnerQuery.getOwner(extfile2));
assertEquals("even for the projdir", p2, FileOwnerQuery.getOwner(ext2));
assertEquals("but not for something else", null, FileOwnerQuery.getOwner(scratch));
assertEquals("still correct for first proj", p, FileOwnerQuery.getOwner(extfile1));
FileObject ext3 = scratch.getFileObject("external3");
assertEquals("no owner yet", null, FileOwnerQuery.getOwner(ext3));
FileOwnerQuery.markExternalOwner(ext3, p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
assertEquals("now have an owner", p, FileOwnerQuery.getOwner(ext3));
FileObject ext3subproj = ext3.getFileObject("subproject");
Project p3 = FileOwnerQuery.getOwner(ext3subproj);
assertNotSame("different project", p, p3);
assertEquals(
"but subprojects are not part of it",
ProjectManager.getDefault().findProject(ext3subproj),
p3);
FileOwnerQuery.markExternalOwner(ext3, null, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
assertEquals("unmarking an owner works", null, FileOwnerQuery.getOwner(ext3));
}
private void deleteScene(String sceneName) {
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
ArrayList<SceneVO> scenes = projectManager.currentProjectInfoVO.scenes;
SceneVO sceneToDelete = null;
for (SceneVO scene : scenes) {
if (scene.sceneName.equals(sceneName)) {
sceneToDelete = scene;
break;
}
}
if (sceneToDelete != null) {
scenes.remove(sceneToDelete);
}
projectManager.currentProjectInfoVO.scenes = scenes;
String projPath =
projectManager.getCurrentWorkingPath() + "/" + projectManager.currentProjectVO.projectName;
try {
FileUtils.writeStringToFile(
new File(projPath + "/project.dt"),
projectManager.currentProjectInfoVO.constructJsonString(),
"utf-8");
FileUtils.forceDelete(new File(projPath + "/scenes/" + sceneName + ".dt"));
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public String getProjectPath() {
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
return projectManager.getCurrentWorkingPath()
+ "/"
+ projectManager.getCurrentProjectVO().projectName;
}
@Test
public void testCopyProject()
throws IOException, NoProjectLoadedException, ProjectFileParsingException, Exception {
System.out.println("--- testCopyAndRunProject");
String projNameNew = "TestingGranCell";
File projDirNew = new File(MainTest.getTempProjectDirectory(), projNameNew);
if (projDirNew.exists()) {
GeneralUtils.removeAllFiles(projDirNew, false, true, true);
}
System.out.println("Ex " + projDirNew.getCanonicalFile() + ": " + projDirNew.exists());
projDirNew.mkdir();
File projFile = new File(projDirNew, projNameNew + ".ncx");
File oldProjDir = new File(ProjectStructure.getnCModelsDir(), "GranuleCell");
File oldProj = new File(oldProjDir, "GranuleCell.ncx");
ProjectManager p = new ProjectManager();
Project proj = p.copyProject(oldProj, projFile);
System.out.println("Created project at: " + proj.getProjectFile().getCanonicalPath());
assertEquals(proj.getProjectName(), projNameNew);
assertTrue(projFile.exists());
}
@Override
public void reLoadProject() {
Sandbox sandbox = Sandbox.getInstance();
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
projectManager.openProjectAndLoadAllData(projectManager.getCurrentProjectVO().projectName);
sandbox.loadCurrentProject();
facade.sendNotification(ProjectManager.PROJECT_DATA_UPDATED);
}
public String getCurrProjectScenePathByName(String sceneName) {
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
return projectManager.getCurrentWorkingPath()
+ "/"
+ projectManager.currentProjectVO.projectName
+ "/scenes/"
+ sceneName
+ ".dt";
}
private void _testNoDefaultAssignee(final GenericValue project, final GenericValue component) {
assertFalse(testedObject.isDefaultAssignee(project, component));
try {
testedObject.getDefaultAssignee(project, component);
fail("Expected DefaultAssigneeException");
} catch (final DefaultAssigneeException e) {
assertEquals(
"The default assignee does NOT have ASSIGNABLE permission OR Unassigned issues are turned off.",
e.getMessage());
}
}
@Test
public void testUpdateProjectCategory() throws GenericEntityException {
projectCategory.set("name", "A New Name");
projectCategory.set("description", "A New Description");
testedObject.updateProjectCategory(projectCategory);
final GenericValue retrievedProjectCat =
testedObject.getProjectCategory(projectCategory.getLong("id"));
assertEquals("A New Name", retrievedProjectCat.getString("name"));
assertEquals("A New Description", retrievedProjectCat.getString("description"));
}
@Test
public void testGetProjectCategoryFromProject() throws GenericEntityException {
// null project id
GenericValue actualProjectCategory = testedObject.getProjectCategoryFromProject(null);
assertNull(actualProjectCategory);
// valid project id but no association set
projectCategory = testedObject.getProjectCategoryFromProject(projectGV1);
assertNull(actualProjectCategory);
// valid project id and association exists.. return the projectCategory
actualProjectCategory = testedObject.getProjectCategoryFromProject(projectGV1);
assertEquals(projectCategory, actualProjectCategory);
}
@SuppressWarnings("unused")
private static void tryCreateIssue(RedmineManager manager) throws RedmineException {
Issue issue = new Issue();
issue.setSubject("test123");
final Version ver = VersionFactory.create(512);
issue.setTargetVersion(ver);
final IssueCategory cat = IssueCategoryFactory.create(673);
issue.setCategory(cat);
ProjectManager projectManager = manager.getProjectManager();
Project projectByKey = projectManager.getProjectByKey("testid");
issue.setProject(projectByKey);
manager.getIssueManager().createIssue(issue);
}
@Test
public void testSetProjectCategoryNotNull() throws GenericEntityException {
// test null project
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Cannot associate a category with a null project");
testedObject.setProjectCategory((GenericValue) null, null);
}
/**
* Test deleting a package that contains a Class with Statechart diagram. The diagram should be
* deleted, too.
*/
public void testDeletePackageWithStateDiagram() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
assertEquals(2, p.getDiagramList().size());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagramList().size();
// test with a class and class diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1");
Object aClass = Model.getCoreFactory().buildClass(package1);
// try with Statediagram
Object machine = Model.getStateMachinesFactory().buildStateMachine(aClass);
UMLStateDiagram d = new UMLStateDiagram(Model.getFacade().getNamespace(machine), machine);
p.addMember(d);
assertEquals(sizeDiagrams + 1, p.getDiagramList().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(package1);
Model.getPump().flushModelEvents();
assertTrue("Class not in trash", Model.getUmlFactory().isRemoved(aClass));
assertTrue("Statemachine not in trash", Model.getUmlFactory().isRemoved(machine));
assertEquals(sizeDiagrams, p.getDiagramList().size());
assertEquals(sizeMembers, p.getMembers().size());
}
@Test
public void testGetProjectsFromProjectCategory() throws GenericEntityException {
// test null projectCategory id
Collection<GenericValue> projects =
testedObject.getProjectsFromProjectCategory((GenericValue) null);
assertTrue(projects.isEmpty());
// test a valid projectCategory id associated with NO projects
projects = testedObject.getProjectsFromProjectCategory(projectCategory);
assertTrue(projects.isEmpty());
// test a valid projectCategory associated with a project
testedObject.setProjectCategory(projectGV1, projectCategory);
projects = testedObject.getProjectsFromProjectCategory(projectCategory);
assertEquals(Collections.singletonList(projectGV1), projects);
}
/** Test deleting a package that contains a Class diagram. The diagram should be deleted, too. */
public void testDeletePackageWithClassDiagram() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
assertEquals(2, p.getDiagramList().size());
assertEquals(
Translator.localize("misc.untitled-model"), Model.getFacade().getName(p.getModel()));
assertEquals(p.getRoot(), p.getModel());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagramList().size();
// test with a class and class diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1");
assertNotNull(package1);
Object package2 = Model.getModelManagementFactory().buildPackage("test2");
UMLClassDiagram cDiag = new UMLClassDiagram(package2);
p.addMember(cDiag);
assertEquals(sizeDiagrams + 1, p.getDiagramList().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(package2);
Model.getPump().flushModelEvents();
assertEquals(sizeDiagrams, p.getDiagramList().size());
assertEquals(sizeMembers, p.getMembers().size());
}
@Test
public void testGetProjects() throws GenericEntityException {
final List<Project> projects = testedObject.getProjectObjects();
assertEquals(2, projects.size());
assertEquals(projects.get(0), project1);
assertEquals(projects.get(1), project2);
}
/**
* Test deleting an operation that contains a statechart diagram. The diagram should be deleted,
* too.
*/
public void testDeleteOperationWithStateDiagram() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
assertEquals(2, p.getDiagramList().size());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagramList().size();
// test with a class and class diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1");
Object aClass = Model.getCoreFactory().buildClass(package1);
Object voidType = p.getDefaultReturnType();
Object oper = Model.getCoreFactory().buildOperation(aClass, voidType);
// try with Statediagram
Object machine = Model.getStateMachinesFactory().buildStateMachine(oper);
UMLStateDiagram d = new UMLStateDiagram(Model.getFacade().getNamespace(machine), machine);
p.addMember(d);
assertEquals(sizeDiagrams + 1, p.getDiagramList().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(oper);
Model.getPump().flushModelEvents();
assertTrue("Operation not in trash", p.isInTrash(oper));
/* Changed by issue 4281: */
assertTrue("Statemachine in trash", !Model.getUmlFactory().isRemoved(machine));
assertEquals(sizeDiagrams + 1, p.getDiagramList().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
/* After issue 4284 will be solved, we
* may even delete the class, and the diagram
* should still exist. */
}
/**
* Test deleting a package with a Class with a Activity diagram. The diagram should be deleted,
* too.
*/
public void testDeletePackageWithClassWithActivityDiagram() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
assertEquals(2, p.getDiagramList().size());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagramList().size();
// test with a package and a class and activity diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1");
Object aClass = Model.getCoreFactory().buildClass(package1);
// build the Activity Diagram
Object actgrph = Model.getActivityGraphsFactory().buildActivityGraph(aClass);
UMLActivityDiagram d = new UMLActivityDiagram(Model.getFacade().getNamespace(actgrph), actgrph);
p.addMember(d);
assertEquals(sizeDiagrams + 1, p.getDiagramList().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(package1);
Model.getPump().flushModelEvents();
assertTrue("Class not in trash", Model.getUmlFactory().isRemoved(aClass));
assertTrue("ActivityGraph not in trash", Model.getUmlFactory().isRemoved(actgrph));
assertEquals(sizeDiagrams, p.getDiagramList().size());
assertEquals(sizeMembers, p.getMembers().size());
}
@SuppressWarnings("unused")
private static void tryGetNews(ProjectManager mgr) throws RedmineException {
List<News> news = mgr.getNews(null);
for (News aNew : news) {
System.out.println(aNew);
}
}
@Test
public void testGetProjectByLeadWhereNoProjectsExistForLead()
throws OperationNotPermittedException, InvalidUserException, InvalidCredentialException {
final Collection<Project> projectsWithoutLead =
testedObject.getProjectsLeadBy(userMockFactory.getComponentLead());
assertEquals(0, projectsWithoutLead.size());
}
/** Test the moveToTrash function for package and content. */
public void testTrashcanPackageContent() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
// test with a class in a package
Object package1 = Model.getModelManagementFactory().buildPackage("test1");
Model.getCoreHelper().setNamespace(package1, p.getRoot());
Object cls1 = Model.getCoreFactory().buildClass(package1);
Object cls2 = Model.getCoreFactory().buildClass(package1);
Object cls3 = Model.getCoreFactory().buildClass(package1);
Object cls4 = Model.getCoreFactory().buildClass(p.getRoot());
Object c1 = Model.getFacade().getOwnedElements(p.getRoot());
assertTrue(c1 instanceof Collection);
// Let's make it a bit more difficult by setting the target:
TargetManager.getInstance().setTarget(cls2);
p.moveToTrash(package1);
Model.getPump().flushModelEvents();
// TODO: We should also test that the object
// have been removed from their namespace.
// Collection c = Model.getFacade().getOwnedElements(p.getRoot());
assertTrue("Package not in trash", p.isInTrash(package1));
assertTrue("Package not deleted", Model.getUmlFactory().isRemoved(package1));
assertTrue("Class 1 not deleted", Model.getUmlFactory().isRemoved(cls1));
assertTrue("Class 2 not deleted", Model.getUmlFactory().isRemoved(cls2));
assertTrue("Class 3 not deleted", Model.getUmlFactory().isRemoved(cls3));
assertTrue("Class 4 has been deleted", !Model.getUmlFactory().isRemoved(cls4));
}
/** Test the makeUntitledProject() function. */
public void testMakeUntitledProject() {
Project p = ProjectManager.getManager().getCurrentProject();
assertEquals(2, p.getDiagrams().size());
assertEquals("untitledModel", Model.getFacade().getName(p.getModel()));
// maybe next test is going to change in future
assertEquals(p.getRoot(), p.getModel());
}
/**
* Test deleting a package with a package with a Activity diagram. The diagram should be deleted,
* too.
*/
public void testDeletePackageWithPackageWithActivityDiagram() {
Project p = ProjectManager.getManager().getCurrentProject();
assertEquals(2, p.getDiagrams().size());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagrams().size();
// test with a package and a class and activity diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1", null);
Model.getCoreHelper().setNamespace(package1, p.getModel());
Object package2 = Model.getModelManagementFactory().buildPackage("test2", null);
Model.getCoreHelper().setNamespace(package2, package1);
// build the Activity Diagram
Object actgrph = Model.getActivityGraphsFactory().buildActivityGraph(package2);
UMLActivityDiagram d = new UMLActivityDiagram(Model.getFacade().getNamespace(actgrph), actgrph);
p.addMember(d);
assertEquals(sizeDiagrams + 1, p.getDiagrams().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(package1);
assertTrue("Package 2 not in trash", Model.getUmlFactory().isRemoved(package2));
assertTrue("ActivityGraph not in trash", Model.getUmlFactory().isRemoved(actgrph));
assertEquals(sizeDiagrams, p.getDiagrams().size());
assertEquals(sizeMembers, p.getMembers().size());
}
/**
* Test deleting an operation that contains a statechart diagram. The diagram should be deleted,
* too.
*/
public void testDeleteOperationWithStateDiagram() {
Project p = ProjectManager.getManager().getCurrentProject();
assertEquals(2, p.getDiagrams().size());
int sizeMembers = p.getMembers().size();
int sizeDiagrams = p.getDiagrams().size();
// test with a class and class diagram
Object package1 = Model.getModelManagementFactory().buildPackage("test1", null);
Object aClass = Model.getCoreFactory().buildClass(package1);
Collection propertyChangeListeners = p.findFigsForMember(aClass);
Object model = p.getModel();
Object voidType = p.findType("void");
Object oper =
Model.getCoreFactory().buildOperation(aClass, model, voidType, propertyChangeListeners);
// try with Statediagram
Object machine = Model.getStateMachinesFactory().buildStateMachine(oper);
UMLStateDiagram d = new UMLStateDiagram(Model.getFacade().getNamespace(machine), machine);
p.addMember(d);
assertEquals(sizeDiagrams + 1, p.getDiagrams().size());
assertEquals(sizeMembers + 1, p.getMembers().size());
p.moveToTrash(oper);
assertTrue("Operation not in trash", p.isInTrash(oper));
assertTrue("Statemachine not in trash", Model.getUmlFactory().isRemoved(machine));
assertEquals(sizeDiagrams, p.getDiagrams().size());
assertEquals(sizeMembers, p.getMembers().size());
}
public void saveScene(SceneVO vo) {
ProjectManager projectManager = facade.retrieveProxy(ProjectManager.NAME);
try {
FileUtils.writeStringToFile(
new File(
projectManager.getCurrentWorkingPath()
+ "/"
+ projectManager.currentProjectVO.projectName
+ "/scenes/"
+ vo.sceneName
+ ".dt"),
vo.constructJsonString(),
"utf-8");
} catch (IOException e) {
e.printStackTrace();
}
}
/** Test the makeUntitledProject() function. */
public void testMakeUntitledProject() {
Project p = ProjectManager.getManager().getOpenProjects().get(0);
assertEquals(2, p.getDiagramList().size());
assertEquals(
Translator.localize("misc.untitled-model"), Model.getFacade().getName(p.getModel()));
// maybe next test is going to change in future
assertEquals(p.getRoot(), p.getModel());
}
@Test
public void testGetProjectObj() {
// non-existing project - ID is null - not a requirement at the moment
Project project = testedObject.getProjectObj(null);
assertNull(project);
// non-existing project
project = testedObject.getProjectObj(new Long(666));
assertNull(project);
// existing project
project = testedObject.getProjectObj(project1.getId());
assertEquals(project1, project);
project = testedObject.getProjectObj(project2.getId());
assertEquals(project2, project);
}
@Test
public void testGetProjectObjectsFromProjectCategory() throws GenericEntityException {
// test null projectCategory id
Collection<Project> projects = testedObject.getProjectObjectsFromProjectCategory(null);
assertTrue(projects.isEmpty());
// test a valid projectCategory id associated with NO projects
projects = testedObject.getProjectObjectsFromProjectCategory(projectCategory.getLong("id"));
assertTrue(projects.isEmpty());
// test a valid projectCategory associated with a project
testedObject.setProjectCategory(projectGV1, projectCategory);
projects = testedObject.getProjectObjectsFromProjectCategory(projectCategory.getLong("id"));
final Project project = Iterables.getOnlyElement(projects);
assertEquals(project1.getId(), project.getId());
assertEquals(projectCategory, project.getProjectCategory());
}
@Test
public void testSetProjectCategory() throws GenericEntityException {
// test setting up a relation with a project that has no categories
assertNull(testedObject.getProjectCategoryFromProject(null));
testedObject.setProjectCategory(projectGV1, projectCategory);
assertEquals(projectCategory, testedObject.getProjectCategoryFromProject(projectGV1));
assertEquals(
1,
nodeAssociationStore
.getSinksFromSource(
projectGV1, "ProjectCategory", ProjectRelationConstants.PROJECT_CATEGORY)
.size());
// test setting up a relation with a project that has one category already
testedObject.setProjectCategory(projectGV1, projectCategory2);
assertEquals(projectCategory2, testedObject.getProjectCategoryFromProject(projectGV1));
assertEquals(
1,
nodeAssociationStore
.getSinksFromSource(
projectGV1, "ProjectCategory", ProjectRelationConstants.PROJECT_CATEGORY)
.size());
// test setting up a relation with a null category (ie no project category)
testedObject.setProjectCategory(project1, null);
assertEquals(null, testedObject.getProjectCategoryFromProject(projectGV1));
assertEquals(
0,
nodeAssociationStore
.getSinksFromSource(
projectGV1, "ProjectCategory", ProjectRelationConstants.PROJECT_CATEGORY)
.size());
}
