private void TestTemplate(InvokeCallback invoke, TestCallback proceed, TestCallback verify, bool verifyInCallback) { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; object state = new object(); bool testCompleted = false; AsyncCallback asyncCallback = ar => { Assert.IsNotNull(ar, "IAsyncResult should not be null."); Assert.AreEqual(state, ar.AsyncState, "States should be equal."); ExceptionHelper.ExpectException <NotSupportedException>( () => Assert.IsNull(ar.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(ar.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); Assert.IsTrue(ar.IsCompleted || mock.DomainClient.CancellationRequested, "IAsyncResult should be complete or cancelled."); try { verify(mock, service, ar); } catch (Exception ex) { this.EnqueueCallback(() => { throw ex; }); } testCompleted = true; }; IAsyncResult asyncResult = invoke(mock, service, verifyInCallback ? asyncCallback : null, state); Assert.IsNotNull(asyncResult, "IAsyncResult should not be null."); Assert.AreEqual(state, asyncResult.AsyncState, "States should be equal."); ExceptionHelper.ExpectException <NotSupportedException>( () => Assert.IsNull(asyncResult.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(asyncResult.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); // We don't have a dispatcher SynchronizationContext when running tests on the // full framework, so the operation will complete on another thread which can happen before we reach this assert // TODO: Try to get tests to run on a dispatcher by using mstest v2 extensobility #if SILVERLIGHT Assert.IsFalse(asyncResult.IsCompleted, "IAsyncResult should not be complete."); #endif proceed(mock, service, asyncResult); if (!verifyInCallback) { this.EnqueueCallback(() => asyncCallback(asyncResult)); } this.EnqueueConditional(() => testCompleted); }
public void InvalidCancelAndEndIARs() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; IAsyncResult invalidResult = service.BeginLoadUserMock(null, null); // Canceling the result once makes it invalid for subsequent use. Since we really just need // to confirm that the input is handled by AsyncResultBase, this is sufficient for the test. service.CancelLoadUserMock(invalidResult); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.CancelLoadUserMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.CancelLoginMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.CancelLogoutMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.CancelSaveUserMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.EndLoadUserMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.EndLoginMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.EndLogoutMock(invalidResult)); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.EndSaveUserMock(invalidResult)); }
public void LogoutThrowsNotSupported() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); WindowsAuthentication service = new WindowsAuthentication(); service.DomainContext = mock; ExceptionHelper.ExpectException <NotSupportedException>( () => service.Logout(false)); }
public void LoginWithNullParametersThrows() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; ExceptionHelper.ExpectArgumentNullExceptionStandard( () => service.LoginAsync(null, CancellationToken.None), "parameters"); }
public void LogoutThrowsNotSupported() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); WindowsAuthentication service = new WindowsAuthentication(); service.DomainContext = mock; ExceptionHelper.ExpectException<NotSupportedException>( () => service.Logout(false)); }
public async Task SaveAnonymousUserThrows() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; await ExceptionHelper.ExpectExceptionAsync <InvalidOperationException>( () => service.SaveUserAsync(service.User, CancellationToken.None)); }
public void SaveAnonymousUserThrows() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; ExceptionHelper.ExpectException <InvalidOperationException>( () => service.BeginSaveUserMock(service.User, null, null)); }
public void LoginWithNullParametersThrows() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; ExceptionHelper.ExpectArgumentNullExceptionStandard( () => service.BeginLoginMock(null, null, null), "parameters"); }
public void DefaultUser() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; IPrincipal defaultUser = service.CreateDefaultUserMock(); Assert.IsInstanceOfType(defaultUser, typeof(MockUser), "DefaultUser should be of type MockUser after service has started."); }
private void TestTemplate(InvokeCallback invoke, TestCallback proceed, TestCallback verify, bool verifyInCallback) { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; object state = new object(); bool testCompleted = false; AsyncCallback asyncCallback = ar => { Assert.IsNotNull(ar, "IAsyncResult should not be null."); Assert.AreEqual(state, ar.AsyncState, "States should be equal."); ExceptionHelper.ExpectException <NotSupportedException>( () => Assert.IsNull(ar.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(ar.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); Assert.IsTrue(ar.IsCompleted || mock.DomainClient.CancellationRequested, "IAsyncResult should be complete or cancelled."); verify(mock, service, ar); testCompleted = true; }; IAsyncResult asyncResult = invoke(mock, service, verifyInCallback ? asyncCallback : null, state); Assert.IsNotNull(asyncResult, "IAsyncResult should not be null."); Assert.AreEqual(state, asyncResult.AsyncState, "States should be equal."); ExceptionHelper.ExpectException <NotSupportedException>( () => Assert.IsNull(asyncResult.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(asyncResult.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); Assert.IsFalse(asyncResult.IsCompleted, "IAsyncResult should not be complete."); proceed(mock, service, asyncResult); if (!verifyInCallback) { this.EnqueueCallback(() => asyncCallback(asyncResult)); } this.EnqueueConditional(() => testCompleted); }
public void DomainContext() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; Assert.AreEqual(mock, service.DomainContext, "DomainContexts should be equal."); WebAuthenticationServiceTest.InitializeService(service); Assert.AreEqual(mock, service.DomainContext, "DomainContexts should be equal."); ExceptionHelper.ExpectException <InvalidOperationException>( () => service.DomainContext = null); }
public async Task LoginError() { LoginParameters parameters = new LoginParameters(AuthenticationDomainClient.ValidUserName, string.Empty); AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService { DomainContext = mock }; mock.DomainClient.Error = new Exception(WebAuthenticationServiceTest.ErrorMessage); var task = service.LoginAsync(parameters, CancellationToken.None); mock.DomainClient.RequestCallback(); await ExceptionHelper.ExpectExceptionAsync <DomainOperationException>( () => task, string.Format(Resource.DomainContext_LoadOperationFailed, "Login", WebAuthenticationServiceTest.ErrorMessage)); }
private void TestTemplate <T>(Func <AuthenticationDomainContext, MockWebAuthenticationService, Task <T> > invoke, Action <AuthenticationDomainContext, MockWebAuthenticationService, Task <T> > proceed, Action <AuthenticationDomainContext, MockWebAuthenticationService, Task <T> > verify) { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService { DomainContext = mock }; Task <T> task = invoke(mock, service); Assert.IsNotNull(task); proceed(mock, service, task); this.EnqueueConditional(() => task.IsCompleted); this.EnqueueCallback(() => { verify(mock, service, task); }); }
private void CancelTemplate <T>(Func <AuthenticationDomainContext, MockWebAuthenticationService, CancellationToken, Task <T> > invoke, Action <AuthenticationDomainContext, MockWebAuthenticationService> verify = null) { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService { DomainContext = mock }; using var cts = new CancellationTokenSource(); Task <T> task = invoke(mock, service, cts.Token); Assert.IsNotNull(task); Assert.IsFalse(task.IsCompleted, "task should not be complete."); cts.Cancel(); this.EnqueueConditional(() => task.IsCompleted); this.EnqueueCallback(() => { Assert.IsTrue(task.IsCanceled, "task should be cancelled"); verify?.Invoke(mock, service); }); this.EnqueueTestComplete(); }
private void TestTemplate(InvokeCallback invoke, TestCallback proceed, TestCallback verify, bool verifyInCallback) { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService() ; service.DomainContext = mock; object state = new object(); bool testCompleted = false; AsyncCallback asyncCallback = ar => { Assert.IsNotNull(ar, "IAsyncResult should not be null."); Assert.AreEqual(state, ar.AsyncState, "States should be equal."); ExceptionHelper.ExpectException<NotSupportedException>( () => Assert.IsNull(ar.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(ar.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); Assert.IsTrue(ar.IsCompleted || mock.DomainClient.CancellationRequested, "IAsyncResult should be complete or cancelled."); verify(mock, service, ar); testCompleted = true; }; IAsyncResult asyncResult = invoke(mock, service, verifyInCallback ? asyncCallback : null, state); Assert.IsNotNull(asyncResult, "IAsyncResult should not be null."); Assert.AreEqual(state, asyncResult.AsyncState, "States should be equal."); ExceptionHelper.ExpectException<NotSupportedException>( () => Assert.IsNull(asyncResult.AsyncWaitHandle, "This property is not supported.")); Assert.IsFalse(asyncResult.CompletedSynchronously, "IAsyncResult should not have completed synchronously."); Assert.IsFalse(asyncResult.IsCompleted, "IAsyncResult should not be complete."); proceed(mock, service, asyncResult); if (!verifyInCallback) { this.EnqueueCallback(() => asyncCallback(asyncResult)); } this.EnqueueConditional(() => testCompleted); }
public void SaveAnonymousUserThrows() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; ExceptionHelper.ExpectException<InvalidOperationException>( () => service.BeginSaveUserMock(service.User, null, null)); }
public void InvalidCancelAndEndIARs() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; IAsyncResult invalidResult = service.BeginLoadUserMock(null, null); // Canceling the result once makes it invalid for subsequent use. Since we really just need // to confirm that the input is handled by AsyncResultBase, this is sufficient for the test. service.CancelLoadUserMock(invalidResult); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.CancelLoadUserMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.CancelLoginMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.CancelLogoutMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.CancelSaveUserMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.EndLoadUserMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.EndLoginMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.EndLogoutMock(invalidResult)); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.EndSaveUserMock(invalidResult)); }
public void DomainContext() { AuthenticationDomainContext mock = new AuthenticationDomainContext(); MockWebAuthenticationService service = new MockWebAuthenticationService(); service.DomainContext = mock; Assert.AreEqual(mock, service.DomainContext, "DomainContexts should be equal."); WebAuthenticationServiceTest.InitializeService(service); Assert.AreEqual(mock, service.DomainContext, "DomainContexts should be equal."); ExceptionHelper.ExpectException<InvalidOperationException>( () => service.DomainContext = null); }