Add a FakeItEasy.FSharp package

Spun off from https://github.com/FakeItEasy/FakeItEasy/issues/229#issuecomment-31921208

Will include similar extensions to http://trelford.com/blog/post/MoqEx.aspx

More examples:

//C#
A.CallTo(() => comparer.Compare(
    A<string>._,
    A<string>.That.Matches(s => s == "must be equal to this"))).Returns(-1);

//F#
A.CallTo(fun () -> comparer.Compare(ignored(), is((=) "must be equal to this"))).Returns(-1)

//C#
A.CallTo(() => factory.Create()).Returns(A.Fake<IWidget>());

//F#
A.CallTo(fun () -> factory.Create()).Returns(fake())

We should add a FakeItEasy.FSharp project to FakeItEasy.sln and ensure it gets built, packaged and released along with the other projects.

As for testing, an acceptance test project is probably enough. I don’t think unit tests would add much value.

The test project layout and naming convention is a little messy right now. What is under the Integration Tests solution folder right now is generally anything that is not unit tests. Perhaps the test project should be Integration Tests\FakeItEasy.FSharp.Tests.Acceptance.

I’ve no idea what test framework would be suitable for F#. Currently we use NUnit (which we’re considering replacing with xunit.net) and MSpec.

[thomaslevesque]

Alternative implementation, a bit more complete, and more idiomatic:

open FakeItEasy
open FakeItEasy.Configuration
open Microsoft.FSharp.Linq.RuntimeHelpers

module FakeItEasyFSharp =

    let private toExpression (quotation : Quotations.Expr<'a>) =
        let body = LeafExpressionConverter.QuotationToExpression quotation
        Expression.Lambda<Func<'a>>(body)

    let private toVoidExpression (quotation : Quotations.Expr) =
        let body = LeafExpressionConverter.QuotationToExpression quotation
        Expression.Lambda<Action>(body)

    let fake<'a>() = A.Fake<'a>()

    let aCallTo (quotation: Quotations.Expr<'a>) = A.CallTo(toExpression quotation)
    let aCallToVoid (quotation: Quotations.Expr) = A.CallTo(toVoidExpression quotation)
    let anyCallTo(fake: Object) = A.CallTo(fake)

    let ignored<'a>() = A<'a>.Ignored
    let is<'a> f = A<'a>.That.Matches(fun x -> f x)
    
    let returns (value:'a) (configuration: IReturnValueConfiguration<'a>) = configuration.Returns(value)
    let throws (ex: Exception) (configuration: IExceptionThrowerConfiguration<'a>) = configuration.Throws(ex)
    let doesNothing (configuration: IDoNothingConfiguration<'a>) = configuration.DoesNothing()
    let invokes (callback: (unit -> unit)) (configuration: ICallbackConfiguration<'a>) = configuration.Invokes(fun () -> callback())

Usage:

open FakeItEasyFSharp
#nowarn "20"

type IFoo =
    abstract Bar : unit -> unit
    abstract Baz : string -> int

type IFooFactory =
    abstract Create : unit -> IFoo

let comparer = A.Fake<IComparer<string>>()
aCallTo <@ comparer.Compare(ignored(), is((=) "foo")) @> |> returns -1
aCallToVoid <@ comparer.ToString() @> |> throws (Exception("oops"))

let factory = A.Fake<IFooFactory>()
let foo = fake()
aCallTo <@ factory.Create() @> |> returns(foo)
anyCallTo foo |> throws (NotImplementedException())
aCallToVoid <@ foo.Bar() @> |> invokes (fun () -> printfn "hello")

[thomaslevesque]

OK, apparently my approach isn’t perfect yet… A.CallTo(<@ foo.VoidMethod() @>) still picks the overload with Quotations.Expr<'a> (where 'a is unit; F# doesn’t really have the notion of void). So we would need a method with a different name for configuring void methods, which is annoying… In this case, there’s no real point in using methods rather than functions, since the whole point was to allow overloads.