コード例 #1
0
 public Permalink(TableBuilderConfiguration configuration,
                  TableBuilderResultViewModel result,
                  ObservationQueryContext query)
 {
     Id            = Guid.NewGuid();
     Created       = DateTime.UtcNow;
     Configuration = configuration;
     FullTable     = result;
     Query         = query;
 }
        public async Task Create_WithoutReleaseId()
        {
            var subject = new Subject
            {
                Id = Guid.NewGuid()
            };

            var request = new PermalinkCreateViewModel
            {
                Query =
                {
                    SubjectId = subject.Id
                }
            };

            var release = new Release
            {
                Id = Guid.NewGuid()
            };

            var tableResult = new TableBuilderResultViewModel
            {
                SubjectMeta = new ResultSubjectMetaViewModel()
            };

            var blobStorageService  = new Mock <IBlobStorageService>(MockBehavior.Strict);
            var releaseRepository   = new Mock <IReleaseRepository>(MockBehavior.Strict);
            var subjectRepository   = new Mock <ISubjectRepository>(MockBehavior.Strict);
            var tableBuilderService = new Mock <ITableBuilderService>(MockBehavior.Strict);

            // Permalink id is assigned on creation and used as the blob path
            // Capture it so we can compare it with the view model result
            string blobPath        = string.Empty;
            var    blobPathCapture = new CaptureMatch <string>(callback => blobPath = callback);

            blobStorageService.Setup(s => s.UploadAsJson(
                                         Permalinks,
                                         Capture.With(blobPathCapture),
                                         It.Is <Permalink>(p =>
                                                           p.Configuration.Equals(request.Configuration) &&
                                                           p.FullTable.IsDeepEqualTo(new PermalinkTableBuilderResult(tableResult)) &&
                                                           p.Query.Equals(request.Query)),
                                         It.IsAny <JsonSerializerSettings>()))
            .Returns(Task.CompletedTask);

            releaseRepository
            .Setup(s => s.GetLatestPublishedRelease(_publicationId))
            .Returns(release);

            subjectRepository
            .Setup(s => s.Get(subject.Id))
            .ReturnsAsync(subject);

            subjectRepository
            .Setup(s => s.GetPublicationIdForSubject(subject.Id))
            .ReturnsAsync(_publicationId);

            subjectRepository
            .Setup(s => s.IsSubjectForLatestPublishedRelease(subject.Id))
            .ReturnsAsync(true);

            tableBuilderService
            .Setup(s => s.Query(release.Id, request.Query, CancellationToken.None))
            .ReturnsAsync(tableResult);

            var service = BuildService(blobStorageService: blobStorageService.Object,
                                       releaseRepository: releaseRepository.Object,
                                       subjectRepository: subjectRepository.Object,
                                       tableBuilderService: tableBuilderService.Object);

            var result = (await service.Create(request)).AssertRight();

            MockUtils.VerifyAllMocks(
                blobStorageService,
                releaseRepository,
                subjectRepository,
                tableBuilderService);

            Assert.Equal(Guid.Parse(blobPath), result.Id);
            Assert.InRange(DateTime.UtcNow.Subtract(result.Created).Milliseconds, 0, 1500);
            Assert.False(result.Invalidated);
        }