How to mock and unit test? about dbcontextscope HOT 6 CLOSED

         public async Task Test_vendor_async_service()
       {
        //shortened for brevity
        var data = new List<Vendor>();

        var mockSet = new Mock<DbSet<Vendor>>();
        mockSet.As<IDbAsyncEnumerable<Vendor>>()
            .Setup(m => m.GetAsyncEnumerator())
            .Returns(new TestDbAsyncEnumerator<Vendor>(data.GetEnumerator()));

        mockSet.As<IQueryable<Vendor>>()
            .Setup(m => m.Provider)
            .Returns(new TestDbAsyncQueryProvider<Vendor>(data.Provider));

        mockSet.As<IQueryable<Vendor>>().Setup(m => m.Expression).Returns(data.Expression);
        mockSet.As<IQueryable<Vendor>>().Setup(m => m.ElementType).Returns(data.ElementType);
        mockSet.As<IQueryable<Vendor>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

        //this is where I am not so sure what needs to be done.
        var mockFactory = new Mock<IDbContextScopeFactory>();
        mockFactory.As<MyContext>()
            .Setup(c => c.Vendors).Returns(mockSet.Object);

        //I can't really pass in the mockfactory because it of type Mock<T>
        //confused
        var service = new VendorsService(mockFactory);
        var vendors = await service.GetAllAsync().ConfigureAwait(false);

        Assert.AreEqual(3, vendors.Count);
        Assert.AreEqual("AAA", vendors[0].BusinessName);
        Assert.AreEqual("BBB", vendors[1].BusinessName);
        Assert.AreEqual("ZZZ", vendors[2].BusinessName);
    }

public class UnitScanDefinitionsControllerTest
 {   
 private CrawlerContext _dbEntities;
     private readonly ICrawlerRepository _crawlerRepository;
     private IScanDefinitionService _scanDefinitionService;

     public UnitScanDefinitionsControllerTest()
     {
         IAmbientDbContextLocator ambientDbContextLocator = new AmbientDbContextLocator();
         _crawlerRepository = new CrawlerRepository(ambientDbContextLocator);
     }

     [Fact]
     public async Task ScanDefinitionView()
     {
         var data = new List<ScanDefinition>
         {
             new ScanDefinition { Name = "AAA" },
             new ScanDefinition { Name = "BBB" },
             new ScanDefinition { Name = "CCC" },

         }.AsQueryable();


         var mockSet = new Mock<DbSet<ScanDefinition>>();
         mockSet.As<IDbAsyncEnumerable<ScanDefinition>>()
             .Setup(m => m.GetAsyncEnumerator())
             .Returns(new DbAsyncEnumerator<ScanDefinition>(data.GetEnumerator()));

         mockSet.As<IQueryable<ScanDefinition>>()
             .Setup(m => m.Provider)
             .Returns(new DbAsyncQueryProvider<ScanDefinition>(data.Provider));

         mockSet.As<IQueryable<ScanDefinition>>().Setup(m => m.Expression).Returns(data.Expression);
         mockSet.As<IQueryable<ScanDefinition>>().Setup(m => m.ElementType).Returns(data.ElementType);
         mockSet.As<IQueryable<ScanDefinition>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

         var mockFactory = new Mock<IDbContextFactory>();
         mockFactory.Setup(c => c.CreateDbContext<CrawlerContext>()).Returns(_dbEntities);

         _dbContextFactory = mockFactory.Object;

         // Setup DbContextScopeFactory to use mocked context
         _mockContextScope = new DbContextScopeFactory(_dbContextFactory);
         _scanDefinitionService = new ScanDefinitionService(_mockContextScope, _crawlerRepository);

         var scanDefinitions = await _scanDefinitionService.GetScanDefinitions().ToListAsync();

         Assert.Equal(3, scanDefinitions.Count);
         Assert.Equal("AAA", scanDefinitions[0].Name);
         Assert.Equal("BBB", scanDefinitions[1].Name);
         Assert.Equal("ZZZ", scanDefinitions[2].Name);
     }
 }

public class ScanDefinitionService : IScanDefinitionService
    {
        private readonly IDbContextScopeFactory _dbContextScopeFactory;
        private readonly ICrawlerRepository _crawlerRepository;

        public ScanDefinitionService(IDbContextScopeFactory dbContextScopeFactory, ICrawlerRepository context)
        {
            _dbContextScopeFactory = dbContextScopeFactory;
            _crawlerRepository = context;
        }

        public IQueryable<ScanDefinition> GetScanDefinitions()
        {
            using (_dbContextScopeFactory.CreateReadOnly())
            {
                return _crawlerRepository.GetScanDefinitions();
            }
        }
	}

public class CrawlerRepository : ICrawlerRepository

    {
        private readonly IAmbientDbContextLocator _ambientDbContextLocator;

        private CrawlerContext DbContext
        {
            get
            {
                var dbContext = _ambientDbContextLocator.Get<CrawlerContext>();

                if (dbContext == null)
                    throw new InvalidOperationException("Db Context Error message");

                return dbContext;
            }
        }

        public CrawlerRepository(IAmbientDbContextLocator ambientDbContextLocator)
        {
            if (ambientDbContextLocator == null) throw new ArgumentNullException("ambientDbContextLocator");
            _ambientDbContextLocator = ambientDbContextLocator;
        }
	
	    
		public IQueryable<ScanDefinition> GetScanDefinitions()
        {
            return DbContext.ScanDefinitions  **<--- TEST FAILS HERE; Message: System.NullReferenceException : Object reference not set to an instance of an object.**
                .Include(sd => sd.ScanBases)
                .Include(sd => sd.ScanDefinitionFileTypes)
                .Include(sd => sd.ScanDefinitionRuleDefinitions);
        }
	}