public void LoginSuccessfulTest_MakesSureAccountIsCreated_VerifiesAndAssertsTheReturnedValue()
{
RegistrationController registrationController = (RegistrationController)_applicationContext["RegistrationController"];
IHttpActionResult httpActionResult = registrationController.Register(new SignUpParam("*****@*****.**", "user", "123", "Pakistan",
TimeZone.CurrentTimeZone, ""));
OkNegotiatedContentResult <string> okResponseMessage =
(OkNegotiatedContentResult <string>)httpActionResult;
string activationKey = okResponseMessage.Content;
Assert.IsNotNullOrEmpty(activationKey);
UserController userController = (UserController)_applicationContext["UserController"];
httpActionResult = userController.ActivateUser(new UserActivationParam("user", "123", activationKey));
OkNegotiatedContentResult <string> okResponseMessage1 =
(OkNegotiatedContentResult <string>)httpActionResult;
Assert.AreEqual(okResponseMessage1.Content, "activated");
LoginController loginController = (LoginController)_applicationContext["LoginController"];
httpActionResult = loginController.Login(new LoginParams("user", "123"));
OkNegotiatedContentResult <UserValidationEssentials> keys =
(OkNegotiatedContentResult <UserValidationEssentials>)httpActionResult;
Assert.IsNotNullOrEmpty(keys.Content.ApiKey);
Assert.IsNotNullOrEmpty(keys.Content.SecretKey);
Assert.IsNotNullOrEmpty(keys.Content.SessionLogoutTime.ToString());
}
public Registrations_tests()
{
_registrationController = new RegistrationController(_IRegistrationRepoMock.Object);
_registrationDto = new RegistrationDto()
{
Title = "Test",
Description = "This is a test",
DateTime = DateTime.Now,
DoctorComment = "test comment",
EmployeeId = 1,
PatientId = 3
};
_registrationCreate = new RegistrationCreate()
{
Title = "Test",
Description = "This is a test",
DateTime = DateTime.Now,
EmployeeId = 1,
PatientId = 3
};
_registrationUpdate = new RegistrationUpdate()
{
Title = "Updated Test",
Description = "This is a test",
DateTime = DateTime.Now,
DoctorComment = "test comment",
EmployeeId = 1,
PatientId = 3,
};
}
public void ReturnRegisterValueSensorView_WithViewModel_WhenParameterIsValueType()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
var httpClientMock = new Mock <IHttpClientProvider>();
var controller = new RegistrationController(sensorServiceMock.Object,
httpClientMock.Object);
controller.UserMocking("test");
var apiParameter = new SensorApiData
{
IsValueType = true,
Highestvalue = 10,
LowestValue = 5,
Id = "21312312",
MeasureType = "W",
MinPollingIntervalInSeconds = 1
};
// Act
controller.GetProperRegView(apiParameter);
// Assert
controller
.WithCallTo(r => r.GetProperRegView(apiParameter))
.ShouldRenderView("RegisterValueSensor")
.WithModel <SensorViewModel>(s =>
{
Assert.IsTrue(apiParameter.IsValueType);
Assert.AreEqual(s.HighestValue, apiParameter.Highestvalue);
Assert.AreEqual(s.LowestValue, apiParameter.LowestValue);
});
}
public given_controller()
{
this.bus = Mock.Of <ICommandBus>();
this.viewRepository = Mock.Of <IViewRepository>();
this.sut = new RegistrationController(this.bus, () => this.viewRepository);
}
public async Task WhenJsonSourceIsValid_CanReturnAllRegistrations()
{
//Arrange
var registrations = FakeModels.Registrations;
var testViewData = FakeModels.CatsViewForRender;
var renderingData = FakeModels.RenderingData;
var stubILogger = StubHelper.StubILogger <RegistrationController>();
var stubIFetchService = StubHelper.StubIFetchService;
stubIFetchService.Setup(x => x.GetRegistrations())
.Returns(Task.FromResult(registrations));
var stubIVewingService = StubHelper.StubIVewingService;
stubIVewingService.Setup(x => x.ViewRegistrations(It.IsAny <List <OwnerInfo> >(), ViewType.CatsUnderOnwersGender))
.Returns(testViewData);
var stubIRenderService = StubHelper.StubIRenderService;
stubIRenderService.Setup(x => x.RenderRegistrations(It.IsAny <List <ResultFormat> >()))
.Returns(renderingData);
var testedService = new RegistrationController(stubILogger.Object,
stubIFetchService.Object,
stubIVewingService.Object,
stubIRenderService.Object);
//Act
var result = await testedService.GetAll();
var actual = result as ContentResult;
//Assert
Assert.Equal((int)HttpStatusCode.OK, actual.StatusCode);
}
public RegistrationPg()
{
this.InitializeComponent();
registrationController = new RegistrationController();
registrationViewModel = registrationController.registrationViewModel;
this.DataContext = registrationViewModel;
}
public async Task RegisterTest(HttpStatusCode statusCode, int customerId)
{
Customer customer = new() { FirstName = "Test", Surname = "Test", DoB = DateTime.Now.AddYears(-18), PolicyReference = "AF-123456" };
var mocklogger = new Mock <ILogger>();
var mockRegistrationService = new Mock <IRegistration>();
var mockRegisterResponse = new Outcome <int>("Test Error", statusCode, customerId);
mockRegistrationService.Setup(x => x.Register(It.IsAny <CustomerServiceModel>())).Returns(Task.FromResult(mockRegisterResponse));
_RegistrationController = new RegistrationController(mockRegistrationService.Object, _mapper, mocklogger.Object);
var result = await _RegistrationController.Register(customer);
var okresult = result.Result as ObjectResult;
if (mockRegisterResponse.StatusCode == HttpStatusCode.OK)
{
Assert.AreEqual(mockRegisterResponse.Result, okresult.Value);
}
else
{
Assert.AreEqual("Test Error", okresult.Value);
}
Assert.AreEqual(Convert.ToInt32(mockRegisterResponse.StatusCode), okresult.StatusCode);
}
public async void WhenEnteringStarWarsUser_ExpectUserIdentityTrue()
{
var registrationController = new RegistrationController();
var userExists = await registrationController.CheckUserIdentity("han solo");
Assert.True(userExists);
}
private void BackgroundWorkerSequential_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
RegistrationController controller = new RegistrationController(RegistrationParametersMultiple, worker);
controller.RunRegistration(ImageStackToRegister);
}
const int SPEAKER_RECOGNITION_API_INTERVAL = 3000; //Min time allowed between requests to speaker recognition API.
public static void TestTranscription(string audioFileLoc)
{
/*Subscription key for Azure SpeakerRecognition service. */
var speakerIDKey = ""; //Free tier key for testing
FileInfo testRecording = new FileInfo(audioFileLoc);
FileInfo meetingMinutes = new FileInfo(@"../transcript/minutes.txt");
//var voiceprints = MakeTestVoiceprints(testRecording); //Make a test set of voiceprint objects
string userEmail = "*****@*****.**";
var regCon = RegistrationController.BuildController("",
new List <string>()
{
userEmail
});
var speechConfig = SpeechConfig.FromSubscription("", "centralus");
/*Setup the TranscribeController instance which manages the details of the transcription procedure */
var controller = new TranscribeController(testRecording, regCon.UserProfiles, speechConfig);
Console.WriteLine("Please press <Return> to continue.");
Console.ReadLine();
// performs transcription and speaker recognition
if (controller.Perform())
{
controller.WriteTranscriptionFile();
}
}
private void backgroundWorkerNonRigid_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
RegistrationController controller = new RegistrationController(RegistrationParametersNonRigid, worker);
controller.RunRegistration(ImageStackToRegister);
}
public void GivenTheSelectedOrderItems(Table table)
{
conferenceInfo = ScenarioContext.Current.Get <ConferenceInfo>();
registrationController = RegistrationHelper.GetRegistrationController(conferenceInfo.Slug);
orderViewModel = RegistrationHelper.GetModel <OrderViewModel>(registrationController.StartRegistration().Result);
Assert.NotNull(orderViewModel);
registration = new RegisterToConference {
ConferenceId = conferenceInfo.Id, OrderId = orderViewModel.OrderId
};
foreach (var row in table.Rows)
{
var orderItemViewModel = orderViewModel.Items.FirstOrDefault(s => s.SeatType.Description == row["seat type"]);
Assert.NotNull(orderItemViewModel);
int qt;
if (!row.ContainsKey("quantity") || !Int32.TryParse(row["quantity"], out qt))
{
qt = orderItemViewModel.SeatType.Quantity;
}
registration.Seats.Add(new SeatQuantity(orderItemViewModel.SeatType.Id, qt));
}
// Store for sharing between steps implementations
ScenarioContext.Current.Set(registration);
ScenarioContext.Current.Set(registrationController.ConferenceAlias);
}
public void SetUp()
{
moq = new Mock <IUserService>();
moq.Setup(s => s.StoringInfoAboutNewUser(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
moqService = moq.Object;
controller = new RegistrationController(moqService);
}
/// <summary>
/// Register and login
/// </summary>
/// <param name="userName"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="applicationContext"></param>
/// <returns></returns>
public static UserValidationEssentials RegisterAndLogin(string userName, string email, string password, IApplicationContext applicationContext)
{
//register
RegistrationController registrationController =
applicationContext["RegistrationController"] as RegistrationController;
IHttpActionResult httpActionResult = registrationController.Register(new SignUpParam(email, userName, password, "Pakistan",
TimeZone.CurrentTimeZone, ""));
OkNegotiatedContentResult <string> okResponseMessage =
(OkNegotiatedContentResult <string>)httpActionResult;
string activationKey = okResponseMessage.Content;
//activate account
UserController userController = applicationContext["UserController"] as UserController;
httpActionResult = userController.ActivateUser(new UserActivationParam(userName, password, activationKey));
//login
LoginController loginController = applicationContext["LoginController"] as LoginController;
httpActionResult = loginController.Login(new LoginParams("user", "123"));
OkNegotiatedContentResult <UserValidationEssentials> keys =
(OkNegotiatedContentResult <UserValidationEssentials>)httpActionResult;
//return keys
return(keys.Content);
}
public async Task SubmitCustomerRegistrationReturnsSuccessfulRegistrationAsOkObjectResultWithCustomerRegistrationCreatedObject()
{
var registrationServiceMock = new Mock <AFIExercise.Services.ICustomerRegistrationService>();
var request = new Models.CustomerRegistrationRequest
{
FirstName = "Bob",
Surname = "Smith",
DateOfBirth = new DateTime(2000, 1, 1),
EmailAddress = "*****@*****.**",
PolicyNumber = "AB-123456"
};
registrationServiceMock.Setup(a => a.Register(It.Is <AFIExercise.Services.CustomerRegistrationRequest>(
registration => registration.FirstName == request.FirstName &&
registration.Surname == request.Surname &&
registration.DateOfBirth == request.DateOfBirth &&
registration.EmailAddress == request.EmailAddress &&
registration.PolicyNumber == request.PolicyNumber)))
.ReturnsAsync(new AFIExercise.Services.CustomerRegistrationResult(101));
var controller = new RegistrationController(registrationServiceMock.Object, ServiceExtensions.CreateMapper());
var result = await controller.SubmitCustomerRegistration(request);
var okObjectResult = result as OkObjectResult;
okObjectResult.Should().NotBeNull();
var customerRegistrationCreated = okObjectResult.Value as Models.CustomerRegistrationCreated;
customerRegistrationCreated.Should().NotBeNull();
customerRegistrationCreated.CustomerId.Should().Be(101);
}
public async void WhenEnteringNonStarWarsUser_ExpectUserIdentityFalse()
{
var registrationController = new RegistrationController();
var userExists = await registrationController.CheckUserIdentity("TestUserName");
Assert.False(userExists);
}
private void RegistrationButton_Click(object sender, RoutedEventArgs e)
{
RegistrationController controller = new RegistrationController();
if (Regex.Match(Password.Password, @"^[0-9]+$").Success&&
Regex.Match(UserName.Text, @"^[а-яА-ЯёЁa-zA-Z]+[а-яА-ЯёЁa-zA-Z0-9]+$").Success&& UserName.Text.Length > 4)
{
if (Password.Password.Length >= 6 && Password.Password == PasswordRepit.Password)
{
User user = new User(UserName.Text, Password.Password, Email.Text);
controller.Register(user);
if (new LoginControl().login(user))
{
LoginWindow parentWindow = Window.GetWindow(this) as LoginWindow;
parentWindow.Close();
}
}
else
{
MessageBox.Show("Пароли не совпадают или слишком короткий пароль");
}
}
else
{
MessageBox.Show("Введены некорректные символы");
}
}
public static IEnumerator RequestRegister(string username, string password, string email, string character, string matricNo, string confirmPassword)
{
WWWForm form = new WWWForm();
form.AddField("username", username);
form.AddField("password", password);
form.AddField("password2", confirmPassword);
form.AddField("email", email);
form.AddField("character", character);
form.AddField("matricNo", matricNo);
string RequestRegisterURL = baseRegisterAPIURL;
UnityWebRequest registerRequest = UnityWebRequest.Post(RequestRegisterURL, form);
yield return(registerRequest.SendWebRequest());
JSONNode registerInfo = JSON.Parse(registerRequest.downloadHandler.text);
if (registerRequest.isNetworkError || registerRequest.isHttpError)
{
Debug.LogError(registerRequest.error);
MissingInputField.setText(registerInfo["message"]);
MissingInputField.promptMissingField();
yield break;
}
else if (registerInfo["message"].Equals("Register successfully"))
{
RegistrationController.registerSuccessful();
}
}
public void Initialize()
{
_employeeMock = new Mock <IGenericRepository <Employee> >();
objController = new RegistrationController(_employeeMock.Object);
listEmployee = new List <Employee>()
{
new Employee()
{
Id = 1, Address = "India", Email = "*****@*****.**", ModifiedDate = DateTime.Now,
Name = "UserTest1", Number = 1, PhoneNumber = "001", Position = "Developer"
},
new Employee()
{
Id = 2, Address = "India", Email = "*****@*****.**", ModifiedDate = DateTime.Now,
Name = "UserTest2", Number = 2, PhoneNumber = "002", Position = "Developer"
}
};
emp = new Employee()
{
Id = 1,
Address = "India",
Email = "*****@*****.**",
ModifiedDate = DateTime.Now,
Name = "UserTest1",
Number = 1,
PhoneNumber = "001",
Position = "Developer"
};
}
public async Task WhenJsonSourceIsNotValid_HTT500_CanReturnAnEmptyArray()
{
//Arrange
var registrations = new List <OwnerInfo>();
var stubILogger = StubHelper.StubILogger <RegistrationController>();
var stubIFetchService = StubHelper.StubIFetchService;
stubIFetchService.Setup(x => x.GetRegistrations())
.Returns(Task.FromResult(registrations));
var stubIRenderService = StubHelper.StubIRenderService;
var stubIVewingService = StubHelper.StubIVewingService;
var testedService = new RegistrationController(stubILogger.Object,
stubIFetchService.Object,
stubIVewingService.Object,
stubIRenderService.Object);
//Act
var result = await testedService.GetAll();
var actual = result as NoContentResult;
//Assert
Assert.Equal((int)HttpStatusCode.NoContent, actual.StatusCode);
}
public void isValidPhoneTest(bool expected,
[Frozen] Mock <ILogger <RegistrationController> > mockLogger,
[Frozen] Mock <IRegistrationService> moqRegistrationService)
{
var data = "{\"phone\":\"034234234\"}";
var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(data));
var httpContext = new DefaultHttpContext();
httpContext.Request.Body = stream;
httpContext.Request.ContentLength = stream.Length;
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
moqRegistrationService
.Setup(x => x.IsValidCustomerPhone(It.IsAny <string>()))
.Returns(expected);
var controller = new RegistrationController(moqRegistrationService.Object)
{
ControllerContext = controllerContext
};
var actual = controller.IsValidPhone("0234234243");
var tactual = true;
Assert.Equal(expected, tactual);
}
public async Task UsersShouldNotBeAbleToRegisterIfNotAllowed()
{
var mockUserManager = UsersMockHelper.MockUserManager <IUser>().Object;
var settings = new RegistrationSettings {
UsersCanRegister = UserRegistrationType.NoRegistration
};
var mockSiteService = Mock.Of <ISiteService>(ss =>
ss.GetSiteSettingsAsync() == Task.FromResult(
Mock.Of <ISite>(s => s.Properties == JObject.FromObject(new { RegistrationSettings = settings }))
)
);
var mockSmtpService = Mock.Of <ISmtpService>();
var controller = new RegistrationController(
mockUserManager,
Mock.Of <IAuthorizationService>(),
mockSiteService,
Mock.Of <INotifier>(),
Mock.Of <IEmailAddressValidator>(),
Mock.Of <ILogger <RegistrationController> >(),
Mock.Of <IHtmlLocalizer <RegistrationController> >(),
Mock.Of <IStringLocalizer <RegistrationController> >());
var result = await controller.Register();
Assert.IsType <NotFoundResult>(result);
// Post
result = await controller.Register(new RegisterViewModel());
Assert.IsType <NotFoundResult>(result);
}
public async Task ThenAnInvitationIsAdded(
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <IAuthenticationService> authService,
RegistrationController controller,
NewEmployerUserViewModel model,
string command,
string providerName)
{
//arrange
authService.Object.TryGetUserClaimValue(ProviderClaims.DisplayName, out var displayName);
mediator.Setup(s => s.Send(It.IsAny <GetProviderByUkprnQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetProviderByUkprnQueryResult(providerName));
//act
await controller.InviteEmployeruser(model, command);
//assert
mediator.Verify(x => x.Send(It.Is <AddInvitationCommand>(s =>
s.EmployerEmail == model.EmployerEmailAddress &&
s.EmployerFirstName == model.EmployerFirstName &&
s.EmployerLastName == model.EmployerLastName &&
s.EmployerOrganisation == model.EmployerOrganisation &&
s.Ukprn == authService.Object.Ukprn.Value &&
s.UserRef == authService.Object.UserId &&
s.ProviderOrganisationName == providerName &&
s.ProviderUserFullName == displayName), It.IsAny <CancellationToken>()), Times.Once);
}
public void ReturnRegisterBoolensorView_WithViewModel_WhenParameterIBoolType()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
var httpClientMock = new Mock <IHttpClientProvider>();
var controller = new RegistrationController(sensorServiceMock.Object,
httpClientMock.Object);
controller.UserMocking("test");
var apiParameter = new SensorApiData
{
IsValueType = false,
Id = "21312312",
MeasureType = "true/false",
MinPollingIntervalInSeconds = 1
};
// Act
controller.GetProperRegView(apiParameter);
// Assert
controller
.WithCallTo(r => r.GetProperRegView(apiParameter))
.ShouldRenderView("RegisterBoolSensor")
.WithModel <SensorViewModel>(s =>
{
Assert.IsFalse(apiParameter.IsValueType);
});
}
public void RegisteringNewCompany()
{
RegistrationController controller = new RegistrationController();
CompanyViewModel testModel = new CompanyViewModel();
TestHelper helper = new TestHelper();
testModel.CompanyName = helper.RandomString(50, false);
testModel.CompanyEmailAddress = helper.RandomString(250, false);
testModel.CompanyPhoneNumber = helper.RandomString(20, false);
testModel.CompanyAddressLine1 = helper.RandomString(250, false);
testModel.CompanyAddressLine2 = helper.RandomString(250, false);
testModel.CompanyAddressLine3 = helper.RandomString(250, false);
testModel.PostalCode = helper.RandomNumber(1000, 9999).ToString();
testModel.City = helper.RandomString(50, false);
Array values = Enum.GetValues(typeof(State));
Random random = new Random();
State rdmState = (State)values.GetValue(helper.RandomNumber(0, 12));
//Passing empty model
int returnedResult = controller.CreateNewCompany(null);
Assert.AreEqual(0, returnedResult);
//Register company successfully
int secondReturnedResult = controller.CreateNewCompany(testModel);
Assert.AreEqual(1, secondReturnedResult);
//Same company registering
//testModel.CompanyEmailAddress = "*****@*****.**";
//int thirdReturnedResult = controller.CreateNewCompany(testModel);
//Assert.AreEqual(2, thirdReturnedResult);
}
public void LoginFailTest_ChecksThatUserCannotLoginBeforeActivatingAccount_VerifiesByReturnedValueAndDatabaseQuerying()
{
RegistrationController registrationController = (RegistrationController)_applicationContext["RegistrationController"];
string username = "******";
IHttpActionResult httpActionResult = registrationController.Register(new SignUpParam("*****@*****.**", username, "123", "Pakistan",
TimeZone.CurrentTimeZone, ""));
OkNegotiatedContentResult <string> okResponseMessage =
(OkNegotiatedContentResult <string>)httpActionResult;
string activationKey = okResponseMessage.Content;
Assert.IsNotNullOrEmpty(activationKey);
// Login attempt without Activating Account
LoginController loginController = (LoginController)_applicationContext["LoginController"];
httpActionResult = loginController.Login(new LoginParams(username, "123"));
BadRequestErrorMessageResult badRequest = (BadRequestErrorMessageResult)httpActionResult;
Assert.IsNotNull(badRequest);
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
User userByUserName = userRepository.GetUserByUserName(username);
Assert.IsNotNull(userByUserName);
// Not logged in yet
Assert.AreEqual(DateTime.MinValue, userByUserName.LastLogin);
Assert.IsFalse(userByUserName.IsActivationKeyUsed.Value);
}
public async Task Registration_FailsOnInvalidCSRF(string csrfValue)
{
var csrfMock = new Mock <ITokenVerifier>();
csrfMock.Setup(csrf => csrf.IsValidCSRFToken(csrfValue, null, false))
.Returns(false).Verifiable();
var notificationsMock = new Mock <IModelUpdateNotificationSender>();
var jobClientMock = new Mock <IBackgroundJobClient>();
await using var database = new NotificationsEnabledDb(dbOptions, notificationsMock.Object);
var controller = new RegistrationController(logger, dummyRegistrationStatus, csrfMock.Object, database,
jobClientMock.Object);
var result = await controller.Post(new RegistrationFormData()
{
CSRF = csrfValue, Email = "*****@*****.**", Name = "test", Password = "******",
RegistrationCode = RegistrationCode
});
var objectResult = Assert.IsAssignableFrom <ObjectResult>(result);
Assert.Equal(400, objectResult.StatusCode);
Assert.Empty(database.Users);
csrfMock.Verify();
}
public given_controller()
{
this.bus = Mock.Of <ICommandBus>();
this.conferenceDao = Mock.Of <IConferenceDao>(x => x.GetConferenceAlias(conferenceAlias.Code) == conferenceAlias);
this.orderDao = Mock.Of <IOrderDao>();
this.routes = new RouteCollection();
this.routeData = new RouteData();
this.routeData.Values.Add("conferenceCode", conferenceAlias.Code);
var requestMock = new Mock <HttpRequestBase>(MockBehavior.Strict);
requestMock.SetupGet(x => x.ApplicationPath).Returns("/");
requestMock.SetupGet(x => x.Url).Returns(new Uri("http://localhost/request", UriKind.Absolute));
requestMock.SetupGet(x => x.ServerVariables).Returns(new NameValueCollection());
var responseMock = new Mock <HttpResponseBase>(MockBehavior.Strict);
responseMock.Setup(x => x.ApplyAppPathModifier(It.IsAny <string>())).Returns <string>(s => s);
var context = Mock.Of <HttpContextBase>(c => c.Request == requestMock.Object && c.Response == responseMock.Object);
this.sut = new RegistrationController(this.bus, this.orderDao, this.conferenceDao);
this.sut.ConferenceAlias = conferenceAlias;
this.sut.ConferenceCode = conferenceAlias.Code;
this.sut.ControllerContext = new ControllerContext(context, this.routeData, this.sut);
this.sut.Url = new UrlHelper(new RequestContext(context, this.routeData), this.routes);
}
public static RegistrationController GetRegistrationController(string conferenceCode)
{
Func <ConferenceRegistrationDbContext> ctxFactory = () => new ConferenceRegistrationDbContext(ConferenceRegistrationDbContext.SchemaName);
var orderDao = new OrderDao(ctxFactory, GetBlobStorage(), new JsonTextSerializer());
var conferenceDao = new ConferenceDao(ctxFactory);
// Setup context mocks
var requestMock = new Mock <HttpRequestBase>(MockBehavior.Strict);
requestMock.SetupGet(x => x.ApplicationPath).Returns("/");
requestMock.SetupGet(x => x.Url).Returns(new Uri("http://localhost/request", UriKind.Absolute));
requestMock.SetupGet(x => x.ServerVariables).Returns(new NameValueCollection());
var responseMock = new Mock <HttpResponseBase>(MockBehavior.Strict);
responseMock.Setup(x => x.ApplyAppPathModifier(It.IsAny <string>())).Returns <string>(s => s);
var context = Mock.Of <HttpContextBase>(c => c.Request == requestMock.Object && c.Response == responseMock.Object);
var routes = new RouteCollection();
var routeData = new RouteData();
routeData.Values.Add("conferenceCode", conferenceCode);
// Create the controller and set context
var controller = new RegistrationController(ConferenceHelper.BuildCommandBus(), orderDao, conferenceDao);
controller.ControllerContext = new ControllerContext(context, routeData, controller);
controller.Url = new UrlHelper(new RequestContext(context, routeData), routes);
return(controller);
}
public void Register_Post_Fail_Already_Registered()
{
// arrange
var auth = new Mock <IAuthenticationService>();
var notification = new Mock <INotificationService>();
var redirect = new RedirectService();
var controller = new RegistrationController(auth.Object, notification.Object, redirect);
var model = new RegisterUserModel()
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
auth.Setup(a => a.ValidateCaptcha()).Returns(true);
auth.Setup(a => a.RegisterNewUser("*****@*****.**", "password")).Returns(false);
//act
controller.Register(model);
var result = controller.Register(model) as ViewResult;
//assert
Assert.That(model, Is.EqualTo(result.ViewData.Model));
Assert.That(controller.ModelState[""].Errors[0].ErrorMessage, Is.EqualTo("Sorry, user with such email already exist. Please register with different email."));
}
public static RegistrationController Fixture()
{
RegistrationController controller = new RegistrationController(new RegistrationRepository(), "", new LoginView());
return controller;
}
