Test unitaire .Net Core - IOptions simulées <T>

J'ai l'impression de manquer quelque chose de vraiment évident ici. J'ai des classes qui nécessitent l'injection d'options à l'aide du modèle .Net Core IOptions (?). Quand je vais au test unitaire de cette classe, je veux me moquer de différentes versions des options pour valider la fonctionnalité de la classe. Est-ce que quelqu'un sait comment simuler / instancier / remplir correctement les IOptions en dehors de la classe Startup?

Voici quelques exemples des classes avec lesquelles je travaille:

Modèle de paramètres / options

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; }
    }
}

Classe à tester qui utilise les paramètres:

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<AzureStorageQueuePassthru> _logger;

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

        public async Task Get()
        {
        }
    }
}

Test unitaire dans un assembly différent des autres classes:

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<SampleOptions> _options;
        private SampleRepo _sampleRepo;


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

            _sampleRepo = new SampleRepo(_options);
        }
    }
}

Vous devez créer et remplir manuellement un IOptions<SampleOptions>objet. Vous pouvez le faire via la Microsoft.Extensions.Options.Optionsclasse helper. Par exemple:

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

Vous pouvez simplifier un peu cela pour:

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

De toute évidence, ce n'est pas très utile en l'état. Vous devrez créer et remplir un objet SampleOptions et le transmettre à la méthode Create.

Si vous avez l'intention d'utiliser le Mocking Framework comme indiqué par @TSeng dans le commentaire, vous devez ajouter la dépendance suivante dans votre fichier project.json.

   "Moq": "4.6.38-alpha",

Une fois la dépendance restaurée, l'utilisation du framework MOQ est aussi simple que de créer une instance de la classe SampleOptions, puis, comme mentionné, de l'affecter à Value.

Voici un aperçu du code à quoi cela ressemblerait.

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

Une fois la maquette configurée, vous pouvez maintenant transmettre l'objet maquette au constructeur en tant que

SampleRepo sr = new SampleRepo(mock.Object);   

HTH.

Pour info, j'ai un référentiel git qui décrit ces 2 approches sur Github / patvin80

Vous pouvez éviter d'utiliser MOQ du tout. Utilisez dans votre fichier de configuration de tests .json. Un fichier pour de nombreux fichiers de classe de test. Ce sera bien d'utiliser ConfigurationBuilderdans ce cas.

Exemple de appsetting.json

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

Exemple de classe de mappage des paramètres:

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

Exemple de service nécessaire pour tester:

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

Classe de test NUnit:

[TestFixture]
public class SomeServiceTests
{

    private IOptions<SomeServiceConfiguration> _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<SomeServiceConfiguration>());
    }

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

Classe donnée Personqui dépend de ce PersonSettingsqui suit:

public class PersonSettings
{
    public string Name;
}

public class Person
{
    PersonSettings _settings;

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

    public string Name => _settings.Name;
}

IOptions<PersonSettings>peuvent être moqués et Personpeuvent être testés comme suit:

[TestFixture]
public class Test
{
    ServiceProvider _provider;

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

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

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

Pour injecter IOptions<PersonSettings>dans Personau lieu de le passer explicitement au ctor, utilisez ce code:

[TestFixture]
public class Test
{
    ServiceProvider _provider;

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

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

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

Vous pouvez toujours créer vos options via Options.Create () et utiliser simplement AutoMocker.Use (options) avant de créer l'instance simulée du référentiel que vous testez. L'utilisation d'AutoMocker.CreateInstance <> () facilite la création d'instances sans passer manuellement les paramètres

J'ai un peu changé votre SampleRepo afin de pouvoir reproduire le comportement que je pense que vous souhaitez obtenir.

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

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

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

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

public class SampleRepo : ISampleRepo
{
    private SampleOptions _options;

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

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

public interface ISampleRepo
{
    string GetFirstSetting();
}

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

Voici un autre moyen simple qui n'a pas besoin de Mock, mais utilise à la place le OptionsWrapper:

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

Pour mes tests système et d'intégration, je préfère avoir une copie / un lien de mon fichier de configuration dans le projet de test. Et puis j'utilise ConfigurationBuilder pour obtenir les options.

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<T>()
    {
        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<ProductOptions>(configuration.GetSection("Products"));
            services.Configure<MonitoringOptions>(configuration.GetSection("Monitoring"));
            services.Configure<WcfServiceOptions>(configuration.GetSection("Services"));
            ServiceProvider = services.BuildServiceProvider();
            return (T)ServiceProvider.GetServices(typeof(T)).First();
        }
    }
}
}

De cette façon, je peux utiliser la configuration partout dans mon TestProject. Pour les tests unitaires, je préfère utiliser MOQ comme décrit par patvin80.

D'accord avec Aleha, l'utilisation d'un fichier de configuration testSettings.json est probablement meilleure. Et puis, au lieu d'injecter l'IOption, vous pouvez simplement injecter les vrais SampleOptions dans votre constructeur de classe, lorsque vous testez la classe unitaire, vous pouvez faire ce qui suit dans un fixture ou à nouveau simplement dans le constructeur de la classe de test:

   var builder = new ConfigurationBuilder()
  .AddJsonFile("testSettings.json", true, true)
  .AddEnvironmentVariables();

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