private void HandleResponse(LoadResult loadResult)
 {
     RequiresRetry = _loadOperation.SetResult(loadResult);
     if (RequiresRetry == false)
     {
         Result = _loadOperation.Complete <T>();
     }
 }
        public Task <T> LoadAsync <T>(string id)
        {
            object existingEntity;

            if (entitiesByKey.TryGetValue(id, out existingEntity))
            {
                return(CompletedTask.With((T)existingEntity));
            }

            IncrementRequestCount();
            var shardRequestData = new ShardRequestData
            {
                EntityType = typeof(T),
                Keys       = { id }
            };

            var dbCommands = GetCommandsToOperateOn(shardRequestData);
            var results    = shardStrategy.ShardAccessStrategy.ApplyAsync(dbCommands, shardRequestData, (commands, i) =>
            {
                var loadOperation = new LoadOperation(this, commands.DisableAllCaching, id);

                Func <Task> executer = null;
                executer             = () =>
                {
                    loadOperation.LogOperation();

                    var loadContext = loadOperation.EnterLoadContext();
                    return(commands.GetAsync(id).ContinueWith(task =>
                    {
                        if (loadContext != null)
                        {
                            loadContext.Dispose();
                        }

                        if (loadOperation.SetResult(task.Result))
                        {
                            return executer();
                        }
                        return new CompletedTask();
                    }).Unwrap());
                };
                return(executer().ContinueWith(_ =>
                {
                    _.AssertNotFailed();
                    return loadOperation.Complete <T>();
                }));
            });

            return(results.ContinueWith(task =>
            {
                var shardsContainThisDocument = task.Result.Where(x => !Equals(x, default(T))).ToArray();
                if (shardsContainThisDocument.Count() > 1)
                {
                    throw new InvalidOperationException("Found document with id: " + id +
                                                        " on more than a single shard, which is not allowed. Document keys have to be unique cluster-wide.");
                }

                return shardsContainThisDocument.FirstOrDefault();
            }));
        }
Exemple #3
0
        /// <summary>
        /// Begins the async load operation
        /// </summary>
        public async Task <T[]> LoadAsyncInternal <T>(string[] ids, CancellationToken token = default(CancellationToken))
        {
            if (ids.Length == 0)
            {
                return(new T[0]);
            }

            // only load documents that aren't already cached
            var idsOfNotExistingObjects = ids.Where(id => IsLoaded(id) == false && IsDeleted(id) == false)
                                          .Distinct(StringComparer.OrdinalIgnoreCase)
                                          .ToArray();

            if (idsOfNotExistingObjects.Length > 0)
            {
                IncrementRequestCount();
                var        loadOperation = new LoadOperation(this, AsyncDatabaseCommands.DisableAllCaching, idsOfNotExistingObjects, null);
                LoadResult loadResult;
                do
                {
                    loadOperation.LogOperation();
                    using (loadOperation.EnterLoadContext())
                    {
                        loadResult = await AsyncDatabaseCommands.GetAsync(idsOfNotExistingObjects, null).ConfigureAwait(false);
                    }
                } while (loadOperation.SetResult(loadResult));

                loadOperation.Complete <T>();
            }

            var loadTasks  = ids.Select(async id => await LoadAsync <T>(id, token).ConfigureAwait(false)).ToArray();
            var loadedData = await Task.WhenAll(loadTasks).WithCancellation(token).ConfigureAwait(false);

            return(loadedData);
        }
