Я чувствую, что упускаю что-то действительно очевидное. У меня есть классы, требующие ввода параметров с использованием шаблона .NET Core IOptions (?). При модульном тестировании этого класса я хочу имитировать различные версии параметров, чтобы проверить функциональность класса. Кто-нибудь знает, как правильно имитировать / создавать / заполнять IOptions вне класса Startup?

Вот несколько примеров классов, с которыми я работаю:

Настройки / Опции Модель

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace OptionsSample.Models
{
    public class SampleOptions
    {
        public string FirstSetting { get; set; }
        public int SecondSetting { get; set; }
    }
}

Класс для тестирования, который использует настройки:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using OptionsSample.Models
using System.Net.Http;
using Microsoft.Extensions.Options;
using System.IO;
using Microsoft.AspNetCore.Http;
using System.Xml.Linq;
using Newtonsoft.Json;
using System.Dynamic;
using Microsoft.Extensions.Logging;

namespace OptionsSample.Repositories
{
    public class SampleRepo : ISampleRepo
    {
        private SampleOptions _options;
        private ILogger _logger;

        public SampleRepo(IOptions options)
        {
            _options = options.Value;
        }

        public async Task Get()
        {
        }
    }
}

Модульный тест в сборке, отличной от других классов:

using OptionsSample.Repositories;
using OptionsSample.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;

namespace OptionsSample.Repositories.Tests
{
    public class SampleRepoTests
    {
        private IOptions _options;
        private SampleRepo _sampleRepo;


        public SampleRepoTests()
        {
            //Not sure how to populate IOptions here
            _options = options;

            _sampleRepo = new SampleRepo(_options);
        }
    }
}

Ответы (9)

Here's another easy way that doesn't need Mock, but instead uses the OptionsWrapper:

var myAppSettingsOptions = new MyAppSettingsOptions();
appSettingsOptions.MyObjects = new MyObject[]{new MyObject(){MyProp1 = "one", MyProp2 = "two", }};
var optionsWrapper = new OptionsWrapper(myAppSettingsOptions );
var myClassToTest = new MyClassToTest(optionsWrapper);

Вы можете вообще избежать использования MOQ. Используйте в своих тестах файл конфигурации .json. Один файл для множества файлов тестовых классов. В этом случае можно использовать ConfigurationBuilder.

Пример appsetting.json

{
    "someService" {
        "someProp": "someValue
    }
}

Пример настройки класса сопоставления:

public class SomeServiceConfiguration
{
     public string SomeProp { get; set; }
}

Пример услуги, которую необходимо протестировать:

public class SomeService
{
    public SomeService(IOptions config)
    {
        _config = config ?? throw new ArgumentNullException(nameof(_config));
    }
}

Тестовый класс NUnit:

[TestFixture]
public class SomeServiceTests
{

    private IOptions _config;
    private SomeService _service;

    [OneTimeSetUp]
    public void GlobalPrepare()
    {
         var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", false)
            .Build();

        _config = Options.Create(configuration.GetSection("someService").Get());
    }

    [SetUp]
    public void PerTestPrepare()
    {
        _service = new SomeService(_config);
    }
}

Использование класса Microsoft.Extensions.Options.Options:

var someOptions= Options.Create(new SampleOptions(){Field1="Value1",Field2="Value2"});

ИЛИ

var someOptions= Options.Create(new SampleOptions{Field1="Value1",Field2="Value2"});

Данный класс Person, который зависит от PersonSettings следующим образом:

public class PersonSettings
{
    public string Name;
}

public class Person
{
    PersonSettings _settings;

    public Person(IOptions settings)
    {
        _settings = settings.Value;
    }

    public string Name => _settings.Name;
}

IOptions можно смоделировать, а Person можно протестировать следующим образом:

[TestFixture]
public class Test
{
    ServiceProvider _provider;

    [OneTimeSetUp]
    public void Setup()
    {
        var services = new ServiceCollection();
        // mock PersonSettings
        services.AddTransient>(
            provider => Options.Create(new PersonSettings
            {
                Name = "Matt"
            }));
        _provider = services.BuildServiceProvider();
    }

    [Test]
    public void TestName()
    {
        IOptions options = _provider.GetService>();
        Assert.IsNotNull(options, "options could not be created");

        Person person = new Person(options);
        Assert.IsTrue(person.Name == "Matt", "person is not Matt");    
    }
}

Чтобы внедрить IOptions в Person вместо того, чтобы передавать его явно в ctor, используйте этот код:

[TestFixture]
public class Test
{
    ServiceProvider _provider;

    [OneTimeSetUp]
    public void Setup()
    {
        var services = new ServiceCollection();
        services.AddTransient>(
            provider => Options.Create(new PersonSettings
            {
                Name = "Matt"
            }));
        services.AddTransient();
        _provider = services.BuildServiceProvider();
    }

    [Test]
    public void TestName()
    {
        Person person = _provider.GetService();
        Assert.IsNotNull(person, "person could not be created");

        Assert.IsTrue(person.Name == "Matt", "person is not Matt");
    }
}

Для моих системных и интеграционных тестов я предпочитаю иметь копию / ссылку на мой файл конфигурации внутри тестового проекта. Затем я использую ConfigurationBuilder, чтобы получить параметры.

using System.Linq;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace SomeProject.Test
{
public static class TestEnvironment
{
    private static object configLock = new object();

    public static ServiceProvider ServiceProvider { get; private set; }
    public static T GetOption()
    {
        lock (configLock)
        {
            if (ServiceProvider != null) return (T)ServiceProvider.GetServices(typeof(T)).First();

            var builder = new ConfigurationBuilder()
                .AddJsonFile("config/appsettings.json", optional: false, reloadOnChange: true)
                .AddEnvironmentVariables();
            var configuration = builder.Build();
            var services = new ServiceCollection();
            services.AddOptions();

            services.Configure(configuration.GetSection("Products"));
            services.Configure(configuration.GetSection("Monitoring"));
            services.Configure(configuration.GetSection("Services"));
            ServiceProvider = services.BuildServiceProvider();
            return (T)ServiceProvider.GetServices(typeof(T)).First();
        }
    }
}
}

Таким образом, я могу использовать конфигурацию везде внутри моего TestProject. Для модульных тестов я предпочитаю использовать MOQ, как описано в patvin80.

Вы всегда можете создать свои параметры с помощью Options.Create (), а не просто использовать AutoMocker.Use (options) перед фактическим созданием фиктивного экземпляра репозитория, который вы тестируете. Использование AutoMocker.CreateInstance <> () упрощает создание экземпляров без ручной передачи параметров

Я немного изменил ваш SampleRepo, чтобы иметь возможность воспроизвести поведение, которого, как я думаю, вы хотите достичь.

public class SampleRepoTests
{
    private readonly AutoMocker _mocker = new AutoMocker();
    private readonly ISampleRepo _sampleRepo;

    private readonly IOptions _options = Options.Create(new SampleOptions()
        {FirstSetting = "firstSetting"});

    public SampleRepoTests()
    {
        _mocker.Use(_options);
        _sampleRepo = _mocker.CreateInstance();
    }

    [Fact]
    public void Test_Options_Injected()
    {
        var firstSetting = _sampleRepo.GetFirstSetting();
        Assert.True(firstSetting == "firstSetting");
    }
}

public class SampleRepo : ISampleRepo
{
    private SampleOptions _options;

    public SampleRepo(IOptions options)
    {
        _options = options.Value;
    }

    public string GetFirstSetting()
    {
        return _options.FirstSetting;
    }
}

public interface ISampleRepo
{
    string GetFirstSetting();
}

public class SampleOptions
{
    public string FirstSetting { get; set; }
}

Согласитесь с Алехой, что, вероятно, лучше использовать конфигурационный файл testSettings.json.

И затем, вместо того, чтобы вводить IOption , вы можете просто вставить реальные SampleOptions в свой конструктор класса, при модульном тестировании класса вы можете сделать следующее в фикстуре или снова просто в конструкторе тестового класса:

var builder = new ConfigurationBuilder ()
    .AddJsonFile ("testSettings.json", истина, истина)
    .AddEnvironmentVariables ();

var configurationRoot = builder.Build ();
configurationRoot.GetSection ("SampleRepo"). Bind (_sampleRepo);

Вам необходимо вручную создать и заполнить объект IOptions . Вы можете сделать это с помощью вспомогательного класса Microsoft.Extensions.Options.Options. Например:

IOptions someOptions = Options.Create(new SampleOptions());

Вы можете немного упростить это до:

var someOptions = Options.Create(new SampleOptions());

Очевидно, что это не очень полезно как есть. Вам нужно будет создать и заполнить объект SampleOptions и передать его в метод Create.

Если вы намереваетесь использовать Mocking Framework, как указано @TSeng в комментарии, вам необходимо добавить следующую зависимость в свой файл project.json.

   "Moq": "4.6.38-alpha",

После восстановления зависимости использовать структуру MOQ так же просто, как создать экземпляр класса SampleOptions и затем, как уже упоминалось, назначить его Value.

Вот схема кода, как это будет выглядеть.

SampleOptions app = new SampleOptions(){Title="New Website Title Mocked"}; // Sample property
// Make sure you include using Moq;
var mock = new Mock>();
// We need to set the Value of IOptions to be the SampleOptions Class
mock.Setup(ap => ap.Value).Returns(app);

После того, как макет настроен, вы можете передать его конструктору как

SampleRepo sr = new SampleRepo(mock.Object);   

HTH.

FYI У меня есть репозиторий git, в котором описаны эти 2 подхода на Github / patvin80

2022 WebDevInsider