summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorPetya Sabeva2012-09-17 10:17:12 (EDT)
committer Petya Sabeva2012-09-17 10:31:36 (EDT)
commit49321fa53f2717f31f6747de662243e240c2f943 (patch)
tree2ff8fa756fa7b2dd3b295b6e306b59299d248b39
parent90fcfa8db95bb0646125f8c482ce627a90a8b74e (diff)
downloadwebtools.dali-49321fa53f2717f31f6747de662243e240c2f943.zip
webtools.dali-49321fa53f2717f31f6747de662243e240c2f943.tar.gz
webtools.dali-49321fa53f2717f31f6747de662243e240c2f943.tar.bz2
[383656] - Extend JPA Diagram editor's tests using SWTBot for GEF
-rw-r--r--jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml48
-rw-r--r--jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/category.xml (renamed from jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/site.xml)14
-rw-r--r--jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/pom.xml14
-rw-r--r--jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/build.properties3
-rw-r--r--jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/feature.xml2
-rw-r--r--jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.tests.feature/feature.xml8
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.branding/pom.xml17
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/META-INF/MANIFEST.MF2
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/pom.xml17
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/META-INF/MANIFEST.MF2
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/pom.xml30
-rw-r--r--jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java2
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.classpath7
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.project28
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.settings/org.eclipse.jdt.core.prefs7
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/META-INF/MANIFEST.MF37
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/about.html34
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/build.properties4
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/plugin.properties14
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/pom.xml45
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java643
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPAEditorTestsActivator.java64
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/Utils.java156
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ConnectionIsShown.java24
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ContextMenuHelper.java130
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/DiagramIsEmpty.java24
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java966
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementDisappears.java26
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementIsShown.java25
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/JPADiagramEditorSWTBotTest.java2410
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/pom.xml85
31 files changed, 4797 insertions, 91 deletions
diff --git a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml
index fea3540..587e752 100644
--- a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml
+++ b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml
@@ -8,12 +8,15 @@
<packaging>pom</packaging>
<properties>
- <tycho-version>0.9.0</tycho-version>
+ <tycho-version>0.15.0</tycho-version>
</properties>
<modules>
<module>../../plugins/org.eclipse.jpt.jpadiagrameditor.ui</module>
- <!-- module>../../tests/org.eclipse.jpt.jpadiagrameditor.tests</module -->
+ <module>../../plugins/org.eclipse.jpt.jpadiagrameditor.doc.user</module>
+ <module>../../plugins/org.eclipse.jpt.jpadiagrameditor.branding</module>
+ <!-- module>../../tests/org.eclipse.jpt.jpadiagrameditor.ui.tests</module>
+ <module>../../tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests</module-->
<module>../../features/org.eclipse.jpt.jpadiagrameditor.feature</module>
<module>../org.eclipse.jpt.jpadiagrameditor.repository</module>
</modules>
@@ -21,17 +24,24 @@
<build>
<plugins>
<plugin>
- <groupId>org.sonatype.tycho</groupId>
+ <groupId>org.eclipse.tycho</groupId>
<artifactId>tycho-maven-plugin</artifactId>
<version>${tycho-version}</version>
<extensions>true</extensions>
</plugin>
<plugin>
- <groupId>org.sonatype.tycho</groupId>
+ <groupId>org.eclipse.tycho</groupId>
<artifactId>target-platform-configuration</artifactId>
<version>${tycho-version}</version>
<configuration>
<resolver>p2</resolver>
+ <!-- dependencies>
+ <dependency>
+ <type>eclipse-feature</type>
+ <artifactId>org.eclipse.jpt.jpa.feature</artifactId>
+ <version>0.0.0</version>
+ </dependency>
+ </dependencies-->
</configuration>
</plugin>
</plugins>
@@ -39,13 +49,14 @@
<repositories>
<repository>
- <id>indigo</id>
- <url>http://download.eclipse.org/releases/staging/</url>
+ <id>Juno</id>
+ <url>http://download.eclipse.org/releases/juno/</url>
<layout>p2</layout>
</repository>
<repository>
- <id>Juno</id>
- <url>http://build.eclipse.org/webtools/committers/wtp-R3.4.0-I/20110805150738/I-3.4.0-20110805150738/repository/</url>
+ <id>Kepler</id>
+ <!-- url>http://download.eclipse.org/releases/juno/</url-->
+ <url>http://build.eclipse.org/webtools/committers/wtp4x-R3.5.0-I/20120913044711/I-3.5.0-20120913044711/repository/</url>
<layout>p2</layout>
</repository>
<repository>
@@ -53,7 +64,26 @@
<url>http://download.eclipse.org/graphiti/updates/milestones/</url>
<layout>p2</layout>
</repository>
-
+ <repository>
+ <id>swtbot</id>
+ <layout>p2</layout>
+ <url>http://download.eclipse.org/technology/swtbot/helios/dev-build/update-site</url>
+ </repository>
</repositories>
+ <profiles>
+ <profile>
+ <id>swttests</id>
+ <modules>
+ <module>../../tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests</module>
+ </modules>
+ </profile>
+ <profile>
+ <id>jtests</id>
+ <modules>
+ <module>../../tests/org.eclipse.jpt.jpadiagrameditor.ui.tests</module>
+ </modules>
+ </profile>
+ </profiles>
+
</project> \ No newline at end of file
diff --git a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/site.xml b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/category.xml
index a13eae7..33d1411 100644
--- a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/site.xml
+++ b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/category.xml
@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<site>
- <feature url="features/org.eclipse.jpt.jpadiagrameditor.feature_1.1.0.qualifier.jar" id="org.eclipse.jpt.jpadiagrameditor.feature" version="1.1.0.qualifier">
- <category name="jpa_diagram_editor"/>
- </feature>
- <category-def name="jpa_diagram_editor" label="JPA Diagram Editor"/>
-</site>
+<?xml version="1.0" encoding="UTF-8"?>
+<site>
+ <feature url="features/org.eclipse.jpt.jpadiagrameditor.feature_1.1.0.qualifier.jar" id="org.eclipse.jpt.jpadiagrameditor.feature" version="1.1.0.qualifier">
+ <category name="jpa_diagram_editor"/>
+ </feature>
+ <category-def name="jpa_diagram_editor" label="JPA Diagram Editor"/>
+</site>
diff --git a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/pom.xml b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/pom.xml
index 338dcc4..00ac863 100644
--- a/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/pom.xml
+++ b/jpa_diagram_editor/development/org.eclipse.jpt.jpadiagrameditor.repository/pom.xml
@@ -10,19 +10,7 @@
</parent>
<artifactId>org.eclipse.jpt.jpadiagrameditor.repository</artifactId>
- <packaging>eclipse-update-site</packaging>
+ <packaging>eclipse-repository</packaging>
<name>JPA Editor Update Site</name>
- <build>
- <plugins>
- <plugin>
- <groupId>org.sonatype.tycho</groupId>
- <artifactId>maven-osgi-packaging-plugin</artifactId>
- <configuration>
- <archiveSite>true</archiveSite>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
</project> \ No newline at end of file
diff --git a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/build.properties b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/build.properties
index 9c242a1..8136c53 100644
--- a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/build.properties
+++ b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/build.properties
@@ -10,4 +10,5 @@
###############################################################################
bin.includes = feature.xml,\
eclipse_update_120.jpg,\
- feature.properties \ No newline at end of file
+ feature.properties
+
diff --git a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/feature.xml b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/feature.xml
index 14e1c1e..e2d4038 100644
--- a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/feature.xml
+++ b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.feature/feature.xml
@@ -44,4 +44,4 @@
version="0.0.0"
unpack="false"/>
-</feature> \ No newline at end of file
+</feature>
diff --git a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.tests.feature/feature.xml b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.tests.feature/feature.xml
index 20cf80e..80118ee 100644
--- a/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.tests.feature/feature.xml
+++ b/jpa_diagram_editor/features/org.eclipse.jpt.jpadiagrameditor.tests.feature/feature.xml
@@ -22,7 +22,7 @@
<requires>
<import plugin="org.easymock" version="2.4.0" match="compatible"/>
<import feature="org.eclipse.graphiti.feature" version="0.10.0" match="greaterOrEqual"/>
- <import feature="org.eclipse.jpt.jpa.feature" version="3.0.0" match="greaterOrEqual"/>
+ <import feature="org.eclipse.jpt.jpa.feature" version="3.1.0" match="greaterOrEqual"/>
</requires>
<plugin
@@ -30,5 +30,11 @@
download-size="0"
install-size="0"
version="0.0.0"/>
+
+ <plugin
+ id="org.eclipse.jpt.jpadiagrameditor.swtbot.tests"
+ download-size="0"
+ install-size="0"
+ version="0.0.0"/>
</feature>
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.branding/pom.xml b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.branding/pom.xml
new file mode 100644
index 0000000..8d023a9
--- /dev/null
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.branding/pom.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
+ <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
+ <version>1.1.0-SNAPSHOT</version>
+ <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.jpt.jpadiagrameditor.branding</artifactId>
+ <packaging>eclipse-plugin</packaging>
+ <name>JPA Diagram Editor Branding Plug-in</name>
+
+</project>
+
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/META-INF/MANIFEST.MF b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/META-INF/MANIFEST.MF
index 66fc9f8..6f35b22 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/META-INF/MANIFEST.MF
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/META-INF/MANIFEST.MF
@@ -3,6 +3,6 @@ Bundle-ManifestVersion: 2
Bundle-Name: %pluginName
Bundle-Vendor: %providerName
Bundle-SymbolicName: org.eclipse.jpt.jpadiagrameditor.doc.user; singleton:=true
-Bundle-Version: 1.0.100.qualifier
+Bundle-Version: 1.1.0.qualifier
Bundle-Localization: plugin
Require-Bundle: org.eclipse.help;bundle-version="[3.3.100,4.0.0)"
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/pom.xml b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/pom.xml
new file mode 100644
index 0000000..520c50d
--- /dev/null
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.doc.user/pom.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
+ <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
+ <version>1.1.0-SNAPSHOT</version>
+ <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.jpt.jpadiagrameditor.doc.user</artifactId>
+ <packaging>eclipse-plugin</packaging>
+ <name>JPA Diagram Editor Branding Plug-in</name>
+
+</project>
+
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/META-INF/MANIFEST.MF b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/META-INF/MANIFEST.MF
index b0989d7..4103eba 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/META-INF/MANIFEST.MF
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/META-INF/MANIFEST.MF
@@ -3,7 +3,7 @@ Bundle-ManifestVersion: 2
Bundle-Name: %pluginName
Bundle-Vendor: %providerName
Bundle-SymbolicName: org.eclipse.jpt.jpadiagrameditor.ui;singleton:=true
-Bundle-Version: 1.0.200.qualifier
+Bundle-Version: 1.1.0.qualifier
Bundle-Activator: org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin
Bundle-ActivationPolicy: lazy
Bundle-ClassPath: .
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/pom.xml b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/pom.xml
index b0b1cff..27ced13 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/pom.xml
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/pom.xml
@@ -1,16 +1,16 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <version>1.0.100-SNAPSHOT</version>
-
- <parent>
- <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
- <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
- <version>1.1.0-SNAPSHOT</version>
- <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
- </parent>
-
- <artifactId>org.eclipse.jpt.jpadiagrameditor.ui</artifactId>
- <packaging>eclipse-plugin</packaging>
- <name>JPA Diagram Editor Plug-in</name>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <version>1.1.0-SNAPSHOT</version>
+
+ <parent>
+ <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
+ <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
+ <version>1.1.0-SNAPSHOT</version>
+ <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.jpt.jpadiagrameditor.ui</artifactId>
+ <packaging>eclipse-plugin</packaging>
+ <name>JPA Diagram Editor Plug-in</name>
</project> \ No newline at end of file
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
index 064c5e4..dcd307b 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
@@ -1817,4 +1817,4 @@ public class JpaArtifactFactory {
}
-} \ No newline at end of file
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.classpath b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.classpath
new file mode 100644
index 0000000..8a8f166
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.project b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.project
new file mode 100644
index 0000000..f253c37
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.jpt.jpadiagrameditor.swtbot.tests</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.settings/org.eclipse.jdt.core.prefs b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..f287d53
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/META-INF/MANIFEST.MF b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..dd4411a
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,37 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-Vendor: %providerName
+Bundle-SymbolicName: org.eclipse.jpt.jpadiagrameditor.swtbot.tests;singleton:=true
+Bundle-Version: 1.1.0.qualifier
+Bundle-Activator: org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.JPAEditorTestsActivator
+Bundle-ActivationPolicy: lazy
+Bundle-ClassPath: .
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Require-Bundle: org.easymock;bundle-version="[2.4.0,3.0.0)",
+ org.eclipse.emf.ecore.xmi;bundle-version="[2.5.0,3.0.0)",
+ org.eclipse.emf.transaction;bundle-version="[1.4.0,2.0.0)",
+ org.eclipse.gef;bundle-version="[3.6.0,4.0.0)",
+ org.eclipse.graphiti;bundle-version="[0.9.0,1.0.0)",
+ org.eclipse.graphiti.ui;bundle-version="[0.9.0,1.0.0)",
+ org.eclipse.jpt.common.core;bundle-version="[1.0.0,2.0.0)",
+ org.eclipse.jpt.common.utility;bundle-version="[2.0.0,3.0.0)",
+ org.eclipse.jdt.core;bundle-version="[3.4.0,4.0.0)",
+ org.eclipse.jpt.jpa.core;bundle-version="[3.0.0,4.0.0)",
+ org.eclipse.jpt.jpa.ui;bundle-version="[3.0.0,4.0.0)",
+ org.eclipse.jpt.jpadiagrameditor.ui;bundle-version="[1.0.0,2.0.0)",
+ org.eclipse.ui.ide;bundle-version="[3.4.0,4.0.0)",
+ org.eclipse.ui.views.properties.tabbed;bundle-version="[3.4.0,4.0.0)",
+ org.eclipse.wst.common.frameworks;bundle-version="[1.2.0,2.0.0)",
+ org.eclipse.wst.common.modulecore;bundle-version="[1.2.1,2.0.0)",
+ org.eclipse.wst.common.project.facet.core;bundle-version="[1.3.0,2.0.0)",
+ org.eclipse.core.filesystem;bundle-version="[1.3.1,2.0.0)",
+ org.junit4;bundle-version="[4.0.0,5.0.0)",
+ org.eclipse.swtbot.eclipse.core;bundle-version="2.0.5",
+ org.eclipse.swtbot.eclipse.gef.finder;bundle-version="2.0.5",
+ org.eclipse.swtbot.eclipse.finder;bundle-version="2.0.5",
+ org.eclipse.swtbot.junit4_x;bundle-version="2.0.5",
+ org.hamcrest;bundle-version="1.1.0",
+ org.apache.log4j,
+ org.eclipse.swtbot.forms.finder;bundle-version="2.0.5"
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/about.html b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/about.html
new file mode 100644
index 0000000..be534ba
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/about.html
@@ -0,0 +1,34 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<HTML>
+
+<head>
+<title>About</title>
+<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
+</head>
+
+<BODY lang="EN-US">
+
+<H3>About This Content</H3>
+
+<P>May 02, 2008</P>
+
+<H3>License</H3>
+
+<P>The Eclipse Foundation makes available all content in this plug-in
+("Content"). Unless otherwise indicated below, the Content is provided to you
+under the terms and conditions of the Eclipse Public License Version 1.0
+("EPL"). A copy of the EPL is available at
+<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>.
+For purposes of the EPL, "Program" will mean the Content.</P>
+
+<P>If you did not receive this Content directly from the Eclipse Foundation, the
+Content is being redistributed by another party ("Redistributor") and different
+terms and conditions may apply to your use of any object code in the Content.
+Check the Redistributor's license that was provided with the Content. If no such
+license exists, contact the Redistributor. Unless otherwise indicated below, the
+terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at
+<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
+
+</BODY>
+</HTML>
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/build.properties b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/build.properties
new file mode 100644
index 0000000..41eb6ad
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+ .
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/plugin.properties b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/plugin.properties
new file mode 100644
index 0000000..b5bcd87
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/plugin.properties
@@ -0,0 +1,14 @@
+# ====================================================================
+# To code developer:
+# Do NOT change the properties between this line and the
+# "%%% END OF TRANSLATED PROPERTIES %%%" line.
+# Make a new property name, append to the end of the file and change
+# the code to use the new property.
+# ====================================================================
+
+# ====================================================================
+# %%% END OF TRANSLATED PROPERTIES %%%
+# ====================================================================
+
+pluginName=Dali Java Persistence Tools - JPA Diagram Editor JUnit Tests
+providerName = Eclipse Web Tools Platform \ No newline at end of file
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/pom.xml b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/pom.xml
new file mode 100644
index 0000000..0dd1c08
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/pom.xml
@@ -0,0 +1,45 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
+ <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
+ <version>1.1.0-SNAPSHOT</version>
+ <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.jpt.jpadiagrameditor.swtbot.tests</artifactId>
+ <packaging>eclipse-test-plugin</packaging>
+ <name>JPA Diagram Editor SWTBot Test Plug-in</name>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-surefire-plugin</artifactId>
+ <version>${tycho-version}</version>
+ <configuration>
+ <!-- testSuite>org.eclipse.jpt.jpadiagrameditor.ui.tests</testSuite>
+ <testClass>org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.AllJpaEditorTests</testClass-->
+ <useUIHarness>true</useUIHarness>
+ <useUIThread>false</useUIThread>
+ <systemProperties combine.children="append">
+ <org.eclipse.jpt.jpa.jar>${org.eclipse.jpt.jpa.jar}</org.eclipse.jpt.jpa.jar>
+ </systemProperties>
+ <argLine>-Xms128m -Xmx512m -XX:MaxPermSize=256m</argLine>
+ <product>org.eclipse.sdk.ide</product>
+ <application>org.eclipse.ui.ide.workbench</application>
+ <dependencies>
+ <dependency>
+ <type>p2-installable-unit</type>
+ <artifactId>org.eclipse.sdk.ide</artifactId>
+ <version>0.0.0</version>
+ </dependency>
+ </dependencies>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project> \ No newline at end of file
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java
new file mode 100644
index 0000000..d47bed7
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java
@@ -0,0 +1,643 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2011 SAP AG.
+ * 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:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.StringTokenizer;
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceDescription;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAbstractType;
+import org.eclipse.jpt.common.utility.internal.ArrayTools;
+import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.jpa.core.JpaFile;
+import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.JpaStructureNode;
+import org.eclipse.jpt.jpa.core.context.JpaRootContextNode;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceXml;
+import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetDataModelProperties;
+import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetInstallDataModelProperties;
+import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetInstallDataModelProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+
+@SuppressWarnings("restriction")
+public class JPACreateFactory {
+
+ public static final String JPA_JAR_NAME_SYSTEM_PROPERTY = "org.eclipse.jpt.jpa.jar";
+ public static final String ECLIPSELINK_JAR_NAME_SYSTEM_PROPERTY = "org.eclipse.jpt.eclipselink.jar";
+
+ private static JPACreateFactory factory = null;
+ private IFacetedProject facetedProject;
+ private IProject project;
+ private IJavaProject javaProject;
+ //private IPackageFragmentRoot sourceFolder;
+ JpaProject jpaProject;
+
+ public static synchronized JPACreateFactory instance() {
+ if (factory == null)
+ factory = new JPACreateFactory();
+ return factory;
+ }
+
+ private IProject buildPlatformProject(String projectName) throws CoreException {
+ IWorkspaceDescription description = ResourcesPlugin.getWorkspace().getDescription();
+ description.setAutoBuilding(true);
+ ResourcesPlugin.getWorkspace().setDescription(description);
+ IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
+ p.create(null);
+ p.open(null);
+ return p;
+ }
+
+ protected IDataModel buildJpaConfigDataModel() {
+ IDataModel dataModel = DataModelFactory.createDataModel(new JpaFacetInstallDataModelProvider());
+ dataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, "1.0");
+ dataModel.setProperty(JpaFacetDataModelProperties.PLATFORM, null /*GenericPlatform.VERSION_1_0.getId()*/);
+ dataModel.setProperty(JpaFacetInstallDataModelProperties.CREATE_ORM_XML, Boolean.TRUE);
+ return dataModel;
+ }
+
+ public JpaProject createJPAProject(String projectName) throws CoreException {
+ return createJPAProject(projectName, null, "1.0");
+ }
+
+ public JpaProject createJPA20Project(String projectName) throws CoreException {
+ return createJPAProject(projectName, null, "2.0");
+ }
+
+
+ public JpaProject createJPAProject(String projectName, IDataModel jpaConfig, String jpaFacetVersion) throws CoreException {
+ project = buildPlatformProject(projectName);
+ javaProject = createJavaProject(project, true);
+ if (jpaConfig != null) {
+ jpaFacetVersion = jpaConfig.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
+ }
+ installFacet(facetedProject, "jst.utility", "1.0");
+ installFacet(facetedProject, "jpt.jpa", jpaFacetVersion, jpaConfig);
+ addJar(javaProject, jpaJarName());
+ if (eclipseLinkJarName() != null) {
+ addJar(javaProject, eclipseLinkJarName());
+ }
+ project.refreshLocal(IResource.DEPTH_INFINITE, null);
+ jpaProject = this.getJpaProject(project);
+ int cnt = 0;
+ while ((jpaProject == null) && (cnt < 1000)){
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ jpaProject = this.getJpaProject(project);
+ cnt++;
+ }
+ jpaProject.setDiscoversAnnotatedClasses(true);
+// jpaProject.setUpdater(new SynchronousJpaProjectUpdater(jpaProject));
+ return jpaProject;
+ }
+
+ private JpaProject getJpaProject(IProject p) {
+ return (JpaProject) p.getAdapter(JpaProject.class);
+ }
+
+ public static String eclipseLinkJarName() {
+ return getSystemProperty(ECLIPSELINK_JAR_NAME_SYSTEM_PROPERTY);
+ }
+
+ public void installFacet(IFacetedProject facetedProject,
+ String facetName,
+ String versionName) throws CoreException {
+ installFacet(facetedProject, facetName, versionName, null);
+ }
+
+ public void uninstallFacet(IFacetedProject facetedProject,
+ String facetName,
+ String versionName) throws CoreException {
+ uninstallFacet(facetedProject, facetName, versionName, null);
+ }
+
+ /**
+ * if 'config' is null (and 'facetName' is "jpt.jpa"), the JPA project will be built with the defaults
+ * defined in JpaFacetInstallDataModelProvider#getDefaultProperty(String)
+ */
+ public void installFacet(IFacetedProject facetedProject,
+ String facetName,
+ String versionName,
+ IDataModel config) throws CoreException {
+ facetedProject.installProjectFacet(this.facetVersion(facetName, versionName), config, null);
+ }
+
+ public void uninstallFacet(IFacetedProject facetedProject,
+ String facetName,
+ String versionName,
+ IDataModel config) throws CoreException {
+ facetedProject.uninstallProjectFacet(this.facetVersion(facetName, versionName), config, null);
+ }
+
+ private IProjectFacetVersion facetVersion(String facetName, String versionName) {
+ return ProjectFacetsManager.getProjectFacet(facetName).getVersion(versionName);
+ }
+
+ protected static String getSystemProperty(String propertyName) {
+ return System.getProperty(propertyName);
+ }
+
+ public void addJar(IJavaProject javaProject, String jarPath) throws JavaModelException {
+ this.addClasspathEntry(javaProject, JavaCore.newLibraryEntry(new Path(jarPath), null, null));
+ }
+
+ private void addClasspathEntry(IJavaProject javaProject, IClasspathEntry entry) throws JavaModelException {
+ javaProject.setRawClasspath(ArrayTools.add(javaProject.getRawClasspath(), entry), null);
+ }
+
+ private IFacetedProject createFacetedProject(IProject project) throws CoreException {
+ return ProjectFacetsManager.create(project, true, null); // true = "convert if necessary"
+ }
+
+ public IJavaProject createJavaProject(IProject project,
+ boolean autoBuild) throws CoreException {
+ facetedProject = createFacetedProject(project);
+ installFacet(facetedProject, "jst.java", "5.0");
+ javaProject = JavaCore.create(project);
+ //sourceFolder = javaProject.getPackageFragmentRoot(project.getFolder("src"));
+ return javaProject;
+ }
+
+ public static String jpaJarName() {
+ return getSystemProperty(JPA_JAR_NAME_SYSTEM_PROPERTY);
+ }
+
+ public IFile createEntity(JpaProject jpaProject, String fullyQualifiedName) throws Exception {
+ StringTokenizer tokenizer = new StringTokenizer(fullyQualifiedName, ".");
+ ArrayList<String> nameElements = new ArrayList<String>();
+ while(tokenizer.hasMoreElements()){
+ nameElements.add(tokenizer.nextToken());
+ }
+ ArrayList<String> packageFragments = new ArrayList<String>();
+ for(int i=0;i<nameElements.size()-1;i++){
+ packageFragments.add(nameElements.get(i));
+ }
+ String[] packageStrings = new String[packageFragments.size()];
+ for(int i=0;i<packageFragments.size();i++){
+ packageStrings[i] = packageFragments.get(i);
+ }
+ String name = nameElements.get(Math.max(0, nameElements.size()-1));
+// SynchronousJpaProjectUpdater updater = new SynchronousJpaProjectUpdater(jpaProject);
+// updater.start();
+ JpaRootContextNode jpaProjectContent = jpaProject.getRootContextNode();
+ PersistenceXml persXML = jpaProjectContent.getPersistenceXml();
+ int cnt = 0;
+ while ((persXML == null) && (cnt < 100)) {
+ Thread.sleep(250);
+ persXML = jpaProjectContent.getPersistenceXml();
+ cnt++;
+ }
+ if (persXML == null)
+ throw new NullPointerException("The persistence XML is not created");
+
+ IFile entity1 = createEntityInProject(jpaProject.getProject(), packageStrings, name);
+ JavaResourceAbstractType jrpt = jpaProject.getJavaResourceType(fullyQualifiedName);
+ cnt = 0;
+ while((jrpt == null) && (cnt < 100)) {
+ try {
+ Thread.sleep(250);
+ } catch (Exception e) {}
+ jrpt = jpaProject.getJavaResourceType(fullyQualifiedName);
+ cnt++;
+ }
+ if (jrpt == null)
+ throw new NullPointerException("The entity '" + fullyQualifiedName + "' could not be created");
+ return entity1;
+ }
+
+ public IFile createEntityInProject(IProject project,
+ String[] packageFragments,
+ String entityName) throws IOException,
+ CoreException,
+ JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createEntity(folder, packageName , entityName);
+ }
+
+ @SuppressWarnings("deprecation")
+ private String getFolderName(IProject project, String[] packageFragments)
+ throws JavaModelException {
+ IJavaProject javaProject = JavaCore.create(project);
+ IPackageFragmentRoot[] packageFragmentRoots = new IPackageFragmentRoot[0];
+ final IClasspathEntry[] classpathEntries = javaProject.getRawClasspath();
+ for (IClasspathEntry classpathEntry : classpathEntries) {
+ if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
+ packageFragmentRoots = javaProject.getPackageFragmentRoots(classpathEntry);
+ break;
+ }
+ }
+
+ String folderName = packageFragmentRoots[0].getResource().getName();
+ for (String fragment : packageFragments) {
+ folderName += Path.SEPARATOR + fragment;
+ }
+ return folderName;
+ }
+
+ private IFile createEntity(IFolder folder, String packageName, String entityName) throws IOException, CoreException {
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + ".java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n\n"
+ + "@Entity \n"
+ + "public class " + entityShortName + " {\n"
+ + " private int id;\n"
+ + " @Id \n"
+ + " public int getId() {\n"
+ + " return id;\n"
+ + " }\n"
+ + " public void setId(int id) {\n"
+ + " this.id = id;\n"
+ + " }\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+ public IFile createEntityWithCompositePKInProject(IProject project,
+ String[] packageFragments, String entityName) throws IOException,
+ CoreException, JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createEntityWithCompositePK(folder, packageName, entityName);
+ }
+
+ public IFile createIdClassInProject(IProject project,
+ String[] packageFragments, String entityName) throws IOException,
+ CoreException, JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createIdClass(folder, packageName, entityName);
+ }
+
+ public IFile createEmbeddedClassInProject(IProject project,
+ String[] packageFragments, String entityName) throws IOException,
+ CoreException, JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createEmbeddedClass(folder, packageName, entityName);
+ }
+
+ public IFile createEntityWithEmbeddedPKInProject(IProject project,
+ String[] packageFragments, String entityName) throws IOException,
+ CoreException, JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createEntityWithEmbeddedPK(folder, packageName, entityName);
+ }
+
+
+
+ private IFile createEntityWithCompositePK(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + ".java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n\n"
+ + "@Entity \n"
+ + "@IdClass("+entityShortName+"Id.class)"
+ + "public class " + entityShortName + " {\n"
+ + " @Id \n"
+ + " private String firstName;\n"
+ + " @Id \n"
+ + " private String lastName;\n"
+ + " public "+entityShortName+"Id() {}\n"
+ + " public "+entityShortName+"Id(String firstName, String lastName)\n{"
+ + " this.firstName = firstName;\n"
+ + " this.lastName = lastName;\n"
+ + " }\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+ private IFile createIdClass(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + "Id.java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n\n"
+ +"import java.io.Serializable;"
+ + "public class " + entityShortName + "Id {\n"
+ + " private String firstName;\n"
+ + " private String lastName;\n"
+ + " public String getFirstName() {\n"
+ + " return firstName;\n"
+ + " }\n"
+ + " public void setFirstName(String firstName) {\n"
+ + " this.firstName = firstName;\n"
+ + " }\n"
+ + " public String getLastName() {\n"
+ + " return lastName;\n"
+ + " }\n"
+ + " public void setLastName(String lastName) {\n"
+ + " this.lastName = lastName;\n"
+ + " }\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+ private IFile createEntityWithEmbeddedPK(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + ".java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n\n"
+ + "@Entity\n"
+ + "public class " + entityShortName + " {\n"
+ + "@EmbeddedId\n"
+ + " private "+ entityShortName +"Id id;\n"
+ + "public void setId(" + entityShortName+ "Id param) {\n"
+ + " this.id = param;\n"
+ + "}\n"
+ + "public "+entityShortName+"Id getId() {\n"
+ + "return id;\n"
+ + "}\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+ private IFile createEmbeddedClass(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + ".java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n"
+ + "@Embeddable\n"
+ + "public class " + entityShortName + " {\n"
+ +"private String firstName;\n"
+ +"public String getFirstName() {\n"
+ + " return firstName;\n"
+ + "}\n"
+ + "public void setFirstName(String firstName) {\n"
+ + "this.firstName = firstName;\n"
+ + "}\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+
+ private void createDirectories(IContainer container, boolean force,
+ boolean local, IProgressMonitor monitor) throws CoreException {
+ if (container != null && container instanceof IFolder) {
+ IFolder folder = (IFolder) container;
+ if (!folder.exists()) {
+ // depth first
+ IContainer parent = folder.getParent();
+ createDirectories(parent, force, local, null);
+ // own second
+ folder.create(force, local, monitor);
+ }
+ }
+ }
+
+ public static ReadOnlyPersistentAttribute getPersistentAttribute(IFile entity, String attributeName){
+ Set<ReadOnlyPersistentAttribute> result = getEntityFields(entity);
+ for(ReadOnlyPersistentAttribute attribute : result){
+ if(attributeName.equals(attribute.getName())){
+ return attribute;
+ }
+ }
+ return null;
+ }
+
+ public static PersistentType getPersistentType(IFile file){
+ JpaFile jpaFile = getJpaFile(file);
+ for (JpaStructureNode node : getRootNodes(jpaFile)) {
+ PersistentType entity = (PersistentType) node;
+ return entity;
+ }
+ return null;
+ }
+
+ private static Iterable<JpaStructureNode> getRootNodes(JpaFile jpaFile) {
+ if(jpaFile == null){
+ return EmptyIterable.instance();
+ }
+ return jpaFile.getRootStructureNodes();
+ }
+
+ public static Set<ReadOnlyPersistentAttribute> getEntityFields(IFile file){
+ Set<ReadOnlyPersistentAttribute> result = new HashSet<ReadOnlyPersistentAttribute>();
+ JpaFile jpaFile = getJpaFile(file);
+ if(jpaFile == null){
+ return result;
+ }
+ for (JpaStructureNode node : getRootNodes(jpaFile)) {
+ PersistentType entity = (PersistentType) node;
+ Iterator<ReadOnlyPersistentAttribute> attributes = entity.getAllAttributes().iterator();
+ while (attributes.hasNext()){
+ ReadOnlyPersistentAttribute attribute = attributes.next();
+ result.add(attribute);
+ }
+ }
+ return result;
+ }
+
+ private static JpaFile getJpaFile(IFile file) {
+ return (JpaFile) file.getAdapter(JpaFile.class);
+ }
+
+ public void addAttributes(IFile entity, String attName, String attType, String annotation, String attActName, boolean isCollection){
+ JavaPersistentType javaPersistentType = (JavaPersistentType)getPersistentType(entity);
+ int cnt = 0;
+ while ((javaPersistentType == null) && (cnt < 100)) {
+ try {
+ Thread.sleep(250);
+ } catch (InterruptedException e) {}
+ javaPersistentType = (JavaPersistentType)getPersistentType(entity);
+ cnt++;
+ }
+ if (javaPersistentType == null)
+ throw new RuntimeException("The entity could not be created");
+ ICompilationUnit compilationUnit = JavaCore.createCompilationUnitFrom(entity);
+ JpaArtifactFactory.instance().addNewAttribute(javaPersistentType, compilationUnit, attName, attType, annotation, attActName, isCollection, null);
+ }
+
+ private IFile createFieldAnnotatedEntity(IFolder folder, String packageName, String entityName) throws IOException, CoreException {
+ String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+ if (!folder.exists()) {
+ createDirectories(folder, true, true, new NullProgressMonitor());
+ }
+ IFile file = folder.getFile(entityShortName + ".java");
+ if (!file.exists()) {
+ String content = "package " + packageName + ";\n\n"
+ + "import javax.persistence.*;\n\n"
+ + "@Entity \n"
+ + "public class " + entityShortName + " {\n"
+ + " @Id \n"
+ + " private int id;\n"
+ + " public int getId() {\n"
+ + " return id;\n"
+ + " }\n"
+ + " public void setId(int id) {\n"
+ + " this.id = id;\n"
+ + " }\n"
+ + "}"; //$NON-NLS-1$
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ try {
+ stream.write(content.getBytes());
+ stream.flush();
+ file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+ } finally {
+ stream.close();
+ }
+ }
+ return file;
+ }
+
+ public IFile createFieldAnnotatedEntityInProject(IProject project, String[] packageFragments, String entityName) throws IOException, CoreException, JavaModelException {
+ String folderName = getFolderName(project, packageFragments);
+ String packageName = packageFragments[0];
+ for (int i = 1; i < packageFragments.length; i++) {
+ packageName += "." + packageFragments[i];
+ }
+
+ IPath path = new Path(folderName);
+ IFolder folder = project.getFolder(path);
+ return createFieldAnnotatedEntity(folder, packageName , entityName);
+ }
+
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPAEditorTestsActivator.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPAEditorTestsActivator.java
new file mode 100644
index 0000000..61b3856
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPAEditorTestsActivator.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2012 SAP AG 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:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal;
+
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.Plugin;
+import org.eclipse.jpt.common.utility.internal.ReflectionTools;
+import org.eclipse.jpt.jpa.core.JpaProjectManager;
+import org.osgi.framework.BundleContext;
+
+public class JPAEditorTestsActivator extends Plugin {
+
+ /**
+ *
+ */
+ public JPAEditorTestsActivator() {
+ }
+
+ // The shared instance
+ private static JPAEditorTestsActivator plugin;
+
+ @Override
+ public void start(BundleContext context) throws Exception {
+ super.start(context);
+ plugin = this;
+ JpaProjectManager jpaProjectManager = this.getJpaProjectManager();
+// ReflectionTools.executeMethod(jpaProjectManager, "executeCommandsSynchronously"); //$NON-NLS-1$
+ }
+
+ protected JpaProjectManager getJpaProjectManager() {
+ return (JpaProjectManager) ResourcesPlugin.getWorkspace().getAdapter(JpaProjectManager.class);
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ plugin = null;
+ super.stop(context);
+ }
+
+ /**
+ * Returns the shared instance
+ *
+ * @return the shared instance
+ */
+ public static JPAEditorTestsActivator getDefault() {
+ return plugin;
+ }
+
+
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/Utils.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/Utils.java
new file mode 100644
index 0000000..0f3783e
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/Utils.java
@@ -0,0 +1,156 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Semaphore;
+
+
+/**
+ * Utility for testing purposes
+ * @author i057508
+ *
+ */
+@SuppressWarnings({"restriction", "PMD"})
+public class Utils {
+
+ /**
+ * User space system variable key.
+ */
+ private static Semaphore writeToConsolePermission = new Semaphore(1);
+ static SimpleDateFormat sdf = new SimpleDateFormat(">> [HH:mm:ss.S] ");
+
+ public final static String NEW_LINE = (System.getProperty("line.separator") != null ? System.getProperty("line.separator") : "\n"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+
+
+
+ /** A constant for java validation error markers*/
+
+ /**
+ * the plug-in ID of this plug-in
+ */
+ public static final String COMMON_TEST_PLUGIN_ID = "com.sap.core.tools.eclipse.server.test.common";
+
+ /**
+ * Issues a message into the system console into a friendly format. The format includes current time.
+ * The order is preserved, so if another request is issued in meantime, it will be processed consequently.
+ * At the end of the message no new line will be added.
+ * @param message the message to be issued
+ */
+ public static void printFormatted(String message) {
+ try {
+ writeToConsolePermission.acquire();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print(sdf.format(new Date()) + message);
+ writeToConsolePermission.release();
+ }
+
+ /**
+ * Issues a message into the system console. The format includes current time.
+ * The order is preserved, so if another request is issued in meantime, it will be processed consequently.
+ * At the end of the message no new line will be added.
+ * @param message the message to be issued
+ */
+ public static void print(String message) {
+ try {
+ writeToConsolePermission.acquire();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print(message);
+ writeToConsolePermission.release();
+ }
+
+ /**
+ * Issues a message into the system console into a friendly format. The format includes current time.
+ * The order is preserved, so if another request is issued in meantime, it will be processed consequently.
+ * At the end of the message a new line will be added.
+ * @param message the message to be issued
+ */
+ public static void printlnFormatted(String message) {
+ try {
+ writeToConsolePermission.acquire();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ System.out.println(sdf.format(new Date()) + message);
+ writeToConsolePermission.release();
+ }
+
+ /**
+ * Utility for printing into the system console
+ * @param message a message to be printed
+ * @param t an exception to be printed
+ */
+ public static void printlnFormatted(String message, Throwable t) {
+ StringBuilder buf = new StringBuilder();
+ buf.append(message);
+
+ if (t != null && t.getStackTrace() != null) {
+ buf.append(NEW_LINE);
+ buf.append("Exception:").append(t.getMessage());
+ buf.append(NEW_LINE);
+ buf.append("Stacktrace:");
+ buf.append(NEW_LINE);
+ buf.append(traceToString(t.getStackTrace()));
+ }
+
+ printlnFormatted(buf.toString());
+ }
+
+ /**
+ * Issues a message into the system console. The format includes current time.
+ * The order is preserved, so if another request is issued in meantime, it will be processed consequently.
+ * At the end of the message a new line will be added.
+ * @param message the message to be issued
+ */
+ public static void println(String message) {
+ try {
+ writeToConsolePermission.acquire();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println(message);
+ writeToConsolePermission.release();
+ }
+
+ /**
+ * Indicates a start of a test into the system console into a use friendly format.
+ * @param testName the name of the test.
+ */
+ public static void sayTestStarted(String testName) {
+
+ Utils.println("\n----------------------------------------------------------------------------");
+ Utils.printlnFormatted("Test [" + testName + "] started.");
+ Utils.println("----------------------------------------------------------------------------");
+ }
+
+ /**
+ * Indicates an end of a test into the system console into a use friendly format.
+ * @param testName the name of the test.
+ */
+ public static void sayTestFinished(String testName) {
+
+ Utils.println("\n----------------------------------------------------------------------------");
+ Utils.printlnFormatted("Test [" + testName + "] finished.");
+ Utils.println("----------------------------------------------------------------------------");
+ }
+
+ /**
+ * Converts stacktrace into a string
+ * @param trace the stacktrace
+ * @return the converted stacktrace
+ */
+ public static String traceToString(StackTraceElement[] trace) {
+ StringBuilder builder = new StringBuilder();
+
+ for (int i = 0; i < trace.length; i++) {
+ builder.append(trace[i]).append("\n");
+ }
+ return builder.toString();
+ }
+}
+
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ConnectionIsShown.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ConnectionIsShown.java
new file mode 100644
index 0000000..8acdbae
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ConnectionIsShown.java
@@ -0,0 +1,24 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
+
+public class ConnectionIsShown extends DefaultCondition{
+
+ private SWTBotGefEditPart entity;
+
+ public ConnectionIsShown(SWTBotGefEditPart entity){
+ super();
+ this.entity = entity;
+ }
+
+ public boolean test() throws Exception {
+ return (!entity.sourceConnections().isEmpty() || !entity.targetConnections().isEmpty());
+ }
+
+ public String getFailureMessage() {
+ return "Relationship did not show.";
+ }
+
+}
+
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ContextMenuHelper.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ContextMenuHelper.java
new file mode 100644
index 0000000..38c3a66
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ContextMenuHelper.java
@@ -0,0 +1,130 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import static org.eclipse.swtbot.swt.finder.matchers.WidgetMatcherFactory.withRegex;
+import static org.hamcrest.core.AllOf.allOf;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+
+import java.util.Arrays;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.MenuItem;
+import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
+import org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable;
+import org.eclipse.swtbot.swt.finder.results.VoidResult;
+import org.eclipse.swtbot.swt.finder.results.WidgetResult;
+import org.eclipse.swtbot.swt.finder.widgets.AbstractSWTBot;
+import org.hamcrest.Matcher;
+
+public class ContextMenuHelper
+{
+
+ /**
+ * Clicks the context menu matching the text.
+ *
+ * @param text
+ * the text on the context menu.
+ * @throws WidgetNotFoundException
+ * if the widget is not found.
+ */
+ public static void clickContextMenu( final AbstractSWTBot<?> bot, final String... texts )
+ {
+ final Matcher<?>[] matchers = new Matcher<?>[texts.length];
+ for ( int i = 0; i < texts.length; i++ )
+ {
+ // matchers[i] = allOf( instanceOf( MenuItem.class ), withMnemonic( texts[i] ) );
+ matchers[i] = allOf( instanceOf( MenuItem.class ), withRegex( texts[i] ) );
+ }
+
+ // show
+ final MenuItem menuItem = UIThreadRunnable.syncExec( new WidgetResult<MenuItem>()
+ {
+ public MenuItem run()
+ {
+ MenuItem menuItem = null;
+ Control control = ( Control ) bot.widget;
+ Menu menu = control.getMenu();
+ for ( int i = 0; i < matchers.length; i++ )
+ {
+ menuItem = show( menu, matchers[i] );
+ if ( menuItem != null )
+ {
+ menu = menuItem.getMenu();
+ }
+ else
+ {
+ hide( menu );
+ break;
+ }
+ }
+
+ return menuItem;
+ }
+ } );
+ if ( menuItem == null )
+ {
+ throw new WidgetNotFoundException( "Could not find menu: " + Arrays.asList( texts ) );
+ }
+
+ // click
+ click( menuItem );
+
+ // hide
+ UIThreadRunnable.syncExec( new VoidResult()
+ {
+ public void run()
+ {
+ hide( menuItem.getParent() );
+ }
+ } );
+ }
+
+
+ private static MenuItem show( final Menu menu, final Matcher<?> matcher )
+ {
+ if ( menu != null )
+ {
+ menu.notifyListeners( SWT.Show, new Event() );
+ MenuItem[] items = menu.getItems();
+ for ( final MenuItem menuItem : items )
+ {
+ if ( matcher.matches( menuItem ) )
+ {
+ return menuItem;
+ }
+ }
+ menu.notifyListeners( SWT.Hide, new Event() );
+ }
+ return null;
+ }
+
+
+ private static void click( final MenuItem menuItem )
+ {
+ final Event event = new Event();
+ event.time = ( int ) System.currentTimeMillis();
+ event.widget = menuItem;
+ event.display = menuItem.getDisplay();
+ event.type = SWT.Selection;
+
+ UIThreadRunnable.asyncExec( menuItem.getDisplay(), new VoidResult()
+ {
+ public void run()
+ {
+ menuItem.notifyListeners( SWT.Selection, event );
+ }
+ } );
+ }
+
+
+ private static void hide( final Menu menu )
+ {
+ menu.notifyListeners( SWT.Hide, new Event() );
+ if ( menu.getParentMenu() != null )
+ {
+ hide( menu.getParentMenu() );
+ }
+ }
+} \ No newline at end of file
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/DiagramIsEmpty.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/DiagramIsEmpty.java
new file mode 100644
index 0000000..0a3f5a9
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/DiagramIsEmpty.java
@@ -0,0 +1,24 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
+
+public class DiagramIsEmpty extends DefaultCondition{
+
+ private SWTBotGefEditor gefEditor;
+
+ public DiagramIsEmpty(SWTBotGefEditor gefEditor){
+ super();
+ this.gefEditor = gefEditor;
+ }
+
+ public boolean test() throws Exception {
+ return gefEditor.mainEditPart().children().isEmpty();
+ }
+
+ public String getFailureMessage() {
+ return "Diagram is not empty";
+ }
+
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java
new file mode 100644
index 0000000..8fe4ceb
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java
@@ -0,0 +1,966 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.asyncExec;
+import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.syncExec;
+import static org.eclipse.swtbot.swt.finder.waits.Conditions.shellIsActive;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.awt.AWTException;
+import java.awt.Robot;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.draw2d.FigureCanvas;
+import org.eclipse.draw2d.IFigure;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.gef.GraphicalEditPart;
+import org.eclipse.gef.GraphicalViewer;
+import org.eclipse.gef.LayerConstants;
+import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.mm.pictograms.ContainerShape;
+import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.mm.pictograms.Shape;
+import org.eclipse.graphiti.ui.internal.contextbuttons.ContextButton;
+import org.eclipse.graphiti.ui.internal.contextbuttons.ContextButtonPad;
+import org.eclipse.graphiti.ui.internal.parts.DiagramEditPart;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.widgets.Canvas;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
+import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
+import org.eclipse.swtbot.eclipse.gef.finder.SWTGefBot;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefConnectionEditPart;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.SWTBot;
+import org.eclipse.swtbot.swt.finder.results.VoidResult;
+import org.eclipse.swtbot.swt.finder.utils.Position;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotStyledText;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IEditorReference;
+
+public class EditorProxy {
+
+ private final SWTWorkbenchBot workbenchBot;
+ protected SWTGefBot bot;
+
+
+ /**
+ * Create proxy object.
+ *
+ * @param bot
+ */
+ public EditorProxy(SWTWorkbenchBot workbenchBot, SWTGefBot bot) {
+ this.workbenchBot = workbenchBot;
+ this.bot = bot;
+ }
+
+ public SWTBotGefEditor openDiagramOnJPAContentNode(String name) {
+ SWTBotTree projectTree = workbenchBot.viewByTitle("Project Explorer").bot().tree();
+ projectTree.expandNode(name).expandNode("JPA Content").select();
+ ContextMenuHelper.clickContextMenu(projectTree, "Open Diagram");
+
+ workbenchBot.waitUntil(shellIsActive(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle), 5000);
+ SWTBotShell jpaSupportWarningDialog = workbenchBot.shell(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle);
+ getOkButton(jpaSupportWarningDialog).click();
+
+ SWTBotGefEditor jpaDiagramEditor = bot.gefEditor(name);
+ assertFalse("Editor must not be dirty!", jpaDiagramEditor.isDirty());
+
+ List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart().children();
+ assertTrue("Editor must not contains any entities!", entities.isEmpty());
+
+ return jpaDiagramEditor;
+ }
+
+ public SWTBotGefEditor openDiagramOnJPAProjectNode(String name) {
+ SWTBotTree projectTree = workbenchBot.viewByTitle("Project Explorer").bot().tree();
+ projectTree.expandNode(name).select();
+ ContextMenuHelper.clickContextMenu(projectTree, "JPA Tools", "Open Diagram");
+
+ workbenchBot.waitUntil(shellIsActive(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle), 5000);
+ SWTBotShell jpaSupportWarningDialog = workbenchBot.shell(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle);
+ getOkButton(jpaSupportWarningDialog).click();
+
+ SWTBotGefEditor jpaDiagramEditor = bot.gefEditor(name);
+ assertFalse("Editor must not be dirty!", jpaDiagramEditor.isDirty());
+ return jpaDiagramEditor;
+ }
+
+ /**
+ * Gets the "Select Type" dialog that appears when the attribute's context menu
+ * "Refactor Attribute Type..." is selected
+ * @param jpaDiagramEditor
+ * @param attribute
+ * @return the "Select Type" dialog
+ */
+ public SWTBotShell getSelectNewAttributeTypeDialog(final SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart attribute) {
+ attribute.click();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorAttributeType);
+
+ workbenchBot.waitUntil(shellIsActive(JPAEditorMessages.SelectTypeDialog_chooseAttributeTypeDialogWindowTitle), 5000);
+ SWTBotShell changeTypeDialog = workbenchBot.shell(JPAEditorMessages.SelectTypeDialog_chooseAttributeTypeDialogWindowTitle);
+ getNewTypeInputField(changeTypeDialog);
+ return changeTypeDialog;
+ }
+
+ /**
+ * Gets the text input field of the "Select Type" dialog, which appears when
+ * the attribute's context menu "Refcator Attribute Type..." is selected
+ * @param changeTypeDialog - the "Select Type" dialog
+ * @return the text input field
+ */
+ public SWTBotText getNewTypeInputField(SWTBotShell changeTypeDialog) {
+ SWTBotText attributeType = changeTypeDialog.bot().textWithLabel(JPAEditorMessages.SelectTypeDialog_typeLabel);
+ assertEquals("java.lang.String", attributeType.getText());
+ assertTrue(getOkButton(changeTypeDialog).isEnabled());
+ assertTrue(getCancelButton(changeTypeDialog).isEnabled());
+ return attributeType;
+ }
+
+ /**
+ * Gets the current attribute type value
+ * @param jpaDiagramEditor
+ * @param attributeName
+ * @param fp
+ * @return the value of the attribute's type
+ */
+ public String getAttributeType(SWTBotGefEditor jpaDiagramEditor, String attributeName, final IFeatureProvider fp) {
+ SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart(attributeName);
+ PictogramElement el = (PictogramElement) attribute.part().getModel();
+ Object bo = fp.getBusinessObjectForPictogramElement(el);
+ assertTrue("The selected element is not an attribute!", (bo instanceof JavaPersistentAttribute));
+ String currentAttributeType = JPAEditorUtil.getAttributeTypeName((JavaPersistentAttribute)bo);
+ return currentAttributeType;
+ }
+
+ /**
+ * Adds a new attribute to the entity and checks that:
+ * 1. The newly created attribute is selected
+ * 2. The "Other Attributes" section is visible
+ * @param jpaDiagramEditor
+ * @param attributeName - the name of the attribute
+ * @return the newly added attribute
+ */
+ public SWTBotGefEditPart addAttributeToEntity(final SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart entity, String attributeName) {
+ pressEntityContextButton(jpaDiagramEditor, entity, JPAEditorMessages.JPAEditorToolBehaviorProvider_createAttributeButtonlabel);
+
+ bot.waitUntil(new ElementIsShown(jpaDiagramEditor, attributeName), 10000);
+ SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart(attributeName);
+ assertNotNull("Atrribute is not added.", attribute);
+
+ assertTrue("The newly added attribute must be selected.", jpaDiagramEditor.selectedEditParts().size() == 1);
+ assertTrue("The newly added attribute must be selected.", jpaDiagramEditor.selectedEditParts().contains(attribute));
+
+ assertTrue("\"Other Attributes\" section must be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ return attribute;
+ }
+
+ /**
+ * Checks whether a section with the specified name is visible
+ * @param diagramEditor
+ * @param sectionTitle - the name of the section
+ * @return true, if the section with the specified name is visible,
+ * false otherwise
+ */
+ public boolean isSectionVisible(SWTBotGefEditor diagramEditor, String sectionTitle){
+ SWTBotGefEditPart section = diagramEditor.getEditPart(sectionTitle);
+ ((PictogramElement)section.part().getModel()).isVisible();
+ IFigure figure = ((GraphicalEditPart) section.part()).getFigure();
+ return figure.isVisible();
+ }
+
+ /**
+ * Adds an entity to the diagram
+ * @param jpaDiagramEditor
+ * @param entityName - the name of the entity to be added
+ * @return the added entity
+ */
+ public SWTBotGefEditPart addEntityToDiagram(final SWTBotGefEditor jpaDiagramEditor, int x, int y, String entityName) {
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateJPAEntityFeature_jpaEntityFeatureName);
+ jpaDiagramEditor.doubleClick(x, y);
+ bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 10000);
+
+ List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart().children();
+ assertFalse("Editor must contains at least one entity!", entities.isEmpty());
+
+ SWTBotGefEditPart entity = jpaDiagramEditor.getEditPart(entityName);
+ assertNotNull("Entity is not added!", entity);
+
+ SWTBotGefEditPart idAttribute = jpaDiagramEditor.getEditPart("id");
+ assertNotNull("Entity must have a primary key attribute!", idAttribute);
+
+ assertTrue("\"Primary Key\" section must be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse("\"Relation Attributes\" section must not be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("\"Other Attributes\" section must not be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ return entity;
+ }
+
+ /**
+ * Adds mapped superclass to the diagram
+ * @param jpaDiagramEditor
+ * @param entityName - the name of the mapped superclass to be added
+ * @return the added mapped superclass
+ */
+ public SWTBotGefEditPart addMappedSuperclassToDiagram(final SWTBotGefEditor jpaDiagramEditor, int x, int y, String entityName) {
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateMappedSuperclassFeature_createMappedSuperclassFeatureName);
+ jpaDiagramEditor.doubleClick(x, y);
+ bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 10000);
+
+ List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart().children();
+ assertFalse("Editor must contains at least one mapped superclass!", entities.isEmpty());
+
+ SWTBotGefEditPart mappedSuperclass = jpaDiagramEditor.getEditPart(entityName);
+ assertNotNull("Mapped superclass is not added!", mappedSuperclass);
+
+ SWTBotGefEditPart idAttribute = jpaDiagramEditor.getEditPart("id");
+ assertNull("Mapped superclass must not have a primary key attribute!", idAttribute);
+
+ assertFalse("\"Primary Key\" section must not be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse("\"Relation Attributes\" section must not be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("\"Other Attributes\" section must not be visible!", isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ return mappedSuperclass;
+ }
+
+
+
+ /**
+ * Pressing the "Yes" button of the "Confirm Delete" question dialog.
+ */
+ public void confirmDelete() {
+ SWTBotShell shell = getDeleteEntityDialog();
+ shell.bot().button("Yes").click();
+ }
+
+ /**
+ * Pressing the "No" button of the "Confirm Delete" question dialog.
+ */
+ public void denyDelete() {
+ SWTBotShell shell = getDeleteEntityDialog();
+ shell.bot().button("No").click();
+ }
+
+ /**
+ * Gets the dialog that appears after the "Delete" context button/menu
+ * is pressed.
+ * @return the question dialog, asking whether to the delete the selected entity
+ */
+ public SWTBotShell getDeleteEntityDialog() {
+ workbenchBot.waitUntil(shellIsActive(JPAEditorMessages.DeleteFeature_deleteConfirm), 5000);
+ SWTBotShell shell = workbenchBot.shell(JPAEditorMessages.DeleteFeature_deleteConfirm);
+ return shell;
+ }
+
+ /**
+ * Gets the dialog that appears after the "Refactor Entity Class -> Rename..." context menu
+ * is pressed.
+ * @return the "Rename Compilation Unit" dialog
+ */
+ public SWTBotShell getRenameEntityDialog() {
+ workbenchBot.waitUntil(shellIsActive("Rename Compilation Unit"), 5000);
+ SWTBotShell shell = workbenchBot.shell("Rename Compilation Unit");
+ assertFalse(getFinishButton(shell).isEnabled());
+ assertTrue(getCancelButton(shell).isEnabled());
+ return shell;
+ }
+
+ /**
+ * Gets the dialog that appears after the "Refactor Entity Class -> Move..." context menu
+ * is pressed.
+ * @return the "Move" dialog
+ */
+ public SWTBotShell getMoveEntityDialog() {
+ workbenchBot.waitUntil(shellIsActive("Move"), 5000);
+ SWTBotShell shell = workbenchBot.shell("Move");
+ assertFalse(getOkButton(shell).isEnabled());
+ assertTrue(getCancelButton(shell).isEnabled());
+ return shell;
+ }
+
+ /**
+ * Gets the dialog that appears after the "Remove All Entities from Diagram -> ...and Save/Discard Changes" context menu
+ * is pressed. Press the OK button.
+ */
+ public void confirmRemoveEntitiesFromDiagramDialog() {
+ workbenchBot.waitUntil(shellIsActive(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAllEntitiesMenu), 5000);
+ SWTBotShell shell = workbenchBot.shell(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAllEntitiesMenu);
+ assertTrue("Ok button is disabled", getOkButton(shell).isEnabled());
+ assertTrue(getCancelButton(shell).isEnabled());
+ getOkButton(shell).click();
+ }
+
+
+ /**
+ * Deletes an entity with the specified name using the context button.
+ * @param jpaDiagramEditor
+ * @param entityName - the name of the entity to be deleted
+ */
+ public void deleteDiagramElements(SWTBotGefEditor jpaDiagramEditor){
+
+ jpaDiagramEditor.save();
+
+ List<SWTBotGefEditPart> entitiesInDiagram = jpaDiagramEditor.mainEditPart().children();
+ assertFalse("Diagram must contain at least one entity!", entitiesInDiagram.isEmpty());
+
+ Iterator<SWTBotGefEditPart> iterator = entitiesInDiagram.iterator();
+ while (iterator.hasNext()) {
+ SWTBotGefEditPart editPart = iterator.next();
+ assertNotNull(editPart);
+ editPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ confirmDelete();
+ }
+
+ entitiesInDiagram = jpaDiagramEditor.mainEditPart().children();
+ assertTrue("Diagram must be empty!", entitiesInDiagram.isEmpty());
+ assertTrue("Editor must be dirty!", jpaDiagramEditor.isDirty());
+ }
+
+ /**
+ * Press some of the entity's context buttons
+ * @param jpaDiagramEditor
+ * @param contextButtonName - the name of the button to be pressed
+ */
+ public void pressEntityContextButton(SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart part, String contextButtonName){
+ pressContextButton(jpaDiagramEditor, part, contextButtonName);
+ }
+
+ /**
+ * Press the "Delete Attribute" attribute's context button
+ * @param jpaDiagramEditor
+ */
+ public void pressAttributeDeleteContextButton(SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart part){
+ pressContextButton(jpaDiagramEditor, part, JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteAttributeButtonlabel);
+ }
+
+ /**
+ * Assert that the context button pad is shown, when the mouse is placed over the
+ * entity and press the the desired button
+ * @param jpaDiagramEditor
+ * @param contextButtonName - the name of the button to be pressed.
+ */
+ @SuppressWarnings("restriction")
+ private void pressContextButton(final SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart part, String contextButtonName) {
+ jpaDiagramEditor.click(0, 0);
+ jpaDiagramEditor.click(part);
+
+ ContextButtonPad pad = findContextButtonPad(jpaDiagramEditor);
+ assertNotNull(pad);
+ for(final Object button : pad.getChildren()){
+ if(((ContextButton)button).getEntry().getText().equals(contextButtonName)){
+ asyncExec(new VoidResult() {
+ public void run() {
+ ((ContextButton)button).doClick();
+
+ }
+ });
+ }
+ }
+ }
+
+ /**
+ * Place the mouse over the entity to show the context button pad.
+ * @param jpaDiagramEditor
+ */
+ public void moveMouse(final SWTBotGefEditor jpaDiagramEditor, final int x, final int y) {
+ syncExec(new VoidResult() {
+ public void run() {
+ Robot r;
+ try {
+ r = new Robot();
+ Point p = getOrigin(jpaDiagramEditor);
+ r.mouseMove(p.x + x, p.y + y);
+ } catch (AWTException e) {
+ fail(e.getMessage());
+ }
+ }
+ });
+ }
+
+ /**
+ * Gets the context button pad, after placing the mouse over the entity
+ * @param editor
+ * @return the entity's context button pad
+ */
+ @SuppressWarnings("restriction")
+ private ContextButtonPad findContextButtonPad(SWTBotGefEditor editor) {
+ SWTBotGefEditPart rootEditPart = editor.rootEditPart();
+ IFigure feedbackLayer = ((ScalableFreeformRootEditPart) rootEditPart.part())
+ .getLayer(LayerConstants.HANDLE_LAYER);
+ ContextButtonPad cbp = null;
+ for (Object obj : feedbackLayer.getChildren()) {
+ if (obj instanceof ContextButtonPad) {
+ cbp = (ContextButtonPad) obj;
+ break;
+ }
+ }
+ return cbp;
+ }
+
+
+ private FigureCanvas getCanvas(SWTBotGefEditor editorGef) {
+ IEditorReference reference = editorGef.getReference();
+ final IEditorPart editor = reference.getEditor(true);
+ GraphicalViewer graphicalViewer = (GraphicalViewer) editor.getAdapter(GraphicalViewer.class);
+ final Control control = graphicalViewer.getControl();
+ if (control instanceof FigureCanvas) {
+ FigureCanvas c = (FigureCanvas) control;
+ return c;
+ }
+ return null;
+ }
+
+ private Point getOrigin(SWTBotGefEditor editorGef) {
+ Canvas c = getCanvas(editorGef);
+ Point p = c.toDisplay(0, 0);
+ return p;
+ }
+
+ /**
+ * Get the error message that appears in the "Select Type" dialog
+ * @param dialog
+ * @return the error message
+ */
+ public SWTBotText getDialogErroMessage(SWTBotShell dialog){
+ return dialog.bot().text(1);
+ }
+
+ /**
+ * Gets the "OK" button of a dialog
+ * @param dialog
+ * @return the "OK" button
+ */
+ public SWTBotButton getOkButton(SWTBotShell dialog){
+ return dialog.bot().button(IDialogConstants.OK_LABEL);
+ }
+
+ /**
+ * Gets the "Cancel" button of a dialog
+ * @param dialog
+ * @return the "Cancel" button
+ */
+ public SWTBotButton getCancelButton(SWTBotShell dialog){
+ return dialog.bot().button(IDialogConstants.CANCEL_LABEL);
+ }
+
+ /**
+ * Gets the "Finish" button of a dialog
+ * @param dialog
+ * @return the "Finish" button
+ */
+ public SWTBotButton getFinishButton(SWTBotShell dialog) {
+ return dialog.bot().button("Finish");
+ }
+
+ /**
+ * Find the IRelation object for the given GEF Connection
+ * @param jpaDiagramEditor
+ * @param gefConn
+ * @return the IRelation object for the given GEF Connection
+ */
+ @SuppressWarnings("restriction")
+ public IRelation getConnection(SWTBotGefEditor jpaDiagramEditor, SWTBotGefConnectionEditPart gefConn){
+ IFeatureProvider fp = ((DiagramEditPart)jpaDiagramEditor.mainEditPart().part()).getFeatureProvider();
+ FreeFormConnection conn = (FreeFormConnection) gefConn.part().getModel();
+ Object ob = fp.getBusinessObjectForPictogramElement(conn);
+ if(ob instanceof IRelation){
+ return (IRelation)ob;
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets the business object (JavaPersistentType) for the given GEF element
+ * @param jpaDiagramEditor
+ * @param element
+ * @return the java persistent type for the given element, null if the selected element is not an entity
+ */
+ @SuppressWarnings("restriction")
+ public JavaPersistentType getEntityForElement(SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart element){
+ final IFeatureProvider fp = ((DiagramEditPart)jpaDiagramEditor.mainEditPart().part()).getFeatureProvider();
+ PictogramElement el = (PictogramElement) element.part().getModel();
+ Object bo = fp.getBusinessObjectForPictogramElement(el);
+ if (bo instanceof JavaPersistentType){
+ return (JavaPersistentType)bo;
+ }
+ return null;
+ }
+
+ /**
+ * Gets the existing isARelation
+ * @param jpaDiagramEditor
+ * @return the existing isArelation if exists, null otherwise
+ */
+ @SuppressWarnings("restriction")
+ public IsARelation getIsARelationship(SWTBotGefEditor jpaDiagramEditor){
+ IJPAEditorFeatureProvider fp = (IJPAEditorFeatureProvider) ((DiagramEditPart)jpaDiagramEditor.mainEditPart().part()).getFeatureProvider();
+ Set<IsARelation> isARelationships = fp.getAllExistingIsARelations();
+ assertFalse(isARelationships.isEmpty());
+ assertEquals(1, isARelationships.size());
+ IsARelation relation = isARelationships.iterator().next();
+ return relation;
+ }
+
+ /**
+ * CHecks whether the Entity contains unsaved changes.
+ * @param jpaDiagramEditor
+ * @param element
+ * @return true if the entity contains unsaved changes, false otherwise
+ */
+ @SuppressWarnings("restriction")
+ public boolean isEntityDirty(SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart element){
+ final IFeatureProvider fp = ((DiagramEditPart)jpaDiagramEditor.mainEditPart().part()).getFeatureProvider();
+ PictogramElement el = (PictogramElement) element.part().getModel();
+ Object bo = fp.getBusinessObjectForPictogramElement(el);
+ IResource res = null;
+ if(bo instanceof JavaPersistentAttribute){
+ res = ((JavaPersistentAttribute)bo).getResource();
+ } else if (bo instanceof JavaPersistentType){
+ res = ((JavaPersistentType)bo).getResource();
+ }
+
+ if(res != null){
+ ICompilationUnit unit = JPAEditorUtil.getCompilationUnit((IFile)res);
+ try {
+ return unit.hasUnsavedChanges();
+ } catch (JavaModelException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Select the bidirectional relation and call its "Delete" context menu.
+ * On the confirmation dialog press "No" and assert that
+ * the connection and the relative relation attributes still exist
+ * and the "Relation Attributes" sections of the entities' are visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param entity2
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertBiDirRelationIsNotDeleted(
+ SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart entity1,
+ SWTBotGefEditPart entity2,
+ SWTBotGefConnectionEditPart connection,
+ String ownerAttributeName, String inverseAttributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ denyDelete();
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertFalse(entity2.targetConnections().isEmpty());
+ connection = entity1.sourceConnections().get(0);
+ assertNotNull("Attribute must not be deleted!", connection);
+ assertNotNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertTrue("\"Relation Attributes\" section of the owner entity must be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertTrue("\"Relation Attributes\" section of the inverse entity must be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the bidirectional self relation and call its "Delete" context menu.
+ * On the confirmation dialog press "No" and assert that
+ * the connection and the relative relation attributes still exist
+ * and the "Relation Attributes" sections of the entities' are visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertSelfBiDirRelationIsNotDeleted(
+ SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart entity1,
+ SWTBotGefConnectionEditPart connection,
+ String ownerAttributeName, String inverseAttributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ denyDelete();
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertFalse(entity1.targetConnections().isEmpty());
+ connection = entity1.sourceConnections().get(0);
+ assertNotNull("Attribute must not be deleted!", connection);
+ assertNotNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertTrue("\"Relation Attributes\" section of the owner entity must be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the unidirectional relation and call its "Delete" context menu.
+ * On the confirmation dialog press "No" and assert that
+ * the connection and the relative relation attributes still exist
+ * and the "Relation Attributes" sections of the entities' are visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param entity2
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertUniDirRelationIsNotDeleted(
+ SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart entity1,
+ SWTBotGefEditPart entity2,
+ SWTBotGefConnectionEditPart connection, String attributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ denyDelete();
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertFalse(entity2.targetConnections().isEmpty());
+ connection = entity1.sourceConnections().get(0);
+ assertNotNull("Attribute must not be deleted!", connection);
+ assertNotNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertTrue("\"Relation Attributes\" section of the owner entity must be visible!",isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("\"Relation Attributes\" section of the inverse entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the unidirectional self relation and call its "Delete" context menu.
+ * On the confirmation dialog press "No" and assert that
+ * the connection and the relative relation attributes still exist
+ * and the "Relation Attributes" sections of the entities' are visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertSelfUniDirRelationIsNotDeleted(
+ SWTBotGefEditor jpaDiagramEditor, SWTBotGefEditPart entity1,
+ SWTBotGefConnectionEditPart connection, String attributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ denyDelete();
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertFalse(entity1.targetConnections().isEmpty());
+ connection = entity1.sourceConnections().get(0);
+ assertNotNull("Attribute must not be deleted!", connection);
+ assertNotNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertTrue("\"Relation Attributes\" section of the owner entity must be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the bidirectional relation and call its "Delete" context menu.
+ * On the confirmation dialog press "Yes" and assert that
+ * the connection and the relative relation attributes do not exist anymore
+ * and the "Relation Attributes" sections of the entities' are not visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param entity2
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertBiDirRelationIsDeleted(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1, SWTBotGefEditPart entity2,
+ SWTBotGefConnectionEditPart connection,
+ String ownerAttributeName, String inverseAttributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ confirmDelete();
+ bot.waitUntil(new ElementDisappears(jpaDiagramEditor, ownerAttributeName));
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse("\"Relation Attributes\" section of the owner entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("\"Relation Attributes\" section of the inverse entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the bidirectional self relation and call its "Delete" context menu.
+ * On the confirmation dialog press "Yes" and assert that
+ * the connection and the relative relation attributes do not exist anymore
+ * and the "Relation Attributes" sections of the entities' are not visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertSelfBiDirRelationIsDeleted(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1,
+ SWTBotGefConnectionEditPart connection,
+ String ownerAttributeName, String inverseAttributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ confirmDelete();
+ bot.waitUntil(new ElementDisappears(jpaDiagramEditor, ownerAttributeName));
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity1.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse("\"Relation Attributes\" section of the owner entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the unidirectional relation and call its "Delete" context menu.
+ * On the confirmation dialog press "Yes" and assert that
+ * the connection and the relative relation attributes do not exist anymore
+ * and the "Relation Attributes" sections of the entities' are not visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param entity2
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertUniDirRelationIsDeleted(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1, SWTBotGefEditPart entity2,
+ SWTBotGefConnectionEditPart connection, String attributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ confirmDelete();
+ bot.waitUntil(new ElementDisappears(jpaDiagramEditor, attributeName));
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse("\"Relation Attributes\" section of the owner entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("\"Relation Attributes\" section of the inverse entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Select the unidirectional self relation and call its "Delete" context menu.
+ * On the confirmation dialog press "Yes" and assert that
+ * the connection and the relative relation attributes do not exist anymore
+ * and the "Relation Attributes" sections of the entities' are not visible.
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param connection
+ * @param ownerAttributeName
+ * @param inverseAttributeName
+ */
+ public void assertSelfUniDirRelationIsDeleted(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1,
+ SWTBotGefConnectionEditPart connection, String attributeName) {
+ connection.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ confirmDelete();
+ bot.waitUntil(new ElementDisappears(jpaDiagramEditor, attributeName));
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity1.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse("\"Relation Attributes\" section of the owner entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Assert that there is exactly one GEF element representing the relationship
+ * @param jpaDiagramEditor
+ * @param entity1
+ * @param entity2
+ */
+ public void assertConnectionIsCreated(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1, SWTBotGefEditPart entity2, boolean isBiDIr) {
+ //assert that there is exactly one relationship, which start from entity1
+ //and that there is no relationship which starts from entity2
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertEquals(1, entity1.sourceConnections().size());
+ assertTrue(entity2.sourceConnections().isEmpty());
+
+ //assert that there is exactly one relationship which ends in entity2
+ //and that there is no relationship which end in entity1.
+ assertFalse(entity2.targetConnections().isEmpty());
+ assertEquals(1, entity2.targetConnections().size());
+ assertTrue(entity1.targetConnections().isEmpty());
+
+ assertTrue("\"Relation Attributes\" section of the owner entity must be visible!", isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ if(isBiDIr){
+ assertTrue("\"Relation Attributes\" section of the inverse entity must be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ } else {
+ assertFalse("\"Relation Attributes\" section of the inverse entity must not be visible!", isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+ }
+
+ public void assertIsARelationExists(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1, SWTBotGefEditPart entity2) {
+ // assert that there is exactly one relationship, which start from
+ // entity2 and that there is no relationship which starts from entity2
+ assertFalse(entity2.sourceConnections().isEmpty());
+ assertEquals(1, entity2.sourceConnections().size());
+ assertTrue(entity1.sourceConnections().isEmpty());
+
+ // assert that there is exactly one relationship which ends in entity1
+ // and that there is no relationship which end in entity2.
+ assertFalse(entity1.targetConnections().isEmpty());
+ assertEquals(1, entity1.targetConnections().size());
+ assertTrue(entity2.targetConnections().isEmpty());
+ }
+
+ /**
+ * Assert that there is exactly one GEF element representing the self relationship
+ * @param jpaDiagramEditor
+ * @param entity1
+ */
+ public void assertSelfConnectionIsCreated(SWTBotGefEditor jpaDiagramEditor,
+ SWTBotGefEditPart entity1) {
+ //assert that there is exactly one relationship, which start from entity1
+ //and ends in entity2
+ assertFalse(entity1.sourceConnections().isEmpty());
+ assertEquals(1, entity1.sourceConnections().size());
+
+ assertFalse(entity1.targetConnections().isEmpty());
+ assertEquals(1, entity1.targetConnections().size());
+
+ assertTrue(isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ }
+
+ /**
+ * Assert that the owner relationship attribute exists
+ * @param jpaDiagramEditor
+ * @param rel
+ * @return the name of the owner relationship attribute
+ */
+ public String testOwnerRelationAttributeProperties(
+ SWTBotGefEditor jpaDiagramEditor, IRelation rel) {
+ JavaPersistentAttribute ownerAttr = rel.getOwnerAnnotatedAttribute();
+ String attributeName = rel.getOwnerAttributeName();
+ assertNotNull(ownerAttr);
+ assertNotNull(jpaDiagramEditor.getEditPart(attributeName));
+
+ return attributeName;
+ }
+
+ /**
+ * Assert that the inverse relationship attribute exists.
+ * @param jpaDiagramEditor
+ * @param rel
+ * @return the name of the inverse relationship attribute
+ */
+ public String testInverseRelationAttributeProperties(
+ SWTBotGefEditor jpaDiagramEditor, IRelation rel) {
+ JavaPersistentAttribute inverseAttr = rel.getInverseAnnotatedAttribute();
+ String inverseAttributeName = rel.getInverseAttributeName();
+ assertNotNull(inverseAttr);
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ return inverseAttributeName;
+ }
+
+
+ /**
+ * Checks whether a section of a particular entity is visible
+ * @param diagramEditor
+ * @param editPart - the particular entity
+ * @param sectionTitle - the title of the section to be checked
+ * @return true, if the sections is visible, false otherwise
+ */
+ @SuppressWarnings("deprecation")
+ public boolean isSectionVisible(SWTBotGefEditor diagramEditor, SWTBotGefEditPart editPart, String sectionTitle){
+ List<SWTBotGefEditPart> children = editPart.children();
+ SWTBotGefEditPart section = diagramEditor.getEditpart(sectionTitle, children);
+ ((PictogramElement)section.part().getModel()).isVisible();
+ IFigure figure = ((GraphicalEditPart) section.part()).getFigure();
+ return figure.isVisible();
+ }
+
+ /**
+ * Change the mapping of the type or attribute.
+ * @param newMappingType
+ */
+ public void changeMappingtype(String newMappingType) {
+ workbenchBot.waitUntil(shellIsActive("Mapping Type Selection"), 5000);
+ SWTBotShell mappingTypeShell = workbenchBot.shell("Mapping Type Selection");
+ mappingTypeShell.bot().table().getTableItem(newMappingType).select();
+ getOkButton(mappingTypeShell).click();
+ }
+
+ /**
+ * Click on the mapping type link in the JPA Details view
+ * @param styledText
+ * @param position
+ */
+ public void clickOnStyledText(final SWTBotStyledText styledText, int position) {
+ styledText.navigateTo(new Position(0, position));
+ asyncExec(new VoidResult() {
+ public void run() {
+ styledText.widget.notifyListeners(SWT.MouseDown, new Event());
+ styledText.widget.notifyListeners(SWT.MouseUp, new Event());
+ }
+ });
+ }
+
+ public void waitASecond() {
+ try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Assert that the relation attribute is correctly mapped in the JPA Details view
+ * @param jpaDiagramEditor
+ * @param attributeName
+ * @param relationAttributeMapping - the expected attribute mapping
+ */
+ public void assertAttributeIsCorretlyMapped(
+ SWTBotGefEditor jpaDiagramEditor, String attributeName, String relationAttributeMapping) {
+
+ //assert that the JPA Details view is opened
+ SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+ jpaDetailsView.setFocus();
+ assertTrue("JPA Details view must be opened!", jpaDetailsView.isActive());
+
+ SWTBotGefEditPart oneToManyAttr = jpaDiagramEditor.getEditPart(attributeName);
+ oneToManyAttr.click();
+
+ //assert that the default entity's attribute is mapped as primary key
+ SWTBot jpaDetailsBot = jpaDetailsView.bot();
+ SWTBotStyledText styledText = jpaDetailsBot.styledText();
+ assertEquals("Attribute '" +attributeName+ "' is mapped as " +relationAttributeMapping+ ".", styledText.getText());
+ }
+
+ /**
+ * Assert that the type is correctly mapped in the JPA Details view
+ * @param jpaDiagramEditor
+ * @param typeName
+ * @param typeMapping - the expected type mapping
+ */
+ public void assertTypeIsCorretlyMapped(
+ SWTBotGefEditor jpaDiagramEditor, String typeName, String typeMapping) {
+ workbenchBot.viewByTitle("JPA Details").close();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_openJPADetailsView);
+ //assert that the JPA Details view is opened
+ SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+ assertTrue("JPA Details view must be opened!", jpaDetailsView.isActive());
+
+ SWTBotGefEditPart type = jpaDiagramEditor.getEditPart(typeName);
+ type.click();
+
+ //assert that the default entity's attribute is mapped as the given mapping key
+ SWTBot jpaDetailsBot = jpaDetailsView.bot();
+ SWTBotStyledText styledText = jpaDetailsBot.styledText();
+ assertEquals("Type '" +typeName+ "' is mapped as " +typeMapping+ ".", styledText.getText());
+ }
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementDisappears.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementDisappears.java
new file mode 100644
index 0000000..2e33cb8
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementDisappears.java
@@ -0,0 +1,26 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
+
+public class ElementDisappears extends DefaultCondition{
+
+ private String entityName;
+ private SWTBotGefEditor gefEditor;
+
+ public ElementDisappears(SWTBotGefEditor gefEditor, String entityName){
+ super();
+ this.gefEditor = gefEditor;
+ this.entityName = entityName;
+ }
+
+ public boolean test() throws Exception {
+ return gefEditor.getEditPart(entityName) == null;
+ }
+
+ public String getFailureMessage() {
+ return "Entity with name ''" + entityName + "'' did not show.";
+ }
+
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementIsShown.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementIsShown.java
new file mode 100644
index 0000000..6eb5c5f
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementIsShown.java
@@ -0,0 +1,25 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
+
+public class ElementIsShown extends DefaultCondition{
+
+ private String entityName;
+ private SWTBotGefEditor gefEditor;
+
+ public ElementIsShown(SWTBotGefEditor gefEditor, String entityName){
+ super();
+ this.gefEditor = gefEditor;
+ this.entityName = entityName;
+ }
+
+ public boolean test() throws Exception {
+ return gefEditor.getEditPart(entityName) != null;
+ }
+
+ public String getFailureMessage() {
+ return "Entity with name ''" + entityName + "'' did not show.";
+ }
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/JPADiagramEditorSWTBotTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/JPADiagramEditorSWTBotTest.java
new file mode 100644
index 0000000..cbdd961
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/JPADiagramEditorSWTBotTest.java
@@ -0,0 +1,2410 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+
+import java.util.List;
+
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+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.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.relations.IsARelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
+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.finder.widgets.SWTBotView;
+import org.eclipse.swtbot.eclipse.gef.finder.SWTBotGefTestCase;
+import org.eclipse.swtbot.eclipse.gef.finder.SWTGefBot;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefConnectionEditPart;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart;
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.SWTBot;
+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.SWTBotStyledText;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(SWTBotJunit4ClassRunner.class)
+public class JPADiagramEditorSWTBotTest 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);
+
+ 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 testAddEntity() {
+ Utils.sayTestStarted("testAddEntity");
+
+ editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+ jpaDiagramEditor.save();
+ assertFalse("Editor must not be dirty!", jpaDiagramEditor.isDirty());
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testAddEntity");
+ }
+
+ /**
+ * Remove an entity from the diagram using the entity's context button "Delete"
+ */
+ @Test
+ public void testRemoveEntityViaButton(){
+ Utils.sayTestStarted("testRemoveEntityViaButton");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ editorProxy.pressEntityContextButton(jpaDiagramEditor, entity, JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
+ editorProxy.denyDelete();
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ assertNotNull("Entity is deleted!", entity);
+
+ editorProxy.pressEntityContextButton(jpaDiagramEditor, entity, JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
+ editorProxy.confirmDelete();
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ assertNull("Entity is not deleted!", entity);
+
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveEntityViaButton");
+ }
+
+ /**
+ * Remove an entity from the diagram using the entity's context menu "Delete"
+ */
+ @Test
+ public void testRemoveEntityViaContextMenu(){
+ Utils.sayTestStarted("testRemoveEntityViaContextMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
+ editorProxy.denyDelete();
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ assertNotNull("Entity is deleted!", entity);
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
+ editorProxy.confirmDelete();
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ assertNull("Entity is not deleted!", entity);
+
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveEntityViaContextMenu");
+ }
+
+ /**
+ * Adds a new attribute to the entity using the entity's context button "Create Attribute"
+ */
+ @Test
+ public void testAddAttribute(){
+ Utils.sayTestStarted("testRemoveEntityViaContextMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveEntityViaContextMenu");
+ }
+
+ /**
+ * Removes the attribute using the "Delete Attribute" context button.
+ */
+ @Test
+ public void testRemoveAttributeViaContextButton(){
+ Utils.sayTestStarted("testRemoveAttributeViaContextButton");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ SWTBotGefEditPart attribute = editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ jpaDiagramEditor.save();
+
+ editorProxy.pressAttributeDeleteContextButton(jpaDiagramEditor, attribute);
+ editorProxy.denyDelete();
+ attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNotNull("Attribute must not be deleted!", attribute);
+
+ editorProxy.pressAttributeDeleteContextButton(jpaDiagramEditor, attribute);
+ editorProxy.confirmDelete();
+ attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNull("Attribute must be deleted!", attribute);
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveAttributeViaContextButton");
+ }
+
+ /**
+ * Removes the attribute using the "Delete" context menu.
+ */
+ @Test
+ public void testRemoveAttributeViaMenu(){
+ Utils.sayTestStarted("testRemoveAttributeViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ SWTBotGefEditPart attribute = editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ jpaDiagramEditor.save();
+
+ attribute.click();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.denyDelete();
+ attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNotNull("Attribute must not be deleted!", attribute);
+
+ attribute.click();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNull("Attribute must be deleted!", attribute);
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveAttributeViaMenu");
+ }
+
+ /**
+ * Adds a new attribute and rename it
+ */
+ @Test
+ public void testDirectEditingAttribute(){
+ Utils.sayTestStarted("testDirectEditingAttribute");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ SWTBotGefEditPart attribute = editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertNotNull("The attribute must not be renamed!", attribute);
+
+ jpaDiagramEditor.directEditType("newAttrName");
+ SWTBotGefEditPart oldAttribute = jpaDiagramEditor.getEditPart("attribute1");
+ SWTBotGefEditPart newAttribute = jpaDiagramEditor.getEditPart("newAttrName");
+ assertNotNull("The attribute must be renamed!", newAttribute);
+ assertNull("The attribute must be renamed!", oldAttribute);
+
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testDirectEditingAttribute");
+ }
+
+ /**
+ * Adds a new entity and rename it
+ */
+ @Ignore
+ @Test
+ public void testDirectEditingEntity(){
+ Utils.sayTestStarted("testDirectEditingEntity");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+ editorProxy.moveMouse(jpaDiagramEditor, 100, 70);
+ entity.click();
+ entity.activateDirectEdit();
+ jpaDiagramEditor.directEditType("NewEntityName");
+ editorProxy.moveMouse(jpaDiagramEditor, 0, 0);
+
+ SWTBotGefEditPart oldEntity = jpaDiagramEditor.getEditPart("Entity1");
+ SWTBotGefEditPart newEntity = jpaDiagramEditor.getEditPart("NewEntityName");
+ assertNotNull("The entity must be renamed!", newEntity);
+ assertNull("The attribute must be renamed!", oldEntity);
+
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testDirectEditingEntity");
+ }
+
+ /**
+ * Test that the source of the entity is opened, when is double clicked on it
+ */
+ @Ignore
+ @Test
+ public void testDoubleClickOnEntity(){
+ Utils.sayTestStarted("testDoubleClickOnEntity");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ editorProxy.moveMouse(jpaDiagramEditor, 100, 70);
+ jpaDiagramEditor.doubleClick(entity);
+ editorProxy.moveMouse(jpaDiagramEditor, 0, 0);
+
+ SWTBotEditor activeEditor = workbenchBot.activeEditor();
+ assertEquals("The Java editor of the enity did not open!", "Entity1.java", activeEditor.getTitle());
+ activeEditor.close();
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testDoubleClickOnEntity");
+ }
+
+ /**
+ * Change the attribute type.
+ */
+ @Test
+ @SuppressWarnings("restriction")
+ public void testChangeAttributeType(){
+ Utils.sayTestStarted("testChangeAttributeType");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ SWTBotGefEditPart attribute = editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertNotNull("The attribute must not be renamed!", attribute);
+ final IFeatureProvider fp = ((DiagramEditPart)jpaDiagramEditor.mainEditPart().part()).getFeatureProvider();
+
+ String currentAttributeType = editorProxy.getAttributeType(jpaDiagramEditor, "attribute1", fp);
+ assertEquals("java.lang.String", currentAttributeType);
+
+ SWTBotShell changeTypeDialog = editorProxy.getSelectNewAttributeTypeDialog(jpaDiagramEditor, 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(jpaDiagramEditor, "attribute1", fp);
+ assertEquals("The attribute type must not be changed!", "java.lang.String", currentAttributeType);
+
+ changeTypeDialog = editorProxy.getSelectNewAttributeTypeDialog(jpaDiagramEditor, 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();
+ //assert that the attribute's type is changed
+ String newAttributeType = currentAttributeType = editorProxy.getAttributeType(jpaDiagramEditor, "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());
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testChangeAttributeType");
+ }
+
+ /**
+ * Rename the entity using its context menu "Refactor Entity Class -> Rename..."
+ */
+ @Ignore
+ @Test
+ public void testRenameEntityViaMenu(){
+ Utils.sayTestStarted("testRenameEntityViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ entity.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);
+
+ entity = jpaDiagramEditor.getEditPart("NewEntityName");
+ assertNotNull("Entity name must be changed!", entity);
+ assertNull("Entity naem must be changed!", jpaDiagramEditor.getEditPart("Entity1"));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRenameEntityViaMenu");
+ }
+
+ /**
+ * Move the entity class using the entity's context menu "Refactor Entity Class -> Move..."
+ */
+ @Ignore
+ @Test
+ public void testMoveEntityViaMenu() throws JavaModelException{
+ Utils.sayTestStarted("testMoveEntityViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ JpaArtifactFactory factory = JpaArtifactFactory.instance();
+
+ String packageName = factory.getMappedSuperclassPackageDeclaration(editorProxy.getEntityForElement(jpaDiagramEditor, entity));
+
+ entity.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();
+
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ String newEntityPackage= factory.getMappedSuperclassPackageDeclaration(editorProxy.getEntityForElement(jpaDiagramEditor, entity));
+ assertFalse("Entity must be moved!", packageName.equals(newEntityPackage));
+ assertTrue("Entity must be changed!", newEntityPackage.equals("org"));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testMoveEntityViaMenu");
+ }
+
+ /**
+ * Collapse/expand entity using its context buttons
+ */
+ @Test
+ public void testCollapseExapandEntityViaContextButton(){
+ Utils.sayTestStarted("testCollapseExapandEntityViaContextButton");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ int heigth = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ editorProxy.pressEntityContextButton(jpaDiagramEditor, entity, "Collapse");
+
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ int newHeight = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be collapsed!", JPAEditorConstants.ENTITY_MIN_HEIGHT, newHeight);
+ assertTrue(newHeight < heigth);
+
+ editorProxy.pressEntityContextButton(jpaDiagramEditor, entity, "Expand");
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ newHeight = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be expanded!", heigth, newHeight);
+ assertTrue(newHeight > JPAEditorConstants.ENTITY_MIN_HEIGHT);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testCollapseExapandEntityViaContextButton");
+ }
+
+ /**
+ * Collapse/expand entity using its context menus
+ */
+ @Test
+ public void testCollapseExapandEntityViaMenu(){
+ Utils.sayTestStarted("testCollapseExapandEntityViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ int heigth = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_collapseEntityMenuItem);
+
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ int newHeight = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be collapsed!", JPAEditorConstants.ENTITY_MIN_HEIGHT, newHeight);
+ assertTrue(newHeight < heigth);
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_expandEntityMenuItem);
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ newHeight = ((PictogramElement)entity.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be expanded!", heigth, newHeight);
+ assertTrue(newHeight > JPAEditorConstants.ENTITY_MIN_HEIGHT);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testCollapseExapandEntityViaMenu");
+ }
+
+ /**
+ * Collapse/expand all entities using the context menus
+ */
+ @Test
+ public void testCollapseExapandAllEntitiesViaMenu(){
+ Utils.sayTestStarted("testCollapseExapandAllEntitiesViaMenu");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ int heigth1 = ((PictogramElement)entity1.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 300, 50, "Entity2");
+
+ int heigth2 = ((PictogramElement)entity2.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_collapseAllEntitiesMenuItem);
+
+ //check that entity1 is collapsed
+ entity1 = jpaDiagramEditor.getEditPart("Entity1");
+ int newHeight1 = ((PictogramElement)entity1.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity1 must be collapsed!", JPAEditorConstants.ENTITY_MIN_HEIGHT, newHeight1);
+ assertTrue(newHeight1 < heigth1);
+
+ //check that entity2 is collapsed
+ entity2 = jpaDiagramEditor.getEditPart("Entity2");
+ int newHeight2 = ((PictogramElement)entity2.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity2 must be collapsed!", JPAEditorConstants.ENTITY_MIN_HEIGHT, newHeight2);
+ assertTrue(newHeight2 < heigth2);
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem);
+
+ //check that entity1 is expanded
+ entity1 = jpaDiagramEditor.getEditPart("Entity1");
+ newHeight1 = ((PictogramElement)entity1.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be expanded!", heigth1, newHeight1);
+ assertTrue(newHeight1 > JPAEditorConstants.ENTITY_MIN_HEIGHT);
+
+ //check that entity2 is expanded
+ entity2 = jpaDiagramEditor.getEditPart("Entity2");
+ newHeight2 = ((PictogramElement)entity2.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Entity must be expanded!", heigth2, newHeight2);
+ assertTrue(newHeight2 > JPAEditorConstants.ENTITY_MIN_HEIGHT);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testCollapseExapandAllEntitiesViaMenu");
+ }
+
+ /**
+ * Add a new attribute without saving the entity and call the "Discard Changes" context menu.
+ * Assert that the newly added attribute is removed and the entity does not contain unsaved
+ * changes.
+ */
+ @Test
+ public void testDiscardChanges(){
+ Utils.sayTestStarted("testDiscardChanges");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ assertTrue(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_discardChangesMenuItem);
+ SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNull("Changes must be discard!", attribute);
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testDiscardChanges");
+ }
+
+ /**
+ * Add a new attribute without saving the entity and call the entity's 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 entity does not contain unsaved changes.
+ */
+ @Test
+ public void testRemoveAndDiscardChangesViaMenu(){
+ Utils.sayTestStarted("testRemoveAndDiscardChangesViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("Diagram must contain at least one entity!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ assertTrue(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAndDiscardAllEntitiesAction);
+ editorProxy.confirmRemoveEntitiesFromDiagramDialog();
+ assertTrue("Diagram must be empty!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+ assertFalse("Diagram must contain at least one entity!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNull("Changes must be discard!", attribute);
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveAndDiscardChangesViaMenu");
+ }
+
+ /**
+ * Add a new attribute without saving the entity and call the entity's 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 entity does not contain unsaved changes.
+ */
+ @Test
+ public void testRemoveAndSaveChangesViaMenu(){
+ Utils.sayTestStarted("testRemoveAndSaveChangesViaMenu");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ assertFalse("Diagram must contain at least one entity!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ assertTrue(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAndSaveAllEntitiesAction);
+ editorProxy.confirmRemoveEntitiesFromDiagramDialog();
+ assertTrue("Diagram must be empty!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+ assertFalse("Diagram must contain at least one entity!", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ entity = jpaDiagramEditor.getEditPart("Entity1");
+ SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart("attribute1");
+ assertNotNull("Changes must be discard!", attribute);
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testRemoveAndSaveChangesViaMenu");
+ }
+
+ /**
+ * Add a new attribute to the entity. From the entity's context menu
+ * select "Save". Assert that the entity does not contain any unsaved changes,
+ * but the diagram editor is still dirty.
+ */
+ @Test
+ public void testSaveOnlyEntity(){
+ Utils.sayTestStarted("testSaveOnlyEntity");
+
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ assertFalse("\"Other Attributes\" section must not be visible!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.addAttributeToEntity(jpaDiagramEditor, entity, "attribute1");
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ assertTrue(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ entity.click();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_saveButtonText);
+ assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+ assertFalse(editorProxy.isEntityDirty(jpaDiagramEditor, entity));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSaveOnlyEntity");
+ }
+
+ /**
+ * Create a JPA project and one entity in it.
+ * Open the JPA diagram editor and call the
+ * "Show All Entities" context menu.
+ * Assert that the previously created entity is
+ * shown in the diagram.
+ * @throws Exception
+ */
+ @Test
+ public void testShowAllEntities() throws Exception{
+ Utils.sayTestStarted("testShowAllEntities");
+
+ factory.createEntity(jpaProject, "com.sap.test.Customer");
+ assertTrue(jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+
+ List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart().children();
+ assertFalse("Diagram editor must contain at least one entity!", entities.isEmpty());
+
+ SWTBotGefEditPart entity = jpaDiagramEditor.getEditPart("Customer");
+ assertNotNull(entity);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testShowAllEntities");
+ }
+
+ /**
+ * Collapse/expand "Primary Key" section by double click on it
+ */
+ @Ignore
+ @Test
+ public void testCollapseExpandCompartmentByDoubleClick(){
+ Utils.sayTestStarted("testCollapseExpandCompartmentByDoubleClick");
+
+ editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ editorProxy.moveMouse(jpaDiagramEditor, 100, 100);
+ SWTBotGefEditPart primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+
+ int height = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ primaryKeySection.click();
+
+ jpaDiagramEditor.doubleClick(primaryKeySection);
+ primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+ int newHeight = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Primary Key section must be collapsed!", JPAEditorConstants.COMPARTMENT_MIN_HEIGHT, newHeight);
+ assertTrue(newHeight < height);
+
+ jpaDiagramEditor.doubleClick(primaryKeySection);
+ primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+ int newHeight1 = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Primary Key section must be collapsed!", height, newHeight1);
+ assertTrue(newHeight1 > JPAEditorConstants.COMPARTMENT_MIN_HEIGHT);
+
+ editorProxy.moveMouse(jpaDiagramEditor, 0, 0);
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testCollapseExpandCompartmentByDoubleClick");
+ }
+
+ /**
+ * Collapse/expand compartment by its context menu
+ */
+ @Ignore
+ @Test
+ public void testCollapseExpandCompartmentByContextMenu(){
+ Utils.sayTestStarted("testCollapseExpandCompartmentByContextMenu");
+
+ editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ editorProxy.moveMouse(jpaDiagramEditor, 100, 100);
+ SWTBotGefEditPart primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+
+ int height = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+
+ primaryKeySection.click();
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_collapseAttrGroupMenuItem);
+ primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+ int newHeight = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Primary Key section must be collapsed!", JPAEditorConstants.COMPARTMENT_MIN_HEIGHT, newHeight);
+ assertTrue(newHeight < height);
+
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_expandAttrMenuItem);
+ primaryKeySection = jpaDiagramEditor.getEditPart(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);
+ int newHeight1 = ((PictogramElement)primaryKeySection.part().getModel()).getGraphicsAlgorithm().getHeight();
+ assertEquals("Primary Key section must be collapsed!", height, newHeight1);
+ assertTrue(newHeight1 > JPAEditorConstants.COMPARTMENT_MIN_HEIGHT);
+
+ editorProxy.moveMouse(jpaDiagramEditor, 0, 0);
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testCollapseExpandCompartmentByContextMenu");
+ }
+
+ /**
+ * Test the integration between the JPA diagram editor and the JPA Details view:
+ * 1.) Close the JPA Details view
+ * 2.) Create an entity and call the context menu "Open JPA Details View"
+ * 3.) Assert that the JPA Details view is opened and the appropriate information
+ * is shown (the type is mapped as entity and the expandable sections are available).
+ * 4.) Change the mapping type to "Mapped Superclass"
+ * 5.) Change the mapping type to "Embeddable" and assert that the type is removed from the diagram
+ * 6.) Revert the mapping type to be "Entity" and call the "Show All Entities" context menu
+ * to visualize the entity in the diagram editor.
+ */
+ @Test
+ public void testChangeEntityMappingTypeViaJPADetailsView(){
+ Utils.sayTestStarted("testChangeEntityMappingTypeViaJPADetailsView");
+
+ workbenchBot.viewByTitle("JPA Details").close();
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ jpaDiagramEditor.save();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_openJPADetailsView);
+
+ //assert that the JPA Details view is opened
+ SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+ assertTrue("JPA Details view must be opened!", jpaDetailsView.isActive());
+
+ //assert that the type is mapped as entity in the JPA Deatils view
+ entity.click();
+ SWTBot jpaDetailsBot = jpaDetailsView.bot();
+ SWTBotStyledText styledText = jpaDetailsBot.styledText();
+ assertEquals("Type 'Entity1' is mapped as entity.", styledText.getText());
+ assertNotNull("Entity must be shown in the diagram!", jpaDiagramEditor.getEditPart("Entity1"));
+ //assert that the entity's sections are enabled
+ assertTrue(jpaDetailsBot.label("Entity").isEnabled());
+ assertTrue(jpaDetailsBot.label("Queries").isEnabled());
+ assertTrue(jpaDetailsBot.label("Inheritance").isEnabled());
+ assertTrue(jpaDetailsBot.label("Attribute Overrides").isEnabled());
+ assertTrue(jpaDetailsBot.label("Primary Key Generation").isEnabled());
+ assertTrue(jpaDetailsBot.label("Secondary Tables").isEnabled());
+
+
+ //change the mapping type to "Mapped Superclass" and assert that the type is mapped
+ //as mapped superclass in the JPA Details view
+ editorProxy.clickOnStyledText(styledText, 30);
+ editorProxy.changeMappingtype("Mapped Superclass");
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Type 'Entity1' is mapped as mapped superclass.", styledText.getText());
+ assertNotNull("Entity must be shown in the diagram!", jpaDiagramEditor.getEditPart("Entity1"));
+ //assert that the mapped superclass'es sections are enabled
+ assertTrue(jpaDetailsBot.label("Mapped Superclass").isEnabled());
+ assertTrue(jpaDetailsBot.label("Queries").isEnabled());
+
+ //change the mapping type to "Embeddable" and assert that the element is removed from the diagram
+ //and the type is mapped as embeddable in the JPA Details view
+ editorProxy.clickOnStyledText(styledText, 30);
+ editorProxy.changeMappingtype("Embeddable");
+ bot.waitUntil(new ElementDisappears(jpaDiagramEditor, "Entity1"));
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Type 'Entity1' is mapped as embeddable.", styledText.getText());
+ assertNull("Entity must disappear from the diagram!", jpaDiagramEditor.getEditPart("Entity1"));
+ //assert that the embeddable's section is enabled
+// assertTrue(jpaDetailsBot.label("Embeddable").isEnabled());
+
+ //revert the mapping type to Entity
+ editorProxy.clickOnStyledText(styledText, 30);
+ editorProxy.changeMappingtype("Entity");
+ assertNull("Entity must disappear from the diagram!", jpaDiagramEditor.getEditPart("Entity1"));
+
+ jpaDiagramEditor.click(0, 0);
+
+ //call the "Show All Entities" diagram context menu to visualize the element in the diagram and
+ //assert that the type is mapped as entity in the JPA Details view
+ jpaDiagramEditor.clickContextMenu("Show All Entities");
+ assertNotNull("Entity must be shown in the diagram!", jpaDiagramEditor.getEditPart("Entity1"));
+ jpaDiagramEditor.select("Entity1");
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Type 'Entity1' is mapped as entity.", styledText.getText());
+ //assert that the entity's sections are enabled
+ assertTrue(jpaDetailsBot.label("Entity").isEnabled());
+ assertTrue(jpaDetailsBot.label("Queries").isEnabled());
+ assertTrue(jpaDetailsBot.label("Inheritance").isEnabled());
+ assertTrue(jpaDetailsBot.label("Attribute Overrides").isEnabled());
+ assertTrue(jpaDetailsBot.label("Primary Key Generation").isEnabled());
+ assertTrue(jpaDetailsBot.label("Secondary Tables").isEnabled());
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testChangeEntityMappingTypeViaJPADetailsView");
+ }
+
+ /**
+ * Test the integration between the JPA diagram editor and the JPA Details view:
+ * 1.) Close the JPA Details view
+ * 2.) Create an entity and call the context menu "Open JPA Details View"
+ * 3.) Assert that the JPA Details view is opened and the appropriate information
+ * is shown (the id attribute is mapped as id and the expandable sections are available).
+ * 4.) Change the attribute mapping type to "Basic" and assert that the attribute is moved to "Other Attributes" compartment
+ * 5.) Change the attribute mapping type to "On-To-Many" and assert that the attribute is moved to "Relation Attributes" compartment
+ * 7.) Revert the attribute mapping to "ID" and assert that the attributes is moved back to the "Primary Key" compartment
+ */
+ @Test
+ public void testChangeAttributeMappingTypeViaJPADetailsView(){
+ Utils.sayTestStarted("testChangeAttributeMappingTypeViaJPADetailsView");
+
+ workbenchBot.viewByTitle("JPA Details").close();
+ SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ jpaDiagramEditor.save();
+ jpaDiagramEditor.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_openJPADetailsView);
+
+ //assert that the JPA Details view is opened
+ SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+ assertTrue("JPA Details view must be opened!", jpaDetailsView.isActive());
+
+ SWTBotGefEditPart primaryKeyAttr = jpaDiagramEditor.getEditPart("id");
+ primaryKeyAttr.click();
+
+ //assert that the default entity's attribute is mapped as primary key
+ SWTBot jpaDetailsBot = jpaDetailsView.bot();
+ SWTBotStyledText styledText = jpaDetailsBot.styledText();
+ assertEquals("Attribute 'id' is mapped as ID.", styledText.getText());
+ //assert that the attribute is under "Primary Key" section
+ assertTrue("Attribute must be in the \"Primary Key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse("Attribute must be in the \"Primary Key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("Attribute must be in the \"Primary Key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ //assert that the ID's sections are available
+ assertTrue(jpaDetailsBot.label("ID").isEnabled());
+ assertTrue(jpaDetailsBot.label("Type").isEnabled());
+ assertTrue(jpaDetailsBot.label("Primary Key Generation").isEnabled());
+
+ //change the attribute type to basic
+ editorProxy.clickOnStyledText(styledText, 29);
+ editorProxy.changeMappingtype("Basic");
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Attribute 'id' is mapped as basic.", styledText.getText());
+ //assert that the attribute is moved under "Other Attributes" section
+ assertFalse("Attribute must be in the \"Primary Key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse("Attribute must be in the \"Relation Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertTrue("Attribute must be in the \"Other Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ //assert that the Basic's sections are available
+ assertTrue(jpaDetailsBot.label("Basic").isEnabled());
+ assertTrue(jpaDetailsBot.label("Type").isEnabled());
+
+ //change the attribute type to Many to Many
+ editorProxy.clickOnStyledText(styledText, 29);
+ editorProxy.changeMappingtype("Many to Many");
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Attribute 'id' is mapped as many to many.", styledText.getText());
+ //assert that the attribute is moved under the "Relation Attributes" section
+ assertFalse("Attribute must be in the \"Primary key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertTrue("Attribute must be in the \"Relation Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("Attribute must be in the \"Other Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ //assert that the Many to Many's sections are available
+ assertTrue(jpaDetailsBot.label("Many to Many").isEnabled());
+ assertTrue(jpaDetailsBot.label("Joining Strategy").isEnabled());
+ assertTrue(jpaDetailsBot.label("Ordering").isEnabled());
+
+ //revert the attribute type back to Id
+ editorProxy.clickOnStyledText(styledText, 29);
+ editorProxy.changeMappingtype("ID");
+ styledText = jpaDetailsBot.styledText();
+ assertEquals("Attribute 'id' is mapped as ID.", styledText.getText());
+ //assert that the attribute is under "Primary Key" section
+ assertTrue("Attribute must be in the \"Primary Key\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse("Attribute must be in the \"Relation Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse("Attribute must be in the \"Other Attributes\" section of the entity!", editorProxy.isSectionVisible(jpaDiagramEditor, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+ //assert that the ID's sections are available
+ assertTrue(jpaDetailsBot.label("ID").isEnabled());
+ assertTrue(jpaDetailsBot.label("Type").isEnabled());
+ assertTrue(jpaDetailsBot.label("Primary Key Generation").isEnabled());
+
+ entity.click();
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testChangeAttributeMappingTypeViaJPADetailsView");
+ }
+
+ /**
+ * Creates "One to One" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testOneToOneUniDirRelationship(){
+ Utils.sayTestStarted("testOneToOneUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One unidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to one");
+
+ editorProxy.assertUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, attributeName);
+
+ editorProxy.assertUniDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToOneUniDirRelationship");
+ }
+
+ /**
+ * Creates a "One to One" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore.
+ */
+ @Test
+ public void testOneToOneUniDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testOneToOneUniDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One unidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to one");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(attributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToOneUniDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates "One to One" unidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfOneToOneUniDirRelationship(){
+ Utils.sayTestStarted("testSelfOneToOneUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create One-to-One unidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to one");
+
+ editorProxy.assertSelfUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, attributeName);
+
+ editorProxy.assertSelfUniDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfOneToOneUniDirRelationship");
+ }
+
+ /**
+ * Creates "One to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testOneToOneBiDirRelationship(){
+ Utils.sayTestStarted("testOneToOneBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "one to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to one");
+
+ editorProxy.assertBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertBiDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToOneBiDirRelationship");
+ }
+
+ /**
+ * Creates a "One to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the inverse relationship attribute and
+ * assert that the relationship is converted from bidirectional to unidirectional "One to One"
+ * relationship. Delete also the owner attribute and assert that there is no connection anymore.
+ */
+ @Test
+ public void testOneToOneBiDirRelationshipRemoveInverseAttribute(){
+ Utils.sayTestStarted("testOneToOneBiDirRelationshipRemoveInverseAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "one to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to one");
+
+ //delete the inverse attribute
+ SWTBotGefEditPart inverseAttr = jpaDiagramEditor.getEditPart(inverseAttributeName);
+ inverseAttr.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+
+ //assert that the connection still exists, but it is unidirectional now
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+ connection = entity1.sourceConnections().get(0);
+ rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+ assertEquals(ownerAttributeName, editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel));
+ assertNull(rel.getInverseAnnotatedAttribute());
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "one to one");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttr = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttr.click();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToOneBiDirRelationshipRemoveInverseAttribute");
+ }
+
+ /**
+ * Creates a "One to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore. Assert that the inverse attribute still exists.
+ */
+ @Test
+ public void testOneToOneBiDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testOneToOneBiDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "one to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to one");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ //assert that the inverse attribute still exists
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ //assert that the inverse attribute still exists
+ assertTrue(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToOneBiDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates "One to One" bidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfOneToOneBiDirRelationship(){
+ Utils.sayTestStarted("testSelfOneToOneBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create One-to-One bidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "one to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to one");
+
+ editorProxy.assertSelfBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertSelfBiDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfOneToOneBiDirRelationship");
+ }
+
+ /**
+ * Creates "One to Many" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testOneToManyUniDirRelationship(){
+ Utils.sayTestStarted("testOneToManyUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-Many unidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to many");
+
+ editorProxy.assertUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, attributeName);
+
+ editorProxy.assertUniDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToManyUniDirRelationship");
+ }
+
+ /**
+ * Creates a "One to Many" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore.
+ */
+ @Test
+ public void testOneToManyUniDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testOneToManyUniDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create One-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to many");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(attributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testOneToManyUniDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates "One to Many" unidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfOneToManyUniDirRelationship(){
+ Utils.sayTestStarted("testSelfOneToManyUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create One-to-Many unidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.ONE_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "one to many");
+
+ editorProxy.assertSelfUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, attributeName);
+
+ editorProxy.assertSelfUniDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfOneToManyUniDirRelationship");
+ }
+
+ /**
+ * Creates "Many to One" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testManyToOneUniDirRelationship(){
+ Utils.sayTestStarted("testManyToOneUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-One unidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to one");
+
+ editorProxy.assertUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, attributeName);
+
+ editorProxy.assertUniDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToOneUniDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to One" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore.
+ */
+ @Test
+ public void testManyToOneUniDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testManyToOneUniDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to one");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(attributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToOneUniDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates "Many to One" unidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfManyToOneUniDirRelationship(){
+ Utils.sayTestStarted("testSelfManyToOneUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create Many-to-One unidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to one");
+
+ editorProxy.assertSelfUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, attributeName);
+
+ editorProxy.assertSelfUniDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfManyToOneUniDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testManyToOneBiDirRelationship(){
+ Utils.sayTestStarted("testManyToOneBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to many");
+
+ editorProxy.assertBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertBiDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToOneBiDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the inverse relationship attribute and
+ * assert that the relationship is converted from bidirectional to unidirectional "Many to One"
+ * relationship. Delete als the owner attribute and assert that there is no connection anymore.
+ */
+ @Test
+ public void testManyToOneBiDirRelationshipRemoveInverseAttribute(){
+ Utils.sayTestStarted("testManyToOneBiDirRelationshipRemoveInverseAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to many");
+
+ //delete the inverse attribute
+ SWTBotGefEditPart inverseAttr = jpaDiagramEditor.getEditPart(inverseAttributeName);
+ inverseAttr.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+
+ //assert that the connection still exists, but it is unidirectional now
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+ connection = entity1.sourceConnections().get(0);
+ rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+ assertEquals(ownerAttributeName, editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel));
+ assertNull(rel.getInverseAnnotatedAttribute());
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to one");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttr = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttr.click();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToOneBiDirRelationshipRemoveInverseAttribute");
+ }
+
+ /**
+ * Creates a "Many to One" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore. Assert that the inverse attribute still exists.
+ */
+ @Test
+ public void testManyToOneBiDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testManyToOneBiDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-One bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to many");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ //assert that the inverse attribute still exists
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ //assert that the inverse attribute still exists
+ assertTrue(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToOneBiDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates a "Many to One" bidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfManyToOneBiDirRelationship(){
+ Utils.sayTestStarted("testSelfManyToOneBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create Many-to-Many bidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_ONE, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to one");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "one to many");
+
+ editorProxy.assertSelfBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertSelfBiDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfManyToOneBiDirRelationship");
+ }
+
+ /**
+ * Creates "Many to Many" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testManyToManyUniDirRelationship() {
+ Utils.sayTestStarted("testManyToManyUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-Many unidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to many");
+
+ editorProxy.assertUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, attributeName);
+
+ editorProxy.assertUniDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToManyUniDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to Many" unidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore.
+ */
+ @Test
+ public void testManyToManyUniDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testManyToManyUniDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-Many bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to many");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(attributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(attributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToManyUniDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates "Many to Many" unidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfManyToManyUniDirRelationship(){
+ Utils.sayTestStarted("testSelfManyToManyUniDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create Many-to-Many unidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName, 0);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String attributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+ assertNull(rel.getInverseAnnotatedAttribute());
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, attributeName, "many to many");
+
+ editorProxy.assertSelfUniDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, attributeName);
+
+ editorProxy.assertSelfUniDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, attributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfManyToManyUniDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to Many" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testManyToManyBiDirRelationship(){
+ Utils.sayTestStarted("testManyToManyBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-Many bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to many");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "many to many");
+
+ editorProxy.assertBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, entity2, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertBiDirRelationIsDeleted(jpaDiagramEditor, entity1, entity2,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToManyBiDirRelationship");
+ }
+
+ /**
+ * Creates a "Many to Many" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the inverse relationship attribute and
+ * assert that the relationship is converted from bidirectional to unidirectional "Many to Many"
+ * relationship. Delete also the owner attribute and assert that there is no connection anymore.
+ */
+ @Test
+ public void testManyToManyBiDirRelationshipRemoveInverseAttribute(){
+ Utils.sayTestStarted("testManyToManyBiDirRelationshipRemoveInverseAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-Many bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to many");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "many to many");
+
+ //delete the inverse attribute
+ SWTBotGefEditPart inverseAttr = jpaDiagramEditor.getEditPart(inverseAttributeName);
+ inverseAttr.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+
+ //assert that the connection still exists, but it is unidirectional now
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, false);
+ connection = entity1.sourceConnections().get(0);
+ rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ assertEquals(ownerAttributeName, editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel));
+ assertNull(rel.getInverseAnnotatedAttribute());
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to many");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttr = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttr.click();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToManyBiDirRelationshipRemoveInverseAttribute");
+ }
+
+ /**
+ * Creates a "Many to Many" bidirectional relationship (from entity1 to entity2).
+ * Assert that the relation attributes exists. Delete the owner relationship attributes and
+ * assert that the connection does not exists anymore. Assert that the inverse attribute still exists.
+ */
+ @Test
+ public void testManyToManyBiDirRelationshipRemoveOwnerAttribute(){
+ Utils.sayTestStarted("testManyToManyBiDirRelationshipRemoveOwnerAttribute");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+ SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 200, "Entity2");
+
+ //create Many-to-Many bidirectional relation from entity1 to entity2
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity2);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertConnectionIsCreated(jpaDiagramEditor, entity1, entity2, true);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to many");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "many to many");
+
+ //delete the owner attribute
+ SWTBotGefEditPart ownerAttrPart = jpaDiagramEditor.getEditPart(ownerAttributeName);
+ ownerAttrPart.select();
+ jpaDiagramEditor.clickContextMenu("Delete");
+ editorProxy.confirmDelete();
+ //assert that the connection does not exists anymore
+ assertTrue(entity1.sourceConnections().isEmpty());
+ assertTrue(entity2.targetConnections().isEmpty());
+ assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
+ //assert that the inverse attribute still exists
+ assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ //assert that the inverse attribute still exists
+ assertTrue(editorProxy.isSectionVisible(jpaDiagramEditor, entity2, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testManyToManyBiDirRelationshipRemoveOwnerAttribute");
+ }
+
+ /**
+ * Creates a "Many to Many" bidirectional self relationship (from entity1 to entity1).
+ * Assert that the relation attributes exists. Delete the relationship and
+ * assert that the attributes do not exists anymore.
+ */
+ @Test
+ public void testSelfManyToManyBiDirRelationship(){
+ Utils.sayTestStarted("testSelfManyToManyBiDirRelationship");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ //create Many-to-Many bidirectional self relation from entity1 to entity1
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName, 1);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(entity1);
+ bot.waitUntil(new ConnectionIsShown(entity1));
+
+ editorProxy.waitASecond();
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertSelfConnectionIsCreated(jpaDiagramEditor, entity1);
+
+ SWTBotGefConnectionEditPart connection = entity1.sourceConnections().get(0);
+ IRelation rel = editorProxy.getConnection(jpaDiagramEditor, connection);
+ assertNotNull(rel);
+ assertEquals(IRelation.RelDir.BI, rel.getRelDir());
+ assertEquals(IRelation.RelType.MANY_TO_MANY, rel.getRelType());
+
+ String ownerAttributeName = editorProxy.testOwnerRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ String inverseAttributeName = editorProxy.testInverseRelationAttributeProperties(
+ jpaDiagramEditor, rel);
+
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, ownerAttributeName, "many to many");
+ editorProxy.assertAttributeIsCorretlyMapped(jpaDiagramEditor, inverseAttributeName, "many to many");
+
+ editorProxy.assertSelfBiDirRelationIsNotDeleted(jpaDiagramEditor,
+ entity1, connection, ownerAttributeName,
+ inverseAttributeName);
+
+ editorProxy.assertSelfBiDirRelationIsDeleted(jpaDiagramEditor, entity1,
+ connection, ownerAttributeName, inverseAttributeName);
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testSelfManyToManyBiDirRelationship");
+ }
+
+ /**
+ * Creates a new Inherited entity by entity. Assert that the inherited entity
+ * does not contain a primary key.
+ */
+ @Test
+ public void testInheritedEntityByEntity(){
+ Utils.sayTestFinished("testInheritedEntityByEntity");
+
+ SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(jpaDiagramEditor, 50, 50, "Entity1");
+
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName);
+ jpaDiagramEditor.click(entity1);
+ jpaDiagramEditor.click(50, 200);
+
+ bot.waitUntil(new ElementIsShown(jpaDiagramEditor, "Entity2"));
+
+ SWTBotGefEditPart inheritedEntity = jpaDiagramEditor.getEditPart("Entity2");
+ assertNotNull(inheritedEntity);
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertIsARelationExists(jpaDiagramEditor, entity1, inheritedEntity);
+
+ SWTBotGefConnectionEditPart connection = entity1.targetConnections().get(0);
+ FreeFormConnection conn = (FreeFormConnection) connection.part().getModel();
+ assertTrue(IsARelation.isIsAConnection(conn));
+ IsARelation rel = editorProxy.getIsARelationship(jpaDiagramEditor);
+ assertNotNull(rel);
+
+ assertEquals(editorProxy.getEntityForElement(jpaDiagramEditor, inheritedEntity), rel.getSubclass());
+ assertEquals(editorProxy.getEntityForElement(jpaDiagramEditor, entity1), rel.getSuperclass());
+
+ editorProxy.assertTypeIsCorretlyMapped(jpaDiagramEditor, "Entity1", "entity");
+ editorProxy.assertTypeIsCorretlyMapped(jpaDiagramEditor, "Entity2", "entity");
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testInheritedEntityByEntity");
+ }
+
+ /**
+ * Creates a new Inherited entity by mapped superclass. Assert that the inherited entity
+ * contains a primary key.
+ */
+ @Test
+ public void testInheritedEntityByMappedSuperclass(){
+ Utils.sayTestStarted("testInheritedEntityByMappedSuperclass");
+
+ SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(jpaDiagramEditor, 50, 50, "MpdSuprcls1");
+
+ jpaDiagramEditor.activateTool(JPAEditorMessages.CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName);
+ jpaDiagramEditor.click(mappedSuperclass);
+ jpaDiagramEditor.click(50, 200);
+
+ bot.waitUntil(new ElementIsShown(jpaDiagramEditor, "Entity1"));
+
+ SWTBotGefEditPart inheritedEntity = jpaDiagramEditor.getEditPart("Entity1");
+ assertNotNull(inheritedEntity);
+ assertTrue(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+ assertFalse(editorProxy.isSectionVisible(jpaDiagramEditor, inheritedEntity, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes));
+
+ jpaDiagramEditor.activateDefaultTool();
+
+ editorProxy.assertIsARelationExists(jpaDiagramEditor, mappedSuperclass, inheritedEntity);
+
+ SWTBotGefConnectionEditPart connection = mappedSuperclass.targetConnections().get(0);
+ FreeFormConnection conn = (FreeFormConnection) connection.part().getModel();
+ assertTrue(IsARelation.isIsAConnection(conn));
+ IsARelation rel = editorProxy.getIsARelationship(jpaDiagramEditor);
+ assertNotNull(rel);
+
+ assertEquals(editorProxy.getEntityForElement(jpaDiagramEditor, inheritedEntity), rel.getSubclass());
+ assertEquals(editorProxy.getEntityForElement(jpaDiagramEditor, mappedSuperclass), rel.getSuperclass());
+
+ editorProxy.assertTypeIsCorretlyMapped(jpaDiagramEditor, "MpdSuprcls1", "mapped superclass");
+ editorProxy.assertTypeIsCorretlyMapped(jpaDiagramEditor, "Entity1", "entity");
+
+ editorProxy.deleteDiagramElements(jpaDiagramEditor);
+
+ jpaDiagramEditor.save();
+
+ Utils.sayTestFinished("testInheritedEntityByMappedSuperclass");
+ }
+
+ /**
+ * Test that the JPA Diagram editor is opened when the context menu
+ * "JPA Tools -> Open Diagram" of the project is called.
+ */
+ @Test
+ public void testOpenDiagramOnProjectLevel(){
+ Utils.sayTestStarted("testOpenDiagramOnProjectLevel");
+
+ workbenchBot.closeAllEditors();
+ //open JPA diagram editor on project level: JPA Tools -> Open Diagram
+ SWTBotGefEditor diagramEditor = editorProxy.openDiagramOnJPAProjectNode(TEST_PROJECT);
+ diagramEditor.close();
+
+ Utils.sayTestFinished("testOpenDiagramOnProjectLevel");
+ }
+
+ /**
+ * Test that the JPA Diagram editor is opened when the context menu "Open Diagram"
+ * of the JPA content node is called.
+ */
+ @Test
+ public void testOpenDiagramOnJPAContentNodeLevel() {
+ Utils.sayTestStarted("testOpenDiagramOnJPAContentNodeLevel");
+
+ workbenchBot.closeAllEditors();
+ //open JPA diagram editor on JPA content level: Open Diagram
+ SWTBotGefEditor diagramEditor = editorProxy.openDiagramOnJPAContentNode(TEST_PROJECT);
+ diagramEditor.close();
+
+ Utils.sayTestFinished("testOpenDiagramOnJPAContentNodeLevel");
+ }
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/pom.xml b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/pom.xml
index 3acda23..821d9bf 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/pom.xml
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/pom.xml
@@ -1,42 +1,45 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
- <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
- <version>1.1.0-SNAPSHOT</version>
- <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
- </parent>
-
- <artifactId>org.eclipse.jpt.ui.diagrameditor.test</artifactId>
- <packaging>eclipse-test-plugin</packaging>
- <name>JPA Diagram Editor Test Plug-in</name>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.sonatype.tycho</groupId>
- <artifactId>maven-osgi-test-plugin</artifactId>
- <version>${tycho-version}</version>
- <configuration>
- <testSuite>org.eclipse.jpt.jpadiagrameditor.tests</testSuite>
- <testClass>org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.AllJpaEditorTests</testClass>
- <useUIHarness>true</useUIHarness>
- <useUIThread>true</useUIThread>
- <argLine>-Xms128m -Xmx512m -XX:MaxPermSize=256m</argLine>
- <product>org.eclipse.sdk.ide</product>
- <application>org.eclipse.ui.ide.workbench</application>
- <dependencies>
- <dependency>
- <type>p2-installable-unit</type>
- <artifactId>org.eclipse.sdk.ide</artifactId>
- <version>0.0.0</version>
- </dependency>
- </dependencies>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <artifactId>org.eclipse.jpt.jpadiagrameditor_parent</artifactId>
+ <groupId>org.eclipse.jpt.jpadiagrameditor</groupId>
+ <version>1.1.0-SNAPSHOT</version>
+ <relativePath>../../development/org.eclipse.jpt.jpadiagrameditor.releng/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.jpt.jpadiagrameditor.ui.tests</artifactId>
+ <packaging>eclipse-test-plugin</packaging>
+ <name>JPA Diagram Editor Test Plug-in</name>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-surefire-plugin</artifactId>
+ <version>${tycho-version}</version>
+ <configuration>
+ <!-- testSuite>org.eclipse.jpt.jpadiagrameditor.ui.tests</testSuite>
+ <testClass>org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.AllJpaEditorTests</testClass-->
+ <useUIHarness>true</useUIHarness>
+ <useUIThread>false</useUIThread>
+ <systemProperties combine.children="append">
+ <org.eclipse.jpt.jpa.jar>${org.eclipse.jpt.jpa.jar}</org.eclipse.jpt.jpa.jar>
+ </systemProperties>
+ <argLine>-Xms128m -Xmx512m -XX:MaxPermSize=256m</argLine>
+ <product>org.eclipse.sdk.ide</product>
+ <application>org.eclipse.ui.ide.workbench</application>
+ <dependencies>
+ <dependency>
+ <type>p2-installable-unit</type>
+ <artifactId>org.eclipse.sdk.ide</artifactId>
+ <version>0.0.0</version>
+ </dependency>
+ </dependencies>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
</project> \ No newline at end of file