Only Software matters

Experiences in software development

Archive for August, 2011

Best Java Testing Articles during Summer 2011

Posted by Patroklos Papapetrou on August 31, 2011


Starting from today I will try to post every month or so , a list of articles  that cover a specific topic and were initially posted during the last month.

For the beginning I the selected topic is Testing and covers not only August but also July. Enjoy!!

5 reasons to write tests for you code
If you are not yet convinced about the necessity of testing your code then this article is your last chance 🙂
http://masternerd.lucianocheng.com/5-reasons-for-testing-masternerdposterouscom

Unit Testing for Java EE
Think testing Java EE applications is difficult, inconvenient, or too complex? Learn why this isn’t the case and how do unit testing efficiently in this article.Unit testing and mocking of Java EE 6 (CDI, JPA and EJB) applications.
http://www.oracle.com/technetwork/articles/java/unittesting-455385.html

Why testing code for thread safety is flawed
A blog for testing thread-safety code and the problems behind that.
http://vanillajava.blogspot.com/2011/08/why-testing-code-for-thread-safety-is.html

Test Driven: It is the mindset not the tool!
Interersting point of view on how you have to approach TDD.
http://blog.jonasbandi.net/2011/08/test-driven-it-is-mindset-not-tool.html

DBUnit Express Tips – Setup Simplification and Custom Data File Convention
Simple Guide for DBUnit Express. If you plan to perform Database Unit testing then drop an eye on this post
http://theholyjava.wordpress.com/2011/08/05/dbunit-express-tips-setup-simplificatio-custom-data-file-convention

Good Unit Test Check List
Are you writing Unit Tests? Then check this list if you are on the correct path.
http://jbrieu.info/leblog/2011/good-unit-test-checklist/

Unit Tests are better than excellent specification
Excellent specifications = Very refined exhaustive view of future potential features
Good unit tests
 = Very refined exhaustive view of actual features
http://jbrieu.info/leblog/2011/test-culture-episode-6-unit-tests-are-better-than-excellent-specifications/

What is the cost of Unit Tests
Simple blog showing how much you earn by writing unit tests instead of running manual tests or debugging your application
http://jbrieu.info/leblog/2011/test-culture-episode-12-cost-of-unit-test/

UDIAS – The five levels of an ideal agile testing strategy
The UDIAS (unit, database, integration, acceptance, stress) testing strategy is probably not a silver bullet, but it covers all the different layers and views of an application. The time needed to set running all the above build jobs is significantly large but the ROI of investment worth the effort. I don’t think that there is something more important in a system under development / maintenance than an automated testing plan.
https://onlysoftware.wordpress.com/2011/07/24/the-5-levels-of-agile-testing

 

Advertisements

Posted in agile, quality, software, testing | 1 Comment »

Creating composite JSF components

Posted by Dimitra Konstantinidou on August 30, 2011


A composite component is a component that consists of other components and it can be reused with a minimal effort. JSF 2.0 simplifies the creation of custom components.

In this post, we describe the steps in creating a simple composite custom component with child components using JSF 2.0. We also show how we can pass methods and event listeners as attributes to a custom composite component.

1. We create a .xhtml page that consists of two main sections: a) the section where the attributes of the component are declared and b) the implementation of the component. For example:

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:p="http://primefaces.prime.com.tr/ui"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:composite="http://java.sun.com/jsf/composite">


<composite:interface componentType="customComponent">
<composite:attribute name="id" required="true"/>
<composite:attribute name="columns" required="false" default="4"/>
<composite:attribute name="columnClasses" required="false" default="labelColumn,dataColumn,labelColumn,dataColumn"/>

</composite:interface>
<composite:implementation>
<h:panelGrid id="#{cc.attrs.id}_panel" columns="#{cc.attrs.columns}" width="100%" columnClasses="#{cc.attrs.columnClasses}" >
<h:outputLabel value="#{general['label']}:"/>

 <composite:insertChildren/>
</h:panelGrid>
</composite:implementation>
</html>

