Monthly Archives: December 2011

THIS POST explains how to avoid the following error message when running tests covering a validate(…) throws ValidatorException method in JSF.

Absent Code attribute in method that is not native or abstract in class file javax/faces/validator/ValidatorException

From my cursory search, it appears that the test-runner expects actual implementations of ValidatorException, whereas compiled tests have access to the API [interfaces] only. There are many pointers to solutions along the line of “use an alternative JavaEE API that includes the implementation, e.g. Geronimo”.

However, basing the correctness of one’s code on specific implementations does more harm than good, and a better solution is to design classes in such a way that the code under test is isolated into an abstract class.

For example, say I have an

<f:viewParam id=”id” name=”id” value=”#{actionDetailsBean.id}”>

with a validator bound to method #{actionDetailsBean.validate}.

The proper approach to implement this is to decouple the validation code from JSF, such that you end up with a method delegated to by the bound validate(…) method.

The following code snippet shows how the validation method would be called.

@ManagedBean(name="actionDetailsBean")
@RequestScoped
public class ActionDetailsBean extends AbstractActionDetailsBean {

    private static final String COMPONENT_ID = "id";

    public ActionDetailsBean() {
        super();
    }

    public ActionDetailsBean(ActionDetailsBeanOut actionDetailsBeanOut) {
        super(actionDetailsBeanOut);
    }

    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException{
        switch (component.getId().toLowerCase()) {
            case COMPONENT_ID:
                validateId();
                break;
        }
    }

    private void validateId() {
        load();
        if (!isLoaded())
            throw new ValidatorException(new FacesMessage("Id not recognised."));
    }
}

Here, the extracted method validateId() calls method load(). The method isLoaded() returns a boolean value to indicate whether the “action details” were loaded and, by extension, whether the id was valid.

Another tenet of unit-testing is that methods should be tested for their ability to fulfil their responsibility without exposing their implementations. In the present case, there is no need to test methods validate(…) and validateId(). We trust that validate(…) will get called by JSF and will throw a ValidatorException if a validation error occurs, which means that testing method load() is sufficient.

The following code extract shows the base class for ActionDetailsBean.

public abstract class AbstractActionDetailsBean {

    @Inject
    protected ActionDetailsBeanOut actionDetailsBeanOut;

    private String id;
    private String title;
    private String description;
    private String context;
    private boolean loaded;

    public AbstractActionDetailsBean() {
    }

    public AbstractActionDetailsBean(ActionDetailsBeanOut actionDetailsBeanOut) {
        this.actionDetailsBeanOut = actionDetailsBeanOut;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getContext() {
        return context;
    }

    public void setContext(String context) {
        this.context = context;
    }

    protected boolean isLoaded() {
        return loaded;
    }

    public void load() {
        if (loaded) return;
        Map actionDetails = actionDetailsBeanOut.requestActionDetails(id);
        if (null == actionDetails) return;
        setId((String) actionDetails.get("id"));
        setTitle((String) actionDetails.get("title"));
        setDescription((String) actionDetails.get("description"));
        setContext((String) actionDetails.get("context"));
        loaded = true;
    }
}

ActionDetailsBeanOut is a Service Provider Interface (SPI), the implementation of which is injected at run-time to provide “action data”. load() populates the bean and sets loaded to true, if successful. AbstractActionDetailsBean has no dependency other than the injection.

Finally, coming back to the initial premise of this post, the way to avoid the dependency on a concrete JavaEE class and make your unit-test runnable is to test an anonymous implementation of AbstractActionDetailsBean, as follows.

public class AbstractActionDetailsBeanTest {

