ASP.NET MVC with automatic testing (follow up)

Question

This is a follow-up of this question regarding MVC application architecture fit for automatic testing.

I have rewritten the DI code based on the answer provided there and also created some tests to see if I can properly benefit from the newly refactored code. I will repeat here the application structure, so that the question can be understood without reading the original question:

1. Common assembly - contains generic functionalities, including models definition
2. Fetch job - daily job that fetches and processes raw article data
3. Web application - the actual Web application that allows users to see processed data
4. Test project - an automatic testing project based on NUnit that currently contains only integrative tests (no mocking, no real unit tests)

The actual code:

1) Common DI bindings (for Job and Web App mainly)

public class NinjectCommon
{
 public static void RegisterCommonServices(IKernel kernel)
 {
 kernel.Bind<IUnitOfWork>().To<UnitOfWork>();
 kernel.Bind<IAggregatorContext>().ToFactory(() => new AggregatorContextProvider());
 kernel.Bind<IEntitiesCache>().To<EntitiesCache>().InSingletonScope();
 kernel.Bind<IExtDictionaryParser>().To<ExtDictionaryParser>().InSingletonScope();
 kernel.Bind(typeof(IRepository<>)).To(typeof(Repository<>));
 }
}

2) Repository definition

public interface IRepository
{
}
public interface IRepository<TEntity> : IRepository
 where TEntity : class
{
 IQueryable<TEntity> AllNoTracking { get; }
 IQueryable<TEntity> All { get; }
 TEntity Get(int id);
 void Insert(TEntity entity);
 void Delete(TEntity entity);
 void Update(TEntity entity);
}
public class Repository<T> : IRepository<T> where T : class, new()
{
 private IAggregatorContext _context;
 public Repository(IAggregatorContext context)
 {
 this._context = context;
 }
 public IQueryable<T> All
 {
 get { return _context.Set<T>().AsQueryable(); }
 }
 public IQueryable<T> AllNoTracking
 {
 get { return _context.Set<T>().AsNoTracking(); }
 }
 public T Get(int id)
 {
 return _context.Set<T>().Find(id);
 }
 public void Delete(T entity)
 {
 if (_context.Entry(entity).State == EntityState.Detached)
 _context.Set<T>().Attach(entity);
 _context.Set<T>().Remove(entity);
 }
 public void Insert(T entity)
 {
 _context.Set<T>().Add(entity);
 }
 public void Update(T entity)
 {
 _context.Set<T>().Attach(entity);
 _context.Entry(entity).State = EntityState.Modified;
 }
}

3) Unit of work

public class UnitOfWork : IUnitOfWork
{
 #region Members
 private IAggregatorContext _context;
 #endregion
 #region Properties
 public IRepository<Lexem> LexemRepository { get; private set; }
 public IRepository<Word> WordRepository { get; private set; }
 public IRepository<Synset> SynsetRepository { get; private set; }
 // other repositories come here (removed for brevity)
 #endregion
 #region Constructor
 public UnitOfWork(IAggregatorContext context,
 IRepository<Lexem> lexemRepository, IRepository<Word> wordRepository, IRepository<Synset> synsetRepository,
 /* other repositories params here */)
 {
 this._context = context;
 LexemRepository = lexemRepository;
 WordRepository = wordRepository;
 SynsetRepository = synsetRepository;
 }
 #endregion
 #region Methods
 public IRepository<T> GetRepository<T>()
 where T: class
 {
 Type thisType = this.GetType();
 foreach (var prop in thisType.GetProperties())
 {
 var propType = prop.PropertyType;
 if (!typeof(IRepository).IsAssignableFrom(propType))
 continue;
 var repoType = propType.GenericTypeArguments[0];
 if (repoType == typeof(T))
 return (IRepository<T>) prop.GetValue(this);
 }
 throw new ArgumentException(String.Format("No repository of type {0} found", typeof(T).FullName));
 }
 public void SaveChanges()
 {
 _context.SaveChanges();
 }
 public bool SaveChangesEx()
 {
 return _context.SaveChangesEx();
 }
 #endregion
}

4) Fetch job DI setup

class Program
{
 #region Members
 private static Logger logger = LogManager.GetCurrentClassLogger();
 #endregion
 #region Properties
 private static IUnitOfWork _UnitOfWork { get; set; }
 private static IKernel _Kernel { get; set; }
 private static IFetchJob _FetchJob { get; set; }
 #endregion
 #region Methods
 private static void init()
 {
 // setup DI
 _Kernel = new StandardKernel();
 _Kernel.Load(Assembly.GetExecutingAssembly());
 NinjectCommon.RegisterCommonServices(_Kernel);
 registerServices();
 _UnitOfWork = _Kernel.Get<IUnitOfWork>();
 _FetchJob = _Kernel.Get<IFetchJob>();
 }
 private static void registerServices()
 {
 _Kernel.Bind<INlpUtils>().To<NlpUtils>();
 _Kernel.Bind<IFetchJob>().To<FetchJob>().InSingletonScope();
 }
 static void Main(string[] args)
 {
 init();
 Utils.InitNLogConnection();
 logger.LogEx(LogLevel.Info, "FetchJob started");
 MappingConfig.CreateMappings();
 try
 {
 _FetchJob.FetchArticleData();
 }
 catch (Exception exc)
 {
 logger.LogEx(LogLevel.Fatal, "Global unhandled exception", exc);
 }
 finally
 {
 logger.LogEx(LogLevel.Info, "FetchJob stopped");
 }
 }
 #endregion
}

