In Java unit testing, how to mock the variables that are not injected but created inside the to-be-tested class?

For example, the class to be tested is

public class toBeTested {
    private Object variable;

    public toBeTested(){
        variable = someFactory();         // What if this someFactory() sends internet request? 
                                          // Can I mock "variable" without calling 
                                          // someFactory() in testing?
    }

    public void doSomething(){
        ...
        Object returnedValue = variable.someMethod();  // In testing, can I mock the behavior of 
                                                       // this someMethod() method when 
                                                       // "variable" is a private instance 
                                                       // variable that is not injected? 
        
        Object localVariable = new SomeClass();        // Can I mock this "localVariable" in 
                                                       // testing?
        ...
    }
}

My questions are as stated in the comments above.

In short, how to mock the variables that are not injected but created inside the to-be-tested class?

Thanks in advance!

Your question is more about the design, the design of your class is wrong and it is not testable, It is not easy (and sometimes it is not possible at all) to write a unit test for a method and class that have been developed before. Actually one of the great benefit of TDD(Test Driven Development) is that it helps the developer to develop their component in a testable way.

Your class would have not been developed this way if its test had been written first. In fact one of the inevitable thing that you should do when you are writing test for your component is refactoring. So here to refactor your component to a testable component you should pass factory to your class's constructor as a parameter.

And what about localVariable:

It really depends on your situation and what you expect from your unit to do (here your unit is doSomething method). If it is a variable that you expext from your method to create as part of its task and it should be created based on some logic in method in each call, there is no problem let it be there, but if it provides some other logic to your method and can be passed as parameter to your class you can pass it as parameter to your class's cunstructor.

One more thing, be carefull when you are doing refactoring there will be many other components that use your component, you should do your refactoring step by step and you should not change the logic of your method.

To add another perspective: If faced with situations in which you have to test a given class and aren't permitted to change the class you need to test, you have the option to use a framework like PowerMock (https://github.com/powermock/powermock) that offers enhanced mocking capabilities.

But be aware that using PowerMock for the sole purpose of justifying hard to test code is not advisable. Tashkhisi's answer is by far the better general purpose approach.