Exemple #4
0
        /// <summary>
        /// Begins the async load operation
        /// </summary>
        public async Task <T[]> LoadAsyncInternal <T>(string[] ids, KeyValuePair <string, Type>[] includes, CancellationToken token = default(CancellationToken))
        {
            if (CheckIfIdAlreadyIncluded(ids, includes))
            {
                var loadTasks  = ids.Select(id => LoadAsync <T>(id, token)).ToArray();
                var loadedData = await Task.WhenAll(loadTasks).WithCancellation(token).ConfigureAwait(false);

                return(loadedData);
            }

            IncrementRequestCount();
            var loadOperation = new LoadOperation(this, AsyncDatabaseCommands.DisableAllCaching, ids, includes);

            loadOperation.LogOperation();
            var includePaths = includes != null?includes.Select(x => x.Key).ToArray() : null;

            LoadResult result;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    result = await AsyncDatabaseCommands.GetAsync(ids, includePaths, token : token).ConfigureAwait(false);
                }
            } while (loadOperation.SetResult(result));
            return(loadOperation.Complete <T>());
        }
        public T[] LoadInternal <T>(string[] ids, KeyValuePair <string, Type>[] includes)
        {
            if (ids.Length == 0)
            {
                return(new T[0]);
            }

            if (CheckIfIdAlreadyIncluded(ids, includes))
            {
                return(ids.Select(Load <T>).ToArray());
            }
            var includePaths = includes != null?includes.Select(x => x.Key).ToArray() : null;


            IncrementRequestCount();
            var        loadOperation = new LoadOperation(this, DatabaseCommands.DisableAllCaching, ids, includes);
            LoadResult loadResult;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    loadResult = DatabaseCommands.Get(ids, includePaths);
                }
            } while (loadOperation.SetResult(loadResult));

            return(loadOperation.Complete <T>());
        }
        public T[] LoadInternal <T>(string[] ids)
        {
            if (ids.Length == 0)
            {
                return(new T[0]);
            }

            // only load documents that aren't already cached
            var idsOfNotExistingObjects = ids.Where(id => IsLoaded(id) == false && IsDeleted(id) == false)
                                          .Distinct(StringComparer.OrdinalIgnoreCase)
                                          .ToArray();

            if (idsOfNotExistingObjects.Length > 0)
            {
                IncrementRequestCount();
                var        loadOperation = new LoadOperation(this, DatabaseCommands.DisableAllCaching, idsOfNotExistingObjects, null);
                LoadResult loadResult;
                do
                {
                    loadOperation.LogOperation();
                    using (loadOperation.EnterLoadContext())
                    {
                        loadResult = DatabaseCommands.Get(idsOfNotExistingObjects, null);
                    }
                } while (loadOperation.SetResult(loadResult));

                loadOperation.Complete <T>();
            }

            return(ids.Select(Load <T>).ToArray());
        }
Exemple #7
0
        /// <summary>
        /// Loads the specified entity with the specified id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">The id.</param>
        /// <returns></returns>
        public T Load <T>(string id)
        {
            if (id == null)
            {
                throw new ArgumentNullException("id", "The document id cannot be null");
            }
            object existingEntity;

            if (entitiesByKey.TryGetValue(id, out existingEntity))
            {
                return((T)existingEntity);
            }

            IncrementRequestCount();
            var  loadOperation = new LoadOperation(this, DatabaseCommands.DisableAllCaching, id);
            bool retry;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    retry = loadOperation.SetResult(DatabaseCommands.Get(id));
                }
            } while (retry);
            return(loadOperation.Complete <T>());
        }
Exemple #8
0
 private void HandleResponse(JsonDocument jsonDocument)
 {
     RequiresRetry = loadOperation.SetResult(jsonDocument);
     if (RequiresRetry == false)
     {
         Result = loadOperation.Complete <T>();
     }
 }
