Тест простого метода

    [Fact]
    public void ParseDbSchemeTest()
    {
        //
        //Подготовка окружения.
 
        //Подключение к тестовому SQL-серверу.
        using var conn = CreateConnection();
 
        //Создание тестовой БД, создание структуры БД, покрывающей все сценарии.
        var dbName = "sample_db";
        PreapareTestDb(conn, dbName);
 
        //Структура БД для сравнения (загрузка из JSON, например).
        Database expectedDbStructure = PrepareExpected();
 
        //
        //Выполнение тестируемого метода.
        //* через information_schema считывает структуру БД (таблицы, колонки, индексы и т.п.)
        //* и раскладывает её в многоуровевую структуру объктов.
        Database actualDbStructure = new DatabaseParser().Parse(conn, dbName);
        DropTestDb(conn, dbName);
 
        //
        //Проверка результата.
        //* тут полное сравнение структур на всю глубину.
        Assert.True(expectedDbStructure.Equals(actualDbStructure));
    }

    [Fact]
    public void DbSchemeStructureTest()
    {
        //
        var type = typeof(Database);
 
        //Ожидаемая структура (из JSON, например).
        var expectedTypeInfo = LoadExcpectedTypeStructure(type);
 
        //Разбор (через reflection) структуры типа 'Database' на всю глубину.
        var actualTypeInfo = ParseByReflection(type);
 
        //
        Assert.True(expectedTypeInfo.Equals(actualTypeInfo));
    }

private static string EscapeName(string name) => $"[{name}]";

static class SqlServerHelpers
{
    public static string EscapeName(string name) => $"[{name}]";
}

sealed class SqlServerColumnsProvider : IColumnsProvider
{
    //Тут сокрыт конкретный SQL-запрос.
    //И отсюда в каком-то виде возвращаются сырые данные.
}

sealed class SqlServerColumnsProvider : IColumnsProvider
{

static class SqlServerHelpers
{
    public static string EscapeName(string name) => $"[{name}]";
}

public class Updater
{
    public void Apply(string json, IDbConnection conn);
}

class Some
{
}

using System.Runtime.CompilerServices;
 
[assembly: InternalsVisibleTo("Nya.ExampleInternalTest.UnitTest")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
 
public class PublicService
{
    private readonly IInternalService _internalService;
 
    public PublicService()
        : this(new InternalService())
    { }
    internal PublicService(IInternalService internalService)
    {
        _internalService = internalService;
    }
 
    public string CalculateAndFormat(int a, int b)
    { 
        var result = _internalService.Calc(a,b);
        return $"result = {result}";
    }
}
 
internal class InternalService : IInternalService
{
    public int Calc(int a, int b)
        => a + b;
}
 
internal interface IInternalService
{
    int Calc(int a, int b);
}

using Moq;
using Nya.ExampleInternalTest.Lib;
 
[TestClass]
public sealed class PublicServiceTests
{
 
    [DataRow(1, 2, "result = 0")]
    [TestMethod]
    public void TestCalculateAndFormat(int a, int b, string expected)
    {
        // Arrange
        var mockInternalService = new Mock<IInternalService>();
        mockInternalService.Setup(x => x.Calc(It.IsAny<int>(), It.IsAny<int>()))
            .Returns(0);
        var publicService = new PublicService(mockInternalService.Object);
 
        // Act
        var actual = publicService.CalculateAndFormat(a, b);
 
        // Assert
        Assert.AreEqual(expected, actual);
    }
}
 
[TestClass]
public sealed class InternalServiceTests
{
    [DataRow(1, 2, 3)]
    [TestMethod]
    public void TestCalculateAndFormat(int a, int b, int expected)
    {
        // Arrange
        var publicService = new InternalService();
 
        // Act
        var actual = publicService.Calc(a, b);
 
        // Assert
        Assert.AreEqual(expected, actual);
    }
}

using Nya.ExampleInternalTest.Lib;
 
var service = new PublicService();
//var internalService = new InternalService(); // not access
//var service2 = new PublicService(null); // not access
 
var result = service.CalculateAndFormat(-1, 5);

static class StringHelpers
{
    public static string CamelCaseToSnakeCase(string str)
    {
        ..
    }
}