How to combine with Mockito?

[liechtir]

Hi
we are using Mockito in our tests to mock certain functionality.
Mockito also offers to @Injectmocks, which creates an instance and injects dummy mocks on all dependencies in a class.
Archunit does not find method references/calls of such objects.

In example:

@RunWith(MockitoJUnitRunner.class)
public class MyTest  {
    @InjectMocks
    MyService testee;

    @Test
    public void testSomething(){
       testee.doSomething();
    }
}

When doing ArchRuleDefinition.methods(), the call to doSomething is not there.

Any idea how to combine ArchUnit with Mockito?

Thanks

[nbrugger-tgm]

Maybe I am getting it wrong but methods() returns all methods not all method calls or references, if you want to know if method a accesses/calls/references method b you have to use Java Method or JavaCodeUnit.getAccesses()(pseudocode from the top of my head)
So you would need to write your own DescribedPredicate to check it. I am working on an integration of functionality that will look like this

methods ()
   .that().areStatic()
   .shouldNot().call(methodsThat(areNamed("mockedMethodName") ;

I am trying to open a pr soon but my personal live is quite busy

[codecholeric]

I'm not sure I fully get the question. ArchUnit will only detect static properties of code, not runtime properties. So it will not know that there is a mock proxy injected at runtime or something like that. It can only detect what you can also see on the screen, i.e. a field is annotated with @InjectMocks and an @Test method calls the method MyService.doSomething().

Can you outline a little more what you actually want to achieve? What do you mean by "When doing ArchRuleDefinition.methods(), the call to doSomething is not there."? In which context? How does your rule and class import look like?

[liechtir]

Hi guys, thanks for your answers. Sorry that I was not accurate enough.
Basically, I want to find dead code. To put it simplified for this thread here, I want all methods to be called at least once:

@Test
    public void deadMethods() {
        JavaClasses importedClasses = new ClassFileImporter().importPackages("my.packages");
        ArchRule rule = ArchRuleDefinition.methods().should(new ArchCondition<JavaMethod>("be called at least once") {
            @Override
           public void check(JavaMethod method, ConditionEvents events) {
                if (method.getAccessesToSelf().isEmpty()) {
                    events.add(SimpleConditionEvent.violated(method, method.getDescription()));
                }
            }
        });
        rule.check(importedClasses);
    }

For methods that are called in a mocked environment, like below

@RunWith(MockitoJUnitRunner.class)
public class MyTest  {
    @InjectMocks
    MyService testee;

    @Test
    public void testSomething(){
       testee.doSomething();
    }
}

The call to 'doSomething()' is not tracked and not found in the rule. A violation is added even though the code is called. So this creates a false-positive.
Yes, I agree, for code that is called from tests only, we should remove the code from production code and move it into the test setup or the like. However, this should be a different rules for later on, now focus on real dead code that is never called.

Thanks!

[codecholeric]

But ArchUnit should see this call just fine 🤔 If you import MyTest, then it should also see that MyService.doSomething() is called. Is it possible that the test is simply missing from the import somehow?

[liechtir]

yes it was a maven setup issue

[nbrugger-tgm]

As far as I see the call should be found, maybe the test is not in the scope that you analyze because not only the class that is accessed needs to be in the scan but also the accessor

…

On Tue, 30 Aug 2022, 09:54 liechtir ***@***.***> wrote: Hi guys, thanks for your answers. Sorry that I was not accurate enough. Basically, I want to find dead code. To put it simplified for this thread here, I want all methods to be called at least once: @test public void deadMethods() { JavaClasses importedClasses = new ClassFileImporter().importPackages("my.packages"); ArchRule rule = ArchRuleDefinition.methods().should(new ArchCondition<JavaMethod>("be called at least once") { @OverRide public void check(JavaMethod method, ConditionEvents events) { if (method.getAccessesToSelf().isEmpty()) { events.add(SimpleConditionEvent.violated(method, method.getDescription())); } } }); rule.check(importedClasses); } For methods that are called in a mocked environment, like below @RunWith(MockitoJUnitRunner.class) public class MyTest { @Injectmocks MyService testee; @test public void testSomething(){ testee.doSomething(); } } The call to 'doSomething()' is not tracked and not found in the rule. A violation is added even though the code is called. So this creates a false-positive. Yes, I agree, for code that is called from tests only, we should remove the code from production code and move it into the test setup or the like. However, this should be a different rules for later on, now focus on real dead code that is never called. Thanks! — Reply to this email directly, view it on GitHub <#948 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AIETDIYQVJUACFVQE2QYZVTV3W45DANCNFSM57PFUEWA> . You are receiving this because you commented.Message ID: ***@***.***>

[liechtir]

might be. I will write another test case to see if that class is found.

Is there some kind of limit of number of classes/methods that arch unit supports?
Because I got some methods reported as not used, wiped the methods, and in a new run I now get methods mentioned that were not found before, even though they were never called from the start. (so nothing like called from the method that was removed only and now is obsolete because the first method got removed)
Our code base is 1.4mio lines for production and 2.3mio for tests.