can we write junit testcase for any java class?

[J radolf]

is it possible to write junit class for any type of java file?

[Marco Ehrentreich]

Basically yes... Of course some things are harder to test than others without additional test libraries etc.

What is your problem?

Marco

[J radolf]

 import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Properties;

import javax.annotation.Resource;
import javax.ejb.Stateless;
import javax.naming.NamingException;
import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;


@Stateless
public class DESProxyImpl extends Thread implements DESProxy {

    /**
     * Logger instance.
     */
    private static Log log = LogFactory.getLog(DESProxyImpl.class);

    private Connection clientCon = null;
    private CallableStatement prepareStmt = null;
    private CallableStatement waitStmt = null;
    private DESProxyImpl desProxy = null;
    private DBDESProxyImpl dbDESProxyImpl = null;
    private String clientAlertName;
    private int proxyFreq;

    @Resource(mappedName = "java:/istDS")
    private DataSource dataSource;

    /**
     * {@inheritDoc}
     */
    public Connection getClientDBConnection() throws SQLException,
            NamingException {
        clientCon = dataSource.getConnection();

        log.debug("Connection is " + clientCon);
        return null;
    }

    /**
     * C'tor for the class DESProxyImpl class
     */
    public DESProxyImpl() {
        loadProperties();
    }

    /**
     * DESProxy thread.
     */
    public void run() {

        String errorMessage = "";
        int status = 1;
        String msg = null;
        int sleepTime_in_ms = proxyFreq * 1000;

        if (clientCon == null) {
            errorMessage = "Client database not responding. Cannot start DESProxy. Terminating.....";
            log.error(errorMessage);
            try {
                throw new DESProxyException(errorMessage);
            } catch (DESProxyException e) {
                throw new RuntimeException(errorMessage, e);
            }
        }

        try {
            dbDESProxyImpl = new DBDESProxyImpl(clientCon);
            log.debug("DBDESProxy object created");
        } catch (Exception e) {
            errorMessage = "Error occured while creating DBDESProxy object for DESProxy. DESProxy cannot continue. Quitting...";
            log.error(errorMessage, e);

            try {
                throw new DESProxyException(errorMessage);
            } catch (DESProxyException desEx) {
                throw new RuntimeException(errorMessage, desEx);
            }
        }

        try {
            prepareStmt = clientCon
                    .prepareCall("begin DBMS_ALERT.register(?); end;");
            prepareStmt.setString(1, clientAlertName);
            prepareStmt.execute();
        } catch (SQLException e) {
            errorMessage = "Error registering DBMS_ALERT.";
            log.error(errorMessage, e);

            try {
                throw new DESProxyException(errorMessage);
            } catch (DESProxyException desEx) {
                throw new RuntimeException(errorMessage, desEx);
            }
        }

        try {
            int wait = 100;
            waitStmt = clientCon
                    .prepareCall("begin DBMS_ALERT.waitone(?,?,?,?); end;");
            waitStmt.setString(1, clientAlertName);
            waitStmt.registerOutParameter(2, Types.VARCHAR);
            waitStmt.registerOutParameter(3, Types.NUMERIC);
            waitStmt.setInt(4, wait);
            log.debug("Checking for new alerts every " + wait + " seconds.");
        } catch (Exception e) {
            errorMessage = "Error while preparing wait for the alert";
            log.error(errorMessage, e);

            try {
                throw new DESProxyException(errorMessage);
            } catch (DESProxyException desEx) {
                throw new RuntimeException(errorMessage, desEx);
            }
        }

        do {
            // Start the waiting process
            try {
                log.debug("Waiting for alert..");
                waitStmt.execute();
            } catch (SQLException e) {

                // If oracle is unavailable, keep trying to re-connect.
                errorMessage = "Database not available. Resetting connections....";

                log.error(errorMessage, e);

                try {
                    throw new DESProxyException(errorMessage);
                } catch (DESProxyException desEx) {
                    resetConnections();
                }
            }

            // When an interruption occurs, it could be due to 2 reasons - a
            // genuine database change or timeout. A status of 0 indicates the
            // former case while a status of 1 indicates the latter.
            try {
                status = waitStmt.getInt(3);
                log.debug("Alert has occured with status : " + status);
                msg = waitStmt.getString(2);
            } catch (SQLException e) {
                log.error("Error while reading the result of the alert.");
            }

            // If the status is 0, its an actual request - either a distribution
            // or publish request. Process them.
            if (status == 0) {
                try {
                    log.debug("Status is 0. Processing request..");
                    try {
                        log.debug("Processing distribution request..");
                        dbDESProxyImpl.processDistRequests();
                        log.debug("Done processing.");
                    } catch (Exception e) {
                        log.error("Error during DistRequest transfer.", e);
                    }
                } catch (Exception e) {
                    log.error("Error while processing the request.", e);
                }
            }

            // Status of 1 means that a timeout has occurred. Sleep for the
            // specified frequency and start again.
            if (status == 1) {
                try {
                    log.debug("Status is 1. Timeout occurred. Sleep for "
                            + (sleepTime_in_ms / 1000) + " seconds");
                    sleep(sleepTime_in_ms);
                } catch (InterruptedException ie) {
                    log.error(ie);
                }
            }
        } while (true);
    }

    /**
     * Method which is used to keep polling the database and re-create
     * connections and prepare the method for re-starting the execution
     */
    private void resetConnections() {

        String errorMessage = "";

        // TODO Auto-generated method stub
        int waitTime = 30000; // Keep trying every 30 seconds

        try {
            log.debug("Closing connections..");
            clientCon.close();
            clientCon = null;
        } catch (Exception e2) {
        }
        while (true) {

            try {
                // Re-create the connections - keep trying till we are able to.
                log.debug("Re-creating the database connections...");

                // Try connecting to the client DB.
                desProxy = new DESProxyImpl();
                clientCon = desProxy.getClientDBConnection();

                if (clientCon == null) {
                    errorMessage = "Client database not responding. Cannot start DESProxy. Terminating.....";
                    log.error(errorMessage);
                    try {
                        throw new DESProxyException(errorMessage);
                    } catch (DESProxyException e) {
                        throw new RuntimeException(errorMessage, e);
                    }
                }

                // Re-register DBMS_ALERT
                try {
                    prepareStmt = clientCon
                            .prepareCall("begin DBMS_ALERT.register(?); end;");
                    prepareStmt.setString(1, clientAlertName);
                } catch (SQLException e) {
                    log.error("Error while preparing the register call for the alert.",
                                    e);
                }

                try {
                    prepareStmt.execute();
                    log
                            .debug("Registered alert with name : "
                                    + clientAlertName);
                } catch (Exception e) {
                    log.error("Error while registering the alert.", e);
                }

                try {
                    // Re-create the waitStatement
                    waitStmt = clientCon
                            .prepareCall("begin DBMS_ALERT.waitone(?,?,?,?); end;");
                    waitStmt.setString(1, clientAlertName);
                    waitStmt.registerOutParameter(2, Types.VARCHAR);
                    waitStmt.registerOutParameter(3, Types.NUMERIC);
                    waitStmt.setInt(4, 100);

                    log.debug("Waiting for alert..");
                    waitStmt.execute();
                } catch (Exception e) {
                    log.error("Error while prepareing wait for the alert.", e);
                }

                // Having reached here, it only means that everything is OK.
                // Break out.
                break;
            } catch (Exception e) {
                log
                        .error("Error while reconnecting. Sleep for 30 sec and try again...");

                try {
                    sleep(waitTime);
                } catch (Exception e1) {

                }

                // Closing the existing connections...
                try {
                    clientCon.close();
                    clientCon = null;
                } catch (Exception e2) {

                }
                continue;
            }
        }
    }

