public async Task ThrowIfMoreThanOneRoot()
        {
            var provider = new TestTreeDbContextProvider(nameof(ThrowIfMoreThanOneRoot));

            using (var context = provider.CreateContext())
            {
                await context.Nodes.AddRangeAsync(
                    new Node
                {
                    Id   = 1,
                    Name = "Root 1"
                },
                    new Node
                {
                    Id   = 2,
                    Name = "Root 2"
                }
                    );

                await context.SaveChangesAsync();
            }

            var         manager = new TreeManager(provider);
            Func <Task> action  = async() => await manager.GetRootWithRecursiveChildrenAsync();

            await action.Should().ThrowAsync <InvalidOperationException>("Sequence contains more than one matching element");
        }
        public async Task ReturnNullIfRootDoesNotExist()
        {
            var provider = new TestTreeDbContextProvider(nameof(ReturnNullIfRootDoesNotExist));

            var manager = new TreeManager(provider);
            var root    = await manager.GetRootWithRecursiveChildrenAsync();

            root.Should().BeNull();
        }
        public async Task ReturnSingleRoot()
        {
            var provider = new TestTreeDbContextProvider(nameof(ReturnSingleRoot));

            using (var context = provider.CreateContext())
            {
                await context.Nodes.AddAsync(new Node
                {
                    Id   = 1,
                    Name = "Root"
                });

                await context.SaveChangesAsync();
            }

            var manager = new TreeManager(provider);
            var root    = await manager.GetRootWithRecursiveChildrenAsync();

            root.Should().BeEquivalentTo(new Node
            {
                Id   = 1,
                Name = "Root"
            });
        }
예제 #4
0
        public async Task CascadeMarkAsRemoved()
        {
            var provider = new TestTreeDbContextProvider(nameof(CascadeMarkAsRemoved));

            using (var context = provider.CreateContext())
            {
                await context.Nodes.AddAsync(new Node
                {
                    Id       = 1,
                    Children =
                    {
                        new Node
                        {
                            Id       = 2,
                            Children =
                            {
                                new Node         {
                                    Id = 21
                                },
                                new Node
                                {
                                    Id       = 22,
                                    Children =
                                    {
                                        new Node {
                                            Id = 221
                                        }
                                    }
                                }
                            }
                        },
                        new Node                 {
                            Id = 3
                        }
                    }
                });

                await context.SaveChangesAsync();
            }

            var manager = new TreeManager(provider);
            await manager.ApplyChangesAsync(new ChangeModel
            {
                NodesToRemove = new HashSet <long>()
                {
                    2
                }
            });

            using (var context = provider.CreateContext())
            {
                var all = await context.Nodes.ToListAsync();

                var node = await context.Nodes.SingleAsync(x => x.Id == 1);

                node.Should().BeEquivalentTo(new Node
                {
                    Id        = 1,
                    IsRemoved = false,
                    Children  =
                    {
                        new Node
                        {
                            Id        = 2,
                            IsRemoved = true,
                            Children  =
                            {
                                new Node         {
                                    Id = 21, IsRemoved = true
                                },
                                new Node
                                {
                                    Id        = 22,
                                    IsRemoved = true,
                                    Children  =
                                    {
                                        new Node {
                                            Id = 221, IsRemoved = true
                                        }
                                    }
                                }
                            }
                        },
                        new Node                 {
                            Id = 3, IsRemoved = false
                        }
                    }
                }, o => o.Excluding(x => x.SelectedMemberPath.Contains("Parent")).IgnoringCyclicReferences());
            }
        }