Wie kann ich Leerzeichen in einem Moq VerifySet()-Ausdruck ignorieren?

Question

Ich möchte überprüfen, ob eine Zeichenfolge auf einen bestimmten Wert in einem Moq-Objekt gesetzt wird.

Ich habe eine kleine Konsolenanwendung erstellt, um zu simulieren, was ich tun möchte.

using System;
using Moq;

namespace MoqVerifySet
{
    public interface MyInterface
    {
        string MyValue { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Mock<MyInterface> mockMyInterface = new Mock<MyInterface>();
            var myI = mockMyInterface.Object;
            myI.MyValue = @"hello 
                            world.
                            Please ignore
                            the whitespace";

            try
            {
                mockMyInterface.VerifySet(i => i.MyValue = "hello world. Please ignore the whitespace");
                Console.WriteLine("Success");
            }
            catch(Exception ex)
            {
                Console.WriteLine("Error : {0}", ex.Message);
            }

            Console.WriteLine("\n\nPress any key to exit...");
            Console.ReadKey();
        }
    }
}

Also dachte ich, ich könnte einfach eine kleine Methode entwickeln

public static string PrepSqlForComparison(string sql)
{
    Regex re = new Regex(@"\s+");
    return re.Replace(sql, " ").Trim().ToLower();
}

Und Veränderung

mockMyInterface.VerifySet(i => i.MyValue = "hello world. Please ignore the whitespace");

zu

mockMyInterface.VerifySet(i => PrepSqlForComparison(i.MyValue) = "hello world. Please ignore the whitespace");

Das lässt sich jedoch nicht kompilieren, da der Operator in dem Ausdruck eine Zuweisung und kein Gleichheitszeichen ist.

Wenn ich es also nicht auf diese Weise machen kann, wie kann ich es dann überprüfen, ohne Groß- und Kleinschreibung, Leerzeichen und andere Formatierungen zu berücksichtigen?

Answer 1

Wenn Sie die Funktionalität von VerifySet nicht benötigen (wenn Sie sich nur für den zuletzt gesetzten Wert interessieren), können Sie die MyValue-Eigenschaft in Ihrem Mock-Objekt so einrichten, dass der zuletzt gesetzte Wert einfach durch einen Aufruf zurückgesendet wird:

mockMyInterface.SetupProperty(f => f.MyValue);

Dann könnten Sie eine Vergleichs-/Gleichheitsprüfung durchführen, die die Leerzeichen und Zeilenumbrüche ignoriert. Ich habe einen benutzerdefinierten StringComparer erstellt, um diese Logik in meinem Test zu kapseln:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

namespace MoqVerifySet
{
public interface MyInterface
{
    string MyValue { get; set; }
}

internal class Program
{
    private static void Main(string[] args)
    {
        var mockMyInterface = new Mock<MyInterface>();
        mockMyInterface.SetupProperty(f => f.MyValue);

        MyInterface myI = mockMyInterface.Object;
        myI.MyValue = @"hello 
                        world.
                        Please ignore
                        the whitespace";
        try
        {
            var comparer = new CompareWithoutWhitespace(StringComparison.CurrentCultureIgnoreCase);
            Assert.IsTrue(comparer.Equals(myI.MyValue, "hello world. Please ignore the whitespace"));
            Console.WriteLine("Success");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error : {0}", ex.Message);
        }

        Console.WriteLine("\n\nPress any key to exit...");
        Console.ReadKey();
    }
}

internal class CompareWithoutWhitespace : StringComparer
{
    private readonly StringComparison _stringComparison;

    public CompareWithoutWhitespace(StringComparison stringComparison)
    {
        _stringComparison = stringComparison;
    }

    public override int Compare(string x, string y)
    {
        return String.Compare(RemoveWhitespace(x), RemoveWhitespace(y), _stringComparison);
    }

    public override bool Equals(string x, string y)
    {
        return String.Equals(RemoveWhitespace(x), RemoveWhitespace(y), _stringComparison);
    }

    public override int GetHashCode(string obj)
    {
        return RemoveWhitespace(obj).GetHashCode();
    }

    private static string RemoveWhitespace(string input)
    {
        if (string.IsNullOrEmpty(input)) return input;
        input = input.Replace(Environment.NewLine, "");
        return input.Replace(" ", "");
    }
}
}

Answer 2

Ihr Whitespace Problem ist nichts mit Mock zu tun, Ihre myI.MyValue ist mit einem wortwörtliches String-Wort .

Die Linie:

myI.MyValue = @"hello world.
                Please ignore
                the whitespace";

Beachten Sie den gesamten Leerraum links vom ersten Buchstaben der letzten beiden Zeilen. Ist gleichbedeutend mit dem Schreiben:

myI.MyValue = @"hello world.                            Please ignore                            the whitespace";