.Net, Base de Tests Unitaires - Maquette IOptions<T>

Si vous avez l'intention d'utiliser les Moqueries Cadre comme indiqué par @TSeng, dans le commentaire, vous devez ajouter la dépendance suivant dans votre projet.fichier json.

   "Moq": "4.6.38-alpha",

Une fois que la dépendance est restauré à l'aide de l'MOQ cadre est aussi simple que de créer une instance de la SampleOptions classe et puis comme c'est dit de l'affecter à la Valeur.

Voici un code décrire comment il devrait ressembler.

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 est de l'installation, vous pouvez maintenant passer à l'objet fantaisie pour le constructeur que

SampleRepo sr = new SampleRepo(mock.Object);   

HTH.

Pour info j'ai un dépôt git qui décrit ces 2 approches sur Github/patvin80

Classe donnée Person qui dépend de la PersonSettings comme 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> peut se moque de lui et Person peut être vérifiée 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");    
    }
}

À injecter IOptions<PersonSettings> en Person au lieu de passer explicitement à la 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");
    }
}

Pour mon système et des tests d'intégration, je préfère avoir un copier/lien de mon fichier de config à l'intérieur du projet de test. Puis-je utiliser le ConfigurationBuilder pour accéder aux 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 config partout à l'intérieur de mon projet d'essai. Pour les tests unitaires, je préfère utiliser MOQ comme patvin80 décrit.

Vous pouvez toujours créer vos options via les Options.Create() et que de simplement utiliser AutoMocker.Utilisation(options) avant la création de l'instance factices du dépôt que vous effectuez le test. À L'Aide De AutoMocker.CreateInstance<>() rend plus facile à créer des instances manuellement sans passer des paramètres

J'ai changé vous êtes SampleRepo un peu afin d'être en mesure de reproduire le problème, je pense que vous voulez atteindre.

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