philippdolder · August 29, 2015 14:17 · dennisdoomen · Mar 24, 2015 · dennisdoomen · Mar 24, 2015
diff --git a/all my code.cs b/all my code.cs
 namespace Project1
 {
    using System.Collections;
    using System.Collections.Generic;

    using FluentAssertions;
    using FluentAssertions.Execution;
    using FluentAssertions.Primitives;

    public static class MyOwnAssertionsExtensions
    {
        public static MyOwnAssertions Should(this MyType subject)
        {
            return new MyOwnAssertions(subject);
        }
    }

    public class MyOwnAssertions : ReferenceTypeAssertions<MyType, MyOwnAssertions>
    {
        public MyOwnAssertions(MyType subject)
        {
            this.Subject = subject;
        }

        protected override string Context
        {
            get
            {
                return "mytype";
            }
        }

        public AndConstraint<MyOwnAssertions> ContainMagic()
        {
            // I have some additional asserts 
            Execute.Assertion
                .ForCondition(this.Subject.ContainsMagicString())
                .FailWith("No, there's no magic here");

            return new AndConstraint<MyOwnAssertions>(this);
        }

        public AndConstraint<MyOwnAssertions> Contain(string expected)
        {
            // and like to use some of the already existing ones.
            // I know there is a 
            // public AndWhichConstraint<TAssertions, T> Contain(T expected, string because = "", params object[] reasonArgs)
            // implementation in the GenericCollectionAssertions.
            // And I try to just refer it to that method with something like. But this leads to a endless recursive loop, because it uses my own Contain() implementation of course.
            this.Subject.Should().Contain(expected);

            // this line does the job. But is it how I should do it? Not sure if I miss something.
            this.Subject.As<IEnumerable<string>>().Should().Contain(expected);

            return new AndConstraint<MyOwnAssertions>(this);
        }
    }

    public class MyType : IEnumerable<string>
    {
        private const string Magic = "It's a kind of magic!";

        private readonly List<string> strings;

        public MyType()
        {
            this.strings = new List<string>();
        }

        public bool ContainsMagicString()
        {
            return this.strings.Contains(Magic);
        }

        public void AddString(string someText)
        {
            this.strings.Add(someText);
        }

        public void AddMagicString()
        {
            this.strings.Add(Magic);
        }

        public IEnumerator<string> GetEnumerator()
        {
            return this.strings.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
 }
diff --git a/ExtensionMethodApproach.cs b/ExtensionMethodApproach.cs
    public static class MyCollectionAssertionExtensions
    {
        public static AndConstraint<StringCollectionAssertions> ContainMagic(this StringCollectionAssertions assertions)
        {
            Execute.Assertion
                .ForCondition(assertions.Subject.As<MyType>().ContainsMagicString())
                .FailWith("No, there's no magic");

            return new AndConstraint<StringCollectionAssertions>(assertions);
        }
    }
	namespace Project1
	{
	using System.Collections;
	using System.Collections.Generic;

	using FluentAssertions;
	using FluentAssertions.Execution;
	using FluentAssertions.Primitives;

	public static class MyOwnAssertionsExtensions
	{
	public static MyOwnAssertions Should(this MyType subject)
	{
	return new MyOwnAssertions(subject);
	}
	}

	public class MyOwnAssertions : ReferenceTypeAssertions<MyType, MyOwnAssertions>
	{
	public MyOwnAssertions(MyType subject)
	{
	this.Subject = subject;
	}

	protected override string Context
	{
	get
	{
	return "mytype";
	}
	}

	public AndConstraint<MyOwnAssertions> ContainMagic()
	{
	// I have some additional asserts
	Execute.Assertion
	.ForCondition(this.Subject.ContainsMagicString())
	.FailWith("No, there's no magic here");

	return new AndConstraint<MyOwnAssertions>(this);
	}

	public AndConstraint<MyOwnAssertions> Contain(string expected)
	{
	// and like to use some of the already existing ones.
	// I know there is a
	// public AndWhichConstraint<TAssertions, T> Contain(T expected, string because = "", params object[] reasonArgs)
	// implementation in the GenericCollectionAssertions.
	// And I try to just refer it to that method with something like. But this leads to a endless recursive loop, because it uses my own Contain() implementation of course.
	this.Subject.Should().Contain(expected);

	// this line does the job. But is it how I should do it? Not sure if I miss something.
	this.Subject.As<IEnumerable<string>>().Should().Contain(expected);

	return new AndConstraint<MyOwnAssertions>(this);
	}
	}

	public class MyType : IEnumerable<string>
	{
	private const string Magic = "It's a kind of magic!";

	private readonly List<string> strings;

	public MyType()
	{
	this.strings = new List<string>();
	}

	public bool ContainsMagicString()
	{
	return this.strings.Contains(Magic);
	}

	public void AddString(string someText)
	{
	this.strings.Add(someText);
	}

	public void AddMagicString()
	{
	this.strings.Add(Magic);
	}

	public IEnumerator<string> GetEnumerator()
	{
	return this.strings.GetEnumerator();
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
	return this.GetEnumerator();
	}
	}
	}
	public static class MyCollectionAssertionExtensions
	{
	public static AndConstraint<StringCollectionAssertions> ContainMagic(this StringCollectionAssertions assertions)
	{
	Execute.Assertion
	.ForCondition(assertions.Subject.As<MyType>().ContainsMagicString())
	.FailWith("No, there's no magic");

	return new AndConstraint<StringCollectionAssertions>(assertions);
	}
	}