754 lines
28 KiB
TeX
754 lines
28 KiB
TeX
\part{Allgemeines \& Config}
|
||
\section{Logging}
|
||
\subsubsection{Vorteile Logging mittels Framework (z.B.: log4j)}
|
||
\begin{itemize}
|
||
\item Nutzt ein einheitliches Format / Konventionen
|
||
\item logging kann optional an und ausgeschalten werden
|
||
\item durch verschiedene Log-level können Logs gefiltert erstellt werden
|
||
\item Layout für Ausgabe kann zentral definiert/geändert werden
|
||
\end{itemize}
|
||
\section{Annotationen}
|
||
\begin{itemize}
|
||
\item @MappedSuperclass
|
||
\begin{itemize}
|
||
\item ist im Hybernate Framework
|
||
\item eine Klasse durch die gemeinsame Felder definiert werden.
|
||
\item definiert eine abstrakte Superklasse
|
||
\end{itemize}
|
||
\item @Produces
|
||
\begin{itemize}
|
||
\item kommt während deployment, markiert Factory Method damit man nicht direkt auf die Klasse zugreifen muss
|
||
\end{itemize}
|
||
\item @Typed
|
||
\begin{itemize}
|
||
\item zeigt die Vererbung Wieso bei uns allein stehend?
|
||
\end{itemize}
|
||
\item @Named
|
||
\begin{itemize}
|
||
\item Zeigt bei Mehrdeutigkeit das richtige Objekt mit dem Namen
|
||
\end{itemize}
|
||
\item @Resource
|
||
\begin{itemize}
|
||
\item fast wie Dependency Injection
|
||
\item damit weiß der Container wie er das Annotierte Feld instanzieren muss
|
||
\end{itemize}
|
||
\item @Stateless
|
||
\begin{itemize}
|
||
\item speichert den Client Status nicht
|
||
\end{itemize}
|
||
\item @Entity
|
||
\begin{itemize}
|
||
\item Data Access Layer
|
||
\end{itemize}
|
||
\item @Table
|
||
\begin{itemize}
|
||
\item Tabellenname im SQL
|
||
\end{itemize}
|
||
\item @Column
|
||
\begin{itemize}
|
||
\item SQL-Spalten nullable=false
|
||
\end{itemize}
|
||
\item @OneToMany
|
||
\item @JoinColums
|
||
\begin{itemize}
|
||
\item welche Spalten zusammen gehören FK
|
||
\end{itemize}
|
||
\item @OneToMany
|
||
\begin{itemize}
|
||
\item auf anderen Seite
|
||
\end{itemize}
|
||
\item @ApplicationScoped
|
||
\begin{itemize}
|
||
\item lebt die ganze Applikation lang, wird einmal gemacht.
|
||
\end{itemize}
|
||
\item @PersistenceContext
|
||
\begin{itemize}
|
||
\item persistance.xml auslesen für Treiber und andere JPA Geschichten + Data Source. Entity Manager
|
||
\end{itemize}
|
||
\item @Id
|
||
\begin{itemize}
|
||
\item das ist die id
|
||
\end{itemize}
|
||
\item @GeneratedValue
|
||
\begin{itemize}
|
||
\item Wert kommt aus der DB
|
||
\end{itemize}
|
||
\item @Local
|
||
\begin{itemize}
|
||
\item Klasse für lokale Aufrufe.
|
||
\end{itemize}
|
||
\item @Remote
|
||
\begin{itemize}
|
||
\item interprozessaufrufe. RMI
|
||
\end{itemize}
|
||
\item @ApplicationException
|
||
\begin{itemize}
|
||
\item Rollback wenn so eine Exception kommt, Nachricht zum Client.
|
||
\end{itemize}
|
||
\end{itemize}
|
||
|
||
|
||
\subsection{Annotationen - Details}
|
||
\begin{itemize}
|
||
\item CascadeType.Remove löscht die damit Annotierte Verknüpfung mit
|
||
\item dies geht auch rekursiv in der kompletten Datenbank
|
||
\item CascadeType.Remove und orphanRemoval=true ist equivalent
|
||
\end{itemize}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
...
|
||
@OneToOne(fetch = FetchType.EAGER,
|
||
cascade = CascadeType.ALL,
|
||
orphanRemoval = true)
|
||
@JoinColumn(name = "documentlibrary_id")
|
||
private Documentlibrary documentlibrary;
|
||
|
||
@Column(nullable = false, unique = true)
|
||
private String name;
|
||
...
|
||
public enum CascadeType {
|
||
/* Cascade all operations /
|
||
ALL,
|
||
/* Cascade persist operation /
|
||
PERSIST,
|
||
/* Cascade merge operation /
|
||
MERGE,
|
||
/* Cascade remove operation /
|
||
REMOVE,
|
||
/* Cascade refresh operation /
|
||
REFRESH,
|
||
*/
|
||
DETACH
|
||
...
|
||
}
|
||
)
|
||
\end{minted}
|
||
|
||
\section{Konfigurationsdateien}
|
||
\subsection{persistence.xml}
|
||
|
||
Die Datei \emph{persistence.xml} ist der zentrale Bestandteil der Persistierungs-Konfiguration.
|
||
|
||
Folgende Dinge können konfiguriert werden:
|
||
|
||
\begin{itemize}
|
||
\item SQL dialect
|
||
\item the persistence provider that shall be used at runtime
|
||
\item the data source you want to use to connect to your database
|
||
\item several provider-specific configuration parameters
|
||
\end{itemize}
|
||
|
||
|
||
\begin{code}
|
||
\captionof{listing}{persistence.xml}
|
||
|
||
|
||
\begin{minted}[linenos,breaklines=true]{xml}
|
||
|
||
<?xml version="1.0" encoding="UTF-8"?>
|
||
<persistence version="2.0"
|
||
xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
|
||
|
||
<persistence-unit name="primary">
|
||
<jta-data-source>java:jboss/datasources/psoeDS</jta-data-source>
|
||
<properties>
|
||
<!-- Properties for Hibernate -->
|
||
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
|
||
<property name="hibernate.enable_lazy_load_no_trans" value="true" />
|
||
<!--
|
||
SQL stdout logging
|
||
-->
|
||
<property name="hibernate.show_sql" value="true"/>
|
||
<property name="hibernate.format_sql" value="false"/>
|
||
<property name="use_sql_comments" value="true"/>
|
||
|
||
<!--
|
||
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
|
||
-->
|
||
</properties>
|
||
</persistence-unit>
|
||
|
||
</persistence>
|
||
|
||
\end{minted}
|
||
\end{code}
|
||
|
||
|
||
\begin{figure}[!htp]
|
||
\centering
|
||
\includegraphics[width=0.7\textwidth]{pics/ConfigFiles.png}
|
||
\end{figure}
|
||
\subsection{web.xml}
|
||
\begin{itemize}
|
||
\item konfiguriert den Java Webserver (Wildfly - JBOSS)
|
||
\item Einbindung des Faces-Servlet (FrontController - Implementierung, Zugriffskontrolle, Rollenkonfiguration)
|
||
\item befindet sich im Ordner \textbf{src/main/webapp/WEB-INF/web.xml}
|
||
\end{itemize}
|
||
\begin{minted}[linenos,breaklines=true]{xml}
|
||
<?xml version="1.0" encoding="UTF-8"?>
|
||
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
|
||
|
||
<servlet>
|
||
<servlet-name>Faces Servlet</servlet-name>
|
||
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
|
||
<load-on-startup>1</load-on-startup>
|
||
</servlet>
|
||
<servlet-mapping>
|
||
<servlet-name>Faces Servlet</servlet-name>
|
||
<url-pattern>*.xhtml</url-pattern>
|
||
</servlet-mapping>
|
||
|
||
<!-- Security roles -->
|
||
<security-role>
|
||
<description>administrators</description>
|
||
<role-name>ADMIN</role-name>
|
||
</security-role>
|
||
|
||
<!-- Security constraints -->
|
||
<security-constraint>
|
||
<web-resource-collection>
|
||
<web-resource-name>admin area</web-resource-name>
|
||
<url-pattern>/admin/*</url-pattern>
|
||
</web-resource-collection>
|
||
<auth-constraint>
|
||
<role-name>ADMIN</role-name>
|
||
</auth-constraint>
|
||
</security-constraint>
|
||
|
||
<login-config>
|
||
<auth-method>FORM</auth-method>
|
||
<realm-name>pse</realm-name>
|
||
<form-login-config>
|
||
<form-login-page>/login.xhtml</form-login-page>
|
||
<form-error-page>/login.xhtml</form-error-page>
|
||
<!-- <form-error-page>/loginerror.xhtml</form-error-page> -->
|
||
</form-login-config>
|
||
</login-config>
|
||
</web-app>
|
||
\end{minted}
|
||
\subsection{pom.xml}
|
||
\begin{itemize}
|
||
\item \textit{resources}-plugin (bindet die Serverressourcen ein - Ordner \textit{configuration} im Projekt - z.B. \textit{standalone-psoe.xml})
|
||
\item Wildfly (JBoss)– Webserver
|
||
\begin{multicols}{2}
|
||
\begin{enumerate}
|
||
\item Compile
|
||
\item Surefire (unitTests)
|
||
\item Packaging - war file erstellen
|
||
\item Wildfly - fressen und deployen
|
||
\item Failsafe IT-test
|
||
\item MVN site
|
||
\item Gui test
|
||
\end{enumerate}
|
||
\end{multicols}
|
||
\item Primeface = jsf Framework
|
||
\item Jacoco = test Coverage
|
||
\item Slf4j = logger
|
||
\item Jaxb – xml
|
||
\item Cdi = context dependancy injection
|
||
\end{itemize}
|
||
\subsubsection{Aufbau pom.xml}
|
||
\begin{figure}[h]
|
||
\centering
|
||
\includegraphics[width=0.3\linewidth]{pics/pom-structure}
|
||
\includegraphics[width=0.3\linewidth]{pics/pom-properties}
|
||
\label{fig:pom}
|
||
\end{figure}
|
||
|
||
\subsection{standalone-psoe.xml}
|
||
|
||
Wird ein JBoss Applikationsserver im \emph{standalone}-Modus betrieben, läuft jede Instanz in einem eigenen Prozess.
|
||
Diese Datei ist eine Java Enterprise Edition 6 zertifizierte Web-Profil Konfiguration welche alle benötigten Technologien (z.B. Extensions von JBoss, Datasources etc.) definiert.
|
||
|
||
JBoss EAP benutzt standardmäßig die standalone.xml Konfigurationsdatei, kann aber auch unter Verwendung einer anderen gestartet werden.
|
||
|
||
Abschnitte der standalone.xml
|
||
\begin{itemize}
|
||
\item extensions (z.B. diverse Wildfly Module)
|
||
\item management (z.B. Access Control -> role-mapping)
|
||
\item profile (z.B. JPA Subsystem)
|
||
\item interfaces (z.B. \${jboss.bind.address:127.0.0.1})
|
||
\item socket-binding-group (z.B \${jboss.http.port:8080})
|
||
\item Rechte (Management-Realm)
|
||
\item Datenbankzugriffsparameter
|
||
\end{itemize}
|
||
|
||
\begin{code}
|
||
\captionof{listing}{standalone.xml (auszugsweise)}
|
||
|
||
|
||
\begin{minted}[linenos,breaklines=true]{xml}
|
||
|
||
........
|
||
|
||
</endpoint-config>
|
||
<client-config name="Standard-Client-Config"/>
|
||
</subsystem>
|
||
<subsystem xmlns="urn:jboss:domain:weld:3.0"/>
|
||
</profile>
|
||
<interfaces>
|
||
<interface name="management">
|
||
<inet-address value="${jboss.bind.address.management:127.0.0.1}"/>
|
||
</interface>
|
||
<interface name="public">
|
||
<inet-address value="${jboss.bind.address:127.0.0.1}"/>
|
||
</interface>
|
||
</interfaces>
|
||
<socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">
|
||
<socket-binding name="management-http" interface="management" port="${jboss.management.http.port:9990}"/>
|
||
<socket-binding name="management-https" interface="management" port="${jboss.management.https.port:9993}"/>
|
||
<socket-binding name="ajp" port="${jboss.ajp.port:8009}"/>
|
||
<socket-binding name="http" port="${jboss.http.port:8080}"/>
|
||
<socket-binding name="https" port="${jboss.https.port:8443}"/>
|
||
<socket-binding name="txn-recovery-environment" port="4712"/>
|
||
<socket-binding name="txn-status-manager" port="4713"/>
|
||
<outbound-socket-binding name="mail-smtp">
|
||
<remote-destination host="localhost" port="25"/>
|
||
</outbound-socket-binding>
|
||
</socket-binding-group>
|
||
</server>
|
||
|
||
\end{minted}
|
||
\end{code}
|
||
|
||
\subsection{log4j.properties}
|
||
textit{src/test/resources/log4j.properties}
|
||
|
||
\section{Fehler im Projekt}
|
||
\subsection{Return null}
|
||
Anstatt von Null einfach eine Leere Liste bzw. ein default Objekt (oder new <Object>) zurückgeben
|
||
\subsection{Exception nicht gefangen}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.service.impl;
|
||
...
|
||
@Override
|
||
public void removeCommunityByAdmin(CommunityDTO communityDTO) {
|
||
Community community = communityDAO.findById(communityDTO.getId());
|
||
String errorText;
|
||
try {
|
||
communityDAO.removeCommunityByAdmin(community);
|
||
} catch (DaoException e) {
|
||
errorText = "Error removing community";
|
||
logger.error(errorText, e);
|
||
throw new ServiceException(errorText);
|
||
}
|
||
}
|
||
\end{minted}
|
||
\subsection{Destructive Wrapping - Logging fehlt - Information geht verloren}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.service.impl;
|
||
...
|
||
@Override
|
||
public CommunityDTO updateCommunityEnabled(String adminUserId, String communityName, boolean isEnabled) {
|
||
String errorText = "";
|
||
try {
|
||
boolean hasPermission = false;
|
||
User adminUser = userDao.getByUserId(adminUserId);
|
||
Community community = communityDAO.getByName(communityName);
|
||
|
||
|
||
for (Role r : adminUser.getRoles()) {
|
||
if (r.getname().equals("ADMIN") || r.getname().equals("PORTALADMIN")) {
|
||
hasPermission = true;
|
||
}
|
||
}
|
||
if (hasPermission || adminUser.getUserId().equals(community.getCommunityAdminUser().getUserId())) {
|
||
community.setIsEnabled(isEnabled);
|
||
communityDAO.update(community);
|
||
} else {
|
||
errorText = "No Permission to update community";
|
||
throw new AuthenticationException(errorText);
|
||
}
|
||
return CommunityMapper.toDTO(community);
|
||
} catch (DaoException e) {
|
||
errorText = "Error updating community enabled";
|
||
throw new ServiceException(errorText);
|
||
} catch (AuthenticationException e) {
|
||
throw new ServiceException(errorText);
|
||
} catch (Throwable e) {
|
||
errorText = "Unknown error updating community enabled";
|
||
throw new ServiceException(errorText);
|
||
}
|
||
}
|
||
\end{minted}
|
||
\subsection{Logger mit falschem Parameter}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.service.impl;
|
||
...
|
||
@Stateless
|
||
public class DepartmentHierarchyServiceImpl implements DepartmentHierarchyService, Serializable {
|
||
|
||
private static final long serialVersionUID = -2467949382018996094L;
|
||
private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
|
||
...
|
||
\end{minted}
|
||
\subsection{Fehlendes Exception Handling}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.service.impl;
|
||
...
|
||
@Local(MessageService.class)
|
||
@Remote(MessageServiceRemote.class)
|
||
@Stateless
|
||
public class MessageServiceImpl implements MessageService, MessageServiceRemote, Serializable {
|
||
...
|
||
@Override
|
||
public MessageDTO getByMessageId(long id) {
|
||
Message message = messageDAO.getById(id);
|
||
if (message == null) {
|
||
return null;
|
||
}
|
||
return MessageMapper.toDTO(message);
|
||
}
|
||
|
||
@Override
|
||
public MessageDTO updateByAdmin(long id, String content, Date changed) {
|
||
Message message = messageDAO.getById(id);
|
||
message.setContent(content);
|
||
message.setEditedByAdmin(changed);
|
||
return MessageMapper.toDTO(messageDAO.update(message));
|
||
}
|
||
|
||
@Override
|
||
public MessageDTO updateByUser(long messageId, String content, Date changed) {
|
||
Message message = messageDAO.getById(messageId);
|
||
message.setContent(content);
|
||
message.setEditedByUser(changed);
|
||
return MessageMapper.toDTO(messageDAO.update(message));
|
||
}
|
||
\end{minted}
|
||
\subsection{Exception werfen und gleich wieder fangen}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
...
|
||
public class MessageServiceImpl implements MessageService, MessageServiceRemote, Serializable {
|
||
private static final long serialVersionUID = 6768291437557855130L;
|
||
...
|
||
// nicht optimal, da die IllegalArgumentException gleich wieder gefangen wird
|
||
// überdies wird alles andere nicht gefangen
|
||
|
||
|
||
@Override
|
||
public void deleteMessage(long id) {
|
||
try {
|
||
Message message = messageDAO.getById(id);
|
||
if (message == null) {
|
||
throw new IllegalArgumentException("Message cannot be empty");
|
||
}
|
||
messageDAO.delete(message);
|
||
logger.info("Message deleted successfully");
|
||
}
|
||
catch (IllegalArgumentException ex) {
|
||
String errorMsg = "Could not delete the message (illegal argument)";
|
||
logger.error(errorMsg, ex);
|
||
throw new ServiceException(errorMsg);
|
||
}
|
||
}
|
||
|
||
//---------- besser wäre
|
||
package at.fhj.swd.psoe.service.impl;
|
||
...
|
||
// erst loggen, dass man in die Methode gekommen ist
|
||
// wenn userDTO null ist wird IllegalArgument geworfen und das außerhalb des try catch blocks
|
||
// erst wird die DaoException gefangen und anschließend alle anderen
|
||
// Stacktrace wird geloggt und jeweils die ServiceException weitergegeben
|
||
@Override
|
||
public void saveUser(UserDTO userDTO) {
|
||
logger.debug("UserService saveUser() called with parameter: '{}'", userDTO);
|
||
|
||
if (userDTO == null) {
|
||
throw new IllegalArgumentException("userDTO is null");
|
||
}
|
||
|
||
try {
|
||
User user = (userDTO.getId() == null) ? new User() : userDao.getById(userDTO.getId());
|
||
userDao.update(UserMapper.toEntity(userDTO, user));
|
||
} catch (DaoException e) {
|
||
logger.error("Error saving user", e);
|
||
throw new ServiceException("Error saving user");
|
||
} catch (Throwable e) {
|
||
logger.error("Unknown error saving user", e);
|
||
throw new ServiceException("Unknown error saving user");
|
||
}
|
||
}
|
||
\end{minted}
|
||
\section{Tests}
|
||
\begin{figure}[h!]
|
||
\centering
|
||
\includegraphics[width=0.7\linewidth]{pics/test-architecture}
|
||
\caption{}
|
||
\label{fig:test-architecture}
|
||
\end{figure}
|
||
\begin{itemize}
|
||
\item Ziel der Tests ist es, 100\% Codecoverage im Service-Layer zu erreichen (Anforderung für unser Projekt),
|
||
\item Private und Protected-Methoden müssen per se nicht getestet werden (Rule of Thumb),Wege zum erfolgreichen Test:
|
||
\begin{itemize}
|
||
\item Access-Modifier der Methoden auf public (public static) ändern,
|
||
\item Extrahieren der Methoden in neue Klassen,
|
||
\item Notfalls Package-Sichtbarkeit in Methode, wenn diese privat bleiben muss, Tests aber unbedingt notwendig sind.
|
||
\end{itemize}
|
||
\end{itemize}
|
||
\subsection{Testpyramide}
|
||
\begin{figure}[ht!]
|
||
\centering
|
||
\includegraphics[width=0.9\linewidth]{pics/testpyramide}
|
||
\caption{}
|
||
\label{fig:testpyramide}
|
||
\end{figure}
|
||
\subsection{Unit}
|
||
\begin{itemize}
|
||
\item Im Build-Cycle werden zuerst Unit-Tests ausgeführt,
|
||
\item sie befinden sich im Projekt im Ordner \textit{src/test/at/fhj/swd/psoe/service/*Test.java},
|
||
\item ein Unit-Test muss jede Methode der Service-Klasse testen
|
||
\item Mockito imitiert die Methoden, die von der Datenbank abhängen, da diese zu diesem Zeitpunkt noch nicht zur Verfügung steht (Build-Cycle => Compile - Unit-Tests)
|
||
\item Im Unit-Test wird jeweils die kleinste Einheit getestet
|
||
\item Exceptions einfach mit Mockito werfen und testen, ob sie geworfen wurden
|
||
\end{itemize}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
@Test(expected = ServiceException.class)
|
||
public void testGetCommunityByUserMessagesDAOException()
|
||
{
|
||
Mockito.when(this.userPrincipal.getId()).thenReturn(-1L);
|
||
Mockito.when(this.communityService.loadAllCommunitiesByUser(-1L)).thenThrow(new DaoException(new RuntimeException()));
|
||
|
||
this.activitystreamService.getCommunityByUserMessages();
|
||
}
|
||
\end{minted}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
@Test
|
||
public void getDocumentsFromCommunity_ShouldReturnDocuments() {
|
||
Community community = Mockito.mock(Community.class);
|
||
Mockito.when(community.getId()).thenReturn(DOCUMENTID);
|
||
Documentlibrary doclib = Mockito.mock(Documentlibrary.class);
|
||
|
||
Mockito.when(community.getDocumentlibrary()).thenReturn(doclib);
|
||
Mockito.when(doclib.getCommunity()).thenReturn(community);
|
||
User user = Mockito.mock(User.class);
|
||
|
||
Mockito.when(communityDAO.findById(community.getId())).thenReturn(community);
|
||
|
||
List<Document> documents = prepareTwoDocuments(doclib,user);
|
||
Mockito.when(documentDAO.findByCommunity(community)).thenReturn(documents);
|
||
|
||
List<DocumentDTO> documentsDTO = documentService.getDocumentsFromCommunity(community.getId());
|
||
|
||
Assertions.assertThat(documentsDTO)
|
||
.usingElementComparatorIgnoringFields("user")
|
||
.containsExactlyInAnyOrder(DocumentMapper.toDTO(documents.get(0)), DocumentMapper.toDTO(documents.get(1)));
|
||
}
|
||
\end{minted}
|
||
\subsection{Integration Tests}%TODO Wolfimajer - moch fertig , bi
|
||
\begin{itemize}
|
||
\item testen alle Komponenten mit (Datenbank)
|
||
\item werden im Build-Cycle erst nach dem Deployen des WAR-Files ausgeführt (laufende Applikation)
|
||
\item In unserem Projekt kommt das Plugin \textit{failsafe} zum Einsatz
|
||
\item Datenbankscripts werden separat zu den anderen Scripts ausgeführt (Datenbank vorbereiten und auf den alten Stand zurückbringen)
|
||
\item
|
||
\begin{figure}[h]
|
||
\centering
|
||
\includegraphics[width=0.7\linewidth]{pics/test_structure}
|
||
\caption{}
|
||
\label{fig:teststructure}
|
||
\end{figure}
|
||
\end{itemize}
|
||
\subsection{GUI-Test}
|
||
\subsubsection{Page Object Pattern}
|
||
\begin{itemize}
|
||
\item stellt Screens der Web-App als Reihe von Objekten dar
|
||
\item tatsächlich werden nicht alle Seiten sondern wesentliche Elemente in Objekte gekapselt
|
||
\item eine HTML Seite wird so mitunter mit mehreren Objekten dargestellt (z.B. Header und Footer Page Object)
|
||
\item Das Page Objekt Design eignet sich besonders gut um Selenium Tests umzusetzen
|
||
\item Mittels der Page Objekte kann HTML Code verändert werden (Verkapselung)
|
||
\item ermöglichen die Modellierung der Benutzeroberfläche für Tests
|
||
\item reduziert Code duplication
|
||
\item verbessert Testwartbarkeit und macht Tests robuster
|
||
\end{itemize}
|
||
\subsection{Page Object Pattern lt. Zahnlücke}
|
||
\begin{itemize}
|
||
\item Trennung zwischen Testmethode und Page Code
|
||
\item Je Page eine Klasse mit Services / Operationen
|
||
\item Return einer Operation ist ein PageObject
|
||
\item Einfachere Wartbarkeit (Kapselung in PageObject)
|
||
\end{itemize}
|
||
\begin{figure}[!htp]
|
||
\centering
|
||
\includegraphics[width=0.8\textwidth]{pics/page-object.png}
|
||
\end{figure}
|
||
\subsection{Beispiel aus dem Projekt}
|
||
\subsubsection{Integration GUI Test mit Selenium}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.gui.pages;
|
||
|
||
import org.openqa.selenium.By;
|
||
import org.openqa.selenium.WebDriver;
|
||
import org.openqa.selenium.WebElement;
|
||
import java.util.List;
|
||
|
||
public class DocumentsListPage extends AbstractPage {
|
||
private List<WebElement> list;
|
||
|
||
public DocumentsListPage(WebDriver driver) {
|
||
super(driver);
|
||
}
|
||
public List<WebElement> getList() {
|
||
list = this.getDriver().findElements(By.xpath("//*[@id=\"documents:comdoctable_data\"]"));
|
||
return list;
|
||
}
|
||
|
||
}
|
||
\end{minted}
|
||
\subsubsection{Durch Selenium getestetes Page Objekt}
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
package at.fhj.swd.psoe.gui;
|
||
|
||
import at.fhj.swd.psoe.JdbcTestHelper;
|
||
import at.fhj.swd.psoe.gui.pages.*;
|
||
import org.junit.After;
|
||
import org.junit.Assert;
|
||
import org.junit.Before;
|
||
import org.junit.Test;
|
||
|
||
import java.io.IOException;
|
||
import java.sql.SQLException;
|
||
import java.util.stream.Collectors;
|
||
|
||
public class ShowDocumentsListITCase extends AbstractChromeTest {
|
||
final private String roleName = "ADMIN";
|
||
private LoginPage loginPage;
|
||
private WelcomePage welcomePage;
|
||
private DocumentsListPage documentsListPage;
|
||
private String baseUrl = "http://localhost:8080/chr-krenn-fhj-ws2018-swd16-pse";
|
||
private static final JdbcTestHelper JDBC_HELPER = new JdbcTestHelper();
|
||
|
||
@Before
|
||
@Override
|
||
public void setUp() {
|
||
super.setUp();
|
||
JDBC_HELPER.executeSqlScript(
|
||
"src/test/resources/sql/DocumentServiceITCase-addDocument.sql");
|
||
loginPage = new LoginPage(this.driver, baseUrl, 60);
|
||
welcomePage = loginPage.login("testdocument@swd.com", "admin");
|
||
CommunitiesPage communitiesPage = welcomePage.openCommunitiesPage();
|
||
CommunityPage communityPage = communitiesPage.openCommunityPage();
|
||
documentsListPage = communityPage.openDocumentListPage();
|
||
}
|
||
|
||
@Test
|
||
public void testTwoDocumentsListed() {
|
||
String content = documentsListPage.getList().stream().map(x -> x.getText()).collect(Collectors.joining());
|
||
Assert.assertTrue(content.contains("documentuser123"));
|
||
Assert.assertTrue(content.contains("DocumentITCase1"));
|
||
Assert.assertTrue(content.contains("DocumentITCase2"));
|
||
}
|
||
|
||
@After
|
||
@Override
|
||
public void tearDown() {
|
||
super.tearDown();
|
||
JDBC_HELPER.executeSqlScript(
|
||
"src/test/resources/sql/DocumentServiceITCase-deleteDocument.sql");
|
||
}
|
||
}
|
||
\end{minted}
|
||
\section{Toni FRAAGNAA}
|
||
Den Code durchgehen - was statt null - könnte leere Liste sein, return null sollte aber auch okay sein
|
||
welche Exception - logger ok?
|
||
ob ein Throw im try Block ok ist - sollte okay sein, da wenn nicht im try-Block, erfolgt kein Mapping als DAO-Exception.
|
||
|
||
\begin{minted}[linenos,breaklines=true]{java}
|
||
|
||
@Override
|
||
public List<Document> findByUser(User user) {
|
||
logger.debug("dao: documents findByUser");
|
||
try {
|
||
if(user == null) throw new IllegalArgumentException("user must not be null");
|
||
return entityMangaer.createQuery("from Document d where d.user.userId = :userid", Document.class).setParameter("userid", user.getUserId()).getResultList();
|
||
} catch(NoResultException noresex) {
|
||
logger.info("dao: findByUser no documents found");
|
||
return null;
|
||
}
|
||
catch (Exception e) {
|
||
throw new DaoException("error finding documents of user",e);
|
||
}
|
||
}
|
||
|
||
// throw in try - passt
|
||
@Override
|
||
public void delete(Document document) {
|
||
logger.debug("dao: delete document");
|
||
|
||
try {
|
||
if(document == null) throw new IllegalArgumentException("document must not be null");
|
||
if(!entityMangaer.contains(document)) {
|
||
document = entityMangaer.merge(document);
|
||
}
|
||
entityMangaer.remove(document);
|
||
}
|
||
catch (Exception e) {
|
||
throw new DaoException("error deleting document",e);
|
||
}
|
||
}
|
||
// ist loggen ohne stacktrace ok? - Stack-Trace gehört eigentlich dazu
|
||
@Override
|
||
public TimeRecording getTimeRecordingByTask(Task task) {
|
||
TimeRecording result = new TimeRecording();
|
||
try {
|
||
result = entityManager.createQuery("select t from TimeRecording t where t.task.id = :id", TimeRecording.class)
|
||
.setParameter("id", task.getId()).getSingleResult();
|
||
} catch (NoResultException e) {
|
||
logger.warn("Not Possible to find TimeRecording with task id " + task.getId());
|
||
}
|
||
return result;
|
||
}
|
||
// UserDTO - @XmlElement
|
||
@XmlElement - sichtbar in XmlSerializerTest - für den automatischen Import der User via XML
|
||
public void setPhoneNumber(String phoneNumber) {
|
||
this.phoneNumber = phoneNumber;
|
||
}
|
||
// wos is produces
|
||
@Override
|
||
@Produces - ist eine Factory-Methode - kommt während dem Deployment und erstellt das Objekt
|
||
@Named("userPrincipal")
|
||
@SessionScoped
|
||
public UserPrincipal getUserPrincipal() {
|
||
String principalName = sessionContext.getCallerPrincipal().getName();
|
||
logger.info(principalName);
|
||
try {
|
||
User user = userDao.getByEmail(principalName);
|
||
return new UserPrincipal(user.getId(), user.getUserId(), user.getEmail(), user.getFirstname(), user.getLastname());
|
||
} catch (DaoException e) {
|
||
logger.error("Error loading user '{}'", principalName, e);
|
||
throw new ServiceException("Error loading user");
|
||
} catch (Throwable e) {
|
||
logger.error("Unknown error loading user '{}'", principalName, e);
|
||
throw new ServiceException("Unknown error loading user");
|
||
}
|
||
// @Typed - zeigt bei Mehrdeutigkeit die Vererbung (z.B. implementiert Interface und leitet von Klasse ab - muss aber in Klammer immer mitgegeben werden, wovon Java Server Beans dann die Ableitung macht)
|
||
|
||
// warum immer mappedBy Mehrzahl
|
||
@ManyToMany(mappedBy = "businessTrips") - Name vom Feld in der Entity, die verbunden wird, da ManyToMany, ist es egal, bei welcher Tabelle
|
||
|
||
// dependency Injection - wird schon im Skript erklärt
|
||
|
||
// braucht man im Controller (ViewHelper) überhaupt noch Exception Handling - es passiert nur Nutzereingabenvalidierung und die Fehlermeldung kann nicht weitergeworfen werden - es wird nur mehr in den Logger geschrieben
|
||
|
||
//müssen wir die Folien genau beherrschen (Stubs vs. Mocks?) Nein
|
||
|
||
//Bei welchem Goal wird was mitausgeführt? IT-Test bei mvn wildfy:run?
|
||
|
||
//Woher weiß PrimeFaces, wie es zum Ordner web mit den Controllern kommt?
|
||
|
||
//MessagePrincipal - @Typed - bereits oben erklärt
|
||
|
||
//Wie löst Maven Abhängigkeiten zu Libraries auf? Es wirdim Maven-Repository nach dem Package gesucht und dort nach der Version, die in der Dependency angegeben wurde. Wird die Library nicht gefunden, muss ein alternatives Repo angegeben werden. WICHTIG: niemals Libraries mit Plugins verwechseln (Plugin ist eine Erweiterung der Maven-Funktionalität, Library ist ein bestehender Java-Code, der verwendet werden kann)
|
||
\end{minted}
|
||
\section{Frageart Prüfung}
|
||
Welche Fehler können bei Exception-Handling vorkommen in unserem Projekt?? – wie funktioniert es grundsätzlich in unserem Code
|
||
|
||
DocumentDAO – DocumentService – DocumentController – so sollte Exception-Handling implementiert warden
|
||
|
||
DAO wirft Exception – im ServiceLayer wird dies gefangen und der Stack-Trace wird im weggeloggt und eine benutzerfreundliche Fehlermeldung wird ausgegeben (Destructive Wrapping).
|
||
|
||
Alle Patterns, die vorkommen – praktische Beispiele aus dem Code
|
||
|
||
Was sind JavaBeans? Wie funktioniert das Konzept? Wie wird es genau implementiert?
|
||
NamedBean, TypedBean etc.
|