Reflection or public?

spec.cs

    [Subject(typeof(Bootstrapper))]
    public class When_injecting_unit_of_work_and_repositories_and_parameter_config_in_a_consumer
    {
        class ConsumerForTest
        {
            private readonly IUnitOfWork _unitOfWork;
            private readonly IRepository<PosDevice> _posDeviceRepository;
            private readonly IRepository<Store> _storeRepository;
            private readonly ParameterConfig _parameterConfig;

            public ConsumerForTest(IUnitOfWork unitOfWork, IRepository<PosDevice> posDeviceRepository, 
                IRepository<Store> storeRepository, ParameterConfig parameterConfig)
            {
                _unitOfWork = unitOfWork;
                _posDeviceRepository = posDeviceRepository;
                _storeRepository = storeRepository;
                _parameterConfig = parameterConfig;
            }

            public IUnitOfWork UnitOfWork
            {
                get { return _unitOfWork; }
            }

            public IRepository<PosDevice> PosDeviceRepository
            {
                get { return _posDeviceRepository; }
            }

            public IRepository<Store> StoreRepository
            {
                get { return _storeRepository; }
            }

            public ParameterConfig ParameterConfig
            {
                get { return _parameterConfig; }
            }
        }

        static ConsumerForTest Consumer;
        static ObjectContext PosDeviceContext;
        static ObjectContext UnitOfWorkContext;
        static ObjectContext StoreContext;
        static ObjectContext ParameterConfigContext;

        Establish context = () =>
                                {
                                    var bootstrapper = new Bootstrapper();
                                    bootstrapper.BootAppConfig();
                                    bootstrapper.BootIoCContainer();
                                };

        Because of = () =>
        {
            Consumer = ObjectFactory.GetInstance<ConsumerForTest>();

            PosDeviceContext = Consumer.PosDeviceRepository.GetObjectContext();
            UnitOfWorkContext = Consumer.UnitOfWork.GetObjectContext();
            StoreContext = Consumer.StoreRepository.GetObjectContext();
            ParameterConfigContext = Consumer.ParameterConfig.ParameterRepository.GetObjectContext();
        };

        It should_share_the_same_object_context = () =>
        {
            PosDeviceContext.ShouldBeTheSameAs(UnitOfWorkContext);
            UnitOfWorkContext.ShouldBeTheSameAs(StoreContext);
            StoreContext.ShouldBeTheSameAs(ParameterConfigContext);
        };
    }

Die Repositories sind public im Consumer. Im Normfall wäre das nicht so. Der ObjectContext wird beispielsweise nicht nach außen gegeben. Im Test hole ich den ObjectContect per Reflection von den Repositories und dem UnitOfWork (GetObjectContext). Gibt es da ne bessere Lösung?

Wenn ich es richtig verstanden habe geht's in erster Linie also darum den ObjectContext aus der UnitOfWork zu ziehen. Da der nicht public ist hast du dir die extension method (?) GetObjectContext geschrieben, die aktuell per Reflection arbeitet. Korrekt?

Ich würde sagen, Reflection ist hier OK, solche Infrastruktur ändert sich ja nicht häufig.

Warum arbeitet das Repository nicht mit der UoW und nutzt dessen ObjectContext indirekt? Dann könntest du dir einen Teil der Tests vielleicht sparen.

Japp.
Mit dem UnitOfWork und den Repositories könnte ich mal umstellen. Danke so weit.