Example #1
0
        public async Task Should_restore_indices_for_all_non_deleted_rules()
        {
            var appId = Guid.NewGuid();

            var ruleId1 = Guid.NewGuid();
            var ruleId2 = Guid.NewGuid();
            var ruleId3 = Guid.NewGuid();

            var context = new RestoreContext(appId, new UserMapping(new RefToken(RefTokenType.Subject, "123")), A.Fake <IBackupReader>());

            await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
            {
                RuleId = ruleId1
            }), context);

            await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
            {
                RuleId = ruleId2
            }), context);

            await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
            {
                RuleId = ruleId3
            }), context);

            await sut.RestoreEventAsync(Envelope.Create(new RuleDeleted
            {
                RuleId = ruleId3
            }), context);

            HashSet <Guid>?newIndex = null;

            A.CallTo(() => index.RebuildAsync(appId, A <HashSet <Guid> > ._))
            .Invokes(new Action <Guid, HashSet <Guid> >((_, i) => newIndex = i));

            await sut.RestoreAsync(context);

            Assert.Equal(new HashSet <Guid>
            {
                ruleId1,
                ruleId2
            }, newIndex);
        }
Example #2
0
        public async Task Should_restore_indices_for_all_non_deleted_rules()
        {
            var ruleId1 = DomainId.NewGuid();
            var ruleId2 = DomainId.NewGuid();
            var ruleId3 = DomainId.NewGuid();

            var context = new RestoreContext(appId.Id, new UserMapping(RefToken.User("123")), A.Fake <IBackupReader>(), DomainId.NewGuid());

            await sut.RestoreEventAsync(AppEvent(new RuleCreated
            {
                RuleId = ruleId1
            }), context, ct);

            await sut.RestoreEventAsync(AppEvent(new RuleCreated
            {
                RuleId = ruleId2
            }), context, ct);

            await sut.RestoreEventAsync(AppEvent(new RuleCreated
            {
                RuleId = ruleId3
            }), context, ct);

            await sut.RestoreEventAsync(AppEvent(new RuleDeleted
            {
                RuleId = ruleId3
            }), context, ct);

            var rebuildAssets = new HashSet <DomainId>();

            A.CallTo(() => rebuilder.InsertManyAsync <RuleDomainObject, RuleDomainObject.State>(A <IEnumerable <DomainId> > ._, A <int> ._, ct))
            .Invokes(x => rebuildAssets.AddRange(x.GetArgument <IEnumerable <DomainId> >(0) !));

            await sut.RestoreAsync(context, ct);

            Assert.Equal(new HashSet <DomainId>
            {
                DomainId.Combine(appId, ruleId1),
                DomainId.Combine(appId, ruleId2)
            }, rebuildAssets);
        }