5) Web application DI setup

public static class NinjectWebCommon 
{
 private static readonly Bootstrapper bootstrapper = new Bootstrapper();
 /// <summary>
 /// Starts the application
 /// </summary>
 public static void Start() 
 {
 DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
 DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
 bootstrapper.Initialize(CreateKernel);
 }
 /// <summary>
 /// Stops the application.
 /// </summary>
 public static void Stop()
 {
 bootstrapper.ShutDown();
 }
 /// <summary>
 /// Creates the kernel that will manage your application.
 /// </summary>
 /// <returns>The created kernel.</returns>
 private static IKernel CreateKernel()
 {
 var kernel = new StandardKernel();
 try
 {
 kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
 kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();
 RegisterServices(kernel);
 return kernel;
 }
 catch
 {
 kernel.Dispose();
 throw;
 }
 }
 /// <summary>
 /// Load your modules or register your services here!
 /// </summary>
 /// <param name="kernel">The kernel.</param>
 private static void RegisterServices(IKernel kernel)
 {
 NinjectCommon.RegisterCommonServices(kernel);
 // other bindings come here
 } 
}

6) Automatic tests projects DI setup

All test classes inherit a base test class that provides some functionality for all test groups:

public abstract class BaseTest
{
 #region Variables
 protected IKernel _Kernel { get; private set; }
 [Inject]
 public IUnitOfWork UnitOfWork { get; private set; }
 #endregion
 #region Constructor
 protected BaseTest()
 {
 _Kernel = new NSubstituteMockingKernel();
 _Kernel.Load(Assembly.GetExecutingAssembly());
 NinjectCommon.RegisterCommonServices(_Kernel);
 RegisterServices();
 UnitOfWork = _Kernel.Get<IUnitOfWork>();
 // used to inject into properties
 _Kernel.Inject(this);
 }
 #endregion
 #region Abstract methods
 [SetUp]
 protected virtual void Init()
 {
 MappingConfig.CreateMappings();
 Utils.InitNLogConnection();
 }
 protected virtual void RegisterServices()
 {
 _Kernel.Bind<INlpUtils>().To<NlpUtils>();
 }
 [TearDown]
 protected abstract void TearDown();
 #endregion
}

7) A test that rebinds to a mockup type that replaces all real type functionality

public class ExtDictionaryParserTest : BaseTest
{
 #region Properties
 [Inject]
 public IExtDictionaryParser ExtDictionaryParser { get; set; }
 #endregion
 #region Overrides
 protected override void TearDown()
 {
 }
 protected override void RegisterServices()
 {
 base.RegisterServices();
 _Kernel.Rebind<IExtDictionaryParser>().To<ExtDictionaryParserMockup>();
 }
 #endregion
 #region Tests
 [Test]
 [Category(Constants.Fast)]
 public void ExtDictionaryParse()
 {
 bool isForeign = false;
 Assert.AreEqual(ExtDictionaryParser.WordFromExtDictionary("pagina", out isForeign), "pagina");
 Assert.IsFalse(isForeign);
 Assert.AreEqual(ExtDictionaryParser.WordFromExtDictionary("pagini", out isForeign), "pagina");
 Assert.IsFalse(isForeign);
 Assert.AreEqual(ExtDictionaryParser.WordFromExtDictionary("pages", out isForeign), "page");
 Assert.IsTrue(isForeign);
 Assert.IsNull(ExtDictionaryParser.WordFromExtDictionary("nonexisting_word", out isForeign));
 }
 #endregion
}

8) A test that replaces a repository return function that is used by another function

public class EntitiesCacheTest : BaseTest
{
 #region Tests
 [Test]
 [Category(Constants.Fast)]
 public void BaseWordExists()
 {
 var dummyList = new List<Lexem>() {
 new Lexem() { Word = "something" },
 new Lexem() { Word = "other" },
 new Lexem() { Word = "nothing" }
 };
 var unitOfWorkSubst = Substitute.For<IUnitOfWork>();
 unitOfWorkSubst.LexemRepository.AllNoTracking.Returns(dummyList.AsQueryable());
 _Kernel.Rebind<IUnitOfWork>().ToConstant(unitOfWorkSubst);
 _Kernel.Rebind<IEntitiesCache>().To<EntitiesCache>().InSingletonScope();
 var entitiesCache = _Kernel.Get<IEntitiesCache>();
 Assert.IsTrue(entitiesCache.BaseWordExists("something"));
 Assert.IsTrue(entitiesCache.BaseWordExists("other"));
 Assert.IsFalse(entitiesCache.BaseWordExists("authentic"));
 Assert.IsFalse(entitiesCache.BaseWordExists("Something"));
 Assert.IsFalse(entitiesCache.BaseWordExists("NonExistent"));
 }
 #endregion
}

My questions is:

am I using correctly DI in the above automated tests? Should I improve something to what is already there? As the application grows, I expect to have hundreds of tests, so managing them correctly is important.