How to mock a final class with mockito

Question

I have a final class  something like this   public final class RainOnTrees      public void startRain                some code here          I am using this class in some other class like this   public class Seasons      RainOnTrees rain   new RainOnTrees        public void findSeasonAndRain             rain startRain               and in my JUnit test class for Seasons java I want to mock the RainOnTrees class  How can I do this with Mockito

User · Answer

Add these dependencies for run mockito successfully    testImplementation  org mockito mockito-core 2 24 5  testImplementation  org mockito mockito-inline 2 24 5

User · Answer

If you trying to run unit-test under the test folder  the top solution is fine  Just follow it adding an extension   But if you want to run it with android related class like context or activity which is under androidtest folder  the answer is for you

User · Answer

Solutions provided by RC and Luigi R  Viggiano together is possibly the best idea   Although Mockito cannot  by design  mock final classes  the delegation approach is possible  This has its advantages    You are not forced to change your class to non-final if that is what your API intends in the first place  final classes have their benefits   You are testing the possibility of a decoration around your API    In your test case  you deliberately forward the calls to the system under test  Hence  by design  your decoration does not do anything   Hence you test can also demonstrate that the user can only decorate the API instead of extending it   On a more subjective note  I prefer keeping the frameworks to a minimum  which is why JUnit and Mockito are usually sufficient for me  In fact  restricting this way sometimes forces me to refactor for good as well

User · Answer

Just to follow up  Please add this line to your gradle file   testCompile group   org mockito   name   mockito-inline   version   2 8 9    I have tried various version of mockito-core and mockito-all  Neither of them work

User · Answer

For us  it was because we excluded mockito-inline from koin-test   One gradle module actually needed this and for reason only failed on release builds  debug builds in the IDE worked   -P

User · Answer

Time saver for people who are facing the same issue  Mockito   Final Class  on Android   Kotlin  As in Kotlin classes are final by default  I found a solution in one of Google Android samples with Architecture component  Solution picked from here   https   github com googlesamples android-architecture-components blob master GithubBrowserSample  Create following annotations           This annotation allows us to open some classes for mocking purposes while they are final in    release builds       Target AnnotationTarget ANNOTATION CLASS  annotation class OpenClass         Annotate a class with  OpenForTesting  if you want it to be extendable in debug builds       OpenClass  Target AnnotationTarget CLASS  annotation class OpenForTesting   Modify your gradle file  Take example from here   https   github com googlesamples android-architecture-components blob master GithubBrowserSample app build gradle  apply plugin   kotlin-allopen   allOpen          allows mocking for classes w o directly opening them for release builds     annotation  com android example github testing OpenClass      Now you can annotate any class to make it open for testing     OpenForTesting class RepoRepository

User · Answer

As others have stated  this won t work out of the box with Mockito  I would suggest using reflection to set the specific fields on the object that is being used by the code under test  If you find yourself doing this a lot  you can wrap this functionality in a library   As an aside  if you are the one marking classes final  stop doing that  I ran across this question because I am working with an API where everything was marked final to prevent my legitimate need for extension  mocking   and I wish that the developer had not assumed that I would never need to extend the class

User · Answer

I had the same problem  Since the class I was trying to mock was a simple class  I simply created an instance of it and returned that

User · Answer

In Mockito 3 and more I have the same problem and fixed it as from this link Mock Final Classes and Methods with Mockito as follow  Before Mockito can be used for mocking final classes and methods  it needs to be  gt  configured  We need to add a text file to the project s src test resources mockito-extensions directory named org mockito plugins MockMaker and add a single line of text  mock-maker-inline  Mockito checks the extensions directory for configuration files when it is loaded  This file enables the mocking of final methods and classes

User · Answer

