protected override void Context()
        {
            AccountService = MockRepository.GenerateStub<IAccountService>();

            Identity = new FakeIdentity(Username);
            _user = new FakePrincipal(Identity, null);

            HttpRequest = MockRepository.GenerateStub<HttpRequestBase>();
            HttpContext = MockRepository.GenerateStub<HttpContextBase>();
            HttpContext.Stub(x => x.Request).Return(HttpRequest);
            HttpContext.User = _user;

            _httpResponse = MockRepository.GenerateStub<HttpResponseBase>();
            _httpResponse.Stub(x => x.Cookies).Return(new HttpCookieCollection());
            HttpContext.Stub(x => x.Response).Return(_httpResponse);

            Logger = MockRepository.GenerateStub<ILogger>();
            WebAuthenticationService = MockRepository.GenerateStub<IWebAuthenticationService>();

            MappingEngine = MockRepository.GenerateStub<IMappingEngine>();
            AccountCreator = MockRepository.GenerateStub<IAccountCreator>();

            AccountController = new AccountController(AccountService, Logger, WebAuthenticationService, MappingEngine, null, AccountCreator);
            AccountController.ControllerContext = new ControllerContext(HttpContext, new RouteData(), AccountController);
        }

 public MyAccountViewModelBuilder(string userEmail, ICustomerAccountService customerAccountService, IOrderRepository orderRepository, IMappingEngine mapper)
 {
     this.userEmail = userEmail;
     this.customerAccountService = customerAccountService;
     this.orderRepository = orderRepository;
     this.mapper = mapper;
 }

 public EmailRingEmailTemplateViewModelBuilder(EmailRingModel model, IJewelRepository jewelRepository,
     IMappingEngine mapper)
 {
     this.model = model;
     this.jewelRepository = jewelRepository;
     this.mapper = mapper;
 }

 public CompositionsViewModelProvider(
     IImageRepository imageRepository, 
     IMappingEngine mappingEngine)
 {
     _imageRepository = imageRepository;
     _mappingEngine = mappingEngine;
 }

 public PrinterMessageProvider(
     QueueListenerFactory listenerFactory,
     IMappingEngine mappingEngine)
 {
     _listenerFactory = listenerFactory;
     _mappingEngine = mappingEngine;
 }

 public BorrowerItemController(IBorrowerItemRepository borrowerItemRepository, IMappingEngine mappingEngine, IBorrowerRepository borrowerRepository, IItemRepository itemRepository)
 {
     _borrowerItemRepository = borrowerItemRepository;
     _mappingEngine = mappingEngine;
     _borrowerRepository = borrowerRepository;
     _itemRepository = itemRepository;
 }

        public void Initialize()
        {
            _uow = A.Fake<IUnitOfWork>();
            _mapper = A.Fake<IMappingEngine>();
            _service = new HouseService(_uow, _mapper);

            // Initializing HouseDTO's
            _nonExistingHouseDTO = new HouseDTO();
            _existingHouseDTO = new HouseDTO();
            _houseWithBookingsDTO = new HouseDTO();
            _houseWithNoBookingsDTO = new HouseDTO();

            // Initializing Houses
            _nonExistingHouse = new House();
            _existingHouse = new House();
            _houseWithBookings = new House();
            _houseWithNoBookings = new House();

            // Controlling mapper behaviour
            A.CallTo(() => _mapper.Map<House>(_nonExistingHouseDTO)).Returns(_nonExistingHouse);
            A.CallTo(() => _mapper.Map<House>(_existingHouseDTO)).Returns(_existingHouse);
            A.CallTo(() => _mapper.Map<House>(_houseWithBookingsDTO)).Returns(_houseWithBookings);
            A.CallTo(() => _mapper.Map<House>(_houseWithNoBookingsDTO)).Returns(_houseWithNoBookings);

            // Controlling service behaviour
            A.CallTo(() => _uow.HouseRepository.IsDuplicate(_nonExistingHouse)).Returns(false);
            A.CallTo(() => _uow.HouseRepository.IsDuplicate(_existingHouse)).Returns(true);
            A.CallTo(() => _uow.HouseRepository.HasBookings(_houseWithBookings)).Returns(true);
            A.CallTo(() => _uow.HouseRepository.HasBookings(_houseWithNoBookings)).Returns(false);
        }

 public TitleService(IUnitOfWork unitOfWork, IApplicationUserManager userManager, IMappingEngine mappingEngine)
 {
     _userManager = userManager;
     _unitOfWork = unitOfWork;
     _titles = _unitOfWork.Set<Title>();
     _mappingEngine = mappingEngine;
 }

        public UserModule(IMappingEngine mappingEngine, IReadOnlyRepository readOnlyRepository)
        {
            Get["/me"] = r => mappingEngine.Map<User, MeResponse>(this.UserSession().User);

            Get["/user/exists"] =
                r =>
                    {
                        bool exists = false;
                        bool activated = false;
                        var email = (string) Request.Query.email;
                        try
                        {
                            var user =
                                readOnlyRepository.First<User>(x => x.Email == email);
                            exists = true;
                            activated = user.Activated;
                        }
                        catch (ItemNotFoundException<User>)
                        {
                        }
                        return new UserExistenceResponse
                                   {
                                       Exists = exists,
                                       Activated = activated,
                                   };
                    };
        }

 public BalanceDateRepository(
                 IModelContextFactory factory, 
                 IMappingEngine mapper)
 {
     this.factory = factory;
     this.mapper = mapper;
 }

 public ModuleManagedViewModel(SettingsProvider settingsProvider, IViewModelNavigator navigator,
     IMappingEngine mappingEngine)
 {
     _settingsProvider = settingsProvider;
     _navigator = navigator;
     _mappingEngine = mappingEngine;
 }

        public UserModule(IMappingEngine mappingEngine, IReadOnlyRepository readOnlyRepository)
        {
            Get["/me"] = r =>
                             {
                                 return mappingEngine.Map<User, MeResponse>(this.UserSession().User);
                             };

            Get["/user/exists"] =
                r =>
                {
                    bool exists = false;
                    bool activated = false;
                    var facebookid = (long)Request.Query.facebookid;
                    try
                    {
                        var user =
                            readOnlyRepository.First<User>(x => x.FacebookId == facebookid);
                        if (user != null)
                        {
                            exists = true;
                            activated = user.Verified;
                        }

                    }
                    catch (ItemNotFoundException<User>)
                    {
                    }
                    return new UserExistenceResponse
                    {
                        Exists = exists,
                        Activated = activated,
                    };
                };
        }

        public ReportModule(IReportService reportService, IReportResultService reportResultService, IMappingEngine mappingEngine)
            : base("data/reports", mappingEngine, UserRole.Standard)
        {
            this.reportService = reportService;
            this.reportResultService = reportResultService;

            Get["/"] = SearchReports;

            Get["/{id}"] = GetReport;

            Post["/"] = AddReport;

            Put["/{id}"] = UpdateReport;

            Delete["/{id}"] = DeleteReport;

            Put["/{id}/request"] = RequestReport;

            Get["/myResults"] = GetMyResults;

            Get["/results/{id}"] = ViewReportResults;

            Get["/results/{id}/download/{*}"] = DownloadReportResults;

            Get["/builder"] = GetReportBuilderData;

            Get["/builder/summary"] = GetReportDataSummary;
        }

 public PersonController(IPersonRepository personRepository, IMappingEngine mappingEngine)
 {
     if (personRepository == null) throw new ArgumentNullException(nameof(personRepository));
     if (mappingEngine == null) throw new ArgumentNullException(nameof(mappingEngine));
     this._personRepository = personRepository;
     this._mappingEngine = mappingEngine;
 }

        public MyAccountModule(IUserService userService, IMappingEngine mappingEngine)
            : base("data/users", mappingEngine, UserRole.Standard)
        {
            Get["/myAccount"] = args =>
            {
                var authorizedUser = Context.GetAuthorizedUser();

                var foundUser = userService.Get(authorizedUser.Id);
                return MapTo<User>(foundUser);
            };

            Put["/myAccount"] = args =>
            {
                var model = this.BindAndValidate<Models.User>();

                if (!ModelValidationResult.IsValid)
                {
                    return RespondWithValidationFailure(ModelValidationResult);
                }

                var authorizedUser = Context.GetAuthorizedUser();
                var updateEntity = MapTo<SystemUser>(model);
                var updatedUser = userService.UpdateUser(authorizedUser.Id, authorizedUser.Id, updateEntity);

                Context.SetupSession(updatedUser);
                return MapTo<User>(updatedUser);
            };
        }

 public AuditLogService(IUnitOfWork unitOfWork, IApplicationUserManager userManager, IMappingEngine mappingEngine)
 {
     _userManager = userManager;
     _unitOfWork = unitOfWork;
     _logs = _unitOfWork.Set<AuditLog>();
     _mappingEngine = mappingEngine;
 }

        public GenreServiceBuilder WithDefaultFakeMapper()
        {
            var fakeMapping = A.Fake<IMappingEngine>();
            _mapper = fakeMapping;

            return this;
        }

 public EntireEvaluationService(IUnitOfWork unitOfWork, IApplicationUserManager userManager, IMappingEngine mappingEngine)
 {
     _userManager = userManager;
     _unitOfWork = unitOfWork;
     _entireEvaluations = _unitOfWork.Set<EntireEvaluation>();
     _mappingEngine = mappingEngine;
 }

        public void Setup()
        {
            _session = new HappyPathInMemorySession();
            _mappingEngine = Substitute.For<IMappingEngine>();

            _personService = new PersonService(_session, _mappingEngine);
        }

 public AuctionsController(
     IAuctionBlockService auctionBlockService,
     IMappingEngine mappingEngine)
 {
     _auctionBlockService = auctionBlockService;
     _mappingEngine = mappingEngine;
 }