Chained assertion methods to check file result

[robdmoore]

Note: this is a "Jump In" issue, which means it's suitable for people that want to contribute to the project, but aren't confident with the codebase yet. See the TestStack contribution page for details. If you get stuck then feel free to add a comment and one of the TestStack contributors will help guide you! Good luck :)

Add assertions after the .WithCallTo(...) extension to check for the various file results.

I wouldn't expect this issue to be done in one go - maybe a PR per each one or two of the following.

In terms of implementation: you want to put this stuff in the ControllerResultTest class and similarly add unit tests to the ControllerResultTestShould class. Note the test class has data-driven tests for checking the return type checks by adding lines to the ReturnTypes field in the "Test cases" region.

Check for result type being FileResult

note this is a breaking change (because the current method checks for and returns FileContentResult) and would need to be added to a BREAKING_CHANGES.md file (example: from Seleno)

_controller.WithCallTo(c => c.Index())
    .ShouldRenderFile();

Check for result type being FileResult and content type being "text/plain"

note this is a breaking change (because the current method checks for and returns FileContentResult) and would need to be added to a BREAKING_CHANGES.md file (example: from Seleno)

const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFile(expectedContentType);

Check for result type being FileContentResult

_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileContents();

Check for result type being FileContentResult and the content matching

const string expectedContent = "asdf";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileContents(expectedContent);

var expectedContent = new byte[]{1,2,3};
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileContents(expectedContent);

Check for result type being FileContentResult and the content matching and the content type matching

const string expectedContent = "asdf";
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileContents(expectedContent, expectedContentType);

var expectedContent = new byte[]{1,2,3};
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileContents(expectedContent, expectedContentType);

Check for result type being FileStreamResult

_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream();

Check for result type being FileStreamResult and the stream matching

var expectedStream = new MemoryStream();
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedStream);

Check for result type being FileStreamResult and the stream matching and the content type matching

var expectedStream = new MemoryStream();
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedStream, expectedContentType);

Check for result type being FileStreamResult and the stream contents matching

const string expectedContent = "asdf";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedContent);

var expectedContent = new byte[]{1,2,3};
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedContent);

Check for result type being FileStreamResult and the stream contents matching and the content type matching

var expectedContent = "asdf";
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedContent, expectedContentType);

var expectedContent = new byte[]{1,2,3};
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFileStream(expectedContent, expectedContentType);

Check for result type being FilePathResult

_controller.WithCallTo(c => c.Index())
    .ShouldRenderFilePath();

Check for result type being FilePathResult and file path matching

const string expectedFilePath;
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFilePath(expectedFilePath);

Check for result type being FilePathResult and file path matching and the content type matching

const string expectedFilePath;
const string expectedContentType = "text/plain";
...
_controller.WithCallTo(c => c.Index())
    .ShouldRenderFilePath(expectedFilePath, expectedContentType);

[AlexArchive]

Please let me know if I understand you correctly.

The existing method ShouldRenderFile checks for a FileContentResult. You want to change this method to check for an abstract FileResult instead (and consequently introduce a breaking change.)

You want to re-enable the developer to test for a FileContentResult by introducing a new controller result test: ShouldRenderFileContents.

Thanks.

Oh and by the way, would it be reasonable for me to introduce a #region for the file controller result tests and their respective unit tests:?

[robdmoore]

I've been reevaluating my thinking on that.

You can't check for the actual file contents without knowing the type of FileResult. I'm thinking instead of the breaking change we have a:

.ShouldRenderAnyFile(string contentType = null)

What do you think?

Makes sense re: regions. I actually hate regions (as per http://www.richard-banks.org/2011/02/anti-region-campaign.html), but I did this project a long time ago so they are here.

[AlexArchive]

Sounds good.

I will work on these updates shortly.

[AlexArchive]

I feel as though now that I have implemented ShouldRenderAnyFile it will be reasonable to rename ShouldRenderFile to ShouldRenderFileContents as per this specification. Before I can submit a pull request however, I need to add support to compare the contents of two FileContentResults and I have a couple of questions regarding that.

According to your code listing, the ShouldRenderFileContents method ought to accept an argument called expectedContent of type string:

const string expectedContent = "asdf";
...
_controller.WithCallTo(c => c.Index())
           .ShouldRenderFileContents(expectedContent);

This is confusing to me because it would appear as though FileContentResult can only contain a byte array. Should I test for a byte array instead or am I missing something?

var expectedContent = new byte[] { 0x00, 0x01, 0x02  };
...
_controller.WithCallTo(c => c.Index())
           .ShouldRenderFileContents(expectedContent);

(I suppose I could use Enumerable.SequenceEquals internally for this.)

Thanks Rob.

[robdmoore]

What I'd do is keep the existing ShouldRenderFile method, but mark it Obsolete with the [Obsolete] attribute (don't trigger a compile error, still allow them to use it for now) with a message telling them to use ShouldRenderFileContents instead.

That way we avoid the breaking change, but give ourselves the flexibility of reusing ShouldRenderFile later (with a major version bump).

I'd say that we allow a byte[] and a string (in separate overloads) - we can use UTFEncoding.UTF8 to convert the bytes to a string for comparison. What do you think?

[robdmoore]

FYI I just published the latest to NuGet. Thanks for the work so far @byteblast!

[AlexArchive]

I can definitely see how the string overload would be a nicety but I must say, it feels somewhat brittle to me for reasons that I cannot articulate very well - perhaps because I do not know what I am talking about 😛

Imagine the controller uses an encoding other than UTF8, might it cause confusion if the test fails even though the string contents are the same?

public class Controller
{
    public FileContentResult Index()
    {
        var contents = Encoding.BigEndianUnicode.GetBytes("{status: true}");
        return new FileContentResult(contents, "application/json");
    }
}

public class ControllerTest
{
    static void Main(string[] args)
    {
        var controller = new Controller();
        var expected = Encoding.UTF8.GetBytes("{status: true}");
        var actual = controller.Index().FileContents;

         // The *string* content is the same but this assertion fails. Could this be confusing? 
         Assert.True(expected.SequenceEqual(actual));
    }
}

[robdmoore]

Good point. How about we have this:

    ShouldRenderFileContents(string contents, Encoding encoding = null)

And if encoding is null it assumes UTF8