c# - EntityFunctions.AddDays 関数を含む GetNewValues() を単体テストする方法

Question

以下のサンプルコードは本番環境では正常に動作していますが、EntityFunctions が原因で単体テストを行うことはできません。

私の単体テストプロジェクトは、実際の SQL データベースの代わりに InMemoryDatabase を使用しています。計算列 myValue と newValue を使用して SQL データベースにビューを作成することで、問題を簡単に解決できます。メソッドを変更したり、新しい SQL ビューを作成したりせずに単体テスト作業を行う方法を見つけたい

public class EcaseReferralCaseRepository : Repository
{

        public class myType
        {
                public DateTime myValue;
                public DateTime newValue;
        }

        public myType GetNewValues()
        {
                return 
                        (myType)(from o in context.EcaseReferralCases
                        select new myType
                        {
                            // LINQ to Entity
                            myValue = (DateTime)System.Data.Objects.EntityFunctions.AddDays(o.StartDate, 0),
                            newValue = (DateTime)System.Data.Objects.EntityFunctions.AddDays(o.StartDate, 30)

                            // LINQ to Object
                            //myValue = o.StartDate.AddDays(0),
                            //newValue = o.StartDate.AddDays(30)

                        });
        }
}

このリンクは、単体テスト EntityFunctions の良い例を示しています。そのアプローチを使用して、単体テストの難しさの1つを解決しましたが、この問題を解決する方法がわかりません。

score 5 · Accepted Answer

私が間違っていない限り、EcaseReferralCases の実装を別のIQueryable、おそらく LINQ To Objects クエリ可能なソースに切り替えることになります。

最も堅牢な方法は、おそらく式ビジターを使用して、呼び出しをEntityFunctions独自の L2Objects 互換関数に置き換えることです。

これが私の実装です：

using System;
using System.Data.Objects;
using System.Linq;
using System.Linq.Expressions;

