fluentassertions Discussions Rss Feed

New Post: Comparing object equivalence for dictionaries

dennisdoomen — Fri, 10 May 2013 19:18:18 GMT

Hi Sarah,

Version 2.0 doesn't even really support dictionaries. It just compares the value pairs in order of appearance. In the upcoming version 2.1, I've added logic that tries to match the values with the same keys. However, what you ask is a bit more special. I don't think it should be core functionality, but in 2.1, you can add your own equivalency step that would do just that.

New Post: Comparing object equivalence for dictionaries

sarah99 — Thu, 09 May 2013 13:00:38 GMT

I've been using ShouldBeEquivalentTo() to compare 2 dictionaries, which works fine.

What I want to be do is check that the keys are the same, while the values can be within a range (say within 1 %) through the assertion options. Is this possible?

At the moment I'm doing the following (both dictionaries are sorted by key):

foreach (var o in actual)
{
    expectedValues.Should().ContainKey(o.Key);
    o.Value.Should().BeInRange(oo.Value*0.99, oo.Value*1.01);
}

Which works but doesn't look very elegant...

New Post: Support for C# Dynamics

sarah99 — Wed, 01 May 2013 08:43:15 GMT

You could try delcaring your test item as an object, that worked for me :) e.g. ((object)queryResult.Single().Value2).Should().NotBeNull

New Post: Bug: Optional parameters in .NET 3.5 build

dennisdoomen — Tue, 23 Apr 2013 14:52:15 GMT

Actually, you need Visual Studio 2010. Named and optional arguments is just syntactical sugar provided by the compiler and has nothing to do with the .NET Framework version.

New Post: Bug: Optional parameters in .NET 3.5 build

nengberg — Tue, 23 Apr 2013 14:44:42 GMT

Hi,

I'm working on a project that has target framework of .NET 3.5 and recently imported Fluent Assertions for that specific version. It seems that this build version uses optional parameters that are not supported in earlier versions of .NET than 4.0 I think this should be changed to overloads instead.

Anyone else that have been addressing this problem?

Regards
Niklas

New Post: Adding a method to measure how many times some text repeats within a string

EyalShilony — Wed, 10 Apr 2013 15:01:18 GMT

Well, overloading Contains seems like one way to do that or adding a new method such as Find?

int times = 3;
string text = "textX textY textZ";
text.Should().Find("text", times);

In addition, I think that it would be a good idea to include an overload that supports StringComparison.

New Post: Adding a method to measure how many times some text repeats within a string

dennisdoomen — Wed, 10 Apr 2013 13:51:02 GMT

Thanks for the suggestion.

Could you provide us with the suggested syntax?

New Post: Adding a method to measure how many times some text repeats within a string

EyalShilony — Wed, 10 Apr 2013 13:36:15 GMT

Hello,

I want to measure how many times some text repeats within a string so I'd really love to have additional method that does that.

Here is an example.

int times = 1;
string text = "Some text that should not contain repetitions";

text.Should().Contains("text", times);

Thank you for your hard work.

New Post: Exception in Excluding from nested property.

d3nver — Wed, 27 Mar 2013 11:12:26 GMT

dennisdoomen wrote:

Then you need the other overload and use the string-representation of the PropertyPath property on ISubjectInfo.

You can a sample please?
Thanks.

New Post: Exception in Excluding from nested property.

dennisdoomen — Wed, 27 Mar 2013 10:34:06 GMT

Then you need the other overload and use the string-representation of the PropertyPath property on ISubjectInfo.

New Post: Exception in Excluding from nested property.

d3nver — Wed, 27 Mar 2013 09:14:26 GMT

dennisdoomen wrote:

I think using an Expression with an indexer only works if the collection is an array. You should use the overload that takes a Func<ISubjectInfo, bool>() to compare the property path against "Products[0].Status".

Big Thanks!!!

Yes
I wrote:

public class Order
    {
        public Int32 Id { get; set; }
        public Product[] Products { get; set; }
    }

~~~~~~~
[Test]
~~~
order2.ShouldBeEquivalentTo(order1, options => options.Excluding(o => o.Products[0].Status).Excluding(o => o.Products[1].Status));

And test is success.
With List<Product> don't working :( May can used List<T> ?

private List<Product> _product;
public Product[] Products 
{
   get{ return _product.ToArray(); }
}

is bad option.

And second question:
How can exclude property Status from class Product for all elements of array?
Thanks.

New Post: Exception in Excluding from nested property.

dennisdoomen — Tue, 26 Mar 2013 19:53:11 GMT

I think using an Expression with an indexer only works if the collection is an array. You should use the overload that takes a Func<ISubjectInfo, bool>() to compare the property path against "Products[0].Status".

New Post: Exception in Excluding from nested property.

d3nver — Tue, 26 Mar 2013 15:48:33 GMT

hi
I tried exclude from test one property how writing in Docs:

orderDto.ShouldBeEquivalentTo(order, options => options.Excluding(o => o.Products[1].Status));

