When you have a class that is populated using "configuration.Bind" you might find it useful to test that the properties are correctly set. This confirms that the property names are correctly aligned with your expected keys and that all your bound properties have accessible "setters" to be called by the binding engine. (Given that the interface that my config files implement are usually "read-only" then the "set" is not enforced) See the example class:
public class SomeSettings
{
    public SomeSettings(IConfiguration configuration)
    {
        if (configuration == null) throw new ArgumentNullException(nameof(configuration));
        configuration.Bind("SomeSettings", this);
    }

    public int SomeIntSetting { get; set; }
    public IReadOnlyList<SomeChildSetting> SomeListOfObjects { get; set; }
    public IReadOnlyList<string> SomeListOfValues { get; set; }
}

public class SomeChildSetting
{
    public string SomeChildItem { get; set; }
}
Your appsettings.json file might look like:
{
    "SomeSettings": {
         "SomeIntSetting": 1,
         "SomeListOfObjects": [
             {
                  "SomeChildItem": "hello"
             },
             {
                  "SomeChildItem": "world"
             }
          ],
       "SomeListOfValues": [ "this", "is", "great" ]
    }
}
The above should work, however renaming a property on the class would break the binding or removing the "set" against a property would break the binding, but there would be no errors during compilation or runtime, it would simply ignore the things that couldn't be bound. Therefore, it's worth adding unit tests to protect against such bugs, which can be achieved using the "ConfigurationBuilder" which supports in memory collections, as shown below:
[TestFixture]
public class SomeSettingsTests
{
    private readonly Fixture _fixture = new Fixture();
    private Dictionary<string, string> _stubConfigs;
    private IConfigurationBuilder _configurationBuilder;

    [SetUp]
    public void SetUp()
    {
        _stubConfigs = new Dictionary<string, string>();
        _configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(_stubConfigs);
    }

    [Test]
    public void Ctor_ConfigurationNull_ThrowsException()
    {
        Func<SomeSettings> act = () => new SomeSettings(null);

        act.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("configuration");
    }

    [Test]
    public void SomeIntSetting_WhenConfigured_IsExpected()
    {
        var value = _fixture.Create<int>();
        _stubConfigs.Add("SomeSettings:SomeIntSetting", value.ToString());

        var result = GetDefaultSut().SomeIntSetting;

        result.Should().Be(value);
    }

    [Test]
    public void SomeListOfObjects_WhenConfigured_IsExpected()
    {
        var childSettings = _fixture.CreateMany<SomeChildSetting>().ToList();

        for (var i = 0; i < childSettings.Count; i++)
        {
            foreach (var propertyInfo in typeof(SomeChildSetting).GetProperties())
            {
                _stubConfigs.Add($"SomeSettings:SomeListOfObjects:{i}:{propertyInfo.Name}", propertyInfo.GetGetMethod().Invoke(childSettings[i], null).ToString());
            }
        }

        var result = GetDefaultSut().SomeListOfObjects;

        result.Should().BeEquivalentTo(childSettings);
    }

    [Test]
    public void SomeListOfValues_WhenConfigured_IsExpected()
    {
        var values = _fixture.CreateMany<string>().ToList();

        for (var i = 0; i < values.Count; i++)
        {
            _stubConfigs.Add($"SomeSettings:SomeListOfValues:{i}", values[i]);
        }

        var result = GetDefaultSut().SomeListOfValues;

        result.Should().BeEquivalentTo(values);
    }

    private SomeSettings GetDefaultSut() => new SomeSettings(_configurationBuilder.Build());
}