Maison > développement back-end > Tutoriel C#.Net > C# découple EntityFramework pour les tests unitaires

C# découple EntityFramework pour les tests unitaires

黄舟
Libérer: 2017-02-28 11:18:24
original
2180 Les gens l'ont consulté

1. Tout d'abord, le référentiel d'EF a besoin qu'un comportement abstrait soit mentionné dans l'interface.

Par exemple :

public interface IXXXContext : IDisposable
    {
        IXXXContext NewInstance();
// db sets
        DbSet<AAABBB> aaa { get; set; }
...
// common 
Database Database { get; }
        DbContextConfiguration Configuration { get; }
        int SaveChanges();


        Task<int> SaveChangesAsync();


	// store pros
...
        IStorePro1 StorePro1 { get; }
	...
}
Copier après la connexion


Ensuite, vous pouvez utiliser DataContext et TestDataContext pour implémenter cette interface. Parmi eux, TestDataContext est utilisé en UT et DataContext est automatiquement généré.

TestDataContext nécessite également les classes suivantes pour la simulation.

 public class TestDbSet<TEntity> : DbSet<TEntity>, IQueryable, IEnumerable<TEntity>, IDbAsyncEnumerable<TEntity>
         where TEntity : class
    {
        ObservableCollection<TEntity> _data;
        IQueryable _query;


        public TestDbSet()
        {
            _data = new ObservableCollection<TEntity>();
            _query = _data.AsQueryable();
        }


        public override TEntity Add(TEntity item)
        {
            _data.Add(item);
            return item;
        }


        public override TEntity Remove(TEntity item)
        {
            _data.Remove(item);
            return item;
        }


        public override TEntity Attach(TEntity item)
        {
            _data.Add(item);
            return item;
        }


        public override TEntity Create()
        {
            return Activator.CreateInstance<TEntity>();
        }


        public override TDerivedEntity Create<TDerivedEntity>()
        {
            return Activator.CreateInstance<TDerivedEntity>();
        }


        public override ObservableCollection<TEntity> Local
        {
            get { return _data; }
        }


        Type IQueryable.ElementType
        {
            get { return _query.ElementType; }
        }


        Expression IQueryable.Expression
        {
            get { return _query.Expression; }
        }


        IQueryProvider IQueryable.Provider
        {
            get { return new TestDbAsyncQueryProvider<TEntity>(_query.Provider); }
        }


        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return _data.GetEnumerator();
        }


        IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
        {
            return _data.GetEnumerator();
        }


        IDbAsyncEnumerator<TEntity> IDbAsyncEnumerable<TEntity>.GetAsyncEnumerator()
        {
            return new TestDbAsyncEnumerator<TEntity>(_data.GetEnumerator());
        }
    }


    internal class TestDbAsyncQueryProvider<TEntity> : IDbAsyncQueryProvider
    {
        private readonly IQueryProvider _inner;


        internal TestDbAsyncQueryProvider(IQueryProvider inner)
        {
            _inner = inner;
        }


        public IQueryable CreateQuery(Expression expression)
        {
            return new TestDbAsyncEnumerable<TEntity>(expression);
        }


        public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
        {
            return new TestDbAsyncEnumerable<TElement>(expression);
        }


        public object Execute(Expression expression)
        {
            return _inner.Execute(expression);
        }


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


        public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute(expression));
        }


        public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute<TResult>(expression));
        }
    }


    internal class TestDbAsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T>
    {
        public TestDbAsyncEnumerable(IEnumerable<T> enumerable)
            : base(enumerable)
        { }


        public TestDbAsyncEnumerable(Expression expression)
            : base(expression)
        { }


        public IDbAsyncEnumerator<T> GetAsyncEnumerator()
        {
            return new TestDbAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
        }


        IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator()
        {
            return GetAsyncEnumerator();
        }


        IQueryProvider IQueryable.Provider
        {
            get { return new TestDbAsyncQueryProvider<T>(this); }
        }
    }


    internal class TestDbAsyncEnumerator<T> : IDbAsyncEnumerator<T>
    {
        private readonly IEnumerator<T> _inner;


        public TestDbAsyncEnumerator(IEnumerator<T> inner)
        {
            _inner = inner;
        }


        public void Dispose()
        {
            _inner.Dispose();
        }


        public Task<bool> MoveNextAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(_inner.MoveNext());
        }


        public T Current
        {
            get { return _inner.Current; }
        }


        object IDbAsyncEnumerator.Current
        {
            get { return Current; }
        }
    }
Copier après la connexion


Exemple d'utilisation :

[TestMethod]
        public void TestMethod1()
        {
            var mockSet = new Mock<DbSet<BLACKLISTED_TICKET>>();
            var mockContext = new Mock<TicketDataContextTest>();
            mockContext.Setup(m => m.BLACKLISTED_TICKET).Returns(new TestDbSet<BLACKLISTED_TICKET>());


            var context = mockContext.Object;


            context.BLACKLISTED_TICKET.Add(new BLACKLISTED_TICKET()
            {
                TicketNumber = "aaa",
                CreatedDateTime = DateTime.Now,
                Id = 1,
                ModifiedDateTime = DateTime.Now,
                STATUS = "1"
            });


            Assert.IsTrue(context.BLACKLISTED_TICKET.First().Id == 1);
        }
Copier après la connexion

Si une procédure stockée est utilisée, vous devez en outre définir l'interface de la procédure stockée procédure.
Par exemple :

IStorePro {
...
}


StorePro : IStorePro{
...
}


StoreProFake: IStorePro{


}
Copier après la connexion

Ensuite, IDataContext est chargé de renvoyer l'instance de la procédure stockée

IDataContext{
	...
	IStorePro GetStorePro();
	...
}
Copier après la connexion

Ce qui précède est le contenu du découplage C# EntityFramework pour les tests unitaires, et plus encore. Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn) !


Étiquettes associées:
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal