як модульно протестувати основний додаток asp.net із введенням залежностей конструктора -

У мене є основна програма asp.net, яка використовує ін’єкцію залежностей, визначену в класі програми startup.cs:

    public void ConfigureServices(IServiceCollection services)
    {

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration["Data:FotballConnection:DefaultConnection"]));


        // Repositories
        services.AddScoped<IUserRepository, UserRepository>();
        services.AddScoped<IUserRoleRepository, UserRoleRepository>();
        services.AddScoped<IRoleRepository, RoleRepository>();
        services.AddScoped<ILoggingRepository, LoggingRepository>();

        // Services
        services.AddScoped<IMembershipService, MembershipService>();
        services.AddScoped<IEncryptionService, EncryptionService>();

        // new repos
        services.AddScoped<IMatchService, MatchService>();
        services.AddScoped<IMatchRepository, MatchRepository>();
        services.AddScoped<IMatchBetRepository, MatchBetRepository>();
        services.AddScoped<ITeamRepository, TeamRepository>();

        services.AddScoped<IFootballAPI, FootballAPIService>();

Це дозволяє щось подібне:

[Route("api/[controller]")]
public class MatchController : AuthorizedController
{
    private readonly IMatchService _matchService;
    private readonly IMatchRepository _matchRepository;
    private readonly IMatchBetRepository _matchBetRepository;
    private readonly IUserRepository _userRepository;
    private readonly ILoggingRepository _loggingRepository;

    public MatchController(IMatchService matchService, IMatchRepository matchRepository, IMatchBetRepository matchBetRepository, ILoggingRepository loggingRepository, IUserRepository userRepository)
    {
        _matchService = matchService;
        _matchRepository = matchRepository;
        _matchBetRepository = matchBetRepository;
        _userRepository = userRepository;
        _loggingRepository = loggingRepository;
    }

Це дуже акуратно. Але стає проблемою, коли я хочу юніт-тест. Оскільки у моїй тестовій бібліотеці немає startup.cs, де я встановлюю ін’єкцію залежностей. Тож клас із цими інтерфейсами як params буде просто нульовим.

namespace TestLibrary
{
    public class FootballAPIService
    {
        private readonly IMatchRepository _matchRepository;
        private readonly ITeamRepository _teamRepository;

        public FootballAPIService(IMatchRepository matchRepository, ITeamRepository teamRepository)

        {
            _matchRepository = matchRepository;
            _teamRepository = teamRepository;

У наведеному вище коді в тестовій бібліотеці _matchRepository та _teamRepository просто матимуть значення null . :(

Чи можу я зробити щось на зразок ConfigureServices, де я визначаю введення залежностей у своєму тестовому проекті бібліотеки?

Ваші контролери в ядрі .net з самого початку мають на увазі введення залежностей, але це не означає, що вам потрібно використовувати контейнер для введення залежностей.

Дано простіший клас, такий як:

public class MyController : Controller
{

    private readonly IMyInterface _myInterface;

    public MyController(IMyInterface myInterface)
    {
        _myInterface = myInterface;
    }

    public JsonResult Get()
    {
        return Json(_myInterface.Get());
    }
}

public interface IMyInterface
{
    IEnumerable<MyObject> Get();
}

public class MyClass : IMyInterface
{
    public IEnumerable<MyObject> Get()
    {
        // implementation
    }
}

Отже, у вашому додатку ви використовуєте контейнер для ін'єкцій залежностей у вашому startup.cs, який не робить нічого іншого, як надає конкретну інформацію MyClassдля використання, коли IMyInterfaceзустрічається. Це не означає, що це єдиний спосіб отримати екземпляриMyController .

У сценарії модульного тестування ви можете (і повинні) надати власну реалізацію (або макет / заглушку / підробку) IMyInterfaceяк:

public class MyTestClass : IMyInterface
{
    public IEnumerable<MyObject> Get()
    {
        List<MyObject> list = new List<MyObject>();
        // populate list
        return list;
    }        
}

і у вашому тесті:

[TestClass]
public class MyControllerTests
{

    MyController _systemUnderTest;
    IMyInterface _myInterface;

    [TestInitialize]
    public void Setup()
    {
        _myInterface = new MyTestClass();
        _systemUnderTest = new MyController(_myInterface);
    }

}

Отже, для обсягу модульного тестування MyControllerфактична реалізація IMyInterfaceне має значення (і не повинна мати значення), має значення лише сам інтерфейс. Ми запропонували "фейкову" реалізацію IMyInterfaceскрізь MyTestClass, але ви також можете зробити це з макетом, як через MoqабоRhinoMocks .

Підсумок: для виконання тестів вам насправді не потрібен контейнер для введення залежностей, а лише окрема, керована, реалізація / макет / заглушка / підробка залежностей ваших тестованих класів.

Хоча відповідь @ Kritner є правильною, я віддаю перевагу наступному для цілісності коду та кращого досвіду DI:

[TestClass]
public class MatchRepositoryTests
{
    private readonly IMatchRepository matchRepository;

    public MatchRepositoryTests()
    {
        var services = new ServiceCollection();
        services.AddTransient<IMatchRepository, MatchRepositoryStub>();

        var serviceProvider = services.BuildServiceProvider();

        matchRepository = serviceProvider.GetService<IMatchRepository>();
    }
}

Простим способом я написав загальний допоміжний клас вирішувача залежностей, а потім створив IWebHost у своєму модульному тестовому класі.

Загальний вирішувач залежностей

    public class DependencyResolverHelpercs
    {
        private readonly IWebHost _webHost;

        /// <inheritdoc />
        public DependencyResolverHelpercs(IWebHost WebHost) => _webHost = WebHost;

        public T GetService<T>()
        {
            using (var serviceScope = _webHost.Services.CreateScope())
            {
                var services = serviceScope.ServiceProvider;
                try
                {
                    var scopedService = services.GetRequiredService<T>();
                    return scopedService;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }
            };
        }
    }
}

Проект модульних випробувань

  [TestFixture]
    public class DependencyResolverTests
    {
        private DependencyResolverHelpercs _serviceProvider;

        public DependencyResolverTests()
        {

            var webHost = WebHost.CreateDefaultBuilder()
                .UseStartup<Startup>()
                .Build();
            _serviceProvider = new DependencyResolverHelpercs(webHost);
        }

        [Test]
        public void Service_Should_Get_Resolved()
        {

            //Act
            var YourService = _serviceProvider.GetService<IYourService>();

            //Assert
            Assert.IsNotNull(YourService);
        }


    }

Якщо ви використовуєте конвенцію Program.cs+ Startup.csі хочете швидко запустити цю роботу, ви можете повторно використати свій існуючий конструктор хостів за допомогою одного рядка:

using MyWebProjectNamespace;

public class MyTests
{
    readonly IServiceProvider _services = 
        Program.CreateHostBuilder(new string[] { }).Build().Services; // one liner

    [Test]
    public void GetMyTest()
    {
        var myService = _services.GetRequiredService<IMyService>();
        Assert.IsNotNull(myService);
    }
}

Зразок Program.csфайлу з веб-проекту:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace MyWebProjectNamespace
{
    public class Program
    {
        public static void Main(string[] args) =>
            CreateHostBuilder(args).Build().Run();

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }
}

Чому ви хочете вводити ті, хто навчається у тестовому класі? Зазвичай ви тестуєте MatchController, наприклад, використовуючи такий інструмент, як RhinoMocks, для створення заглушок або макетів . Ось приклад використання цього та MSTest, з якого ви можете екстраполювати:

[TestClass]
public class MatchControllerTests
{
    private readonly MatchController _sut;
    private readonly IMatchService _matchService;

    public MatchControllerTests()
    {
        _matchService = MockRepository.GenerateMock<IMatchService>();
        _sut = new ProductController(_matchService);
    }

    [TestMethod]
    public void DoSomething_WithCertainParameters_ShouldDoSomething()
    {
        _matchService
               .Expect(x => x.GetMatches(Arg<string>.Is.Anything))
               .Return(new []{new Match()});

        _sut.DoSomething();

        _matchService.AssertWasCalled(x => x.GetMatches(Arg<string>.Is.Anything);
    }