Mockito 2 now supports final classes and methods  But for now that s an  quot incubating quot  feature  It requires some steps to activate it which are described in What s New in Mockito 2   Mocking of final classes and methods is an incubating  opt-in feature  It uses a combination of Java agent instrumentation and subclassing in order to enable mockability of these types  As this works differently to our current mechanism and this one has different limitations and as we want to gather experience and user feedback  this feature had to be explicitly activated to be available   it can be done via the mockito extension mechanism by creating the file src test resources mockito-extensions org mockito plugins MockMaker containing a single line  mock-maker-inline  After you created this file  Mockito will automatically use this new engine and one can do    final class FinalClass      final String finalMethod     return  quot something quot          FinalClass concrete   new FinalClass       FinalClass mock   mock FinalClass class    given mock finalMethod    willReturn  quot not anymore quot      assertThat mock finalMethod    isNotEqualTo concrete finalMethod      In subsequent milestones  the team will bring a programmatic way of using this feature  We will identify and provide support for all unmockable scenarios  Stay tuned and please let us know what you think of this feature

User · Answer

This can be done if you are using Mockito2  with the new incubating feature which supports mocking of final classes  amp  methods    Key points to note  1   Create a simple file with the name    org mockito plugins MockMaker    and place it in a folder named    mockito-extensions     This folder should be made available on the classpath  2   The content of the file created above should be a single line as given below  mock-maker-inline  The above two steps are required in order to activate the mockito extension mechanism and use this opt-in feature   Sample classes are as follows -   FinalClass java  public final class FinalClass    public final String hello        System out println  Final class says Hello           return  0          Foo java  public class Foo    public String executeFinal FinalClass finalClass       return finalClass hello           FooTest java  public class FooTest     Test public void testFinalClass           Instantiate the class under test      Foo foo   new Foo            Instantiate the external dependency     FinalClass realFinalClass   new FinalClass            Create mock object for the final class       FinalClass mockedFinalClass   mock FinalClass class           Provide stub for mocked object      when mockedFinalClass hello    thenReturn  1            assert     assertEquals  0   foo executeFinal realFinalClass        assertEquals  1   foo executeFinal mockedFinalClass            Hope it helps   Complete article present here mocking-the-unmockable

User · Answer

Yes same problem here  we cannot mock a final class with Mockito  To be accurate  Mockito cannot mock spy following    final classes anonymous classes primitive types   But using a wrapper class seems to me a big price to pay  so get PowerMockito instead

User · Answer

Another workaround  which may apply in some cases  is to create an interface that is implemented by that final class  change the code to use the interface instead of the concrete class and then mock the interface  This lets you separate the contract  interface  from the implementation  final class   Of course  if what you want is really to bind to the final class  this will not apply

User · Answer

Mocking final static classes methods is possible with Mockito v2 only   add this in your gradle file   testImplementation  org mockito mockito-inline 2 13 0    This is not possible with Mockito v1  from the Mockito FAQ      What are the limitations of Mockito         Needs java 1 5    Cannot mock final classes

User · Answer

Actually there is one way  which I use for spying  It would work for you only if two preconditions are satisfied    You use some kind of DI to inject an instance of final class Final class implements an interface   Please recall Item 16 from Effective Java  You may create a wrapper  not final  and forward all call to the instance of final class   public final class RainOnTrees implement IRainOnTrees        Override public void startRain        some code here      public class RainOnTreesWrapper implement IRainOnTrees       private IRainOnTrees delegate      public RainOnTreesWrapper IRainOnTrees delegate   this delegate   delegate        Override public void startRain     delegate startRain          Now not only can you mock your final class but also spy on it   public class Seasons      RainOnTrees rain      public Seasons IRainOnTrees rain    this rain   rain         public void findSeasonAndRain            rain startRain            IRainOnTrees rain   spy new RainOnTreesWrapper new RainOnTrees       or mock IRainOnTrees class  doNothing   when rain  startRain    new Seasons rain  findSeasonAndRain

User · Answer

For final class add below to mock and call static or non static   1- add this in class level     SuppressStatucInitializationFor value   class name with package   2- PowerMockito mockStatic classname class  will mock class 3- then use your when statement to return mock object when calling method of this class   Enjoy

User · Answer

I was able to overcome this message   org mockito exceptions base MockitoException  Cannot mock spy class org slf4j impl Log4jLoggerAdapter Mockito cannot mock spy because    final or anonymous class   from this  log   spy log   By using this instead  log   mock Logger class   Then it works  I guess that  quot default quot  logger adapter is an instance of a final class so I couldn t  quot spy quot  it  but I could mock the whole thing   Go figure    This may mean that you could substitute it for some other  quot non final quot  instance if you have that handy  as well   Or a simplified version  etc  FWIW