2. For each attribute of the component we specify a name, whether it is required or not, and possibly a default value. Thus, the above component has three attributes (id, columns and columnClasses) one of which is required (id), while for the remaining two we define default values. As a result, the columns attribute has the value 4, unless a different value is specified in the page where the component is used.

In the section where the implementation of the component is defined (composite: implementation) we refer to its attributes using expressions of the form: cc.attrs.AttributeName.

The element <composite:insertChildren/> places any child components declared within the composite component tag in the using page, at the specified point within the <composite:implementation> section. This element can be used only once within the <composite:implementation> section.

3. We create a new folder named components inside the folder resources of a .war file or alternatively in the folder META-INF/resources of a .jar file. We place the above page (customComponent.xhtml) in the folder components.

4. In order to use the component in a .xhtml page at first we specify the url of the library to which it belongs:
xmlns:e=http://java.sun.com/jsf/composite/components

the part http://java.sun.com/jsf/composite notifies JSF that this is a custom component that consists of other JSF components. The second part /components has the same name with the name of the folder where the implementation page of the component is stored.

We then insert a statement like the following:

<e:customComponent id="componentId" >
    <h:outputLabel value="Child component/>
</e:customComponent>                                                                   or

<e:customComponent id="componentId" />

where the name of the component is the same as the name of the page defining its implementation (customComponent.xhtml in our case).

Attributes that correspond to simple methods


In order to set a method as an attribute of a composite component, we do the following:
a. In the attributes section of the component we insert a statement like this:
<composite:attribute name="handleChanges" method-signature="void handleChanges(Object)" required="false"/>

In the definition of the method signature we can use any name for the method.

b. In the implementation section of the component we use the above attribute like this:

<p:ajax event="change" listener="#{cc.attrs.handleChanges}" update="#{cc.attrs.id}_panel" />

Attributes that correspond to JSF event listeners

(The described workaround is based on the following post http://stackoverflow.com/questions/6453842/jsf-2-how-can-i-add-an-ajax-listener-method-to-composite-component-interface/6454339#6454339.)

In order to set a method that is an event listener, as an attribute of the composite component, we work as follows:
a. In the attributes section of the component we insert a statement like the following:
<composite:attribute name="handleChanges" method-signature="void handleChanges(org.primefaces.event.SelectEvent)" />

b. We create a Java class (CustomComponent) which inherits from the base class UIComponentBase (or another class that represents a JSF component ) and also implements the interface javax.faces.component.NamingContainer. The annotation @FacesComponent results in the automatic registration of the class CustomComponent with the JSF runtime as a UIComponent.


The value attribute corresponds to the name of the component.

@FacesComponent(value = "customComponent")

public class CustomComponent extends UIComponentBase implements NamingContainer {

@Override

public String getFamily() {

return "javax.faces.NamingContainer";

}

public void handleChanges(SelectEvent event) {

FacesContext context = FacesContext.getCurrentInstance();

MethodExpression handleChanges = (MethodExpression) getAttributes().get("handleChanges"); (1)
handleChanges.invoke(context.getELContext(), new Object[]{event}); (2)

}

}

The class CustomComponent contains one method which: gets the attribute of the component that contains the declaration of the listener method (1) and then
calls the listener passing the appropriate number of parameters (2).

c. On the implementation page of the component, at first we specify the type of the component as customComponent:
<composite:interface componentType="customComponent">

<composite:attribute name="id" required="true"/>
................................................
</composite:interface>

Then, with a statement like the following we define that each time an item is selected from the list of the primefaces’s autocomplete component, the method handleChanges is called, which in turn calls the listener that is passed as an attribute to our component.

<p:autoComplete>

<p:ajax event="itemSelect" listener="#{cc.handleChanges}" update="#{cc.attrs.id}_panel"/>

</p:autoComplete>

d. In order to use the component on a .xhtml page , we insert a statement like the following:

<e:customComponent handleChanges="#{handler.handleSelectionChanges}" id="componentId" />

The method handleSelectionChanges is defined as follows:

public void handleSelectionChanges(SelectEvent event)

{

}

Posted in java, jsf, software | 3 Comments »

 
%d bloggers like this: