is there a way to both catch and throw an exception

Question

I have a method that is going to the DB so all our JDBC stuff in the DAO method is inside a try/catch block. It is catching SQLException

When I write a test case against this method and if a SqlException occurs then my testcase does not say 'caused an error'. it just goes on its merry way.

However, If I dont catch the SqlException in the DAO method but add throws SqlException to the method instead then my test case says 'caused an error' and shows me the error that happened. (this is what I want).

When I try adding throws SqlException along with the method catching the SqlException then also my test case does not say 'caused an error'.

what is the way around it? one is to have try/catch block inside my test case but even if I do this my Junit test case does not say 'caused an error' though the exception IS posted to standard output.

...but besides that anything else?

My IDE is Netbeans. this is where I run the test cases.

Code:

public class MyDaoClass {
 Connection con;
 public MyDaoClass (Connection connection)
 {
  this.con = connection;
 }


 public SomeObject someMethod (String id)
 {
    try{
  Connection con = this.con;
  CallableStatement cs = con.prepareCall("{call some_sp_name (?)}");
  cs.setString (1, id);
  cs.execute()//imagine an error happens here
  ResultSet rs = cs.getResultSet()
  ...
  ....
  //return SomeObject...
    }
    catch (SqlException e) //If I remove this and add 'throws SQLException to method then everything is ok
    {
     log.error(e.getMessage());//i dont have access to log object in test case
    }

 }
    }

public class MyTestSuite extends TestCase
{
 //populate local connection
 public void testSomeMethod () throws SQLException
 {
  MyDaoClass myd = new MyDaoClass(connection);
  SomeObject s = myd.someMethod("blah");
  assertEquals (s.getFirstName(), "pepe");
 }
}

Answer 1

JUnit doesn't care what you write to standard output. If the exception leaks out of your method, then JUnit takes notice.

If you catch the exception inside your method, then it's correct behavior for the exception not to come out of your method, because it was (we hope!) handled there. So a passing test is a Good Thing.

What you should be testing for is whether your method is producing the correct result (whatever that may be) even in circumstances when an exception is thrown (and handled).

Answer 2

If you add throws SQLException to the method, then you don't have to try-catch it anymore.

And yes, you can catch and throw an exception:

try {
   // some code
}
catch (SomeException e) {
   throw e; 
   // or,
   // throw new SomeOtherException();
}

Answer 3

that is not the full code is it? the compiler would complain that someMethod is not always returning a value.

If you want to keep the method as is, then at least add "return null;" after the try/catch. That way, if an SQLException occurs, then assertEquals should throw NullPointerException which should work on your TestCase.

Side advice, i would check if connection is not null before using it.

Answer 4

All checked exceptions in Java must be declared in the method specification. SqlException is a checked exception, so if you want to throw it, you must include it in the specification.

If you want to throw an exception, but you can't change the method specification, you need to use an unchecked exception, like RuntimeException. It will also cause JUnit to show the error that happened.

The Java Tutorials: Exceptions is an excellent reference on this topic.

Answer 5

Instead of re-throwing the exception, you can also return a null reference instead of an empty or incomplete object. Your callers must check for null's and handle the case when the DAO fails to load the object.

Alternatively, you can stub the log object in your JUnit test and inject it into the DAO via an alternative constructor. Your stubbed logger subclass can deliver the message to your test for inspection.

Answer 6

In addition to what Chip Uni said above re: Runtime exceptions to not need to be declared, you should also note that exceptions can be nested, i.e.

catch (SqlException e)
{
 throw new RuntimeException(e);
}

This will throw a RuntimeException that contains an SqlExceotion.