Exemple #9
0
        public void UnhandledLoadOperationError()
        {
            TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));

            var           query = ctxt.CreateQuery <Product>("ThrowGeneralException", null, false, true);
            LoadOperation lo    = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, false);

            DomainOperationException expectedException = null;
            DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");

            try
            {
                lo.Complete(ex);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.AreSame(ex, expectedException);

            // TODO: Add separate test with mock DomainClient which throws a specific exception
            // and move the following checks there

            /*
             * Assert.IsNotNull(expectedException);
             * Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed, "ThrowGeneralException", ex.Message), expectedException.Message);
             * Assert.AreEqual(ex.StackTrace, expectedException.StackTrace);
             * Assert.AreEqual(ex.Status, expectedException.Status);
             * Assert.AreEqual(ex.ErrorCode, expectedException.ErrorCode);
             */

            Assert.AreEqual(false, lo.IsErrorHandled);

            // now test again with validation errors
            expectedException = null;
            ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) };
            lo = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, false);
            ex = new DomainOperationException("expected", validationErrors);

            try
            {
                lo.Complete(ex);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.AreSame(expectedException, ex);;
            CollectionAssert.AreEqual(validationErrors, lo.ValidationErrors.ToList());
        }
        public T Load <T>(string id)
        {
            if (IsDeleted(id))
            {
                return(default(T));
            }

            object existingEntity;

            if (entitiesByKey.TryGetValue(id, out existingEntity))
            {
                return((T)existingEntity);
            }
            JsonDocument value;

            if (includedDocumentsByKey.TryGetValue(id, out value))
            {
                includedDocumentsByKey.Remove(id);
                return(TrackEntity <T>(value));
            }
            IncrementRequestCount();
            var shardRequestData = new ShardRequestData
            {
                EntityType = typeof(T),
                Keys       = { id }
            };
            var dbCommands = GetCommandsToOperateOn(shardRequestData);
            var results    = shardStrategy.ShardAccessStrategy.Apply(dbCommands, shardRequestData, (commands, i) =>
            {
                var loadOperation = new LoadOperation(this, commands.DisableAllCaching, id);
                bool retry;
                do
                {
                    loadOperation.LogOperation();
                    using (loadOperation.EnterLoadContext())
                    {
                        retry = loadOperation.SetResult(commands.Get(id));
                    }
                } while (retry);
                return(loadOperation.Complete <T>());
            });

            var shardsContainThisDocument = results.Where(x => !Equals(x, default(T))).ToArray();

            if (shardsContainThisDocument.Count() > 1)
            {
                throw new InvalidOperationException("Found document with id: " + id +
                                                    " on more than a single shard, which is not allowed. Document keys have to be unique cluster-wide.");
            }

            return(shardsContainThisDocument.FirstOrDefault());
        }
        public void HandleResponses(GetResponse[] responses, ShardStrategy shardStrategy)
        {
            var list = new List <LoadResult>(
                from response in responses
                let result = response.Result
                             select new LoadResult
            {
                Includes = result.Value <RavenJArray>("Includes").Cast <RavenJObject>().ToList(),
                Results  = result.Value <RavenJArray>("Results").Select(x => x as RavenJObject).ToList()
            });

            var capacity = list.Max(x => x.Results.Count);

            var finalResult = new LoadResult
            {
                Includes = new List <RavenJObject>(),
                Results  = new List <RavenJObject>(Enumerable.Range(0, capacity).Select(x => (RavenJObject)null))
            };


            foreach (var multiLoadResult in list)
            {
                finalResult.Includes.AddRange(multiLoadResult.Includes);

                for (int i = 0; i < multiLoadResult.Results.Count; i++)
                {
                    if (finalResult.Results[i] == null)
                    {
                        finalResult.Results[i] = multiLoadResult.Results[i];
                    }
                }
            }
            RequiresRetry = loadOperation.SetResult(finalResult);
            if (RequiresRetry == false)
            {
                Result = loadOperation.Complete <T>();
            }
        }
Exemple #12
0
        private async Task <T> CompleteLoadAsync <T>(string id, LoadOperation loadOperation, CancellationToken token = default(CancellationToken))
        {
            loadOperation.LogOperation();
            using (loadOperation.EnterLoadContext())
            {
                var result = await AsyncDatabaseCommands.GetAsync(id, token);

                if (loadOperation.SetResult(result) == false)
                {
                    return(loadOperation.Complete <T>());
                }

                return(await CompleteLoadAsync <T>(id, loadOperation, token).WithCancellation(token));
            }
        }
