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 InitializeFixture()
{
//Bootstrapper.Excluding.Assembly("JONMVC.Core.Configurations").With.AutoMapper().Start();
MapsContainer.CreateAutomapperMaps();
mapper = Mapper.Engine;
}
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;
}
public BrokerController(
IBrokerRepository brokerRepository,
IMappingEngine mappingEngine)
{
_brokerRepository = brokerRepository;
_mappingEngine = mappingEngine;
}
public CardController(IReadOnlyRepository readOnlyRepository, IWriteOnlyRepository writeOnlyRepository,
IMappingEngine mappingEngine)
{
_readOnlyRepository = readOnlyRepository;
_writeOnlyRepository = writeOnlyRepository;
_mappingEngine = mappingEngine;
}
public ExampleModule(IRepositoryOfId<int> repository, IMappingEngine engine, ISendOnlyBus bus)
{
Get["/examples"] = _ => repository.Query<ExampleEntity>()
.Project().To<ExampleModel>()
.ToList();
Get["/example/{id:int}"] = _ => {
var entity = repository.Load<ExampleEntity>(_.id);
return engine.Map<ExampleEntity, ExampleModel>(entity);
};
Post["/examples"] = _ => {
var model = this.BindAndValidateModel<NewExampleModel>();
var entity = new ExampleEntity(model.Name);
repository.Save(entity);
return new NewExampleCreatedModel { Id = entity.ID };
};
Post["/examples/close"] = _ => {
var model = this.BindAndValidateModel<CloseExampleModel>();
bus.Send(new CloseExampleCommand {Id = model.Id});
return HttpStatusCode.OK;
};
Delete["/example/{id:int}"] = _ => {
repository.Delete<ExampleEntity>(_.id);
return HttpStatusCode.OK;
};
}
public CashflowRepository(
IModelContextFactory factory,
IMappingEngine mapper)
{
this.factory = factory;
this.mapper = mapper;
}
public BasketController(
IBasketRepository basketRepository,
IMappingEngine mappingEngine)
{
_basketRepository = basketRepository;
_mappingEngine = mappingEngine;
}
public TaskController(ICommandBus commandBus, IMappingEngine mappingEngine, IIdentity identity, IViewModelData viewModelData)
{
_commandBus = commandBus;
_mappingEngine = mappingEngine;
_identity = identity;
_viewModelData = viewModelData;
}
public PeopleController(IMappingEngine mappingEngine, IPersonRepository personRepository)
{
if (mappingEngine == null) throw new ArgumentNullException("mappingEngine");
if (personRepository == null) throw new ArgumentNullException("personRepository");
_mappingEngine = mappingEngine;
_personRepository = personRepository;
}
public ItemsController(IItemsRepository itemsRepository, IMappingEngine mappingEngine)
{
if (itemsRepository == null) throw new ArgumentNullException(nameof(itemsRepository));
if (mappingEngine == null) throw new ArgumentNullException(nameof(mappingEngine));
_itemsRepository = itemsRepository;
_mappingEngine = mappingEngine;
}
public PatternManageViewModelProvider(
IPatternRepository patternsRepository,
IMappingEngine mappingEngine)
{
_patternsRepository = patternsRepository;
_mappingEngine = mappingEngine;
}
