Testing Interactor methods that do more than one thing in a Clean architecture

Question

I have been reading about unit tests & Clean architecture and tried to implement something that would involve those two things.

It is my understanding that a Clean architecture is structured so that the methods of the Interactor object can be unit-tested.

But when the use case is something like "Create a file which content is computed from some data in some format", I get confused because it's not unitary (there's the computation of the file content, and the creation of the file, which are both in the use case)

Here's some pseudo-code illustrating my situation :

/* We are in an Interactor (i.e. UseCaseObject)
 * This method 1)computes fileContent and 2)writes it into a file. 
 */
public void CreateFileFromData(someDataInSomeFormat) {
    var parsedData = SomeParser.Parse(someDataInSomeFormat);

    string fileContent = ???; 

    WriteFile(fileContent); 
}

My questions are the following :

1. Must a method defined in the Interactor be unitary ? (as in, do only one thing)
2. Must a method defined in the Interactor be unit-tested ? (I see a function, unitary or not, as a testable unit, please correct me if this is incorrect)
3. Which class must hold the computation of fileContent in a Clean architecture ?

Answer 1

You not telling from where data for computation will be "loaded", but for example lets assume that data will be read from another file.

Your interactor will have three dependecies
- read file
- calculate data for new file
- write file

public class Interactor
{
    public Interactor(IReader reader, ICalculator calculator, IWriter writer)
    { }

    public void DoJob()
    {
        var data = reader.Read();
        var calculatedData = calculator.Calculate(data);
        writer.Write(calculatedData);
    }
}

With this approach Interactor will have responsibility to "combine" steps required to accomplished a task.

You can simply test Interactor by mocking all dependencies.

Where:
IReader and IWriter are Gateways
ICalculator is implementation detail of UseCase which used by Interactor

Must a method defined in the Interactor be unitary ? (as in, do only one thing)

Method should do one thing - execute use case related task. If task requires using of gateways(external resources) or task is to complicated to keep it in one method - you will introduce all required units as dependencies and interactor responsibility will be to "glue" them together.

Must a method defined in the Interactor be unit-tested ? (I see a function, unitary or not, as a testable unit, please correct me if this is incorrect)

Abstract only gateways(external resources) - Then you can test whole logic of interactor. If you writing test first - you will write tests and whole logic can be in the one function(it could/should be ugly spagetti code, which makes tests pass). Then when you see whole picture of implementation you can start moving staff around by moving things to dedicated classes.

Which class must hold the computation of fileContent in a Clean architecture ?

It can be interactor, if it is simple one line computation. But I prefer to introduce dedicated class for computation and introduce it as dependency. While tests will remain in interactor and dedicated computation class will be tested through interactor tests

Answer 2

One core aspect of Clean Architecture is that all application business logic is in Interactor methods. This means u also want to have ur major test focus on Interactors usually using unit tests and low level acceptance tests.

When designing ur Interactor methods u should still follow SRP: there should be only one reason to change. U can also combine Interactors to follow SRP.

If the computation of the file content is application business logic for u it should be in an Interactor method.

For a more detailed discussion about Interactors pls have a look at my post: https://plainionist.github.io/Implementing-Clean-Architecture-UseCases/