User · Answer

I think you need think more in principle  Instead you final class use his interface and mock interface  instead   For this    public class RainOnTrees      fun startRain   Observable lt Boolean gt               some code here          add  interface iRainOnTrees    public void startRain   Observable lt Boolean gt      and mock you interface     Before     fun setUp             rainService  Mockito mock iRainOnTrees  class java            when  rainService startRain    thenReturn              just true  delay 3  TimeUnit SECONDS

User · Answer

I guess you made it final because you want to prevent other classes from extending RainOnTrees  As Effective Java suggests  item 15   there s another way to keep a class close for extension without making it final    Remove the final keyword  Make its constructor private  No class will be able to extend it because it won t be able to call the super constructor  Create a static factory method to instantiate your class      No more final keyword here  public class RainOnTrees        public static RainOnTrees newInstance             return new RainOnTrees                private RainOnTrees                Private constructor             public void startRain                 some code here            By using this strategy  you ll be able to use Mockito and keep your class closed for extension with little boilerplate code

User · Answer

You cannot mock a final class with Mockito  as you can t do it by yourself   What I do  is to create a non-final class to wrap the final class and use as delegate  An example of this is TwitterFactory class  and this is my mockable class   public class TwitterFactory        private final twitter4j TwitterFactory factory       public TwitterFactory             factory   new twitter4j TwitterFactory               public Twitter getInstance User user            return factory getInstance accessToken user               private AccessToken accessToken User user            return new AccessToken user getAccessToken    user getAccessTokenSecret                public Twitter getInstance             return factory getInstance              The disadvantage is that there is a lot of boilerplate code  the advantage is that you can add some methods that may relate to your application business  like the getInstance that is taking a user instead of an accessToken  in the above case    In your case I would create a non-final RainOnTrees class that delegate to the final class  Or  if you can make it non-final  it would be better

User · Answer

Use Powermock  This link shows  how to do it  https   github com jayway powermock wiki MockFinal

User · Answer

add this in your gradle file  testImplementation  org mockito mockito-inline 2 13 0   this is a configuration to make mockito work with final classes If you faced the Could not initialize inline Byte Buddy mock maker   This mock maker is not supported on Android   Add the Byte Buddy dependency to your build gradle file  testImplementation  net bytebuddy byte-buddy-agent 1 10 19   src  https   mvnrepository com artifact net bytebuddy byte-buddy

User · Answer

Please look at JMockit  It has extensive documentation with a lot of examples  Here you have an example solution of your problem  to simplify I ve added constructor to Seasons to inject mocked RainOnTrees instance    package jmockitexample   import mockit Mocked  import mockit Verifications  import mockit integration junit4 JMockit  import org junit Test  import org junit runner RunWith    RunWith JMockit class  public class SeasonsTest         Test     public void shouldStartRain  Mocked final RainOnTrees rain            Seasons seasons   new Seasons rain            seasons findSeasonAndRain             new Verifications                  rain startRain                           public final class RainOnTrees           public void startRain                    some code here                       public class Seasons            private final RainOnTrees rain           public Seasons RainOnTrees rain                this rain   rain                     public void findSeasonAndRain                 rain startRain

User · Answer

Mocking final classes is not supported for mockito-android as per this GitHub issue  You should use Mockk instead for this  For both unit test and ui test  you can use Mockk with no problem

User · Answer

Didn t try final  but for private  using reflection remove the modifier worked   have checked further  it doesn t work for final

User · Answer

Give this a try   Mockito mock SomeMockableType class AdditionalAnswers delegatesTo someInstanceThatIsNotMockableOrSpyable      It worked for me   SomeMockableType class  is the parent class of what you want to mock or spy  and someInstanceThatIsNotMockableOrSpyable is the actual class that you want to mock or spy   For more details have a look here

[java] How to mock a final class with mockito

Examples related to java

Examples related to junit

Examples related to mockito