Exemple #13
0
        public void UnhandledLoadOperationError()
        {
            TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));

            var           query = ctxt.CreateQuery <Product>("ThrowGeneralException", null, false, true);
            LoadOperation lo    = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            DomainOperationException expectedException = null;
            DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");

            try
            {
                lo.Complete(ex);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.IsNotNull(expectedException);
            Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed, "ThrowGeneralException", ex.Message), expectedException.Message);
            Assert.AreEqual(ex.StackTrace, expectedException.StackTrace);
            Assert.AreEqual(ex.Status, expectedException.Status);
            Assert.AreEqual(ex.ErrorCode, expectedException.ErrorCode);

            Assert.AreEqual(false, lo.IsErrorHandled);

            // now test again with validation errors
            expectedException = null;
            ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) };
            lo = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            try
            {
                lo.Complete(validationErrors);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.IsNotNull(expectedException);
            Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed_Validation, "ThrowGeneralException"), expectedException.Message);
        }
        private Task <T> CompleteLoadAsync <T>(string id, LoadOperation loadOperation)
        {
            loadOperation.LogOperation();
            using (loadOperation.EnterLoadContext())
            {
                return(AsyncDatabaseCommands.GetAsync(id)
                       .ContinueWith(task =>
                {
                    if (loadOperation.SetResult(task.Result) == false)
                    {
                        return Task.Factory.StartNew(() => loadOperation.Complete <T>());
                    }

                    return CompleteLoadAsync <T>(id, loadOperation);
                })
                       .Unwrap());
            }
        }
        /// <summary>
        /// Loads the specified entity with the specified id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">The id.</param>
        /// <returns></returns>
        public T Load <T>(string id)
        {
            if (id == null)
            {
                throw new ArgumentNullException("id", "The document id cannot be null");
            }
            if (IsDeleted(id))
            {
                return(default(T));
            }
            object existingEntity;

            if (EntitiesById.TryGetValue(id, out existingEntity))
            {
                return((T)existingEntity);
            }
            JsonDocument value;

            if (includedDocumentsByKey.TryGetValue(id, out value))
            {
                includedDocumentsByKey.Remove(id);
                return(TrackEntity <T>(value));
            }

            IncrementRequestCount();
            var  loadOperation = new LoadOperation(this, DatabaseCommands.DisableAllCaching, id);
            bool retry;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    retry = loadOperation.SetResult(DatabaseCommands.Get(id));
                }
            } while (retry);
            return(loadOperation.Complete <T>().FirstOrDefault());
        }
Exemple #16
0
        public void HandleResponse(GetResponse response)
        {
            if (response.Status == 404)
            {
                Result        = null;
                RequiresRetry = false;
                return;
            }

            var headers = new NameValueCollection();

            foreach (var header in response.Headers)
            {
                headers[header.Key] = header.Value;
            }
            var jsonDocument = SerializationHelper.DeserializeJsonDocument(key, response.Result, headers, (HttpStatusCode)response.Status);

            RequiresRetry = loadOperation.SetResult(jsonDocument);
            if (RequiresRetry == false)
            {
                Result = loadOperation.Complete <T>();
            }
        }
Exemple #17
0
        /// <summary>
        /// Loads the specified entity with the specified id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">The id.</param>
        /// <returns></returns>
        public T Load <T>(string id)
        {
            object existingEntity;

            if (entitiesByKey.TryGetValue(id, out existingEntity))
            {
                return((T)existingEntity);
            }

            IncrementRequestCount();
            var  loadOperation = new LoadOperation(this, DatabaseCommands.DisableAllCaching, id);
            bool retry;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    retry = loadOperation.SetResult(DatabaseCommands.Get(id));
                }
            } while (retry);
            return(loadOperation.Complete <T>());
        }
        public static async Task <T[]> MoreLikeThisAsync <T>(this IAsyncAdvancedSessionOperations advancedSession, string index, string transformer, MoreLikeThisQuery parameters)
        {
            if (string.IsNullOrEmpty(index))
            {
                throw new ArgumentException("Index name cannot be null or empty", "index");
            }

            parameters.IndexName   = index;
            parameters.Transformer = transformer;

            // /morelikethis/(index-name)/(ravendb-document-id)?fields=(fields)
            var cmd = ((AsyncDocumentSession)advancedSession).AsyncDatabaseCommands;

            var inMemoryDocumentSessionOperations = ((InMemoryDocumentSessionOperations)advancedSession);

            inMemoryDocumentSessionOperations.IncrementRequestCount();

            var        loadOperation = new LoadOperation(inMemoryDocumentSessionOperations, cmd.DisableAllCaching, null, null);
            LoadResult loadResult;

            do
            {
                loadOperation.LogOperation();
                using (loadOperation.EnterLoadContext())
                {
                    var result = await cmd.MoreLikeThisAsync(parameters).ConfigureAwait(false);

                    loadResult = new LoadResult
                    {
                        Includes = result.Includes,
                        Results  = result.Results
                    };
                }
            } while (loadOperation.SetResult(loadResult));

            return(loadOperation.Complete <T>());
        }
