Exemple #1
0
        public void GetObjectsQuery_Validation_Failures()
        {
            // Arrange
            var mediator = GetService <IMediator>();
            var ct       = new CancellationToken();
            var query    = new GetObjectsQuery {
            };

            // Act & Assert
            var ex = Assert.ThrowsAsync <ValidationException>(() => mediator.Send(query, ct));

            Assert.AreEqual("One or more validation failures have occurred.", ex.Message);
            Assert.IsNotNull(ex.Failures);
            Assert.AreEqual(2, ex.Failures.Count);
            var firstEntry = ex.Failures[nameof(query.Page)];

            Assert.AreEqual(2, firstEntry.Length);
            Assert.AreEqual("'Page' must not be empty.", firstEntry[0]);
            Assert.AreEqual("'Page' must be greater than '0'.", firstEntry[1]);
            var secondEntry = ex.Failures[nameof(query.Limit)];

            Assert.AreEqual(3, secondEntry.Length);
            Assert.AreEqual("'Limit' must not be empty.", secondEntry[0]);
            Assert.AreEqual("'Limit' must be greater than '0'.", secondEntry[1]);
            Assert.AreEqual("'Limit' must be one of these values: 10, 25 or 50", secondEntry[2]);
        }
        /// <inheritdoc/>
        public async Task <PaginationResultModel <ObjectModel> > Handle(GetObjectsQuery request, CancellationToken cancellationToken)
        {
            int total = await context.ObjectRepository.CountAsync(cancellationToken);

            var query = context.ObjectRepository
                        .GetQuery()
                        .Select(e => new
            {
                Object  = e,
                Tasks   = e.Tasks.OrderByDescending(e1 => e1.CreatedDate).Take(request.Limit),
                Results = e.Tasks.OrderByDescending(e1 => e1.CreatedDate).Select(e1 => e1.Result).Take(request.Limit)
            })
                        .OrderByDescending(e => e.Object.CreatedDate)
                        .Skip((request.Page - 1) * request.Limit)
                        .Take(request.Limit);

            var entities = await context.ToListAsync(query, cancellationToken);

            var models = entities.Select(e => ObjectModel.Create(e.Object, e.Tasks, e.Results, serializer));

            return(PaginationResultModel <ObjectModel> .Create(models, request.Page, request.Limit, total));
        }
Exemple #3
0
        public void GetObjectsQuery()
        {
            // Arrange
            var    mediator = GetService <IMediator>();
            var    ct       = new CancellationToken();
            string filename = "SMIR.Brain_3more.XX.XX.OT.6560.mha";
            string dataPath = GetDataPath(filename);
            var    command  = new CreateObjectCommand()
            {
                OriginalFilename = filename,
                SourcePath       = CreateTempFile(dataPath)
            };
            var commandResult = mediator.Send(command, ct).Result;
            var query         = new GetObjectsQuery {
                Page = 1, Limit = 25
            };

            try
            {
                // Act
                var result = mediator.Send(query, ct).Result;

                // Assert
                Assert.IsNotNull(result);
                Assert.IsNotNull(result.Pagination);
                Assert.AreEqual(1, result.Pagination.Total);
                Assert.AreEqual(1, result.Pagination.Page);

                DeleteObject(commandResult.Id);
                Assert.IsFalse(File.Exists(GetWorkingDirectoryPath(commandResult.SourcePath)));
            }
            finally
            {
                DeleteDirectory(Path.GetDirectoryName(command.SourcePath));
            }
        }