public async Task DeliverPost_Post()
        {
            var returnUrlPath  = "/index";
            var returnUrlQuery = "?indexquery=indexquery";
            var returnUrl      = returnUrlPath + returnUrlQuery;
            var myBranchIndex  = 0;

            var context = MakeContext(returnUrlPath, returnUrlQuery, myBranchIndex);

            var postId = 1;

            context.Mail.Add(new Post
            {
                Id                  = postId,
                BranchId            = context.Branches[myBranchIndex].Id,
                DestinationBranchId = context.Branches[myBranchIndex].Id,
            });

            var controller = new OperatorController(
                context.CurrentUserService,
                context.BranchesDao,
                context.MailDaoMock.Object)
            {
                TempData          = context.TempDataDictionary,
                ControllerContext = context.ControllerContext
            };

            var r = await controller.DeliverPost(postId, returnUrl) as RedirectResult;

            Assert.NotNull(r);
            Assert.Equal(returnUrl, r.Url);

            var post = context.Mail.First();

            Assert.Null(post.BranchId);
            Assert.Null(post.BranchStockAddress);
            Assert.Null(post.CarId);
            Assert.Equal(PostState.Delivered, post.State);
        }
        public async Task DeliverPost_Get()
        {
            var options = new ListOptions
            {
                Filters = new Dictionary <string, string>
                {
                    { "id", "1" },
                    { "personFrom", "2" },
                    { "personTo", "3" }
                },
                SortKey   = "PersonFrom",
                SortOrder = SortOrder.Descending
            };
            var returnUrlPath  = "/index";
            var returnUrlQuery = "?indexquery=indexquery";
            var returnUrl      = returnUrlPath + returnUrlQuery;
            var myBranchIndex  = 0;

            var context = MakeContext(returnUrlPath, returnUrlQuery, myBranchIndex);
            var random  = new Random();

            for (int i = 0; i < 100; ++i)
            {
                context.Mail.Add(new Post
                {
                    Id                  = random.Next(),
                    PersonFrom          = "personFrom" + random.Next(),
                    PersonTo            = "personTo" + random.Next(),
                    DestinationBranchId = context.Branches[myBranchIndex].Id,
                    State               = PostState.InBranchStock
                });
            }

            var controller = new OperatorController(
                context.CurrentUserService,
                context.BranchesDao,
                context.MailDaoMock.Object)
            {
                TempData          = context.TempDataDictionary,
                ControllerContext = context.ControllerContext
            };

            var r = await controller.DeliverPost(options) as ViewResult;

            Assert.NotNull(r);
            Assert.Null(r.ViewName);
            var vm = r.Model as DeliverPostViewModel;

            Assert.NotNull(vm);
            var expectedMail = context.Mail
                               .Where(p => p.Id.ToString().Contains(options.Filters["id"]))
                               .Where(p => p.PersonFrom.Contains(options.Filters["personFrom"]))
                               .Where(p => p.PersonTo.Contains(options.Filters["personTo"]))
                               .Where(p => p.DestinationBranchId == context.Branches[myBranchIndex].Id)
                               .Where(p => p.State == PostState.InBranchStock)
                               .Order(options.SortKey, options.SortOrder)
                               .ToPaginatedList(options.Page, OperatorController.PageSize);

            Assert.Equal(expectedMail, vm.Mail);
            Assert.Same(options, vm.CurrentListOptions);
            Assert.Equal(returnUrl, vm.ReturnUrl);
        }