Exemple #19
0
        public void Operation_MarkAsHandled()
        {
            TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));

            var           query = ctxt.CreateQuery <Product>("ThrowGeneralException", null, false, true);
            LoadOperation lo    = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            EventHandler action = (o, e) =>
            {
                LoadOperation loadOperation = (LoadOperation)o;
                if (loadOperation.HasError)
                {
                    loadOperation.MarkErrorAsHandled();
                }
            };

            lo.Completed += action;

            DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");

            lo.Complete(ex);

            // verify that calling MarkAsHandled again is a noop
            lo.MarkErrorAsHandled();
            lo.MarkErrorAsHandled();

            // verify that calling MarkAsHandled on an operation not in error
            // results in an exception
            lo = new LoadOperation <Product>(query, LoadBehavior.KeepCurrent, null, null, null);
            Assert.IsFalse(lo.HasError);
            Assert.IsTrue(lo.IsErrorHandled);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                lo.MarkErrorAsHandled();
            }, Resource.Operation_HasErrorMustBeTrue);
        }
        public void Operation_MarkAsHandled()
        {
            TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));

            var query = ctxt.CreateQuery<Product>("ThrowGeneralException", null, false, true);
            LoadOperation lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            EventHandler action = (o, e) =>
            {
                LoadOperation loadOperation = (LoadOperation)o;
                if (loadOperation.HasError)
                {
                    loadOperation.MarkErrorAsHandled();
                }
            };
            lo.Completed += action;

            DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");
            lo.Complete(ex);

            // verify that calling MarkAsHandled again is a noop
            lo.MarkErrorAsHandled();
            lo.MarkErrorAsHandled();

            // verify that calling MarkAsHandled on an operation not in error
            // results in an exception
            lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);
            Assert.IsFalse(lo.HasError);
            Assert.IsTrue(lo.IsErrorHandled);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                lo.MarkErrorAsHandled();
            }, Resource.Operation_HasErrorMustBeTrue);
        }
Exemple #21
0
        public void Exceptions()
        {
            Cities.CityDomainContext cities = new CityDomainContext(TestURIs.Cities);

            Action <LoadOperation <City> > loCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action <SubmitOperation> soCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action <InvokeOperation> ioCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            var query               = cities.GetCitiesQuery();
            var loadBehaviour       = LoadBehavior.MergeIntoCurrent;
            LoadOperation <City> lo = new LoadOperation <City>(query, loadBehaviour, loCallback, null, false);

            // verify completion callbacks that throw
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                try
                {
                    lo.Complete(new LoadResult <City>(query, loadBehaviour, Array.Empty <City>(), Array.Empty <Entity>(), 0));
                }
                catch (Exception ex)
                {
                    Assert.IsTrue(ex.StackTrace.Contains("at OpenRiaServices.DomainServices.Client.Test.OperationTests"), "Stacktrace not preserved.");

                    throw;
                }
            }, "Fnord!");

            // verify cancellation callbacks for all fx operation types
            lo = new LoadOperation <City>(cities.GetCitiesQuery(), LoadBehavior.MergeIntoCurrent, null, null, true);
            lo.CancellationToken.Register(() => throw new InvalidOperationException("Fnord!"));
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                lo.Cancel();
            }, "Fnord!");

            SubmitOperation so = new SubmitOperation(cities.EntityContainer.GetChanges(), soCallback, null, soCallback);

            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                so.Cancel();
            }, "Fnord!");

            InvokeOperation io = new InvokeOperation("Fnord", null, null, null, true);

            io.CancellationToken.Register(() => throw new InvalidOperationException("Fnord!"));
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                io.Cancel();
            }, "Fnord!");
        }
        public void Exceptions()
        {
            Cities.CityDomainContext cities = new CityDomainContext(TestURIs.Cities);

            Action<LoadOperation<City>> loCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action<SubmitOperation> soCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action<InvokeOperation> ioCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            LoadOperation lo = new LoadOperation<City>(cities.GetCitiesQuery(), LoadBehavior.MergeIntoCurrent, loCallback, null, loCallback);

            // verify completion callbacks that throw
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                try
                {
                    lo.Complete(DomainClientResult.CreateQueryResult(new Entity[0], new Entity[0], 0, new ValidationResult[0]));
                }
                catch (Exception ex)
                {
                    Assert.IsTrue(ex.StackTrace.Contains("at OpenRiaServices.DomainServices.Client.Test.OperationTests"), "Stacktrace not preserved.");

                    throw;
                }
            }, "Fnord!");

            // verify cancellation callbacks for all fx operation types
            lo = new LoadOperation<City>(cities.GetCitiesQuery(), LoadBehavior.MergeIntoCurrent, null, null, loCallback);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                lo.Cancel();
            }, "Fnord!");

            SubmitOperation so = new SubmitOperation(cities.EntityContainer.GetChanges(), soCallback, null, soCallback);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                so.Cancel();
            }, "Fnord!");

            InvokeOperation io = new InvokeOperation("Fnord", null, null, null, ioCallback);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                io.Cancel();
            }, "Fnord!");
        }
