NSubstitute DbSet / IQueryable

grâce à Kevin, j'ai trouvé le problème dans ma traduction de code.

unittest exemples de code se DbSet, mais NSubstitute nécessite l'implémentation de l'interface. Donc l'équivalent de Moqs new Mock<DbSet<Blog>>() pour NSubstitute est Substitute.For<IDbSet<Blog>>(). Vous n'êtes pas toujours tenu de fournir l'Interface, c'est pourquoi j'étais confus. Mais dans ce cas précis, il s'est avéré crucial.

il s'est aussi avéré que nous n'avons pas à lancer à Queryable quand en utilisant L'interface IDbSet.

donc le code de test de travail:

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
    new Blog { Name = "BBB" },
    new Blog { Name = "ZZZ" },
    new Blog { Name = "AAA" },
  }.AsQueryable();

  var mockSet = Substitute.For<IDbSet<Blog>>();
  mockSet.Provider.Returns(data.Provider);
  mockSet.Expression.Returns(data.Expression);
  mockSet.ElementType.Returns(data.ElementType);
  mockSet.GetEnumerator().Returns(data.GetEnumerator());

  var mockContext = Substitute.For<BloggingContext>();
  mockContext.Blogs.Returns(mockSet);

  // Act and Assert ...
}

j'ai écrit une petite méthode d'extension pour nettoyer la section arranger des tests unitaires.

public static class ExtentionMethods
{
    public static IDbSet<T> Initialize<T>(this IDbSet<T> dbSet, IQueryable<T> data) where T : class
    {
        dbSet.Provider.Returns(data.Provider);
        dbSet.Expression.Returns(data.Expression);
        dbSet.ElementType.Returns(data.ElementType);
        dbSet.GetEnumerator().Returns(data.GetEnumerator());
        return dbSet;
    }
}

// usage like:
var mockSet = Substitute.For<IDbSet<Blog>>().Initialize(data);

ce n'est Pas la question, mais dans le cas vous devez également être en mesure de soutenir des opérations asynchrones:

public static IDbSet<T> Initialize<T>(this IDbSet<T> dbSet, IQueryable<T> data) where T : class
{
  dbSet.Provider.Returns(data.Provider);
  dbSet.Expression.Returns(data.Expression);
  dbSet.ElementType.Returns(data.ElementType);
  dbSet.GetEnumerator().Returns(data.GetEnumerator());

  if (dbSet is IDbAsyncEnumerable)
  {
    ((IDbAsyncEnumerable<T>) dbSet).GetAsyncEnumerator()
      .Returns(new TestDbAsyncEnumerator<T>(data.GetEnumerator()));
    dbSet.Provider.Returns(new TestDbAsyncQueryProvider<T>(data.Provider));
  }

  return dbSet;
}

// create substitution with async
var mockSet = Substitute.For<IDbSet<Blog>, IDbAsyncEnumerable<Blog>>().Initialize(data);
// create substitution without async
var mockSet = Substitute.For<IDbSet<Blog>>().Initialize(data);

c'est ma méthode statique générique de génération de faux DbSet. Il peut, par utile.

 public static class CustomTestUtils
{
    public static DbSet<T> FakeDbSet<T>(List<T> data) where T : class
    {
        var _data = data.AsQueryable();
        var fakeDbSet = Substitute.For<DbSet<T>, IQueryable<T>>();
        ((IQueryable<T>)fakeDbSet).Provider.Returns(_data.Provider);
        ((IQueryable<T>)fakeDbSet).Expression.Returns(_data.Expression);
        ((IQueryable<T>)fakeDbSet).ElementType.Returns(_data.ElementType);
        ((IQueryable<T>)fakeDbSet).GetEnumerator().Returns(_data.GetEnumerator());

        fakeDbSet.AsNoTracking().Returns(fakeDbSet);

        return fakeDbSet;
    }

}

j'ai écrit un wrapper sur un an autour du même code sont de référencement de Test avec Votre Propre Test en Double (EF6 partir). Cette enveloppe peut être trouvée sur GitHub DbContextMockForUnitTests. Le but de ce wrapper est de réduire la quantité de code répétitif/dupliqué nécessaire pour configurer les tests unitaires qui font usage de EF où vous voulez vous moquer de cela DbContext et DbSets. La plupart du code Fe simulé que vous avez dans L'OP peut être réduit à 2 lignes de code (et seulement 1 si vous utilisez DbContext.Set<T> au lieu des propriétés DbSet) et le code simulé est alors appelé dans le wrapper.

Pour l'utiliser copier et d'inclure les fichiers dans le dossier MockHelpers à votre projet D'essai.

voici un exemple de test en utilisant ce que vous aviez ci-dessus, notez qu'il n'y a maintenant que 2 lignes de code nécessaires pour configurer le mock DbSet<T> sur la moqué DbContext.

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  };

  var mockContext = Substitute.For<BloggingContext>();

  // Create and assign the substituted DbSet
  var mockSet = data.GenerateMockDbSet();
  mockContext.Blogs.Returns(mockSet);

  // act
}

Il est tout aussi facile de faire ce test qui appelle quelque chose qui utilise le motif async/wait comme .ToListAsync() sur le DbSet<T>.

public async Task GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  };

  var mockContext = Substitute.For<BloggingContext>();

  // Create and assign the substituted DbSet
  var mockSet = data.GenerateMockDbSetForAsync(); // only change is the ForAsync version of the method
  mockContext.Blogs.Returns(mockSet);

  // act
}

Vous ne devriez pas avoir besoin de vous moquer de tous les morceaux de L'IQueryable. Quand J'utilise NSubstitute pour me moquer D'un DbContext EF, je fais quelque chose comme ça:

interface IContext
{
  IDbSet<Foo> Foos { get; set; }
}

var context = Substitute.For<IContext>();

context.Foos.Returns(new MockDbSet<Foo>());

avec une simple implémentation D'IDbSet autour d'une liste ou quelque chose pour my MockDbSet().

en général, vous devez vous moquer des interfaces, pas des types car NSubstitute ne fera que surcharger les méthodes virtuelles.