static class EntityFunctionsFake
{
    public static DateTime? AddDays(DateTime? original, int? numberOfDays)
    {
        if (!original.HasValue || !numberOfDays.HasValue)
        {
            return null;
        }
        return original.Value.AddDays(numberOfDays.Value);
    }
}
public class EntityFunctionsFakerVisitor : ExpressionVisitor
{
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Method.DeclaringType == typeof(EntityFunctions))
        {
            var visitedArguments = Visit(node.Arguments).ToArray();
            return Expression.Call(typeof(EntityFunctionsFake), node.Method.Name, node.Method.GetGenericArguments(), visitedArguments);
        }

        return base.VisitMethodCall(node);
    }
}
class VisitedQueryProvider<TVisitor> : IQueryProvider
    where TVisitor : ExpressionVisitor, new()
{
    private readonly IQueryProvider _underlyingQueryProvider;
    public VisitedQueryProvider(IQueryProvider underlyingQueryProvider)
    {
        if (underlyingQueryProvider == null) throw new ArgumentNullException();
        _underlyingQueryProvider = underlyingQueryProvider;
    }

    private static Expression Visit(Expression expression)
    {
        return new TVisitor().Visit(expression);
    }

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        return new VisitedQueryable<TElement, TVisitor>(_underlyingQueryProvider.CreateQuery<TElement>(Visit(expression)));
    }

    public IQueryable CreateQuery(Expression expression)
    {
        var sourceQueryable = _underlyingQueryProvider.CreateQuery(Visit(expression));
        var visitedQueryableType = typeof(VisitedQueryable<,>).MakeGenericType(
            sourceQueryable.ElementType,
            typeof(TVisitor)
            );

        return (IQueryable)Activator.CreateInstance(visitedQueryableType, sourceQueryable);
    }

    public TResult Execute<TResult>(Expression expression)
    {
        return _underlyingQueryProvider.Execute<TResult>(Visit(expression));
    }

    public object Execute(Expression expression)
    {
        return _underlyingQueryProvider.Execute(Visit(expression));
    }
}
public class VisitedQueryable<T, TExpressionVisitor> : IOrderedQueryable<T>
    where TExpressionVisitor : ExpressionVisitor, new()
{
    private readonly IQueryable<T> _underlyingQuery;
    private readonly VisitedQueryProvider<TExpressionVisitor> _queryProviderWrapper;
    public VisitedQueryable(IQueryable<T> underlyingQuery)
    {
        _underlyingQuery = underlyingQuery;
        _queryProviderWrapper = new VisitedQueryProvider<TExpressionVisitor>(underlyingQuery.Provider);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _underlyingQuery.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public Expression Expression
    {
        get { return _underlyingQuery.Expression; }
    }

    public Type ElementType
    {
        get { return _underlyingQuery.ElementType; }
    }

    public IQueryProvider Provider
    {
        get { return _queryProviderWrapper; }
    }
}

そして、ここに使用例があります：

var linq2ObjectsSource = new List<DateTime?>() { null }.AsQueryable();
var visitedSource = new VisitedQueryable<DateTime?, EntityFunctionsFakerVisitor>(linq2ObjectsSource);
var visitedQuery = visitedSource.Select(dt => EntityFunctions.AddDays(dt, 1));
var results = visitedQuery.ToList();
Assert.AreEqual(1, results.Count);
Assert.AreEqual(null, results[0]);

このようにして、望ましい特性をすべて得ることができます。

EntityFunctions開発者は、Entity Framework によって定義された標準を引き続き使用できます。
本番環境の実装は、データベースで実行されていない場合でも例外を発生させることが保証されています。
クエリは、偽のリポジトリに対してテストできます。

score 1 · Accepted Answer

電話するのではなく

System.Data.Objects.EntityFunctions.AddDays

直接、カスタムインターフェイスを挿入します。このインターフェイスは、呼び出しをそのメソッドに転送しますが、テスト目的でモックすることができます。

score 0 · Accepted Answer

Jean Hominal が推奨するように、私は ExpressionVisitor を実装したいと思っています。私の困難は、私の場合、linq2ObjectsSource、visitedSource、visitedQuery を定義する方法です。最後に、メソッド IQuerable GetSelectQuery(IQuerable query) のインターフェイスを作成し、そのインターフェイスから派生した Production and Test プロジェクトに対応するクラスを作成し、GetSelectQuery(IQuerable query) を実装します。それは正常に動作します。

public interface IEntityFunctionsExpressions
{
   IQuerable<myType> GetSelectQuery(IQuerable<EcaseReferralCase> query); 
}

本番プロジェクトで:

public class EntityFunctionsExpressions : IEntityFunctionsExpressions
{
    public EntityFunctionsExpressions()
    {
    }

    public IQuerable<myType> GetSelectQuery(IQuerable<EcaseReferralCase> query)
    {
        // Expression for LINQ to Entities, does not work with LINQ to Objects
        return 
                    (myType)(from o in query
                    select new myType
                    {
                        // LINQ to Entity
                        myValue = (DateTime)System.Data.Objects.EntityFunctions.AddDays(o.StartDate, 0),
                        newValue = (DateTime)System.Data.Objects.EntityFunctions.AddDays(o.StartDate, 30)

                    });
    }
}

単体テストプロジェクトで:

public class MockEntityFunctionsExpressions : IEntityFunctionsExpressions
{
    public MockEntityFunctionsExpressions()
    {
    }

    public IQuerable<myType> GetSelectQuery(IQuerable<EcaseReferralCase> query)
    {
        // Expression for LINQ to Objects, does not work with LINQ to Entities
        return 
                    (myType)(from o in query
                    select new myType
                    {
                        // LINQ to Object
                        myValue = o.StartDate.AddDays(0),
                        newValue = o.StartDate.AddDays(30)
                    });
    }
}

次に GetNewValues() メソッドを書き直します。

public myType GetNewValues() { return myrepository.EntityFunctionsExpressions.GetSelectQuery(context.EcaseReferralCases);

}

c# - EntityFunctions.AddDays 関数を含む GetNewValues() を単体テストする方法

3 に答える 3

Related

Reference