    @Test
    public void testLoad() {
        ActionDetailsBeanOut actionDetailsBeanOut = new ActionDetailsBeanOut() {
            @Override
            public Map requestActionDetails(String id) {
                HashMap details = new HashMap<>();
                details.put("id", "id");
                details.put("title", "title");
                details.put("description", "description");
                details.put("context", "@context");
                return details;
            }
        };
        AbstractActionDetailsBean actionDetailsBean = new AbstractActionDetailsBean(actionDetailsBeanOut) {};
        actionDetailsBean.setId("id");
        actionDetailsBean.load();
        Assert.assertEquals("id", actionDetailsBean.getId());
        Assert.assertEquals("title", actionDetailsBean.getTitle());
        Assert.assertEquals("description", actionDetailsBean.getDescription());
        Assert.assertEquals("@context", actionDetailsBean.getContext());
        Assert.assertTrue(actionDetailsBean.isLoaded());
    }
}

This post describes how multipart/form-data requests can be processed within a Java Server Faces managed bean in order to implement file uploads.

First, intercept the servlet request and wrap it in custom HttpServletRequestWrapper before passing it to FacesServlet for further processing. This is achieved via a web filter, as follows.

@WebFilter(urlPatterns = "/*")
public class MultipartRequestFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpServletRequest;
        if (request instanceof ServletRequest) {
            httpServletRequest = (HttpServletRequest) request;
        } else if (request instanceof ServletRequestWrapper) {
            httpServletRequest = (HttpServletRequest) ((ServletRequestWrapper)request).getRequest();
        } else {
	    throw new UnsupportedOperationException("Not implemented");
	}
        if (isMultipartRequest(httpServletRequest)) {
            request = new MultipartServletRequestWrapper(httpServletRequest);
        }
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }

    private boolean isMultipartRequest(HttpServletRequest request) {
        return "POST".equalsIgnoreCase(request.getMethod()) &&
                request.getContentType() != null &&
                request.getContentType().toLowerCase().startsWith("multipart/");
    }
}

This code extract shows the request being checked, transformed into a MultipartServletRequestWrapper, and passed down the filter chain.

Next, implement MultipartServletRequestWrapper, as follows.

public class MultipartServletRequestWrapper extends HttpServletRequestWrapper {
    private Hashtable<String , Part> managedParts = new Hashtable<>();

    public MultipartServletRequestWrapper(HttpServletRequest request) throws IOException, ServletException {
		super(request);
		readParts(request);
    }

    @Override
    public String getParameter(String name) {
        String[] parameterValues = getParameterValues(name);
        return parameterValues.length > 0 ? parameterValues[0] : null;
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return managedParts.keys();
    }

    @Override
    public String[] getParameterValues(String name) {
        Part p = managedParts.get(name);
        if (null == p) return new String[0];
        byte[] b = new byte[(int) p.getSize()];
        try {
            p.getInputStream().read(b);
            return new String[]{new String(b)};
        } catch (IOException ex) {
            return new String[0];
        }
    }

    @Override
    public Map<String , String[]> getParameterMap() {
        HashMap<String , String[]> map = new HashMap<>();
        Enumeration<String> keys = managedParts.keys();
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            map.put(key, getParameterValues(key));
        }
        return map;
    }

    private void readParts(HttpServletRequest request) throws IOException, ServletException {
        for (Part part : request.getParts()) {
            managedParts.put(part.getName(), part);
        }
    }
}

Overriding the getParameter* methods is the crucial part of this class; without these, JSF is unable to restore views and by extension process the submission.

Finally, in your bean, obtain the part that contains the file upload and process it as desired.

@ManagedBean(name="fileUploadBean")
@RequestScoped
public class FileUploadBean {

    public String upload() throws FileNotFoundException, IOException, ServletException {
        ServletRequest servletRequest = (ServletRequest)FacesContext.getCurrentInstance().getExternalContext().getRequest();
        if (servletRequest instanceof MultipartServletRequestWrapper) {
            Part part = ((MultipartServletRequestWrapper) servletRequest).getPart("fileUpload");
            String header = part.getHeader("Content-disposition");
            String filename = header.substring(header.indexOf("filename=") + "filename=".length());
            if ((null != filename) && (0 < filename.length())) {
                FileOutputStream fos = new FileOutputStream("C:\\Temp\\test.png");
                byte[] b = new byte[(int) part.getSize()];
                part.getInputStream().read(b);
                fos.write(b);
                fos.close();
            }
        }
        return null;
    }
}

This bean here reads the content of the part and writes it to file.