In che modo i linguaggi funzionali gestiscono una situazione di scherno quando si utilizza la progettazione basata sull'interfaccia?

Tipicamente in C # uso l'injection dependance per aiutare con il mocking;

public void UserService
{
  public UserService(IUserQuery userQuery, IUserCommunicator userCommunicator, IUserValidator userValidator)
  {
    UserQuery = userQuery;
    UserValidator = userValidator;
    UserCommunicator = userCommunicator;
  }

  ...

  public UserResponseModel UpdateAUserName(int userId, string userName)
  {
     var result = UserValidator.ValidateUserName(userName)
     if(result.Success)
     {
       var user = UserQuery.GetUserById(userId);
       if(user == null)
       {
          throw new ArgumentException();
          user.UserName = userName;
          UserCommunicator.UpdateUser(user);
       }
     }
     ...
  }

  ...
}

public class WhenGettingAUser
{
  public void AndTheUserDoesNotExistThrowAnException()
  {
     var userQuery = Substitute.For<IUserQuery>();
     userQuery.GetUserById(Arg.Any<int>).Returns(null);
     var userService = new UserService(userQuery);
     AssertionExtensions.ShouldThrow<ArgumentException>(() => userService.GetUserById(-121));
  }
}

Ora in qualcosa di simile a F #: se non scendo il percorso ibrido, come potrei testare situazioni di workflow come sopra che normalmente toccherebbero il livello di persistenza senza usare Interfaces / Mocks?

Mi rendo conto che ogni passo sopra sarebbe stato testato da solo e sarebbe stato il più atomico possibile. Il problema è che a un certo punto devono essere tutti chiamati in linea, e voglio assicurarmi che tutto venga chiamato correttamente.