public async Task Should_not_invoke_enricher_if_already_enriched()
        {
            var result = new RuleEntity();

            var command = CreateCommand(new MyCommand());
            var context = CreateContextForCommand(command);

            context.Complete(result);

            await sut.HandleAsync(context);

            Assert.Same(result, context.Result <IEnrichedRuleEntity>());

            A.CallTo(() => ruleEnricher.EnrichAsync(A <IEnrichedRuleEntity> ._, requestContext))
            .MustNotHaveHappened();
        }
        public async Task Should_enrich_rule_result()
        {
            var result = A.Fake <IRuleEntity>();

            var command = CreateCommand(new MyCommand());
            var context = CreateContextForCommand(command);

            context.Complete(result);

            var enriched = new RuleEntity();

            A.CallTo(() => ruleEnricher.EnrichAsync(result, requestContext))
            .Returns(enriched);

            await sut.HandleAsync(context);

            Assert.Same(enriched, context.Result <IEnrichedRuleEntity>());
        }
Beispiel #3
0
        public async Task Should_update_repositories_on_with_jobs_from_sender()
        {
            var @event = Envelope.Create <IEvent>(new ContentCreated {
                AppId = appId
            });

            var rule1 = new Rule(new ContentChangedTriggerV2(), new TestAction {
                Url = new Uri("https://squidex.io")
            });
            var rule2 = new Rule(new ContentChangedTriggerV2(), new TestAction {
                Url = new Uri("https://squidex.io")
            });

            var job1 = new RuleJob {
                Created = now
            };

            var ruleEntity1 = new RuleEntity {
                RuleDef = rule1
            };
            var ruleEntity2 = new RuleEntity {
                RuleDef = rule2
            };

            A.CallTo(() => appProvider.GetRulesAsync(appId.Id))
            .Returns(new List <IRuleEntity> {
                ruleEntity1, ruleEntity2
            });

            A.CallTo(() => ruleService.CreateJobAsync(rule1, ruleEntity1.Id, @event))
            .Returns(job1);

            A.CallTo(() => ruleService.CreateJobAsync(rule2, ruleEntity2.Id, @event))
            .Returns(Task.FromResult <RuleJob>(null));

            await sut.On(@event);

            A.CallTo(() => ruleEventRepository.EnqueueAsync(job1, now))
            .MustHaveHappened();
        }