dotnet-testing-private-internal-testing

name	dotnet-testing-private-internal-testing
description	Guide for Private and Internal member testing strategies. Use when you need to test private or internal members, configure InternalsVisibleTo, or evaluate testability design. Covers design-first thinking, reflection testing, strategy pattern refactoring, AbstractLogger pattern, and decision frameworks. Keywords: private method testing, internal testing, InternalsVisibleTo, reflection testing, GetMethod BindingFlags, Meziantou.MSBuild.InternalsVisibleTo, testability design, strategy pattern refactoring, testability
metadata	{"short-description":".NET skill guidance for dotnet-testing-private-internal-testing"}

Source: kevintsengtw/dotnet-testing-agent-skills (MIT). Ported into dotnet-agent-harness.

Private and Internal Member Testing Strategy Guide

This skill helps you properly handle testing of private and internal members in .NET testing, emphasizing design-first testing thinking.

Applicable Scenarios

Use this skill when asked to perform the following tasks:

• Test private or internal methods and properties
• Configure InternalsVisibleTo to access internal members
• Evaluate whether to test private methods or refactor design
• Use Reflection to access private members
• Improve code testability design

Core Principles: Design-First Thinking

Golden Rule

Good design naturally has good testability. If you find yourself frequently needing to test private methods, the design is likely problematic

Signs of Design Problems

When you want to test private methods, first check for these signs:

• ❌ Private methods over 10 lines with complex logic
• ❌ Private methods contain important business rules
• ❌ Private methods difficult to test indirectly through public methods
• ❌ Class has multiple responsibilities

Solution: Refactor Rather Than Test

// ❌ Problematic design
public class OrderProcessor
{
    public OrderResult ProcessOrder(Order order)
    {
        // Uses multiple complex private methods
        var discount = CalculateDiscount(order); // 20 lines logic
        var tax = CalculateTax(order, discount);  // 15 lines logic
        // ...
    }

    private decimal CalculateDiscount(Order order) { /* complex logic */ }
    private decimal CalculateTax(Order order, decimal discount) { /* complex logic */ }
}

// ✅ Improved design: Separation of concerns
public class OrderProcessor
{
    private readonly IDiscountCalculator _discountCalculator;
    private readonly ITaxCalculator _taxCalculator;

    public OrderProcessor(
        IDiscountCalculator discountCalculator,
        ITaxCalculator taxCalculator)
    {
        _discountCalculator = discountCalculator;
        _taxCalculator = taxCalculator;
    }

    public OrderResult ProcessOrder(Order order)
    {
        var discount = _discountCalculator.Calculate(order);
        var tax = _taxCalculator.Calculate(order, discount);
        
    }
}


   : 
{
    
    {
        
    }
}
```text







- ✅ Framework    
- ✅    
- ✅ -  
- ✅ -  

###  

- ❌     (  )
- ❌   
- ❌         

###  1:   

  ,    :

```

 ;

[]
[]
```text



- Simple  direct
- No additional packages needed



- Requires hardcoded assembly names
- For signed assemblies, need to include  key



Configure via MSBuild properties:

```xml
<!-- YourProject.csproj -->
<Project Sdk=>
  <PropertyGroup>
    <TargetFramework>net9</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <AssemblyAttribute Include=>
      <_Parameter1>$(AssemblyName).Tests</_Parameter1>
    </AssemblyAttribute>
  </ItemGroup>
</Project>
```text



- Can use MSBuild variables
- Centralized management



For complex projects, recommend   NuGet package:

```xml
<!-- YourProject.csproj -->
<ItemGroup>
  <PackageReference Include= Version=>
    <PrivateAssets>all</PrivateAssets>
    <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
</ItemGroup>

<ItemGroup>
  <InternalsVisibleTo Include= />
  <InternalsVisibleTo Include= />
  <InternalsVisibleTo Include= Key= />
</ItemGroup>
```text



- Automatically handles  keys  signed assemblies
- 
{
    
    {
         basePrice = product.BasePrice;
         discount = CalculateDiscount(customer, product); 
         tax = CalculateTax(product, customer.Location);   
         basePrice - discount + tax;
    }

    
    {
        
    }

    
    {
        
    }
}
```text



```csharp

  
{
    ;
}

  
{
    ;
}


   : 
{
    
    {
        
         (customer.IsVIP)
             product.BasePrice * m;

         ;
    }
}

   : 
{
    
    {
        
         product.BasePrice * m;
    }
}


  
{
      IDiscountStrategy _discountStrategy;
      ITaxStrategy _taxStrategy;

    
    {
        _discountStrategy = discountStrategy;
        _taxStrategy = taxStrategy;
    }

    
    {
         basePrice = product.BasePrice;
         discount = _discountStrategy.Calculate(customer, product);
         tax = _taxStrategy.Calculate(product, customer.Location);
         basePrice - discount + tax;
    }
}
```text



- Each strategy can be tested independently
- Follows Open/Closed Principle
- Easy to extend  strategies
- Reduces dependency  reflection



Sometimes need to mock  behavior of a :

```

  
{
    
    {
         validated = ValidateInput(input);
         (!validated)
             ProcessResult.InvalidInput();

         data = TransformData(input);
         saved = SaveData(data); 

         saved
            ? ProcessResult.Success()
            : ProcessResult.Failed();
    }

    
    {
        
         ;
    }

     => !.IsNullOrEmpty(input);
     => input.ToUpper();
}


   : 
{
    
    {
        
         ;
    }
}


[]

{
    
     processor =  TestableDataProcessor();

    
     result = processor.Process();

    
    result.Success.Should().BeTrue();
}
```text









- Are  methods too complex? (>  lines)
- Does the    ?
-        ?

###  

-   ( ,  )
-     

####  2:   

### :       ?

-       ?
-        ?
-         ?

###  : ()

-     ,   
-      

####  3:   

### :       ?

  :

- ✅      
- ✅    
- ✅   -   

###  : ()

-    ,     
-   ,  ,   

###  

|                     |       |                  |
| :-------------------------- | :----------------------- | :--------------------- |
|    (< 10 ) |     |    |
|    (> 10 ) |     |     |
|    |   |      |
|     |    |    - |
| -   |      |     |
|     |    |    |

##  -  

1. ** **
   - ✅      
   - ✅      
   - ✅       
   - ✅    

2. **  **
   - ✅      
   - ✅       
   - ✅       

3. **  **
   - ✅       
   - ✅     
   - ✅      

4. **  **
   - ✅       
   - ✅        
   - ✅      

## ' -   

1. **' -  **
   - ❌       
   - ❌ '   /
   - ❌     

2. **'   **
   - ❌ '        
   - ❌ '    
   - ❌ '    

3. **'    **
   - ❌       
   - ❌ '     
   - ❌      

4. **'  **
   - ❌ '      
   - ❌     
   - ❌ '       

##  

 `/`    :

- `---` -   
- `--` -    
- `--` -    

##  

###  

       "   '   - 30  "  :

- ** 09 -     :     **
  - : :
  -  : :

###  

- ['  - ](:

###  

- `--` -   
- `-` -    

##  

      ,     :

- [ ]         
- [ ]          
- [ ]     
- [ ]       
- [ ]       (.,  )
- [ ]          
- [ ]  '     
- [ ]     
- [ ]      
- [ ]