package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor; | |
import java.util.Iterator; | |
import java.util.ListIterator; | |
import org.eclipse.core.runtime.NullProgressMonitor; | |
import org.eclipse.graphiti.features.IFeatureProvider; | |
import org.eclipse.graphiti.ui.internal.parts.DiagramEditPart; | |
import org.eclipse.jdt.core.JavaModelException; | |
import org.eclipse.jpt.jpa.core.JpaProject; | |
import org.eclipse.jpt.jpa.core.context.PersistentType; | |
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit; | |
import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages; | |
import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.JPACreateFactory; | |
import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.Utils; | |
import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages; | |
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation; | |
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory; | |
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot; | |
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor; | |
import org.eclipse.swtbot.eclipse.gef.finder.SWTBotGefTestCase; | |
import org.eclipse.swtbot.eclipse.gef.finder.SWTGefBot; | |
import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart; | |
import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor; | |
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner; | |
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences; | |
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell; | |
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText; | |
import org.junit.After; | |
import org.junit.BeforeClass; | |
import org.junit.Ignore; | |
import org.junit.Test; | |
import org.junit.runner.RunWith; | |
@RunWith(SWTBotJunit4ClassRunner.class) | |
@SuppressWarnings("restriction") | |
public class MappedSuperclassesInDiagramSWTBotTest extends SWTBotGefTestCase{ | |
protected static String TEST_PROJECT; | |
protected static JPACreateFactory factory = JPACreateFactory.instance(); | |
protected static JpaProject jpaProject; | |
protected static SWTGefBot bot = new SWTGefBot(); | |
protected static SWTWorkbenchBot workbenchBot = new SWTWorkbenchBot(); | |
protected static EditorProxy editorProxy = new EditorProxy(workbenchBot, | |
bot); | |
protected static SWTBotGefEditor jpaDiagramEditor; | |
@BeforeClass | |
public static void beforeClass() throws Exception { | |
SWTBotPreferences.TIMEOUT = 1000; | |
try { | |
bot.viewByTitle("Welcome").close(); | |
} catch (Exception e) { | |
// ignore | |
} finally { | |
SWTBotPreferences.TIMEOUT = 5000; | |
} | |
workbenchBot.perspectiveByLabel("JPA").activate(); | |
TEST_PROJECT = "Test_" + System.currentTimeMillis(); | |
factory = JPACreateFactory.instance(); | |
jpaProject = factory.createJPA20Project(TEST_PROJECT); | |
assertNotNull(jpaProject); | |
jpaDiagramEditor = editorProxy | |
.openDiagramOnJPAContentNode(TEST_PROJECT, true); | |
editorProxy.setJpaDiagramEditor(jpaDiagramEditor); | |
Thread.sleep(2000); | |
} | |
/** | |
* Add entity to diagram and check that it contains a "Primary Key" section | |
* with one attribute "id" and no "Relation Attributes" and | |
* "Other Attributes" sections. | |
*/ | |
@Test | |
public void testAddMappedSuperclass() { | |
Utils.sayTestStarted("testAddMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
jpaDiagramEditor.save(); | |
assertFalse("Editor must not be dirty!", jpaDiagramEditor.isDirty()); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testAddMappedSuperclass"); | |
} | |
/** | |
* Remove a mapped superclass from the diagram using the entity's context button | |
* "Delete" | |
*/ | |
@Test | |
public void testRemoveEntityViaButton() { | |
Utils.sayTestStarted("testRemoveEntityViaButton"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.deleteJPTViaButton(mappedSuperclass); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveEntityViaButton"); | |
} | |
/** | |
* Remove a mapped superclass from the diagram using the entity's context menu | |
* "Delete" | |
*/ | |
@Test | |
public void testRemoveEntityViaContextMenu() { | |
Utils.sayTestStarted("testRemoveEntityViaContextMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.deleteJPTViaMenu(mappedSuperclass); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveEntityViaContextMenu"); | |
} | |
/** | |
* Adds a new attribute to the mapped superclass using the entity's context button | |
* "Create Attribute" | |
*/ | |
@Test | |
public void testAddAttribute() { | |
Utils.sayTestStarted("testAddAttribute"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertFalse( | |
"\"Other Attributes\" section must not be visible!", | |
editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, mappedSuperclass)); | |
editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testAddAttribute"); | |
} | |
@Test | |
public void testAddElementCollectionAttributeToMappedSuperclass(){ | |
Utils.sayTestStarted("testAddElementCollectionAttributeToMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertFalse( | |
"\"Other Attributes\" section must not be visible!", | |
editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, entity)); | |
editorProxy.addElementCollectionAttributeToJPT(entity, "attribute1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
entity.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testAddElementCollectionAttributeToMappedSuperclass"); | |
} | |
/** | |
* Removes the attribute using the "Delete Attribute" context button. | |
*/ | |
@Test | |
public void testRemoveAttributeViaContextButton() { | |
Utils.sayTestStarted("testRemoveAttributeViaContextButton"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.removeAttributeViaButton(mappedSuperclass, "attribute1"); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveAttributeViaContextButton"); | |
} | |
/** | |
* Removes the attribute using the "Delete" context menu. | |
*/ | |
@Test | |
public void testRemoveAttributeViaMenu() { | |
Utils.sayTestStarted("testRemoveAttributeViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.removeAttributeViaMenu(mappedSuperclass, "attribute1"); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveAttributeViaMenu"); | |
} | |
/** | |
* Adds a new attribute and rename it | |
*/ | |
@Test | |
public void testDirectEditingAttribute() { | |
Utils.sayTestStarted("testDirectEditingAttribute"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.directEditAttribute(mappedSuperclass, "attribute1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testDirectEditingAttribute"); | |
} | |
/** | |
* Adds a new mapped superclass and rename it | |
*/ | |
@Ignore | |
@Test | |
public void testDirectEditingEntity() { | |
Utils.sayTestStarted("testDirectEditingEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
editorProxy.moveMouse(100, 70); | |
mappedSuperclass.click(); | |
mappedSuperclass.activateDirectEdit(); | |
jpaDiagramEditor.directEditType("NewEntityName"); | |
editorProxy.moveMouse(0, 0); | |
SWTBotGefEditPart oldMappedSuperclass = jpaDiagramEditor.getEditPart("MpdSuprcls1"); | |
SWTBotGefEditPart newMappedSuperclass = jpaDiagramEditor | |
.getEditPart("NewEntityName"); | |
assertNotNull("The entity must be renamed!", newMappedSuperclass); | |
assertNull("The attribute must be renamed!", oldMappedSuperclass); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testDirectEditingEntity"); | |
} | |
/** | |
* Test that the source of the mapped superclass is opened, when is double clicked on | |
* it | |
*/ | |
@Ignore | |
@Test | |
public void testDoubleClickOnEntity() { | |
Utils.sayTestStarted("testDoubleClickOnEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty()); | |
editorProxy.moveMouse(100, 70); | |
jpaDiagramEditor.doubleClick(mappedSuperclass); | |
editorProxy.moveMouse(0, 0); | |
SWTBotEditor activeEditor = workbenchBot.activeEditor(); | |
assertEquals("The Java editor of the enity did not open!", | |
"MpdSuprcls1.java", activeEditor.getTitle()); | |
activeEditor.close(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testDoubleClickOnEntity"); | |
} | |
/** | |
* Change the attribute type. | |
*/ | |
@Test | |
public void testChangeAttributeType() { | |
Utils.sayTestStarted("testChangeAttributeType"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
assertFalse("\"Other Attributes\" section must not be visible!", | |
editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, mappedSuperclass)); | |
SWTBotGefEditPart attribute = editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1"); | |
assertNotNull("The attribute must not be renamed!", attribute); | |
final IFeatureProvider fp = ((DiagramEditPart) jpaDiagramEditor | |
.mainEditPart().part()).getFeatureProvider(); | |
String currentAttributeType = editorProxy.getAttributeType("attribute1", fp); | |
assertEquals("java.lang.String", currentAttributeType); | |
SWTBotShell changeTypeDialog = editorProxy | |
.getSelectNewAttributeTypeDialog(attribute); | |
SWTBotText attributeType = editorProxy | |
.getNewTypeInputField(changeTypeDialog); | |
// test invalid attribute type | |
attributeType.setText(""); | |
assertFalse(editorProxy.getOkButton(changeTypeDialog).isEnabled()); | |
assertTrue(editorProxy.getCancelButton(changeTypeDialog).isEnabled()); | |
SWTBotText dialogError = editorProxy | |
.getDialogErroMessage(changeTypeDialog); | |
assertEquals(" The new type name must not be empty", | |
dialogError.getText()); | |
// cancel the dialog | |
editorProxy.getCancelButton(changeTypeDialog).click(); | |
// assert that the attribute type is not changed | |
currentAttributeType = editorProxy.getAttributeType("attribute1", fp); | |
assertEquals("The attribute type must not be changed!", | |
"java.lang.String", currentAttributeType); | |
changeTypeDialog = editorProxy.getSelectNewAttributeTypeDialog(attribute); | |
attributeType = editorProxy.getNewTypeInputField(changeTypeDialog); | |
// change the attribute type to int | |
attributeType.setText("int"); | |
assertTrue(editorProxy.getOkButton(changeTypeDialog).isEnabled()); | |
assertTrue(editorProxy.getCancelButton(changeTypeDialog).isEnabled()); | |
// confirm the dialog | |
editorProxy.getOkButton(changeTypeDialog).click(); | |
editorProxy.waitASecond(); | |
// assert that the attribute's type is changed | |
String newAttributeType = editorProxy | |
.getAttributeType("attribute1", fp); | |
assertFalse("The attribute type must be changed!", | |
("java.lang.String").equals(newAttributeType)); | |
assertEquals("The attribute type must be changed!", "int", | |
newAttributeType); | |
assertTrue("Editor must be dirty!", jpaDiagramEditor.isDirty()); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testChangeAttributeType"); | |
} | |
/** | |
* Rename the mapped superclass using its context menu | |
* "Refactor Entity Class -> Rename..." | |
*/ | |
@Ignore | |
@Test | |
public void testRenameEntityViaMenu() { | |
Utils.sayTestStarted("testRenameEntityViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
mappedSuperclass.click(); | |
jpaDiagramEditor | |
.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_renameEntityClass); | |
SWTBotShell renameEntityDialog = editorProxy.getRenameEntityDialog(); | |
SWTBotText entityName = renameEntityDialog.bot().textWithLabel( | |
"New name:"); | |
// test invalid entity name | |
entityName.setText(""); | |
assertFalse(editorProxy.getFinishButton(renameEntityDialog).isEnabled()); | |
assertTrue(editorProxy.getCancelButton(renameEntityDialog).isEnabled()); | |
entityName.setText("NewEntityName"); | |
assertTrue(editorProxy.getFinishButton(renameEntityDialog).isEnabled()); | |
assertTrue(editorProxy.getCancelButton(renameEntityDialog).isEnabled()); | |
editorProxy.getFinishButton(renameEntityDialog).click(); | |
bot.waitUntil(new ElementIsShown(jpaDiagramEditor, "NewEntityName"), | |
10000); | |
mappedSuperclass = jpaDiagramEditor.getEditPart("NewEntityName"); | |
assertNotNull("Entity name must be changed!", mappedSuperclass); | |
assertNull("Entity naem must be changed!", | |
jpaDiagramEditor.getEditPart("MpdSuprcls1")); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRenameEntityViaMenu"); | |
} | |
/** | |
* Move the mapped superclass class using the entity's context menu | |
* "Refactor Entity Class -> Move..." | |
*/ | |
@Ignore | |
@Test | |
public void testMoveEntityViaMenu() throws JavaModelException { | |
Utils.sayTestStarted("testMoveEntityViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
JpaArtifactFactory factory = JpaArtifactFactory.instance(); | |
String packageName = factory | |
.getMappedSuperclassPackageDeclaration(editorProxy | |
.getJPTObjectForGefElement(mappedSuperclass)); | |
mappedSuperclass.click(); | |
jpaDiagramEditor | |
.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_moveEntityClass); | |
SWTBotShell moveEntityDialog = editorProxy.getMoveEntityDialog(); | |
moveEntityDialog.bot().tree().getTreeItem(TEST_PROJECT).select() | |
.expandNode("src").expandNode("org").select().click(); | |
assertTrue(editorProxy.getOkButton(moveEntityDialog).isEnabled()); | |
editorProxy.getOkButton(moveEntityDialog).click(); | |
editorProxy.waitASecond(); | |
mappedSuperclass = jpaDiagramEditor.getEditPart("MpdSuprcls1"); | |
String newEntityPackage = factory | |
.getMappedSuperclassPackageDeclaration(editorProxy | |
.getJPTObjectForGefElement(mappedSuperclass)); | |
assertFalse("Entity must be moved!", | |
packageName.equals(newEntityPackage)); | |
assertTrue("Entity must be changed!", newEntityPackage.equals("org")); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testMoveEntityViaMenu"); | |
} | |
/** | |
* Collapse/expand mapped superclass using its context buttons | |
*/ | |
@Test | |
public void testCollapseExapandEntityViaContextButton() { | |
Utils.sayTestStarted("testCollapseExapandEntityViaContextButton"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1"); | |
editorProxy.collapseExpandJPTViaButton(mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testCollapseExapandEntityViaContextButton"); | |
} | |
/** | |
* Collapse/expand mapped superclass using its context menus | |
*/ | |
@Test | |
public void testCollapseExapandEntityViaMenu() { | |
Utils.sayTestStarted("testCollapseExapandEntityViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1"); | |
editorProxy.collapseExpandJPTViaMenu(mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testCollapseExapandEntityViaMenu"); | |
} | |
/** | |
* Add a new attribute without saving the mapped superclass and call the | |
* "Discard Changes" context menu. Assert that the newly added attribute is | |
* removed and the mapped superclass does not contain unsaved changes. | |
*/ | |
@Test | |
public void testDiscardChanges() { | |
Utils.sayTestStarted("testDiscardChanges"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(200, 50, "MpdSuprcls1"); | |
editorProxy.discardChanges(mappedSuperclass, "attribute1"); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testDiscardChanges"); | |
} | |
/** | |
* Add a new attribute without saving the mapped superclass and call the mapped superclass'es | |
* context menu "Remove All Entities from Diagram -> ... and Discard | |
* Changes" context menu. Assert that the diagram is empty. Call "Show All | |
* Entities" context menu and assert that the newly added attribute is | |
* removed and the mapped superclass does not contain unsaved changes. | |
*/ | |
@Test | |
public void testRemoveAndDiscardChangesViaMenu() { | |
Utils.sayTestStarted("testRemoveAndDiscardChangesViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.removeAndDiscardChangesViaMenu(mappedSuperclass, "attribute1"); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveAndDiscardChangesViaMenu"); | |
} | |
/** | |
* Add a new attribute without saving the mapped superclass and call the mapped superclass'es | |
* context menu "Remove All Entities from Diagram -> ... and Save | |
* Changes" context menu. Assert that the diagram is empty. Call "Show All | |
* Entities" context menu and assert that the newly added attribute is added | |
* and the mapped superclass does not contain unsaved changes. | |
*/ | |
@Test | |
public void testRemoveAndSaveChangesViaMenu() { | |
Utils.sayTestStarted("testRemoveAndSaveChangesViaMenu"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.removeAndSaveChangesViaMenu(mappedSuperclass, "attribute1"); | |
mappedSuperclass.click(); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testRemoveAndSaveChangesViaMenu"); | |
} | |
/** | |
* Add a new attribute to the mapped superclass. From the mapped superclass'es context menu select | |
* "Save". Assert that the mapped superclass does not contain any unsaved changes, but | |
* the diagram editor is still dirty. | |
*/ | |
@Test | |
public void testSaveOnlyEntity() { | |
Utils.sayTestStarted("testSaveOnlyEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.saveOnlyJPT(mappedSuperclass, "attribute1"); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testSaveOnlyEntity"); | |
} | |
/** | |
* Creates a new Inherited entity by mapped superclass. Assert that the | |
* inherited entity contains a primary key. | |
*/ | |
@Test | |
public void testInheritedEntityByMappedSuperclass() { | |
Utils.sayTestStarted("testInheritedEntityByMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy | |
.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
editorProxy.createInheritedEntity(mappedSuperclass, "Entity1", | |
JptUiDetailsMessages.MappedSuperclassUiProvider_linkLabel, true); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testInheritedEntityByMappedSuperclass"); | |
} | |
/** | |
* Tests that the creation of a one-to-one unidirectional relationship from | |
* mapped superclass to entity is possible. | |
*/ | |
@Test | |
public void testOneToOneUniDirRelFromMappedSuperclass() { | |
Utils.sayTestStarted("testOneToOneUniDirRelFromMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1"); | |
// create One-to-One unidirectional relation from the mapped superclass | |
// to entity | |
editorProxy.testUniDirRelation(JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName, mappedSuperclass, | |
entity, IRelation.RelType.ONE_TO_ONE, JptUiDetailsMessages.OneToOneMappingUiProvider_linkLabel); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testOneToOneUniDirRelFromMappedSuperclass"); | |
} | |
/** | |
* Tests that the creation of a one-to-many unidirectional relationship from | |
* mapped superclass to entity is possible. | |
*/ | |
@Test | |
public void testOneToManyUniDirRelFromMappedSuperclass() { | |
Utils.sayTestStarted("testOneToManyUniDirRelFromMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1"); | |
// create One-to-many unidirectional relation from the mapped superclass | |
// to entity1 | |
editorProxy.testUniDirRelation(JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName, mappedSuperclass, | |
entity, IRelation.RelType.ONE_TO_MANY, JptUiDetailsMessages.OneToManyMappingUiProvider_linkLabel); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testOneToManyUniDirRelFromMappedSuperclass"); | |
} | |
/** | |
* Tests that the creation of a many-to-one unidirectional relationship from | |
* mapped superclass to entity is possible. | |
*/ | |
@Test | |
public void testManyToOneUniDirRelFromMappedSuperclass() { | |
Utils.sayTestStarted("testManyToOneUniDirRelFromMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1"); | |
// create Many-to-One unidirectional relation from the mapped superclass | |
// to entity1 | |
editorProxy.testUniDirRelation(JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName, mappedSuperclass, | |
entity, IRelation.RelType.MANY_TO_ONE, JptUiDetailsMessages.ManyToOneMappingUiProvider_linkLabel); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testManyToOneUniDirRelFromMappedSuperclass"); | |
} | |
/** | |
* Tests that the creation of a many-to-many unidirectional relationship from | |
* mapped superclass to entity is possible. | |
*/ | |
@Test | |
public void testManyToManyUniDirRelFromMappedSuperclass() { | |
Utils.sayTestStarted("testManyToManyUniDirRelFromMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1"); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1"); | |
// create Many-to-Many unidirectional relation from the mapped superclass | |
// to entity1 | |
editorProxy.testUniDirRelation(JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName, mappedSuperclass, | |
entity, IRelation.RelType.MANY_TO_MANY, JptUiDetailsMessages.ManyToManyMappingUiProvider_linkLabel); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testManyToManyUniDirRelFromMappedSuperclass"); | |
} | |
/** | |
* Test no one-to-one unidirectional or bidirectional relationship from entity to | |
* mapped superclass is created. | |
*/ | |
@Test | |
public void testOneToOneRelationFromEntityToMappedSuperclass() { | |
Utils.sayTestStarted("testOneToOneRelationFromEntityToMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName, | |
0, entity, mappedSuperclass); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, | |
1, entity, mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testOneToOneRelationFromEntityToMappedSuperclass"); | |
} | |
/** | |
* Test no one-to-one bidirectional relationship from mapped superclass to | |
* entity is created. | |
*/ | |
@Test | |
public void testOneToOneBiDirRelationFromMappedSuperclassToEntity() { | |
Utils.sayTestStarted("testOneToOneBiDirRelationFromMappedSuperclassToEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, | |
1, mappedSuperclass, entity); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testOneToOneBiDirRelationFromMappedSuperclassToEntity"); | |
} | |
/** | |
* Test no one-to-many unidirectional relationship from entity to | |
* mapped superclass is created. | |
*/ | |
@Test | |
public void testOneToManyUniDirRelationFromEntityToMappedSuperclass() { | |
Utils.sayTestStarted("testOneToManyUniDirRelationFromEntityToMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName, | |
0, entity, mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testOneToManyUniDirRelationFromEntityToMappedSuperclass"); | |
} | |
/** | |
* Test no many-to-one unidirectional or bidirectional relationship from entity to | |
* mapped superclass is created. | |
*/ | |
@Test | |
public void testManyToOneRelationFromEntityToMappedSuperclass() { | |
Utils.sayTestStarted("testManyToOneRelationFromEntityToMappedSuperclass"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName, | |
0, entity, mappedSuperclass); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, | |
1, entity, mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testManyToOneRelationFromEntityToMappedSuperclass"); | |
} | |
/** | |
* Test no many-to-one bidirectional relationship from mapped superclass to | |
* entity is created. | |
*/ | |
@Test | |
public void testManyToOneBiDirRelationFromMappedSuperclassToEntity() { | |
Utils.sayTestStarted("testManyToOneBiDirRelationFromMappedSuperclassToEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, | |
1, mappedSuperclass, entity); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testManyToOneBiDirRelationFromMappedSuperclassToEntity"); | |
} | |
/** | |
* Test no many-to-many unidirectional or bidirectional relationship from entity to | |
* mapped superclass is created. | |
*/ | |
@Test | |
public void testManyToManyUniDirRelationFromEntityToEmbeddable() { | |
Utils.sayTestStarted("testManyToManyUniDirRelationFromEntityToEmbeddable"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName, | |
0, entity, mappedSuperclass); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, | |
1, entity, mappedSuperclass); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.save(); | |
Utils.sayTestFinished("testManyToManyUniDirRelationFromEntityToEmbeddable"); | |
} | |
/** | |
* Test no many-to-many bidirectional relationship from mapped superclass to | |
* entity is created. | |
*/ | |
@Test | |
public void testManyToManyBiDirRelationFromMappedSuperclassToEntity() { | |
Utils.sayTestStarted("testManyToManyBiDirRelationFromMappedSuperclassToEntity"); | |
assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty()); | |
SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, | |
"Entity1"); | |
SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, | |
50, "MpdSuprcls1"); | |
editorProxy | |
.testNoConnectionIsCreated( | |
JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, | |
1, mappedSuperclass, entity); | |
editorProxy.deleteDiagramElements(); | |
jpaDiagramEditor.saveAndClose(); | |
Utils.sayTestFinished("testManyToManyBiDirRelationFromMappedSuperclassToEntity"); | |
} | |
@After | |
public void tearDown() throws Exception { | |
editorProxy.deleteDiagramElements(); | |
Utils.printFormatted(">>>>>>>>>>>> elements are deleted from the diagram."); | |
ListIterator<PersistenceUnit> lit = jpaProject.getRootContextNode().getPersistenceXml().getRoot().getPersistenceUnits().iterator(); | |
PersistenceUnit pu = lit.next(); | |
Iterator<PersistentType> persistentTypesIterator = (Iterator<PersistentType>) pu.getPersistentTypes().iterator(); | |
while(persistentTypesIterator.hasNext()){ | |
Utils.printFormatted(">>>>>>>>>>>>>> persistent type resource must be deleted."); | |
PersistentType type = persistentTypesIterator.next(); | |
type.getResource().delete(true, new NullProgressMonitor()); | |
} | |
} | |
} |