How to unit-test-repository-Muster, das verwendet Entity Framework?

Ich bin gerade dabei, unit test repository machte ich durch Entity Framework:

Was ich will, geschehen wird, das test-repository ohne tatsächlich das senden/verbinden mit der Datenbank, ich möchte diese ohne mocking framework.

Derzeit mein test sendet die Daten in die Datenbank, was ich will, geschehen wird, testen Sie die hinzufügen/entfernen, etc. Methoden ohne das senden der eigentlichen Daten in die Datenbank, da es nur zum testen.

Hier ist das repository:

namespace AbstractFactory.Repository
{
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;

    ///<summary>
    ///This class serves as the structure of the Author repository using a database
    ///</summary>
    public class DbAuthorRepository : IRepository<AuthorEntity>
    {

        private AbstractFactoryPatternEntities context;

        public DbAuthorRepository(AbstractFactoryPatternEntities context)
        {
            this.context = context;
        }

        ///<summary>
        ///Adds the specified author.
        ///</summary>
        ///<param name="author">The author.</param>
        public void Add(AuthorEntity author)
        {
            context.AuthorEntities.Add(author);
        }

        ///<summary>
        ///Removes the specified author.
        ///</summary>
        ///<param name="author">The author.</param>
        public void Remove(AuthorEntity author)
        {
            this.context.AuthorEntities.Remove(author);
        }

        ///<summary>
        ///Saves this instance.
        ///</summary>
        public void Save()
        {
            this.context.SaveChanges();
        }

        ///<summary>
        ///Gets all.
        ///</summary>
        ///<returns>returns a list of all the authors</returns>
        public IEnumerable<AuthorEntity> GetAll()
        {
            List<AuthorEntity> result = this.context.AuthorEntities.Include(a => a.Books).ToList();

            return result;
        }

        ///<summary>
        ///Gets the author by id.
        ///</summary>
        ///<param name="id">The id.</param>
        ///<returns>returns an entity</returns>
        public AuthorEntity GetById(int id)
        {
            AuthorEntity result = this.context.AuthorEntities.Single(a => a.AuthorId == id);

            return result;
        }
    }
}

Hier ist der aktuelle code für den unit-test:

[TestMethod]
        public void Add_MethodIsCalled_EntityCountIsIncrementedByOne()
        {
            using (ShimsContext.Create())
            {
                ShimAbstractFactoryPatternEntities context = new ShimAbstractFactoryPatternEntities(new AbstractFactoryPatternEntities());
                DbAuthorRepository repository = new DbAuthorRepository(context);
                repository.Add(new AuthorEntity { FirstName = "Test", LastName = "testing=" });
                var actual = repository.GetAll().Count();
                repository.Save();
                var expected = repository.GetAll().Count();
                Assert.AreNotEqual(actual, expected);
            }

            //AbstractFactoryPatternEntities context = new AbstractFactoryPatternEntities();
            //DbAuthorRepository repository = new DbAuthorRepository(context);
            //var actual = repository.GetAll().Count();
            //repository.Add(new AuthorEntity { FirstName = "Testing", LastName = "MyTest" });
            //repository.Save();
            //var expected = repository.GetAll().Count();
            //Assert.AreNotEqual(actual, expected);
        }

        [TestMethod]
        public void Remove_MethodIsCalled_EntityCountRemainsTheSame()
        {
            AbstractFactoryPatternEntities context = new AbstractFactoryPatternEntities();
            DbAuthorRepository repository = new DbAuthorRepository(context);
            AuthorEntity newAuthor = new AuthorEntity { FirstName = "Testing", LastName = "MyTest" };
            repository.Add(newAuthor);
            repository.Save();
            var actual = repository.GetAll().Count();
            Console.WriteLine(actual);
            repository.Remove(newAuthor);
            var expected = repository.GetAll().Count();
            Console.WriteLine(expected);
            Assert.AreEqual(actual, expected);
        }

        [TestMethod]
        public void Get_MethodIsCalled_CorrectAuthorIsRetrieved()
        {
            AbstractFactoryPatternEntities context = new AbstractFactoryPatternEntities();
            DbAuthorRepository repository = new DbAuthorRepository(context);
            int target = 4;
            AuthorEntity author = repository.GetById(target);
            Assert.AreEqual(target, author.AuthorId);
        }

Möchte ich unterlegbleche/stub/fakes in Auftrag um die Prüfung zu machen.

Was ist die Frage?
Wenn alle, die Ihre repositories tun, ist eine Zeile code, das ist ein Aufruf zur EF, dann brauchen Sie nicht zu tun, jede form von unit-Tests auf. Sogar Onkel Bob stimmt zu: blog.8thlight.com/uncle-bob/2013/03/06/ThePragmaticsOfTDD.html
+ 1 @IronMan84 - dont bother testing framework, sonst könnten Sie möglicherweise finden sich Tests code, den Sie nicht lösen können.
Was ich will, geschehen wird, das test-repository ohne tatsächlich das senden/verbinden mit der Datenbank
Sie sagen, was Sie wollen, aber Sie nicht Frage von nichts. Ich weiß nicht, was zu beantworten. Und dann, wollen Sie nicht zu verspotten, also was willst du mit fake?

InformationsquelleAutor Randel Ramirez | 2013-04-03

Schreibe einen Kommentar