AutoFixture type customization not invoked - autofixture

Question

Given
This is my class structure being tested.
public class Company
{
public List<Department> Departments { get; set; }
}
public class Department
{
public List<Employee> Employees { get; set; }
}
public class Employee
{
public string Name { get; set; }
public DateTime HireDate { get; set; }
}
And I want to have an customized object of Employee added to Department.Employees when AutoFixture is told to Create<Company>().
I would think this should be written thus:
_fixture.Customize<Department>(
c => c.Do(d => d.Employees
.Add(_fixture.Build<Employee>()
.With(e => e.Name, "simple name")
.Create())));
_fixtrue.Create<Company>();
However
When I run the test, the Company.Departments property is populated with 3 objects, and each of those three objects has a Department.Employees list populated with 3 objects (expected 4 or 1) and none of the Employee objects have the name specified. Why?
Possibly relevant
I am also using the AutoNSubstituteCustomization and a homegrown implementation of ISpecimenBuilder for an unrelated type on the fixture.
That ISpecimenBuilder is:
public class PropertyTypeOmission
{
public SelectionContext<TDeclaringType> For<TDeclaringType>()
{
return new SelectionContext<TDeclaringType>();
}
public class SelectionContext<TDeclaringType>
{
public OmitMemberTypeByType Omitting<TPropertyType>()
{
return new OmitMemberTypeByType(typeof(TDeclaringType), typeof(TPropertyType));
}
public OmitMemberTypeByType Omitting<TMemberType>(Expression<Func<TDeclaringType, TMemberType>> select)
{
var memberExp = GetMemberExpression(select);
var property = GetPropertyInfo(memberExp);
if (property != null)
{
return new OmitMemberTypeByType(typeof(TDeclaringType), property.PropertyType);
}
var field = GetFieldInfo(memberExp);
if (field != null)
{
return new OmitMemberTypeByType(typeof(TDeclaringType), field.FieldType);
}
throw new ArgumentException("Only field or property selectors allowed");
}
private static PropertyInfo GetPropertyInfo(MemberExpression memberExp)
{
if (!(memberExp.Member is PropertyInfo property))
{
return null;
}
return property;
}
private static MemberExpression GetMemberExpression<TMemberType>(Expression<Func<TDeclaringType, TMemberType>> select)
{
if (!(select.Body is MemberExpression memberExp))
{
throw new ArgumentException("only member expressions are allowed");
}
return memberExp;
}
private static FieldInfo GetFieldInfo(MemberExpression memberExp)
{
if (!(memberExp.Member is FieldInfo field))
{
return null;
}
return field;
}
}
}
public class OmitMemberTypeByType : ISpecimenBuilder
{
private Type _declaringType;
private Type _memberType;
public OmitMemberTypeByType(Type declaringType, Type memberType)
{
_declaringType = declaringType;
_memberType = memberType;
}
public object Create(object request, ISpecimenContext context)
{
if ((!(request is PropertyInfo propertyInfo)
|| propertyInfo.DeclaringType != _declaringType
|| propertyInfo.PropertyType != _memberType)
&&
(!(request is FieldInfo fieldInfo)
|| fieldInfo.DeclaringType != _declaringType
|| fieldInfo.FieldType != _memberType))
{
return new NoSpecimen();
}
return new OmitSpecimen();
}
}
used as
_fixture.Customizations.Add(new PropertyTypeOmission().For<State>().Omitting(s => s.SqMiles));

Answer 1

The customization example you gave threw an exception for me.
It did that because the Employees property was not initialized, and then one of cource can't .Add() anything to it.
This worked for me:
List<Employee> EmployeesFactory((List<Employee> employees, Employee employee) input)
{
input.employee.Name = "simple name";
input.employees.Add(input.employee);
return input.employees;
}
_fixture
.Customize<Department>(c =>
c.With<List<Employee>, (List<Employee>, Employee)>(
x => x.Employees,
EmployeesFactory));