コード例 #1
0
        public async Task Deleted_PublishEventsDisabled_NoEventPublished()
        {
            await EventGridPublishingHandler.Deleted(OrchestrationContext);

            A.CallTo(() => EventGridContentClient.Publish(A <ContentEvent> ._, A <CancellationToken> ._))
            .MustNotHaveHappened();
        }
        public async Task Publish_EventGridPublishingHandlerCalled()
        {
            bool success = await DeleteOrchestrator.Delete(ContentItem);

            Assert.True(success);

            A.CallTo(() => EventGridPublishingHandler.Deleted(
                         A <IOrchestrationContext> .That.Matches(ctx => Equals(ctx.ContentItem, ContentItem))))
            .MustHaveHappened();
        }
        protected DeleteOrchestratorTestsBase()
        {
            ContentDefinitionManager = A.Fake <IContentDefinitionManager>();
            Notifier = A.Fake <GraphSyncNotifier>();

            PublishedContentItemVersion = A.Fake <IPublishedContentItemVersion>();
            A.CallTo(() => PublishedContentItemVersion.GraphReplicaSetName)
            .Returns(GraphReplicaSetNames.Published);

            PreviewContentItemVersion = A.Fake <IPreviewContentItemVersion>();
            A.CallTo(() => PreviewContentItemVersion.GraphReplicaSetName)
            .Returns(GraphReplicaSetNames.Preview);

            ServiceProvider = A.Fake <IServiceProvider>();
            Logger          = A.Fake <ILogger <DeleteOrchestrator> >();

            ContentItem = new ContentItem();

            ContentManager = A.Fake <IContentManager>();
            A.CallTo(() => ServiceProvider.GetService(A <Type> .That.Matches(
                                                          t => t.Name == nameof(IContentManager))))
            .Returns(ContentManager);

            PreviewDeleteGraphSyncer   = A.Fake <IDeleteGraphSyncer>();
            PublishedDeleteGraphSyncer = A.Fake <IDeleteGraphSyncer>();

            PreviewAllowSync = A.Fake <IAllowSync>();
            A.CallTo(() => PreviewDeleteGraphSyncer.DeleteAllowed(
                         A <ContentItem> ._,
                         A <IContentItemVersion> .That.Matches(v => v.GraphReplicaSetName == GraphReplicaSetNames.Preview),
                         SyncOperation,
                         null,
                         null))
            .Returns(PreviewAllowSync);

            PublishedAllowSync = A.Fake <IAllowSync>();
            A.CallTo(() => PublishedDeleteGraphSyncer.DeleteAllowed(
                         A <ContentItem> ._,
                         A <IContentItemVersion> .That.Matches(v => v.GraphReplicaSetName == GraphReplicaSetNames.Published),
                         SyncOperation,
                         null,
                         null))
            .Returns(PublishedAllowSync);

            EventGridPublishingHandler = A.Fake <IContentOrchestrationHandler>();
            A.CallTo(() => EventGridPublishingHandler.Published(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.DraftSaved(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Cloned(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Unpublished(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.DraftDiscarded(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Deleted(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);

            DeleteOrchestrator = new DeleteOrchestrator(
                ContentDefinitionManager,
                Notifier,
                ServiceProvider,
                Logger,
                PublishedContentItemVersion,
                PreviewContentItemVersion,
                new List <IContentOrchestrationHandler> {
                EventGridPublishingHandler
            });

            TestActivity = new Activity("UnitTest").Start();
        }
        public SyncOrchestratorTestsBase()
        {
            ContentDefinitionManager = A.Fake <IContentDefinitionManager>();
            Notifier = A.Fake <GraphSyncNotifier>();

            PreviewGraphReplicaSet = A.Fake <IGraphReplicaSet>();
            A.CallTo(() => PreviewGraphReplicaSet.Name)
            .Returns(GraphReplicaSetNames.Preview);

            PublishedGraphReplicaSet = A.Fake <IGraphReplicaSet>();
            A.CallTo(() => PublishedGraphReplicaSet.Name)
            .Returns(GraphReplicaSetNames.Published);

            var graphReplicaSets = new Dictionary <string, IGraphReplicaSet>
            {
                { GraphReplicaSetNames.Preview, PreviewGraphReplicaSet },
                { GraphReplicaSetNames.Published, PublishedGraphReplicaSet },
            };

            GraphCluster = A.Fake <IGraphCluster>();
            A.CallTo(() => GraphCluster.GetGraphReplicaSet(A <string> ._))
            .ReturnsLazily <IGraphReplicaSet, string>(graphReplicaSetName => graphReplicaSets[graphReplicaSetName]);

            PublishedContentItemVersion = A.Fake <IPublishedContentItemVersion>();
            A.CallTo(() => PublishedContentItemVersion.GraphReplicaSetName)
            .Returns(GraphReplicaSetNames.Published);

            ServiceProvider = A.Fake <IServiceProvider>();
            Logger          = A.Fake <ILogger <SyncOrchestrator> >();

            ContentItem = new ContentItem();

            ContentManager = A.Fake <IContentManager>();
            A.CallTo(() => ServiceProvider.GetService(A <Type> .That.Matches(
                                                          t => t.Name == nameof(IContentManager))))
            .Returns(ContentManager);

            PreviewMergeGraphSyncer   = A.Fake <IMergeGraphSyncer>();
            PublishedMergeGraphSyncer = A.Fake <IMergeGraphSyncer>();

            PreviewAllowSync = A.Fake <IAllowSync>();
            A.CallTo(() => PreviewMergeGraphSyncer.SyncAllowed(
                         A <IGraphReplicaSet> .That.Matches(s => s.Name == GraphReplicaSetNames.Preview),
                         A <ContentItem> ._, A <IContentManager> ._, A <IGraphMergeContext?> ._))
            .Returns(PreviewAllowSync);

            PublishedAllowSync = A.Fake <IAllowSync>();
            A.CallTo(() => PublishedMergeGraphSyncer.SyncAllowed(
                         A <IGraphReplicaSet> .That.Matches(s => s.Name == GraphReplicaSetNames.Published),
                         A <ContentItem> ._, A <IContentManager> ._, A <IGraphMergeContext?> ._))
            .Returns(PublishedAllowSync);

            EventGridPublishingHandler = A.Fake <IContentOrchestrationHandler>();
            A.CallTo(() => EventGridPublishingHandler.Published(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.DraftSaved(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Cloned(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Unpublished(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.DraftDiscarded(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);
            A.CallTo(() => EventGridPublishingHandler.Deleted(A <IOrchestrationContext> .Ignored)).Returns(Task.CompletedTask);

            SyncOrchestrator = new SyncOrchestrator(
                ContentDefinitionManager,
                Notifier,
                GraphCluster,
                ServiceProvider,
                Logger,
                PublishedContentItemVersion,
                new List <IContentOrchestrationHandler> {
                EventGridPublishingHandler
            });

            TestActivity = new Activity("UnitTest").Start();
        }