should Discussions Rss Feed

New Post: New Release and Nuget package?

erichexter — Wed, 23 May 2012 18:27:59 GMT

I filled out their form and they are going to hook up the CI off of the current nant build.. once we get it working we can conver that old build to something newer.

The source is now on github.com/erichexter/should feel free to submit pull requests.

New Post: New Release and Nuget package?

mikeobrien — Tue, 22 May 2012 14:49:21 GMT

Perfect, I'll get on it.

I'm not sure what version they are running, I'll check it out.

New Post: New Release and Nuget package?

erichexter — Tue, 22 May 2012 14:34:07 GMT

yes.. I think I would like to publish the ci to a myfeed feed and then just publish releases to the public nuget.. i assume the codebetter server is using TC 7? so the nuget setup is super easy.

New Post: New Release and Nuget package?

mikeobrien — Tue, 22 May 2012 14:23:06 GMT

Awesome! You still interested in getting an automated build/deploy going? If so I can get a script written and get eveything setup on the code better CI server.

New Post: IHideObjectMembers

erichexter — Tue, 22 May 2012 14:15:05 GMT

I think that is a great idea.. we do take pull requests.. i

New Post: New Release and Nuget package?

erichexter — Tue, 22 May 2012 14:13:19 GMT

With the release of Github for Windows.. I talked it over with Tim and we are willing to move to github. I will apply the current pull requests and we can get this thing moved.

New Post: New Release and Nuget package?

taylonr — Sat, 19 May 2012 20:48:56 GMT

I second Mike. I had a similar thought.

New Post: New Release and Nuget package?

mikeobrien — Sun, 06 May 2012 17:00:57 GMT

erichexter wrote:
I can put together a new release on nuget... It is easier for me to just script out the nuget push in our ci server than to manually update the releases on the codeplex project. I have so many OSS projects going right now, I am running out of bandwidth to keep it all going.

That being said, if someone would like to act as a release manager for this project, I would certainly appreciate the help!

What would you think about moving the source to github and we could setup an automated build (And nuget push) on the codebetter CI? I'd be willing to handle this if it's ok w/ you.

New Post: Review after playing with it for a while

Vaccano — Fri, 14 Oct 2011 18:53:23 GMT

This library is great. I really like that I don't have to type open and close parens () for every part of the assertion.

One thing that is missing is that the "Error Message" needs to be more brief when an assertion fails. For example: this is a current error message:

   Test method IntegrationTests.IntegrationOrderTests.SaveNewOrders_NormalOrders_NoErrors threw exception:
   Should.Core.Exceptions.EqualException: Assert.Equal() Failure
   Expected: 1
   Actual:   2

I know what method failed already. What I really want to see in the Error Message is this:

Expected: 1 Actual: 2

That way I don't have to open up the results of every test that failed to see that the assertion failed.

New Post: New Release and Nuget package?

jesuissur — Fri, 03 Jun 2011 15:14:05 GMT

