public async Task LoadAsync_Cancel_DomainClientCompletes() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); var city = new City() { Name = "NewCity", StateName = "NN", CountyName = "NewCounty" }; // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <QueryCompletedResult>(); using var cts = new CancellationTokenSource(); mockDomainClient.QueryCompletedResult = tcs.Task; var loadTask = ctx.LoadAsync(ctx.GetCitiesQuery(), cts.Token); cts.Cancel(); tcs.SetResult(new QueryCompletedResult(new[] { city }, Array.Empty <Entity>(), -1, Array.Empty <ValidationResult>())); var result = await loadTask; Assert.AreEqual(1, result.Entities.Count); Assert.AreSame(city, result.Entities.First()); }
public void Invoke_ValidationErrors() { var mockDomainClient = new CitiesMockDomainClient(); ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) }; mockDomainClient.InvokeCompletedResult = Task.FromResult(new InvokeCompletedResult(null, validationErrors)); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); string myState = "Test User State"; InvokeOperation invoke = ctx.Echo("TestInvoke", TestHelperMethods.DefaultOperationAction, myState); this.EnqueueCompletion(() => invoke); EnqueueCallback(delegate { Assert.IsNotNull(invoke.Error); Assert.AreSame(myState, invoke.UserState); CollectionAssert.AreEqual(validationErrors, (ICollection)invoke.ValidationErrors); // verify the exception properties var ex = (DomainOperationException)invoke.Error; Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status); CollectionAssert.AreEqual(validationErrors, (ICollection)ex.ValidationErrors); Assert.AreEqual(string.Format(Resource.DomainContext_InvokeOperationFailed_Validation, "Echo"), ex.Message); }); EnqueueTestComplete(); }
public void TestInitialize() { this.Error = null; this.LoadOperation = null; this.SubmitOperation = null; this.CityDomainContext = new CityDomainContext(TestURIs.Cities); }
public async Task SubmitAsync_Cancel_DomainClientCancel() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <SubmitCompletedResult>(); using var cts = new CancellationTokenSource(); mockDomainClient.SubmitCompletedResult = tcs.Task; ctx.Cities.Add(new City() { Name = "NewCity", StateName = "NN", CountyName = "NewCounty" }); var submitTask = ctx.SubmitChangesAsync(cts.Token); cts.Cancel(); Assert.IsTrue(ctx.IsSubmitting); Assert.IsTrue(ctx.Cities.First().IsSubmitting, "entity should be in submitting state"); // Return cancellation from domain client tcs.TrySetCanceled(cts.Token); await ExceptionHelper.ExpectExceptionAsync <TaskCanceledException>(() => submitTask); Assert.IsTrue(submitTask.IsCanceled); Assert.IsFalse(ctx.IsSubmitting); Assert.IsFalse(ctx.Cities.First().IsSubmitting, "entity should not be in submitting state"); }
public void Submit() { Cities.CityDomainContext ctx = new Cities.CityDomainContext(new CitiesMockDomainClient()); string myState = "Test User State"; Cities.Zip newZip = new Cities.Zip { Code = 93551, FourDigit = 1234, CityName = "Issaquah", StateName = "Issaquah" }; ctx.Zips.Add(newZip); SubmitOperation so = ctx.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); this.EnqueueCompletion(() => so); EnqueueCallback(delegate { // verify that validation logic is run Assert.IsNotNull(so.Error); Assert.AreSame(newZip, so.EntitiesInError.Single()); // fix by setting the Name newZip.StateName = "WA"; so = ctx.SubmitChanges(null, myState); }); this.EnqueueCompletion(() => so); EnqueueCallback(delegate { Assert.IsNull(so.Error); Assert.AreEqual(myState, so.UserState); }); EnqueueTestComplete(); }
public async Task Submit_Cancel_DomainClientCancel() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <SubmitCompletedResult>(); mockDomainClient.SubmitCompletedResult = tcs.Task; ctx.Cities.Add(new City() { Name = "NewCity", StateName = "NN", CountyName = "NewCounty" }); var submitOp = ctx.SubmitChanges(); submitOp.Cancel(); Assert.IsTrue(submitOp.IsCancellationRequested); Assert.IsFalse(submitOp.IsCanceled); Assert.IsTrue(ctx.IsSubmitting); Assert.IsTrue(ctx.Cities.First().IsSubmitting, "entity should be in submitting state"); tcs.TrySetCanceled(submitOp.CancellationToken); await submitOp; // Return cancellation from domain client Assert.IsTrue(submitOp.IsCanceled); Assert.IsFalse(ctx.IsSubmitting); Assert.IsFalse(ctx.Cities.First().IsSubmitting, "entity should not be in submitting state"); }
public void Load_ValidationErrors() { var mockDomainClient = new CitiesMockDomainClient(); ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) }; mockDomainClient.QueryCompletedResult = Task.FromResult(new QueryCompletedResult(Enumerable.Empty <Entity>(), Enumerable.Empty <Entity>(), 0, validationErrors)); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); string myState = "Test User State"; LoadOperation <Cities.City> loadOperation = ctx.Load(ctx.GetCitiesQuery(), LoadBehavior.RefreshCurrent, l => l.MarkErrorAsHandled(), myState);; this.EnqueueCompletion(() => loadOperation); EnqueueCallback(delegate { Assert.AreSame(myState, loadOperation.UserState); CollectionAssert.AreEqual(validationErrors, (ICollection)loadOperation.ValidationErrors); // verify the exception properties var ex = loadOperation.Error as DomainOperationException; Assert.IsNotNull(ex, "expected exception of type DomainOperationException"); Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status); Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed_Validation, "GetCities"), ex.Message); }); EnqueueTestComplete(); }
public void Paging() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._pagedCollectionView.PageSize = 10; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(10, this._view.Count, "this._ecv.Count should be 10 after the initial load"); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after the initial load"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(1, this._view.Count, "this._ecv.Count should be 1 after moving to the 2nd page"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after moving to the 2nd page"); this._dds.PageSize = 0; Assert.AreEqual(0, this._dds.PageSize, "DDS PageSize should immediately reflect 0"); Assert.AreEqual(0, this._view.PageSize, "this._ecv.PageSize should immediately reflect 0"); Assert.AreEqual(-1, this._view.PageIndex, "this._ecv.PageIndex should immediately reflect -1"); this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after turning off paging and reloading"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after turning off paging and reloading"); Assert.AreEqual(-1, this._view.PageIndex, "this._ecv.PageIndex should remain -1 after reloading"); }); EnqueueTestComplete(); }
public async Task Load_Cancel_DomainClientCancel() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <QueryCompletedResult>(); mockDomainClient.QueryCompletedResult = tcs.Task; var loadOp = ctx.Load(ctx.GetCitiesQuery()); loadOp.Cancel(); Assert.IsTrue(loadOp.IsCancellationRequested); Assert.IsTrue(ctx.IsLoading); Assert.IsFalse(loadOp.IsCanceled); Assert.IsFalse(loadOp.IsComplete); tcs.TrySetCanceled(loadOp.CancellationToken); await loadOp; Assert.IsFalse(ctx.IsLoading); Assert.IsTrue(loadOp.IsCanceled); Assert.IsTrue(loadOp.IsComplete); Assert.IsFalse(loadOp.HasError, "Cancelled operation should not have any error"); }
public async Task SubmitAsync_Exceptions() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); DomainOperationException ex = new DomainOperationException("Submit Failed!", OperationErrorStatus.ServerError, 42, "StackTrace"); // If cancellation results in request beeing cancelled the result should be cancelled mockDomainClient.SubmitCompletedResult = Task.FromException <SubmitCompletedResult>(ex); ctx.Cities.Add(new City() { Name = "NewCity", StateName = "NN", CountyName = "NewCounty" }); Assert.IsTrue(ctx.EntityContainer.HasChanges); var submitEx = await ExceptionHelper.ExpectExceptionAsync <SubmitOperationException>(() => ctx.SubmitChangesAsync()); // verify the exception properties Assert.AreEqual(string.Format(Resource.DomainContext_SubmitOperationFailed, ex.Message), submitEx.Message); Assert.AreEqual(ex.StackTrace, submitEx.StackTrace); Assert.AreEqual(ex.Status, submitEx.Status); Assert.AreEqual(ex.ErrorCode, submitEx.ErrorCode); Assert.IsTrue(ctx.EntityContainer.HasChanges); // now test with validation exception var changeSet = ctx.EntityContainer.GetChanges(); IEnumerable <ChangeSetEntry> entries = ChangeSetBuilder.Build(changeSet); ChangeSetEntry entry = entries.First(); entry.ValidationErrors = new ValidationResultInfo[] { new ValidationResultInfo("Foo", new string[] { "Bar" }) }; mockDomainClient.SubmitCompletedResult = Task.FromResult(new SubmitCompletedResult(changeSet, entries)); submitEx = await ExceptionHelper.ExpectExceptionAsync <SubmitOperationException>(() => ctx.SubmitChangesAsync()); // verify the exception properties Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Validation, submitEx.Message); Assert.AreEqual(OperationErrorStatus.ValidationFailed, submitEx.Status); Assert.AreEqual(1, submitEx.EntitiesInError.Count); Assert.AreEqual(entry.ClientEntity, submitEx.EntitiesInError.First()); // now test again with conflicts entries = ChangeSetBuilder.Build(changeSet); entry = entries.First(); entry.ConflictMembers = new string[] { nameof(City.CountyName) }; entry.StoreEntity = new City() { CountyName = "OtherCounty" }; mockDomainClient.SubmitCompletedResult = Task.FromResult(new SubmitCompletedResult(changeSet, entries)); submitEx = await ExceptionHelper.ExpectExceptionAsync <SubmitOperationException>(() => ctx.SubmitChangesAsync()); // verify the exception properties Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Conflicts, submitEx.Message); Assert.AreEqual(OperationErrorStatus.Conflicts, submitEx.Status); Assert.AreEqual(1, submitEx.EntitiesInError.Count); Assert.AreEqual(entry.ClientEntity, submitEx.EntitiesInError.First()); }
public void ExogenousDomainClient() { Cities.CityDomainContext ctxt1 = new CityDomainContext(TestURIs.Cities); Cities.CityDomainContext ctxt2 = new CityDomainContext(TestURIs.Cities); var q1 = ctxt1.GetCitiesInStateQuery("OH"); ExceptionHelper.ExpectInvalidOperationException(delegate { ctxt2.Load(q1, false); }, string.Format(Resource.DomainContext_InvalidEntityQueryDomainClient, q1.QueryName)); }
public async Task Load() { Cities.CityDomainContext ctx = new Cities.CityDomainContext(new CitiesMockDomainClient()); string myState = "Test User State"; var query = ctx.GetCitiesQuery().Where(p => p.StateName == "WA").OrderBy(p => p.CountyName).Take(4); LoadOperation lo = ctx.Load(query, TestHelperMethods.DefaultOperationAction, myState); await lo; Assert.IsNull(lo.Error); Assert.AreEqual(4, ctx.Cities.Count); Assert.IsTrue(ctx.Cities.All(p => p.StateName == "WA")); Assert.AreEqual(myState, lo.UserState); }
public async Task LoadAsync_ValidationErrors() { var mockDomainClient = new CitiesMockDomainClient(); ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) }; mockDomainClient.QueryCompletedResult = Task.FromResult(new QueryCompletedResult(Enumerable.Empty <Entity>(), Enumerable.Empty <Entity>(), 0, validationErrors)); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); var ex = await ExceptionHelper.ExpectExceptionAsync <DomainOperationException>( () => ctx.LoadAsync(ctx.GetCitiesQuery()), string.Format(Resource.DomainContext_LoadOperationFailed_Validation, "GetCities")); // verify the exception properties Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status); CollectionAssert.AreEqual(validationErrors, (ICollection)ex.ValidationErrors); }
public async Task InvokeAsync_ValidationErrors() { var mockDomainClient = new CitiesMockDomainClient(); ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) }; mockDomainClient.InvokeCompletedResult = Task.FromResult(new InvokeCompletedResult(null, validationErrors)); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); var ex = await ExceptionHelper.ExpectExceptionAsync <DomainOperationException>( () => ctx.EchoAsync("TestInvoke"), string.Format(Resource.DomainContext_InvokeOperationFailed_Validation, "Echo")); // verify the exception properties Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status); CollectionAssert.AreEqual(validationErrors, (ICollection)ex.ValidationErrors); }
public void Invoke() { Cities.CityDomainContext ctx = new Cities.CityDomainContext(new CitiesMockDomainClient()); string myState = "Test User State"; InvokeOperation invoke = ctx.Echo("TestInvoke", TestHelperMethods.DefaultOperationAction, myState); this.EnqueueCompletion(() => invoke); EnqueueCallback(delegate { Assert.IsNull(invoke.Error); Assert.AreSame(myState, invoke.UserState); Assert.AreEqual("Echo: TestInvoke", invoke.Value); }); EnqueueTestComplete(); }
public void Cities_VerifyCustomHost() { CityDomainContext dp = new CityDomainContext(TestURIs.Cities); // Abs URI so runs on desktop too InvokeOperation<bool> invokeOp = dp.UsesCustomHost(TestHelperMethods.DefaultOperationAction, null); EnqueueConditional(() => invokeOp.IsComplete); EnqueueCallback(() => { if (invokeOp.Error != null) Assert.Fail("InvokeOperation.Error: " + invokeOp.Error.Message); Assert.IsTrue(invokeOp.Value, "CityDomainService isn't using a custom host."); }); EnqueueTestComplete(); }
public void CancellationSupport() { var domainClient = new CitiesMockDomainClient(); domainClient.SetSupportsCancellation(false); Cities.CityDomainContext ctx = new Cities.CityDomainContext(domainClient); var query = ctx.GetCitiesQuery(); LoadOperation lo = ctx.Load(query, false); Assert.IsFalse(lo.CanCancel, "Cancellation should not be supported."); Assert.IsFalse(ctx.DomainClient.SupportsCancellation, "Cancellation should not be supported."); ExceptionHelper.ExpectException <NotSupportedException>(delegate { lo.Cancel(); }, string.Format(CultureInfo.CurrentCulture, Resources.AsyncOperation_CancelNotSupported)); }
public async Task InvokeAsync_DomainOperationException() { var mockDomainClient = new CitiesMockDomainClient(); DomainOperationException exception = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace"); mockDomainClient.InvokeCompletedResult = Task.FromException <InvokeCompletedResult>(exception); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); var ex = await ExceptionHelper.ExpectExceptionAsync <DomainOperationException>( () => ctx.EchoAsync("TestInvoke"), string.Format(Resource.DomainContext_InvokeOperationFailed, "Echo", exception.Message)); // verify the exception properties Assert.AreEqual(null, ex.InnerException); Assert.AreEqual(ex.StackTrace, exception.StackTrace); Assert.AreEqual(ex.Status, exception.Status); Assert.AreEqual(ex.ErrorCode, exception.ErrorCode); }
public async Task InvokeAsync_Cancel_DomainClientCancel() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <InvokeCompletedResult>(); using var cts = new CancellationTokenSource(); mockDomainClient.InvokeCompletedResult = tcs.Task; var invokeTask = ctx.EchoAsync("TestInvoke", cts.Token); cts.Cancel(); tcs.TrySetCanceled(cts.Token); await ExceptionHelper.ExpectExceptionAsync <TaskCanceledException>(() => invokeTask); Assert.IsTrue(invokeTask.IsCanceled); }
public async Task InvokeAsync_Cancel_DomainClientCompletes() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If the web requires returns a value even if cancelled // It should still return a result var tcs = new TaskCompletionSource <InvokeCompletedResult>(); using var cts = new CancellationTokenSource(); mockDomainClient.InvokeCompletedResult = tcs.Task; var invokeTask = ctx.EchoAsync("TestInvoke", cts.Token); cts.Cancel(); tcs.SetResult(new InvokeCompletedResult("Res")); var res = await invokeTask; Assert.AreEqual("Res", res.Value); }
public async Task SubmitAsync_Cancel_DomainClientCompletes() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled using var cts = new CancellationTokenSource(); mockDomainClient.SubmitCompletedCallback = async(changeSet, submitOperations) => { // Wait for cancellation, and then return successfully without cancellation try { await Task.Delay(-1, cts.Token); } catch (OperationCanceledException) { // Do nothing this is the expected outcome } // perform mock submit operations SubmitCompletedResult submitResults = new SubmitCompletedResult(changeSet, submitOperations); return(submitResults); }; ctx.Cities.Add(new City() { Name = "NewCity", StateName = "NN", CountyName = "NewCounty" }); var submitTask = ctx.SubmitChangesAsync(cts.Token); Assert.IsTrue(ctx.IsSubmitting); Assert.IsTrue(ctx.Cities.First().IsSubmitting, "entity should be in submitting state"); cts.Cancel(); var result = await submitTask; Assert.IsFalse(ctx.IsSubmitting); Assert.IsFalse(ctx.Cities.First().IsSubmitting, "entity should not be in submitting state"); }
public async Task LoadAsync_Cancel_DomainClientCancel() { var mockDomainClient = new CitiesMockDomainClient(); Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient); // If cancellation results in request beeing cancelled the result should be cancelled var tcs = new TaskCompletionSource <QueryCompletedResult>(); using var cts = new CancellationTokenSource(); mockDomainClient.QueryCompletedResult = tcs.Task; var loadTask = ctx.LoadAsync(ctx.GetCitiesQuery(), cts.Token); Assert.IsTrue(ctx.IsLoading); cts.Cancel(); tcs.TrySetCanceled(cts.Token); await ExceptionHelper.ExpectExceptionAsync <OperationCanceledException>(() => loadTask, allowDerivedExceptions : true); Assert.IsTrue(loadTask.IsCanceled); Assert.IsFalse(ctx.IsLoading); }
public void Cities_LoadStates_TestEnums() { CityDomainContext dp = new CityDomainContext(TestURIs.Cities); SubmitOperation so = null; LoadOperation lo = dp.Load(dp.GetStatesQuery().Where(s => s.TimeZone == Cities.TimeZone.Pacific), false); EnqueueConditional(() => lo.IsComplete); EnqueueCallback(() => { if (lo.Error != null) Assert.Fail("LoadOperation.Error: " + lo.Error.Message); // verify the TimeZones were serialized to the client properly State state = dp.States.Single(p => p.Name == "WA"); Assert.AreEqual(Cities.TimeZone.Pacific, state.TimeZone); Assert.IsFalse(dp.States.Any(p => p.Name == "OH")); // Now test update state.TimeZone = state.TimeZone = Cities.TimeZone.Central; Assert.AreEqual(EntityState.Modified, state.EntityState); EntityChangeSet cs = dp.EntityContainer.GetChanges(); Assert.IsTrue(cs.ModifiedEntities.Contains(state)); so = dp.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); }); EnqueueConditional(() => so.IsComplete); EnqueueCallback(() => { TestHelperMethods.AssertOperationSuccess(so); }); EnqueueTestComplete(); }
public void RemovingAndAddingFromSharedDomainContext() { DomainDataSourceView data1 = null; DomainDataSourceView data2 = null; CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 2; this._dds.Load(); }); this.AssertLoadingData(); EnqueueCallback(() => { this.ResetLoadState(); // Grab a hold of the loaded data and create a new one data1 = this._view; Assert.AreEqual(2, context.Cities.Count, "context.Cities.Count should be 2 after loading the 1st dds"); this.Initialize(); this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadingData(); EnqueueCallback(() => { this.ResetLoadState(); data2 = this._view; Assert.AreEqual(2, data1.Count, "data1.Count should be 2 after loading the 2nd DDS"); Assert.AreEqual(11, data2.Count, "data2.Count should be 11 after loading the 2nd DDS"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after loading the 2nd DDS"); City city = data1[0] as City; data1.Remove(city); Assert.AreEqual(1, data1.Count, "data1.Count should be 1 after removing an item"); Assert.AreEqual(10, data2.Count, "data2.Count should be 10 after removing an item from the data1"); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after removing an item from data1"); context.Cities.Add(city); Assert.AreEqual(2, data1.Count, "data1.Count should be 2 after adding the item back to the context"); Assert.AreEqual(11, data2.Count, "data2.Count should be 11 after adding the item back to the context"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after adding the item back to the context"); city = data2[8] as City; data2.Remove(city); Assert.AreEqual(2, data1.Count, "data1.Count should be 2 after removing an item from data2 that doesn't exist in data1"); Assert.AreEqual(10, data2.Count, "data2.Count should be 10 after removing an item1"); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after removing an item from data2"); context.Cities.Add(city); Assert.AreEqual(2, data1.Count, "data1.Count should be 2 after adding the item back to the context"); Assert.AreEqual(11, data2.Count, "data2.Count should be 11 after adding the item back to the context"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after adding the item back to the context"); }); EnqueueTestComplete(); }
public void RemovingFromDataView() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after the initial load"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after the initial load"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after the initial load"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after the initial load"); City city = this._view[0] as City; this._view.Remove(city); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after removing a city"); Assert.AreEqual(10, this._view.Count, "this._ecv.Count should be 10 after removing a city"); Assert.IsTrue(context.HasChanges, "context.HasChanges should be true after Remove"); Assert.IsTrue(this._dds.HasChanges, "this._dds.HasChanges should be true after Remove"); context.Cities.Add(city); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after adding the city back"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after adding the city back"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after adding the city back"); Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after adding the city back"); }); EnqueueTestComplete(); }
public void AddingToDataView() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.AutoLoad = false; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.SortDescriptors.Add(new SortDescriptor("Name", ListSortDirection.Ascending)); this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after the initial load"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after the initial load"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after the initial load"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after the initial load"); City city = this._editableCollectionView.AddNew() as City; Assert.AreEqual(12, context.Cities.Count, "There should be 12 items in context after adding a new city"); Assert.AreEqual(12, this._view.Count, "this._ecv.Count should be 12 after adding a new city"); Assert.IsTrue(context.HasChanges, "context.HasChanges should be true after the AddNew"); Assert.IsTrue(this._dds.HasChanges, "this._dds.HasChanges should be true after the AddNew"); AssertHelper.AssertSequenceSorting(this._view.Cast<City>().Select(c => c.Name), ListSortDirection.Ascending, "The cities should be sorted by name after adding the city"); city.Name = "Added City"; city.StateName = "ST"; this._editableCollectionView.CommitNew(); Assert.AreEqual(12, context.Cities.Count, "There should be 12 items in context after the CommitNew"); Assert.AreEqual(12, this._view.Count, "this._ecv.Count should be 12 after the CommitNew"); Assert.IsTrue(context.HasChanges, "context.HasChanges should be true after the CommitNew"); Assert.IsTrue(this._dds.HasChanges, "this._dds.HasChanges should be true after the CommitNew"); AssertHelper.AssertSequenceSorting(this._view.Cast<City>().Select(c => c.Name), ListSortDirection.Ascending, "The cities should be sorted by name after committing the city"); this._view.Remove(city); Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after removing the new item"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after removing the new item"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after removing the new item"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after removing the new item"); }); EnqueueTestComplete(); }
public void SubmitChanges_ValidatesEntities() { CityDomainContext domainContext = new CityDomainContext(); City newCity = new City(); domainContext.Cities.Add(newCity); System.ComponentModel.INotifyDataErrorInfo notifier = (System.ComponentModel.INotifyDataErrorInfo)newCity; List<string> actualErrors = new List<string>(); notifier.ErrorsChanged += (s, e) => actualErrors.Add(e.PropertyName); this.EnqueueCallback(() => { // Required fields will be reported as in error this.SubmitOperation = domainContext.SubmitChanges(); // The submission will fail because of the validation error. Mark it as handled. this.SubmitOperation.Completed += (s, e) => this.SubmitOperation.MarkErrorAsHandled(); Assert.IsTrue(newCity.ValidationErrors.Any(r => r.MemberNames.Contains("Name")), "Name is required"); Assert.IsTrue(actualErrors.OrderBy(s => s).SequenceEqual(new string[] { "Name" }), "We should have received errors for Name"); actualErrors.Clear(); }); this.EnqueueConditional(() => SubmitOperation.IsComplete); this.EnqueueCallback(() => { newCity.Name = "West Chester"; newCity.StateName = "OH"; newCity.CountyName = "Butler"; // No validation - but needed for a complete key Assert.IsTrue(actualErrors.OrderBy(s => s).SequenceEqual(new string[] { "Name" }), "We should have received a notification for Name when setting it to a valid value"); actualErrors.Clear(); newCity.ZoneID = -50; // Invalid Assert.IsTrue(actualErrors.SequenceEqual(new string[] { "ZoneID" }), "We should have received an error for ZoneID when setting it to an invalid value"); actualErrors.Clear(); // Property errors will be reported this.SubmitOperation = domainContext.SubmitChanges(); // The submission will fail because of the validation error. Mark it as handled. this.SubmitOperation.Completed += (s, e) => this.SubmitOperation.MarkErrorAsHandled(); Assert.IsTrue(newCity.ValidationErrors.Any(r => r.MemberNames.Contains("ZoneID")), "ZoneID is out of range"); Assert.IsTrue(actualErrors.SequenceEqual(new string[] { "ZoneID" }), "We should have received an error for ZoneID only - errors were cleared and replaced"); actualErrors.Clear(); }); this.EnqueueConditional(() => SubmitOperation.IsComplete); this.EnqueueCallback(() => { newCity.StateName = "ASDF"; // Too long Assert.IsTrue(actualErrors.SequenceEqual(new string[] { "StateName" }), "We should have received an error for StateName when setting it to an invalid value"); actualErrors.Clear(); // Property errors will be reported this.SubmitOperation = domainContext.SubmitChanges(); // The submission will fail because of the validation error. Mark it as handled. this.SubmitOperation.Completed += (s, e) => this.SubmitOperation.MarkErrorAsHandled(); Assert.IsTrue(newCity.ValidationErrors.Any(r => r.MemberNames.Contains("ZoneID")), "ZoneID is invalid"); Assert.IsTrue(newCity.ValidationErrors.Any(r => r.MemberNames.Contains("StateName")), "StateName is too long"); Assert.IsTrue(actualErrors.OrderBy(s => s).SequenceEqual(new string[] { "StateName", "ZoneID" }), "We should have received errors for StateName and ZoneID"); actualErrors.Clear(); }); this.EnqueueConditional(() => SubmitOperation.IsComplete); this.EnqueueCallback(() => { newCity.ZoneID = 0; newCity.StateName = "OH"; Assert.IsTrue(actualErrors.OrderBy(s => s).SequenceEqual(new string[] { "StateName", "ZoneID" }), "We should have received notifications for StateName and ZoneID when setting them to valid values"); actualErrors.Clear(); // Force entity-level validation failure newCity.MakeEntityValidationFail = true; // The entity-level error will be reported this.SubmitOperation = domainContext.SubmitChanges(); // The submission will fail because of the validation error. Mark it as handled. this.SubmitOperation.Completed += (s, e) => this.SubmitOperation.MarkErrorAsHandled(); Assert.IsTrue(newCity.ValidationErrors.Any(r => r.MemberNames == null || !r.MemberNames.Any(m => !string.IsNullOrEmpty(m))), "We should only have entity-level errors (no members or null or empty members only)"); Assert.IsTrue(actualErrors.SequenceEqual(new string[] { null }), "We should have received an error for the entity-level error"); actualErrors.Clear(); }); this.EnqueueConditional(() => SubmitOperation.IsComplete); this.EnqueueCallback(() => { // Allow all validation to pass newCity.MakeEntityValidationFail = false; // The submission will succeed - there are no further validation errors. // But this will still result in notifications because the validation errors are cleared // To help verify this, we will add a validation result to the collection to ensure it's cleared newCity.ValidationErrors.Add(new ValidationResult("Added Error", new string[] { "MakeBelieveProperty" })); actualErrors.Clear(); this.SubmitOperation = domainContext.SubmitChanges(); Assert.IsTrue(!newCity.ValidationErrors.Any(), "There should not be any errors after valid submission"); Assert.IsTrue(actualErrors.OrderBy(s => s).SequenceEqual(new string[] { null, "MakeBelieveProperty" }.OrderBy(s => s)), "We should have received notifications that the entity-level and property-level erros were cleared"); }); this.EnqueueConditional(() => SubmitOperation.IsComplete); this.EnqueueTestComplete(); }
public void PagingCollectionEventsWithServerPaging() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 3; this.TrackCollectionChanged(); this._dds.Load(); }); this.AssertLoadingData(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(0, this._view.PageIndex, "PageIndex should be 0 after initial load"); // TODO: Change from 2 Reset events to 1 when bug 709185 is fixed and our workaround can be removed this.AssertCollectionChanged(0, 0, 2, "Initial load"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(1, this._view.PageIndex, "PageIndex should be 1 on the 2nd page"); // TODO: Change from 2 Reset events to 1 when bug 709185 is fixed and our workaround can be removed this.AssertCollectionChanged(0, 0, 2, "Move to 2nd page"); }); EnqueueTestComplete(); }
public void AddingToCurrentPageIncreasesCount() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.AutoLoad = false; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 3; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); // Our submissions won't succeed with this domain context this._dds.SubmittedChanges += (s, e) => { if (e.HasError) { e.MarkErrorAsHandled(); } }; EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(3, this._view.Count, "3 items should have been loaded onto the page"); Assert.AreEqual(3, context.Cities.Count, "context.Cities.Count should be 3 after the initial load"); City newCity = this._editableCollectionView.AddNew() as City; newCity.Name = "West Chester"; newCity.StateName = "OH"; this._editableCollectionView.CommitNew(); Assert.AreEqual(4, this._view.Count, "this._ecv.Count should be 4 after adding the new item"); Assert.AreEqual(4, context.Cities.Count, "context.Cities.Count should be 4 after adding the new item"); this._dds.SubmitChanges(); }); this.AssertSubmittingChanges(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); this.ResetSubmitState(); this._dds.Load(); }); this.AssertLoadingData(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); this.ResetSubmitState(); Assert.AreEqual(3, this._view.Count, "this._ecv.Count should return to 3 after submitting"); Assert.AreEqual(4, context.Cities.Count, "context.Cities.Count should remain 4 after submitting"); }); EnqueueTestComplete(); }
public void EnumeratorReadyAfterInitialSinglePageLoad() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 5; this.TrackCollectionChanged(); this._dds.Load(); bool isInitialLoad = true; this._collectionView.CollectionChanged += (s, e) => { if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset && !isInitialLoad) { Assert.AreEqual(5, this._view.Count, "this._ecv.Count should be 5 when the Reset event occurs"); } isInitialLoad = false; }; }); this.AssertLoadingData(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); int count = 0; City[] cities = context.Cities.ToArray(); foreach (Entity entity in this._view) { Assert.AreSame(cities[count++], entity, "Entity mismatch at index " + (count - 1).ToString()); } Assert.AreEqual(5, count, "The enumerator should have had 5 items in it"); }); EnqueueTestComplete(); }
public void CustomMethod_ValidationExceptionRecovery() { bool completed = false; Zip zip = null; SubmitOperation submitOp = null; LoadOperation<Zip> loadOp = null; EventHandler completedDelegate = (sender, args) => completed = true; CityDomainContext context = new CityDomainContext(TestURIs.Cities); loadOp = context.Load(context.GetZipsQuery(), false); loadOp.Completed += completedDelegate; this.EnqueueConditional(() => completed); this.EnqueueCallback(() => { Assert.IsFalse(loadOp.HasError, "Failed to load Zips"); // Grab a Zip and invoke a custom operation that will throw a ValidationException. zip = context.Zips.First(); zip.ThrowException(typeof(ValidationException).Name); // Submit completed = false; submitOp = context.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); submitOp.Completed += completedDelegate; // Verify entity state Assert.IsTrue(zip.IsReadOnly, "Expected Zip to be in a read-only state."); Assert.IsTrue(zip.IsSubmitting, "Expected Zip to be in a submitting state."); Assert.AreEqual(1, zip.EntityActions.Count(), "Expected Zip EntityActions property to contain a single invocation"); }); this.EnqueueConditional(() => completed); this.EnqueueCallback(() => { // Verify results Assert.IsTrue(submitOp.HasError, "Expected errors."); Assert.AreEqual(1, submitOp.EntitiesInError.Count(), "Expected 1 Zip entity in error."); Assert.AreEqual(submitOp.EntitiesInError.Single(), zip, "Expected 1 Zip entity in error."); Assert.AreEqual(1, zip.ValidationErrors.Count, "Expected 1 validation error on Zip entity."); // Verify entity state Assert.IsFalse(zip.IsReadOnly, "Zip should not be in a read-only state."); Assert.IsFalse(zip.IsSubmitting, "Zip should not be in a submitting state."); Assert.AreEqual(1, zip.EntityActions.Count(), "Expected Zip EntityActions property to contain a single invocation"); // Explicitly set a property zip.StateName += "x"; }); this.EnqueueTestComplete(); }
public void PagingPastEndSkippingLastPageUnknownTotalItemCount() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.PageSize = 6; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); Action<string> verifyFirstPageLoaded = (string message) => { Assert.AreEqual(6, this._view.Count, message); Assert.AreEqual(0, this._view.PageIndex, message); Assert.AreEqual("Redmond", (this._view[0] as City).Name, message); Assert.AreEqual("Bellevue", (this._view[1] as City).Name, message); Assert.AreEqual("Duvall", (this._view[2] as City).Name, message); Assert.AreEqual("Carnation", (this._view[3] as City).Name, message); Assert.AreEqual("Everett", (this._view[4] as City).Name, message); Assert.AreEqual("Tacoma", (this._view[5] as City).Name, message); }; EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); verifyFirstPageLoaded("First load"); this._view.MoveToPage(5); }); // Attempt to load the non-existent page, then load the first page this.AssertLoadingData(2); this.AssertNoPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); verifyFirstPageLoaded("After paging past the end"); }); EnqueueTestComplete(); }
public void LoadThreePagesAtOnce() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { // Paging and loading pattern: {(2,2,2), (2,2,1)} this._dds.LoadSize = 6; this._dds.PageSize = 2; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after the initial load"); Assert.AreEqual(6, this._pagedCollectionView.ItemCount, "this._ecv.ItemCount should be 6 after the initial load"); Assert.AreEqual(6, context.Cities.Count, "context.Cities.Count should be 6 after the initial load"); this._ddsLoadingDataExpected = 0; this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 2nd page"); Assert.AreEqual(6, this._pagedCollectionView.ItemCount, "this._ecv.ItemCount should be 6 after moving to the 2nd page"); Assert.AreEqual(6, context.Cities.Count, "context.Cities.Count should still be 6 after moving to the 2nd page"); this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 3rd page"); Assert.AreEqual(6, this._pagedCollectionView.ItemCount, "this._ecv.ItemCount should be 6 after moving to the 3rd page"); Assert.AreEqual(6, context.Cities.Count, "context.Cities.Count should be 6 after moving to the 3rd page"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 4th page"); Assert.AreEqual(11, this._pagedCollectionView.ItemCount, "this._ecv.ItemCount should be 11 after moving to the 4th page"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after moving to the 4th page"); }); EnqueueTestComplete(); }
public void LinqQueryWhenLoadingData() { EnqueueCallback(() => { CityDomainContext context = new CityDomainContext(); this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.LoadingData += (object sender, OpenRiaServices.Controls.LoadingDataEventArgs e) => e.Query = context.GetCitiesQuery().Where(c => c.StateName == "WA"); this._dds.Load(); }); this.AssertLoadingData(); EnqueueCallback(() => { Assert.AreEqual(6, this._view.Count); }); EnqueueTestComplete(); }
public void ClearThroughEntitySet() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 5; this._dds.Load(); }); this.AssertLoadingData(); City loadedCity = null; EnqueueCallback(() => { this.ResetLoadState(); Assert.AreEqual<int>(this._dds.PageSize, this._view.Count, "this._view.Count after the load"); Assert.AreEqual<int>(this._dds.PageSize, context.Cities.Count, "context.Cities.Count after the load"); // Grab reference to a city that was loaded. We'll use it later to ensure page tracking is kept intact. loadedCity = (City)this._view[0]; context.Cities.Clear(); Assert.AreEqual<int>(0, this._view.Count, "this._view.Count after Clear()"); Assert.AreEqual<int>(0, context.Cities.Count, "context.Cities.Count after Clear()"); // Add the loaded city back into the domain context, ensuring that page tracking adds it back to the view context.Cities.Add(loadedCity); Assert.AreEqual<int>(1, this._view.Count, "this._view.Count after adding the loaded city back to the context"); Assert.IsTrue(this._view.Contains(loadedCity), "The view should contain the loaded city"); }); EnqueueTestComplete(); }
public void HasChangesAfterAddingItemToContext() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.IsFalse(this._dds.HasChanges, "DDS should not have changes before anything is edited"); Assert.AreEqual(11, this._view.Count, "There should have been 11 items initially loaded"); City city = new City { Name = "City Name", StateName = "ST" }; context.Cities.Add(city); Assert.IsTrue(this._dds.HasChanges, "DDS should have changes after adding an item with AddNew"); }); EnqueueTestComplete(); }
public void RemovingAndRestoringItemFromAnotherPage() { CityDomainContext context = new CityDomainContext(); City city = null; EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 5; this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); city = this._view[0] as City; this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(5, this._view.Count, "this._ecv.Count should be 5 after loading the 2nd page"); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after loading the 2nd page"); context.Cities.Remove(city); Assert.AreEqual(5, this._view.Count, "this._ecv.Count should be 5 after removing the city, since it belongs to another page"); Assert.AreEqual(9, context.Cities.Count, "context.Cities.Count should be 9 after removing the city"); context.Cities.Add(city); Assert.AreEqual(5, this._view.Count, "this._ecv.Count should be 5 after restoring the removed city"); Assert.AreEqual(10, context.Cities.Count, "context.Cities.Count should be 10 after restoring the removed city"); }); EnqueueTestComplete(); }
public void HasChangesAfterRemovingItemFromContext() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.IsFalse(this._dds.HasChanges, "DDS should not have changes before anything is edited"); Assert.AreEqual(11, this._view.Count, "There should have been 11 items initially loaded"); City city = context.Cities.First(); context.Cities.Remove(city); Assert.IsTrue(this._dds.HasChanges, "DDS should have changes after removing an item from context"); }); EnqueueTestComplete(); }
public void CurrencySetAfterLocalPaging() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.PageSize = 3; this._dds.LoadSize = 11; this._asyncEventFailureMessage = "Initial Load"; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreSame(context.Cities.First(), this._view.CurrentItem, "CurrentItem should match the context.Cities[0] after the initial load"); Assert.AreEqual(0, this._view.CurrentPosition, "CurrentPosition should be 0 after the initial load"); this._ddsLoadedDataExpected = 0; this._asyncEventFailureMessage = "MoveToNextPage()"; this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); City[] cities = context.Cities.ToArray(); Assert.AreSame(cities[3], this._view.CurrentItem, "CurrentItem should match the context.Cities[3] after MoveToNextPage()"); Assert.AreEqual(0, this._view.CurrentPosition, "CurrentPosition should be 0 after MoveToNextPage()"); }); EnqueueTestComplete(); }
public void DataInSyncWithContextAfterRemoveFromContext() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.AreEqual(11, this._view.Count, "There should have been 11 items initially loaded"); context.Cities.Remove(context.Cities.First()); Assert.AreEqual(10, this._view.Count, "There should only be 10 items in Data after the remove"); Assert.AreEqual(10, context.Cities.Count, "There should only be 10 items in context.Cities after the remove"); foreach (City city in this._view) { Assert.IsTrue(context.Cities.Contains(city), "Context should have all cities from this._ecv. Missing City: " + city.Name + ", " + city.StateName); } }); EnqueueTestComplete(); }
public void CustomMethodFlag_ChangeNotifications() { List<string> propChanged = new List<string>(); CityDomainContext ctxt = new CityDomainContext(TestURIs.Cities); City city = null; LoadOperation lo = ctxt.Load(ctxt.GetCitiesQuery(), false); SubmitOperation so = null; EnqueueConditional(() => lo.IsComplete); EnqueueCallback(delegate { city = ctxt.Cities.First(); city.PropertyChanged += (s, e) => { propChanged.Add(e.PropertyName); }; Assert.IsTrue(city.CanAssignCityZone); Assert.IsFalse(city.IsAssignCityZoneInvoked); city.AssignCityZone("Twilight"); Assert.IsFalse(city.CanAssignCityZone); Assert.IsTrue(city.IsAssignCityZoneInvoked); Assert.IsTrue(propChanged.Contains("CanAssignCityZone")); Assert.IsTrue(propChanged.Contains("IsAssignCityZoneInvoked")); propChanged.Clear(); so = ctxt.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); }); EnqueueConditional(() => so.IsComplete); EnqueueCallback(delegate { Assert.IsFalse(so.HasError); Assert.IsTrue(city.CanAssignCityZone); Assert.IsFalse(city.IsAssignCityZoneInvoked); Assert.IsTrue(propChanged.Contains("CanAssignCityZone")); Assert.IsTrue(propChanged.Contains("IsAssignCityZoneInvoked")); }); EnqueueTestComplete(); }
public void AddingToDomainContext() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.AutoLoad = false; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.SortDescriptors.Add(new SortDescriptor("Name", ListSortDirection.Ascending)); this._dds.Load(); }); this.AssertLoadedData(); EnqueueCallback(() => { Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after the initial load"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after the initial load"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after the initial load"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after the initial load"); City city = new City { Name = "West Chester", StateName = "OH" }; context.Cities.Add(city); Assert.AreEqual(12, context.Cities.Count, "There should be 12 items in context after adding a new city"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should remain 11 after adding a new city to the context, because it wasn't added to the ECV"); Assert.IsTrue(context.HasChanges, "context.HasChanges should be true after adding to context"); Assert.IsTrue(this._dds.HasChanges, "this._dds.HasChanges should be true after adding to context"); AssertHelper.AssertSequenceSorting(this._view.Cast<City>().Select(c => c.Name), ListSortDirection.Ascending, "The cities should be sorted by name after adding the city"); context.Cities.Remove(city); Assert.IsFalse(this._dds.HasChanges, "this._dds.HasChanges should be false after removing the new item"); Assert.IsFalse(context.HasChanges, "context.HasChanges should be false after removing the new item"); Assert.AreEqual(11, this._view.Count, "this._ecv.Count should be 11 after removing the new item"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after removing the new item"); }); EnqueueTestComplete(); }
public void LoadTwoPagesAtOnce() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.LoadSize = 4; this._dds.PageSize = 2; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after the initial load"); Assert.AreEqual(4, context.Cities.Count, "context.Cities.Count should be 4 after the initial load"); this._ddsLoadingDataExpected = 0; this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 2nd page"); Assert.AreEqual(4, context.Cities.Count, "context.Cities.Count should still be 4 after moving to the 2nd page"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 3rd page"); Assert.AreEqual(8, context.Cities.Count, "context.Cities.Count should be 8 after moving to the 3rd page"); this._view.MoveToNextPage(); }); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 4th page"); Assert.AreEqual(8, context.Cities.Count, "context.Cities.Count should be 8 after moving to the 4th page"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(2, this._view.Count, "this._ecv.Count should be 2 after moving to the 5th page"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after moving to the 5th page"); }); EnqueueTestComplete(); }
public void DomainContext_Submit_DomainMethodOnly() { EntityChangeSet changeset; List<string> propChanged = new List<string>(); CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities); LoadOperation lo = citiesProvider.Load(citiesProvider.GetCitiesQuery(), false); SubmitOperation so = null; City firstRootCity = null; City lastRootCity = null; // wait for Load to complete, then invoke some domain methods EnqueueConditional(() => lo.IsComplete); EnqueueCallback(delegate { changeset = citiesProvider.EntityContainer.GetChanges(); Assert.IsTrue(changeset.IsEmpty); // Find a root city. This test specifically does not want to accidently use a derived type firstRootCity = citiesProvider.Cities.Where(c => c.GetType() == typeof(City)).FirstOrDefault(); Assert.IsNotNull(firstRootCity, "Expected to find a root City type in entity list"); lastRootCity = citiesProvider.Cities.Where(c => c.GetType() == typeof(City)).LastOrDefault(); Assert.IsNotNull(lastRootCity, "Expected to find a root City type in entity list"); Assert.AreNotEqual(firstRootCity, lastRootCity, "Expected first and last city to be different"); firstRootCity.PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e) { bool isEntityBaseProperty = typeof(City).GetProperty(e.PropertyName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null; if (!isEntityBaseProperty) { propChanged.Add(e.PropertyName); } }; Assert.IsTrue(firstRootCity.CanAssignCityZone); firstRootCity.AssignCityZone("Zone15"); }); // wait for prop changed for domain method guards EnqueueConditional(() => propChanged.Count > 0); EnqueueCallback(delegate { Assert.IsTrue(propChanged.Contains("CanAssignCityZone")); Assert.IsTrue(propChanged.Contains("IsAssignCityZoneInvoked")); Assert.IsFalse(propChanged.Contains("CanAutoAssignCityZone")); propChanged.Clear(); Assert.IsTrue(lastRootCity.CanAutoAssignCityZone); lastRootCity.AutoAssignCityZone(); changeset = citiesProvider.EntityContainer.GetChanges(); Assert.AreEqual(2, changeset.ModifiedEntities.Count); so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); Assert.AreEqual(2, so.ChangeSet.ModifiedEntities.Count); Assert.AreEqual(0, so.ChangeSet.AddedEntities.Count); Assert.AreEqual(0, so.ChangeSet.RemovedEntities.Count); }); // wait for submit to complete, then verify invoked entities in changeset EnqueueConditional(() => so.IsComplete); EnqueueCallback(delegate { Assert.IsNull(so.Error); Assert.AreEqual(2, so.ChangeSet.ModifiedEntities.Count); // verify we got the property change notification for the city entity as a result of autosync Assert.AreEqual(8, propChanged.Count); Assert.AreEqual(1, propChanged.Count(prop => prop == "ZoneName")); Assert.AreEqual(1, propChanged.Count(prop => prop == "ZoneID")); Assert.AreEqual(1, propChanged.Count(prop => prop == "CanAssignCityZone")); Assert.AreEqual(1, propChanged.Count(prop => prop == "IsAssignCityZoneInvoked")); Assert.AreEqual(2, propChanged.Count(prop => prop == "CanAutoAssignCityZone")); Assert.AreEqual(2, propChanged.Count(prop => prop == "CanAssignCityZoneIfAuthorized")); // verify entities are auto-synced back to the client as a result of the domain method execution on server Assert.AreEqual(15, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone15")).ZoneID); Assert.AreEqual(1, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Auto_Zone1")).ZoneID); // verify unchanged entities Assert.AreEqual(0, citiesProvider.Cities.First(c => (c.ZoneName == null)).ZoneID); }); EnqueueTestComplete(); }
public void PagingPastEndTwiceCancelsSecondLoad() { CityDomainContext context = new CityDomainContext(); int pageSize = 6; int cityCount = new CityData().Cities.Count; int lastPageIndex = (cityCount / pageSize) - ((cityCount % pageSize == 0) ? 1 : 0); EnqueueCallback(() => { this._dds.PageSize = pageSize; this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); // We need to make sure the second load caused by paging past the last page is cancelable. // To do this, we'll load 4 times. The first is caused by moving past the last page. The second // is automatically started when the first load does not return any entities and shifts back to // the last page. The third and fourth move past and back again and are started such that the // third load cancels the second. this._dds.LoadingData += (sender, e) => { // We only want to reload once to cancel the second load attempt if (this._ddsLoadingData == 2) { this._view.MoveToPage(lastPageIndex + 2); } }; this._dds.LoadedData += (sender, e) => { Assert.IsTrue((this._ddsLoadedData == 2) == e.Cancelled, "Only the second load should have been canceled."); }; this._view.MoveToPage(lastPageIndex + 1); }); this.AssertLoadingData(4); EnqueueTestComplete(); }
public void DomainContext_Submit_DomainMethodAndCRUD() { List<string> propChanged_addedCity = new List<string>(); City newCity = new City { Name = "Sammamish", CountyName = "King", StateName = "WA" }; int refZipCode = 0; int refCityCount = 0; CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities); LoadOperation lo = citiesProvider.Load(citiesProvider.GetCitiesQuery(), false); SubmitOperation so = null; // wait for LoadCities to complete, then LoadZips EnqueueConditional(() => lo.IsComplete); EnqueueCallback(delegate { refCityCount = citiesProvider.Cities.Count; lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false); }); // wait for Load to complete, then invoke some domain methods EnqueueConditional(() => lo.IsComplete); EnqueueCallback(delegate { // this test the following combinations of CRUD and Domain method in changeset: // - Invoke -> update // - Add -> invoke // - Remove // - Invoke only City[] cities = citiesProvider.Cities.ToArray(); cities[0].ZoneName = "Zone44"; cities[0].AssignCityZone("Zone1"); cities[1].AssignCityZone("Zone2"); citiesProvider.Cities.Add(newCity); newCity.AssignCityZone("Zone3"); citiesProvider.Cities.Remove(cities[4]); citiesProvider.Cities.Remove(cities[5]); // keep a reference zip code before invoking the method: this will increment Code by offset=1 on the server Zip zip = citiesProvider.Zips.First(); refZipCode = zip.Code; zip.ReassignZipCode(1, true); newCity.PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e) { if (e.PropertyName != "IsReadOnly" && e.PropertyName != "HasChanges" && e.PropertyName != "EntityState" && e.PropertyName != "ValidationErrors") { propChanged_addedCity.Add(e.PropertyName); } }; Assert.IsTrue(newCity.CanAssignCityZoneIfAuthorized); Assert.IsTrue(newCity.CanAutoAssignCityZone); so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null); Assert.IsFalse(newCity.CanAssignCityZoneIfAuthorized); Assert.IsFalse(newCity.CanAutoAssignCityZone); Assert.AreEqual(3, so.ChangeSet.ModifiedEntities.Count); Assert.AreEqual(1, so.ChangeSet.AddedEntities.Count); Assert.AreEqual(2, so.ChangeSet.RemovedEntities.Count); }); EnqueueConditional(() => so.IsComplete); EnqueueCallback(delegate { Assert.IsNull(so.Error, string.Format("SubmitOperation.Error should be null.\r\nMessage: {0}\r\nStack Trace:\r\n{1}", so.Error != null ? so.Error.Message : string.Empty, so.Error != null ? so.Error.StackTrace : string.Empty)); Assert.IsTrue(newCity.CanAssignCityZoneIfAuthorized); Assert.IsTrue(newCity.CanAutoAssignCityZone); Assert.IsTrue(newCity.CanAssignCityZone); // verify we got property change notifications for the new city entity (guard property should be reverted once SubmitChanges is called) Assert.AreEqual(9, propChanged_addedCity.Count); Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "ZoneName")); Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "ZoneID")); Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "CanAssignCityZone")); Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "IsAssignCityZoneInvoked")); // The other custom method invocations should have changed from true -> false during submit // and from false -> true after submit Assert.AreEqual(2, propChanged_addedCity.Count(prop => prop == "CanAssignCityZoneIfAuthorized")); Assert.AreEqual(2, propChanged_addedCity.Count(prop => prop == "CanAutoAssignCityZone")); // verify entities are auto-synced back to the client as a result of the domain method execution on server Assert.AreEqual(1, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone1" && c.CountyName == "King")).ZoneID); Assert.AreEqual(2, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone2")).ZoneID); Assert.AreEqual(3, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone3" && c.Name == newCity.Name)).ZoneID); Assert.IsTrue(citiesProvider.Zips.Any<Zip>(z => z.Code == refZipCode - 1)); // verify unchanged entities Assert.IsFalse(citiesProvider.Cities.Any(c => (c.ZoneName == null && c.ZoneID != 0))); // verify that after a successful submit, DM invocations on the entities have been accepted Assert.IsFalse(so.ChangeSet.ModifiedEntities.Any(p => p.EntityActions.Any())); EntityChangeSet changeSet = citiesProvider.EntityContainer.GetChanges(); Assert.IsTrue(changeSet.IsEmpty); }); EnqueueTestComplete(); }
public void PagingLargePageSize() { CityDomainContext context = new CityDomainContext(); EnqueueCallback(() => { this._dds.QueryName = "GetCitiesQuery"; this._dds.DomainContext = context; this._dds.LoadSize = 5; this._dds.PageSize = 10; this._dds.Load(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(10, this._pagedCollectionView.ItemCount, "ItemCount should be 10 after initial load"); Assert.AreEqual(10, this._view.Count, "Count should be 10 after initial load"); this._view.MoveToNextPage(); }); this.AssertLoadingData(); this.AssertPageChanged(); EnqueueCallback(() => { this.ResetLoadState(); this.ResetPageChanged(); Assert.AreEqual(11, this._pagedCollectionView.ItemCount, "ItemCount should be 11 after moving to the 2nd page"); Assert.AreEqual(1, this._view.Count, "Count should be 1 after moving to the 2nd page"); Assert.AreEqual(11, context.Cities.Count, "context.Cities.Count should be 11 after moving to the 2nd page"); }); EnqueueTestComplete(); }
public void DomainMethod_InvalidParameterTypes_Bug615860() { // Create a test City Entity CityDomainContext provider = new CityDomainContext(TestURIs.Cities); City city = new City(); city.Name = "TestCity"; city.StateName = "AA"; provider.Cities.Add(city); // attach to set entity set reference // Invoke a domain method with correct number of parameters but incorrect types ExceptionHelper.ExpectException<MissingMethodException>( () => city.InvokeAction("AssignCityZone", 1 /*correct parameter type is string*/), string.Format(Resource.ValidationUtilities_MethodNotFound, "Cities.City", "AssignCityZone", 1, "'System.Int32'")); }