Exemple #23
0
        public void Exceptions()
        {
            Cities.CityDomainContext cities = new CityDomainContext(TestURIs.Cities);

            Action <LoadOperation <City> > loCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action <SubmitOperation> soCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            Action <InvokeOperation> ioCallback = (op) =>
            {
                if (op.HasError)
                {
                    op.MarkErrorAsHandled();
                }

                throw new InvalidOperationException("Fnord!");
            };

            LoadOperation lo = new LoadOperation <City>(cities.GetCitiesQuery(), LoadBehavior.MergeIntoCurrent, loCallback, null, loCallback);

            // verify completion callbacks that throw
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                try
                {
                    lo.Complete(DomainClientResult.CreateQueryResult(new Entity[0], new Entity[0], 0, new ValidationResult[0]));
                }
                catch (Exception ex)
                {
                    Assert.IsTrue(ex.StackTrace.Contains("at OpenRiaServices.DomainServices.Client.Test.OperationTests"), "Stacktrace not preserved.");

                    throw;
                }
            }, "Fnord!");

            // verify cancellation callbacks for all fx operation types
            lo = new LoadOperation <City>(cities.GetCitiesQuery(), LoadBehavior.MergeIntoCurrent, null, null, loCallback);
            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                lo.Cancel();
            }, "Fnord!");

            SubmitOperation so = new SubmitOperation(cities.EntityContainer.GetChanges(), soCallback, null, soCallback);

            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                so.Cancel();
            }, "Fnord!");

            InvokeOperation io = new InvokeOperation("Fnord", null, null, null, ioCallback);

            ExceptionHelper.ExpectInvalidOperationException(delegate
            {
                io.Cancel();
            }, "Fnord!");
        }
        public void UnhandledLoadOperationError()
        {
            TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));

            var query = ctxt.CreateQuery<Product>("ThrowGeneralException", null, false, true);
            LoadOperation lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            DomainOperationException expectedException = null;
            DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");
            try
            {
                lo.Complete(ex);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.IsNotNull(expectedException);
            Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed, "ThrowGeneralException", ex.Message), expectedException.Message);
            Assert.AreEqual(ex.StackTrace, expectedException.StackTrace);
            Assert.AreEqual(ex.Status, expectedException.Status);
            Assert.AreEqual(ex.ErrorCode, expectedException.ErrorCode);

            Assert.AreEqual(false, lo.IsErrorHandled);

            // now test again with validation errors
            expectedException = null;
            ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) };
            lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);

            try
            {
                lo.Complete(validationErrors);
            }
            catch (DomainOperationException e)
            {
                expectedException = e;
            }

            // verify the exception properties
            Assert.IsNotNull(expectedException);
            Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed_Validation, "ThrowGeneralException"), expectedException.Message);
        }