    /**
     * Method to load alert name and proxyRreq
     * 
     * @return Properties
     */
    private Properties loadProperties() {
        Properties props = new Properties();
        InputStream inputStream = this.getClass().getResourceAsStream(
                "/konaDESProxy.properties");

        if (inputStream == null) {
            try {
                throw new FileNotFoundException("property file '"
                        + "konaDESProxy.properties"
                        + "' not found in the classpath");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        try {
            props.load(inputStream);
            clientAlertName = props.getProperty("clientAlertName");
            proxyFreq = Integer.parseInt(props.getProperty("proxyFreq"));
        } catch (IOException e) {
            log.error("Error loading konaDESProxy.properties.", e);
        }
        return props;
    }
}
   

is it possible to write unit test junit for these kind of classes?

i know to write simple junits for small classes.

[J radolf]

how do i write a junit for these kind of classes?

[Marco Ehrentreich]

Hi!

Unfortunately this class you're trying to get under test has even multiple problems which makes it very tricky to test. I doubt that it's even possible to reasonably test it if you don't have the chance to refactor it.

The main problems I see from a quick look are:

- It's an EJB class which may need a JUnit add-on like ejb3unit depending on what you want to test.
- It's designed to be used with multi-threading which is a challenge on its own if you want to create useful concurrency tests.
- You have dependencies for file/database I/O hard-coded into the code.
- The overall design is not really OO and not very well-suited for testing.

That said I'd recommend you to restructure and refactor this code and try to put in test cases in parallel as good as possible. Try to break dependencies so that you can substitute database and file access with fake or mock objects etc. Refactor this big methods into smaller units/methods so that you are able to test one piece of specific functionality within each test method. Unfortunately it's hard to give you more concrete advices because there may be many different way to get this piece of code into a structure which is easier to test.

If it's likely that you will have to deal more often with code of that kind in the near future I would recommend reading "Working Effectively with Legacy Code" ;-) Michael Feathers shows lots of tricks how to get such code into better shape and make it testable.

Good Luck

Marco

[Jeanne Boyarsky]

J radolf wrote:how do i write a junit for these kind of classes?

You start small. What methods can you test? The loadProperties method jumps out at me as being easily testable.

The database code could be refactored into separate methods (or better yet classes) and be unit (using mocks) or integration (using a database) tested there.

You really should refactor regardless of testing. That run method does too much. Suppose you had never seen this class before. How long would it take to figure out what the run method does? What if you compare it to the below method? (I could make it more readable if I was the author and knew exactly the purpose - this attempt was based on the original implementation.)

The refactoring helps with both readability and testing. Readability should be obvious - you don't have to deal with the low level details when reading the run methods. On the testing side, each of the methods can be tested independently. Making it much easier to test error handling. How else would you easily simulate a database failure on a call near the middle?

public void run() {  

  validateDesProxyStarted();
  createDesProxy();
  storedProcWrapper.register();
  storedProcWrapper.waitOne();
  
  do {  
       // Start the waiting process  
      waitForExecute();

     int status = getStatus(waitStmt);
     if (status  == 0) {  
        processDistRequests();
     } else  if (status  == 1) {  
        sleep();
     }
   } while (true);  
}  

[manuel aldana]

there is a fantastic book on this problem (evil-cycle: no tests->no safe refactoring, no testable code -> difficult test setup):
work effectively on legacy code

it discusses how you face bad testable code, and how you make it testable with more conservative refactorings.

[J radolf]

so in case if we want to unit test loadProperties() method should i put a dummy property file to read it?

is it a correct coding style in a real world scenario?

[manuel aldana]

or even better. add a Reader abstraction on it to load properties.

There is a Properties.load

Then you can pass different reader variants (like FileReader for production and StringReader for tests).

[J radolf]

suppose a class has four methods in it. so we need to write 4 different junit classes to test those four methods or do we need to test those four methods in a single junit class?

[Marco Ehrentreich]

There are different testing strategies, personal taste and different opinions on how you should group test methods into test clases. But basically I'd start with one test class per tested class. This make usually most sense and you have all tests for each method of the same production class in one test class.

One more point: It may be necessary to have more than one test method for each tested method ;-)

Marco

[Ilja Preuss]

1) You don't test methods, you test behavior of a class. A test method should test one micro-scenario. As such, you can have test methods that test the interplay of several methods, and methods tested by several test methods.

2) A common good practice is to have one test class per fixture. That is, group test methods with common set up code into a class, and move that set up code into one or more @Before methods.

[J radolf]

thanks for the reply.