How do I unit test overridden methods which call super?

Question

http://stackoverflow.com/questions/6645263/unit-testing-overridden-methods-which-call-super (This question has similar wording but is not the same)

I have something along the lines of:

public class SuperClass {
   private int superClassInteger = 2;

   public void superClassMethod() {
      superClassInteger = 5;
   }

   public int getSuperClassInteger() {
      return superClassInteger();
   }
}

Then in my test I have:

public class SuperClassTest {
   public void testSuperClassMethod() {
       SuperClass superClass = new SuperClass();
       superClass.superClassMethod();
       assertEquals(5, super.getSuperClassInteger())
   }
}

I then have a subclass:

public class SubClass {
   private int subClassInteger = 2;

   public void subClassMethod() {
      super.superClassMethod();
      subClassInteger = 32;
   }

   public int getSuperClassInteger() {
      subClassInteger;
   }
}

Then my test for the subclass:

public class SubClassTest {
   public void testSubClassMethod() {
       SubClass subClass = new SubClass();
       subClass.subClassMethod();
       assertEquals(5, subclass.getSuperClassInteger());
       assertEquals(32, subclass.getSubClassInteger())
   }
}

My problem is that to test the behavior of the subclass, I am repeating the test code I have for the super class. I could take out: assertEquals(5, subclass.getSuperClassInteger()); as I just want to test the business logic of the subclass. However, the problem with this is that if somebody accidentally removes the call to superClassMethod the test will still pass. So I need verify that a call to super is made. What is a common way of testing this use case?

Note: I know composition / strategy pattern vs inheritance helps solve this problem but for that to be the solution you are basically saying that I should NEVER override a method and invoke super in my code (which I find hard to believe there will never be a use for)

score 5 · Answer 1 · edited Mar 26 '22 at 22:26

5

Use mockito spies. You can check for nearly any method call using that testing Framework.

https://github.com/mockito/mockito

edited Mar 26 '22 at 22:26

NightFury

13,436
6
71
120

answered Dec 07 '12 at 11:17

sorencito

2,517
20
21

Tarek · Answer 2 · 2014-04-09T17:43:24.937

This is probably not the answer you want (i.e not a workaround), ~~but the answer you deserve~~ but you should never override a method and invoke super.

I'm working on a legacy project that does that a lot, it's a nightmare to maintain, to debug and to test.

Instead, it's better to use an abstract class with a template method pattern:

Before

public class SuperClass<T> {
  public void include(T t) {
    validate(T);
    dao.save(T);
  }

  // I've found code like that.
  public void validate(T t) {
  }
}

public class SubClass1 extends SuperClass<MyClass> {
  @Override
  public void include(MyClass mc) {
    doStuff(mc);
    doMoreStuff(mc);
    super.include(mc);
  }

  @Override
  public void validate(MyClass mc) {
    doValidationStuff();
  }
}

public class SubClass2 extends SuperClass<AnotherClass> {
  @Override
  public void include(AnotherClass ac) {
    doDifferentStuff();
    super.include(mc);
  }
}

After

public abstract class AbstractClass<T> {
  abstract void validate(T t);

  // this method can now be tested
  public void include(T t) {
    validate(T);
    dao.save(T);
  }
}

public class Class1 extends AbstractClass<MyClass> {
  public void validate(MyClass mc) {
    doValidationStuff();
    doStuff(mc);
    doMoreStuff(mc);
  }
}

public class Class2 extends AbstractClass<AnotherClass> {
  public void validate(AnotherClass ac) {
    doDifferentStuff();
  }
}

As you can see, this refactoring simplifies maintenance and testing, you don't have to worry about having to mock the superclass method call in the Class1 and Class2 tests, and the code is closed to modification and open to extension, i.e, more maintainable.

This is sound advice for most cases but sometimes, especially when dealing with third party APIs, calling `super()` is unavoidable. (At least without a lot of hassle.) — biziclop, Apr 09 '14 at 17:41
In that case, then I guess it'd be better to call other methods in the overriden method before the super call and test these instead. — Tarek, Apr 09 '14 at 17:52
"but you should never override a method and invoke super" what?! — Farid, Mar 16 '22 at 18:11

Jan Schmidt · Answer 3 · 2012-12-07T11:40:44.780

Use JMockit and check the call to super with a Verification.

JMockit

Example for this

public void test {
  SubClass subClass = new SubClass();
  subClass.subClassMethod();
  new Verifications() {
    // mock only this method of superClass - and only in this test
    @Mocked (methods = "superClassMethod") 
    SuperClass superClass; 
    {
     superClass.superClassMethod();
     times = 1; // specify invocation count
    }
  };

 }

How do I unit test overridden methods which call super?

3 Answers3

Before

After