My classes:

public class Product
    {
        public String name { get; set; }
        public Int32 Status { get; set; }
    }
public class Order
    {
        public Int32 Id { get; set; }
        public List<Product> Products { get; set; }
    }

My test:

[Test]
        public void test()
        {
            Order order1 = new Order();
            order1.Products = new List<Product>();
            order1.Products.Add(new Product());
            order1.Products.Add(new Product());

            Order order2 = new Order();
            order2.Products = new List<Product>();
            order2.Products.Add(new Product());
            order2.Products.Add(new Product());

            order2.ShouldBeEquivalentTo(order1, options =>options.Excluding(o => o.Products[0].Status)); 
        }

But Test Failed with:
System.ArgumentException : Expression {Convert(o.Products.get_Item(0).Status)} is not a valid property expression
if i write:

order2.ShouldBeEquivalentTo(order1, options =>options.Excluding(o => o.Products[0]));

Test failed with:
System.ArgumentException : Expression {o.Products.get_Item(0)} is not a valid property expression

When i write:

order2.ShouldBeEquivalentTo(order1, options =>options.Excluding(o => o.Products));

Test is success.

What am I doing wrong?
Thanks.

New Post: Why so many negation methods?

EyalShilony — Sun, 24 Mar 2013 05:24:05 GMT

Yeah you can either do it.Should().Not().BeWhatever() or it.ShouldNot().BeWhatever(), obviously there are few options here but instead of introducing a breaking change, I'd imagine you can create the functionality without breaking anything and let people the time they need to adapt it.

Well, it might not save you time but it will streamline the APIs and make it easier to work with because ShouldNot() (or Should().Not()) and Should() will look exactly the same and it may simplify a thing or two in the design itself.

New Post: Mappings in object graph comparisons

dennisdoomen — Fri, 15 Mar 2013 14:24:00 GMT

Cool!

New Post: Mappings in object graph comparisons

reitzmichnicht — Fri, 15 Mar 2013 14:21:13 GMT

Hi

I have written an extension for property mapping that can be used like this:

result.ShouldBeEquivalentTo(expected, opt => opt.Mapping<YType>(x => x.Foo, y => y.Bar));

    public class EquivalencyAssertionOptions<TSubject>
    {
        public EquivalencyAssertionOptions<TSubject> Mapping<TMatch>(
            Expression<Func<TSubject, object>> propertyFromExpression, Expression<Func<TMatch, object>> propertyToExpression)
        {
            this.Using(new MatchByMappingRule(ExpressionExtensions.GetPropertyPath(propertyFromExpression), ExpressionExtensions.GetPropertyPath(propertyToExpression)));
            return this;
        }
    }
    
    public class MatchByMappingRule : IMatchingRule
    {
        private readonly string _propertyPathSubject;

        private readonly string _propertyPathExpectation;

        public MatchByMappingRule(string propertyPathSubject, string propertyPathExpectation)
        {
            _propertyPathSubject = propertyPathSubject;
            _propertyPathExpectation = propertyPathExpectation;
        }

        public PropertyInfo Match(PropertyInfo subjectProperty, object expectation, string propertyPath)
        {
            if (subjectProperty.Name.Equals(_propertyPathSubject))
            {
                return expectation.GetType().GetProperty(_propertyPathExpectation);
            }

            return null;
        }

        public override string ToString()
        {
            return string.Format("Mapping property {0} to {1}", _propertyPathSubject, _propertyPathExpectation);
        }
    }

But I like the proposed syntax more :)
.Where(dto => dto.Product.ManufacturerName).ShouldMapTo(o => o.Product.Manufacturer.Name)

New Post: Why does Should().ContainSingle() accept predicate mandatory

dennisdoomen — Wed, 13 Mar 2013 19:33:41 GMT

I'm not sure. We started with the idea of chaining. But since then we've run in so many compiler limitations that we're not sure anymore if the entire .And. construct is still useful.

New Post: Why does Should().ContainSingle() accept predicate mandatory

abatishchev — Wed, 13 Mar 2013 19:31:10 GMT

Would you agree to add an overload to mimic LINQ behavior?

And don't you have any plans in addition toAnd add something like AndSubject to switch from original target under assertion to underlying/new? Like in my 2nd question.

Thanks.

New Post: Why doesn't NotBeSameAs() work with GenericCollectionAssertions?

dennisdoomen — Wed, 13 Mar 2013 18:50:00 GMT

Ah, I understand now. Since your subject-under-test is an IEnumerable<T>, it will use the GenericCollectionAssertions rather than the ObjectAssertions. And that is missing the (Not)BeSameAs(). You can work around that by casting your collection object first.

New Post: Why does Should().ContainSingle() accept predicate mandatory

dennisdoomen — Wed, 13 Mar 2013 18:45:30 GMT

Regarding your first question, you're correct. HaveCount() is the only option right now.

Regarding your 2nd question, that's by design. Chaining essentially applies to the original type of the subject.