Substitute With Property return and Collection with values with NSubstitute

Question

This is a IValidationResult interface

public interface IValidationResult
{
    ICollection<IValidationError> Errors { get; }
    bool IsValid { get; }

    IValidationResult Add(IValidationError error);
    IValidationResult Add(string errorMessage);
    IValidationResult Add(params IValidationResult[] validationResults);
    IValidationResult Remove(IValidationError error);
}

I have this test method

[TestMethod]
public async Task ServicoDeveRetornarFalseCasoHajaErroNaCriacaoDoObjeto()
{
    // arrange
    var validation = Substitute.For<IValidationResult>();
    validation.IsValid.Returns(false);
    _contratoFactory.Build(ContratoValues.ContratoComEmpresaNula).Returns(validation);

    // act
    var result = await _contratoService.Create(ContratoValues.ContratoComEmpresaNula);

    // assert
    result.Success.Should().BeFalse();
}

The "validation" substitute is a Mock of IValidationResult. This Interface implements a property called IsValid that returns false is another property, that is a Collection contains any item.

My test method must verify that when

_contratoFactory.Build(any) 

is called, it returns a IValidationResult that isn't valid.

Then, the result of _contratoService.Create(any) should be false.

My mock is not working.

How can I fix it?

UPDATE - Add Create Implementation

public override async Task<IServiceOperationResult> Create(Contrato entity)
{
    var result = new ServiceOperationResult();
    try
    {
        if (entity == null)
        {
            throw new ArgumentNullException(typeof(Contrato).Name);
        }

        var validation = _contratoFactory.Build(entity);
        result.Add(validation);

        if (!result.Success)
        {
            return result;
        }

        return await base.Create(entity);
    }
    catch (ArgumentNullException ex)
    {
        result.Add(ex);
    }
    catch (Exception ex)
    {
        result.Add(ex);
    }

    return result;
}

UPDATE - 20/05/2015

Here is the implementation of IServiceOperationResult

public class ServiceOperationResult : IServiceOperationResult
{
    public ServiceOperationResult()
    {
        Errors = new Dictionary<string, string>();   
    }

    public IDictionary<string, string> Errors { get; }

    public bool Success => !Errors.Any();

    public void Add(string errorMessage)
    {
        if (errorMessage == null || errorMessage.Trim().Length == 0)
        {
            return;
        }

        Errors.Add(Guid.NewGuid().ToString(), errorMessage);
    }

    public void Add(IValidationResult validationResult)
    {
        if (validationResult == null)
        {
            return;
        }

        foreach (var validationError in validationResult.Errors)
        {
            Add(validationError);
        }
    }

    public void Add(IValidationError validationError)
    {
        if (string.IsNullOrEmpty(validationError?.Message) || 
            string.IsNullOrWhiteSpace(validationError.Message))
        {
            return;
        }

        Errors.Add(Guid.NewGuid().ToString(), validationError.Message);
    }

    public void Add(Exception exception)
    {
        if (exception == null)
        {
            return;
        }
        Add($"{nameof(exception)} - {exception.Message}{Environment.NewLine} - {exception.StackTrace}");
    }
}

Answer 1

The problem seems to stem from ServiceOperationResult.Add(IValidationResult validationResult):

    public void Add(IValidationResult validationResult)
    {
        if (validationResult == null) { return; }

        foreach (var validationError in validationResult.Errors)
        {
            Add(validationError);
        }
    }

This is relying on the validationResult.Errors collection, but you have not stubbed this out.

If you modify the test to something like the following it should pass:

        // arrange
        var validation = Substitute.For<IValidationResult>();
        validation.IsValid.Returns(false);
        validation.Errors.Returns (new List<IValidationError> ());
        validation.Errors.Add (new ValidationError { Message = "sample error" });
        _contratoFactory.Build(ContratoValues.ContratoComEmpresaNula).Returns(validation);
        // act ...

However from what I can see in this case I would suggest not faking IValidationResult, but using a real one, as the implementation depends on the real behaviour of the implementation of this interface.

This would make the test more like:

        // arrange
        var validation = new ValidationResult>();
        validation.Errors.Add (new ValidationError { Message = "sample error" }); 
        // I'm guessing for the real class `validation.IsValid` will now return `false`
        _contratoFactory.Build(ContratoValues.ContratoComEmpresaNula).Returns(validation);
        //act...