Would not be best to join efforts under the FluentAssertions library (http://fluentassertions.codeplex.com)? Should assertion library and FluentAssertions seems to have the same goal and a similar syntax.

There's also frequent updates. It may not be as clean as the source code of the should library but it could relieve you of one project and all the release process.

And the community would certainly benefit of your contribution on this project.

Phil

New Post: New Release and Nuget package?

erichexter — Mon, 07 Mar 2011 14:44:08 GMT

I can put together a new release on nuget... It is easier for me to just script out the nuget push in our ci server than to manually update the releases on the codeplex project. I have so many OSS projects going right now, I am running out of bandwidth to keep it all going.

That being said, if someone would like to act as a release manager for this project, I would certainly appreciate the help!

New Post: New Release and Nuget package?

chaliy — Mon, 07 Mar 2011 14:39:39 GMT

+1 to Mike's question. I decided to use to ShouldFluent, but there is no between (IncludedIn) assertion for datetime. With new model ( IBe<DateTime>) its very easy to write. But this new model is not included to v12.

New Post: New Release and Nuget package?

mikeobrien — Mon, 28 Feb 2011 23:26:03 GMT

Any plans on doing a release? There are some goodies added since the last release that look mighty tasty (e.g Greater/Less/OrEqual/Than, ShouldBeType<T>, etc).

Thanks,

New Post: ShouldBeThrownBy

CodeMonkeyKing — Mon, 17 Jan 2011 23:48:58 GMT

Mel,

A simple extension method for an Action will give you the syntax that you want (it's not the lambda's that cause the problem other than the ()=> thingamajig)

    public static class ShouldExtensions
    {
        public static ShouldThrow Should(this Action action)
        {
            return new ShouldThrow(action);
        }
    }

when combining this with the ShouldThrow class:

    public class ShouldThrow : ShouldBase<ShouldThrow, Action, BeAction>
    {
        private readonly Action _action;

        public ShouldThrow(Action target) 
            : base(target, ShouldExtensions.AssertProvider)
        {
            _action = target;
        }

        public Action Action
        {
            get { return _action; }
        }

        public Exception Throw()
        {
            return Be.Throwing<Exception>();
        }

        public TEx Throw<TEx>()
            where TEx : Exception
        {
            return Be.Throwing<TEx>();
        }

        public TEx ThrowBaseOf<TEx>()
            where TEx : Exception
        {
            return Be.ThrowingBaseOf<TEx>();
        }

        public Exception ThrowBaseOf(Type type)
        {
            return Be.ThrowingBaseOf(type);
        }

        public new ShouldThrow Not
        {
            get { 
                Negate = !Negate;
                return this;
            }
        }

        internal bool Negate { get; set; }

    }

and of course the BeAction (I wasn't sure what to call that!)
    public class BeAction
    {
        private readonly ShouldThrow _should;

        public BeAction(ShouldThrow should, IAssertProvider assertProvider)
        {
            _should = should;
        }

        public Exception Throwing()
        {
            return ThrowingInternal<Exception>(ex => ex, MatchAnything);
        }

        public TEx Throwing<TEx>()
            where TEx : Exception
        {
            return ThrowingInternal<TEx>(
                ex => ex,
                ex => typeof(TEx).Equals(ex.GetType()));
        }

        public Exception Throwing(Type exceptionType)
        {
            return ThrowingInternal<Exception>(ex => ex, 
                ex => exceptionType.Equals(ex.GetType()));
        }

        public TEx ThrowingBaseOf<TEx>()
            where TEx : Exception
        {
            return ThrowingInternal<TEx>(
                ex => ex.GetBaseException(),
                ex => typeof(TEx).Equals(ex.GetBaseException().GetType()));
        }

        public Exception ThrowingBaseOf(Type exceptionType)
        {
            return ThrowingInternal<Exception>(ex => ex,
                ex => exceptionType.Equals(ex.GetBaseException().GetType()));
        }

        private static bool MatchAnything(Exception ex)
        {
            return true;
        }

        private TEx ThrowingInternal<TEx>(Func<Exception, Exception> exceptionGetter, Predicate<Exception> exceptionMatcher)
            where TEx : Exception
        {
            var actual = exceptionGetter(RecordException(_should.Action));

            if (_should.Negate)
            {
                if (actual != null)
                {
                    throw new DoesNotThrowException(actual);
                }

                return null;
            }

            if (actual == null)
            {
                throw new ThrowsException(typeof(TEx));
            }

            if (!exceptionMatcher(actual))
            {
                throw new ThrowsException(typeof(TEx), actual);
            }

            return (TEx)actual;
        }

        private static Exception RecordException(Action action)
        {
            try
            {
                action.Invoke();
                return null;
            }
            catch (Exception ex)
            {
                return ex;
            }
        }
    }

NOTE - I didn't put this into a branch as I wasn't sure where the new code base was going. All of this is working nicely for me. 
Also, note that the Executing.This() utility class just makes it easier to consume a lambda expression and convert it (without the ugly casting or temporary Action variable).
    public static class Executing
    {
        public static Action This(Action action)
        {
            return action;
        }
    }

With all of that combined you can have code like this:
Executing.This( () => new ArgumentException() )
    .Should().Throw<ArgumentException>();

// alternatively...

Executing.This( () => new ArgumentException() )
    .Should().Be.Throwing<ArgumentException>();

New Post: ShouldBeThrownBy

MelGrubb — Mon, 17 Jan 2011 18:35:45 GMT

I tried for a while last night to build a decent fluent version of ShouldThrow, and I'm just not getting it. I ran into this same problem with the GreaterThan and LessThan stuff. I just don't GET fluent interfaces as well as I should. I mean, I know how to use them, but building them hurts my head. I know what I would like this to look like:

Action action = () => throw new ArgumentException();
action.Should().Throw<ArgumentException>();

That would be my ideal "fluent" version of the above, but getting there is proving to be a bit of a challenge. Since all the other "should"s hang off of Be, I would need to do something like what CodeMonkeyKing mentioned above (Should().Be.Throwing...) which I don't like at all. If the whole point of a fluent interface is to make things read like a sentence, then why would I want it to sound like a badly-translated one? So it seems to me that I would need to build a "Throw" class that would be a peer of "Be". Can anyone give me any advice on how to wrap my head around the fluent stuff? Alternately, would anyone care to collaborate on this one? I've got the plain old .ShouldThrow pretty much worked out. It's a grand total of TWO whole methods. The only thing I have to work on now is whether ShouldNotThrow even makes sense. Most of the other Shoulds have Nots, but here it just doesn't seem to make any sense. After all, testing whether code throws an exception is already there for free. You just test the method, and if nothing throws, then the test passes. Testing solely for the non-presence of a specific exception seems really sloppy to me.

MG2

New Post: ShouldBeThrownBy

CodeMonkeyKing — Fri, 14 Jan 2011 21:07:50 GMT

Mel,

That's great. You can also drop in this simple 'static factory' class. It isn't less typing but it does read better:

public static class Executing
{
    public static Action This(Action action)
    {
        return action;
    }
}

then your code will read Executing.This(() => ThrowingMethod()).ShouldThrows<ExpectedExceptionType>();

This was borrowed from the SharpTestEx project.

-- John

New Post: ShouldBeThrownBy

MelGrubb — Fri, 14 Jan 2011 18:32:32 GMT

Okay, I've got something that seems to be working now. It is most easily used in a test like this:

Action action = () => ThrowingMethod();
action.ShouldThrow<ExpectedExceptionType>();

You can try to inline the call, but it ends up pretty ugly once all the necessary casting is said and done.:

((Action)(() => ThrowingMethod())).ShouldThrow<ExpectedExceptionType>();

There's not really much to do about it that I can think of, other than to try to leave it in the two-line form. I'm not even sure where to start with creating a fluent version of this, but may give it a look when I get back home from CodeMash.

New Post: ShouldBeThrownBy

CodeMonkeyKing — Wed, 29 Dec 2010 07:21:01 GMT

Mel & Eric,

I came up with something similar - I wrote some extension methods to support the syntax of the fluent portion of the library. My sample looks nearly the same as yours, however, I didn't use the ThrowsDelegate, in it's place I dropped an 'Action' delegate.

[Fact]
public void IndexOfNullArray()
{
      string[] values = null;
      Action action = () => values.IndexOf("find me");
      action.Should().Be.Throwing<ArgumentNullException>();
}

Note that I also went with the '-ing' form of Throw<> as it seems to read cleaner when using the 'Be' part. Otherwise it would read: Should.Throw<ArgumentNullException>().

John

New Post: ShouldBeThrownBy

erichexter — Tue, 28 Dec 2010 11:46:27 GMT

I will take a look at it on thursday. I do not have access to a compiler before then.

sent from my mobile

On Dec 27, 2010 11:30 PM, "MelGrubb" <notifications@codeplex.com> wrote:
> From: MelGrubb
>
> I did some experimenting tonight, and while it's easy enough to define an extension against ThrowsDelegate...public static void ShouldThrow<T>(this Assert.ThrowsDelegate @delegate) where T : Exception{ Assert.Throws<T>(@delegate);}...the syntax for actually using it is less than awesome.Assert.ThrowsDelegate @delegate = () => ThrowMethod();@delegate.ShouldThrow<ArgumentException>();// Or as a single line((Assert.ThrowsDelegate)(() => ThrowMethod())).ShouldThrow<ArgumentException>();I just can't seem to make the syntax any better than this. Maybe someone with better delegate/expression/lambda-fu can jump in and show me a better way, but this is all I have been able to come up with so far. I could be overlooking something obvious. Anyone?
>
>

New Post: ShouldBeThrownBy

erichexter — Tue, 28 Dec 2010 11:45:07 GMT

sent from my mobile