예제 #1
0
        public async Task AnyAsync_DesignatedChannelMappingsDoNotExist_ReturnsFalse(DesignatedChannelMappingSearchCriteria criteria)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.AnyAsync(criteria);

            result.ShouldBeFalse();
        }
        /// <inheritdoc />
        public async Task <int> DeleteAsync(DesignatedChannelMappingSearchCriteria criteria, ulong deletedById)
        {
            var entities = await ModixContext.DesignatedChannelMappings
                           .FilterBy(criteria)
                           .ToArrayAsync();

            foreach (var entity in entities)
            {
                DoEntityDelete(entity, deletedById);
            }

            await ModixContext.SaveChangesAsync();

            return(entities.Length);
        }
 /// <inheritdoc />
 public async Task <IReadOnlyCollection <DesignatedChannelMappingBrief> > SearchBriefsAsync(DesignatedChannelMappingSearchCriteria searchCriteria)
 => await ModixContext.Set <DesignatedChannelMappingEntity>().AsNoTracking()
 .FilterBy(searchCriteria)
 .AsExpandable()
 .Select(DesignatedChannelMappingBrief.FromEntityProjection)
 .ToArrayAsync();
 /// <inheritdoc />
 public async Task <IReadOnlyCollection <ulong> > SearchChannelIdsAsync(DesignatedChannelMappingSearchCriteria searchCriteria)
 => await ModixContext.Set <DesignatedChannelMappingEntity>().AsNoTracking()
 .FilterBy(searchCriteria)
 .Select(x => x.ChannelId)
 .ToArrayAsync();
 /// <inheritdoc />
 public Task <bool> AnyAsync(
     DesignatedChannelMappingSearchCriteria criteria,
     CancellationToken cancellationToken)
 => ModixContext.Set <DesignatedChannelMappingEntity>().AsNoTracking()
 .FilterBy(criteria)
 .AnyAsync(cancellationToken);
예제 #6
0
        public async Task DeleteAsync_DesignatedChannelMappingsDoNotExist_DoesNotUpdateDesignatedChannelMappingsAndReturns0(DesignatedChannelMappingSearchCriteria criteria, ulong deletedById)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.DeleteAsync(criteria, deletedById);

            result.ShouldBe(0);

            modixContext.DesignatedChannelMappings
            .Select(x => x.Id)
            .ShouldBe(DesignatedChannelMappings.Entities
                      .Select(x => x.Id));

            modixContext.DesignatedChannelMappings
            .EachShould(x => x.ShouldNotHaveChanged());

            modixContext.ConfigurationActions
            .Select(x => x.Id)
            .ShouldBe(ConfigurationActions.Entities
                      .Where(x => x.DesignatedChannelMappingId != null)
                      .Select(x => x.Id));

            modixContext.ConfigurationActions
            .EachShould(x => x.ShouldNotHaveChanged());

            await modixContext.ShouldHaveReceived(1)
            .SaveChangesAsync();
        }
예제 #7
0
        public async Task DeleteAsync_DesignatedChannelMappingsAreNotDeleted_UpdatesDesignatedChannelMappingsAndReturnsCount(DesignatedChannelMappingSearchCriteria criteria, ulong deletedById, long[] designatedChannelMappingIds)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.DeleteAsync(criteria, deletedById);

            result.ShouldBe(designatedChannelMappingIds
                            .Where(x => DesignatedChannelMappings.Entities
                                   .Any(y => (y.Id == x) && (y.DeleteActionId == null)))
                            .Count());

            modixContext.DesignatedChannelMappings
            .Select(x => x.Id)
            .ShouldBe(DesignatedChannelMappings.Entities.Select(x => x.Id));

            modixContext.DesignatedChannelMappings
            .Where(x => designatedChannelMappingIds.Contains(x.Id) && (x.DeleteActionId == null))
            .EachShould(entity =>
            {
                var originalEntity = DesignatedChannelMappings.Entities.First(x => x.Id == entity.Id);

                entity.GuildId.ShouldBe(originalEntity.GuildId);
                entity.ChannelId.ShouldBe(originalEntity.ChannelId);
                entity.Type.ShouldBe(originalEntity.Type);
                entity.CreateActionId.ShouldBe(originalEntity.CreateActionId);
                entity.DeleteActionId.ShouldNotBeNull();

                modixContext.ConfigurationActions.ShouldContain(x => x.Id == entity.DeleteActionId);
                var deleteAction = modixContext.ConfigurationActions.First(x => x.Id == entity.DeleteActionId);

                deleteAction.GuildId.ShouldBe(entity.GuildId);
                deleteAction.Type.ShouldBe(ConfigurationActionType.DesignatedChannelMappingDeleted);
                deleteAction.Created.ShouldBeInRange(
                    DateTimeOffset.Now - TimeSpan.FromMinutes(1),
                    DateTimeOffset.Now + TimeSpan.FromMinutes(1));
                deleteAction.CreatedById.ShouldBe(deletedById);
                deleteAction.ClaimMappingId.ShouldBeNull();
                deleteAction.DesignatedChannelMappingId.ShouldBe(entity.Id);
                deleteAction.DesignatedRoleMappingId.ShouldBeNull();
            });

            modixContext.DesignatedChannelMappings
            .Where(x => !designatedChannelMappingIds.Contains(x.Id) || DesignatedChannelMappings.Entities
                   .Any(y => (y.Id == x.Id) && (x.DeleteActionId == null)))
            .EachShould(x => x.ShouldNotHaveChanged());

            modixContext.ConfigurationActions
            .Where(x => DesignatedChannelMappings.Entities
                   .Any(y => (y.DeleteActionId == x.Id) && designatedChannelMappingIds.Contains(y.Id)))
            .EachShould(x => x.ShouldNotHaveChanged());

            await modixContext.ShouldHaveReceived(1)
            .SaveChangesAsync();
        }
예제 #8
0
        public async Task SearchBriefsAsync_DesignatedChannelMappingsDoNotExist_ReturnsEmpty(DesignatedChannelMappingSearchCriteria criteria)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.SearchBriefsAsync(criteria);

            result.ShouldNotBeNull();
            result.ShouldBeEmpty();
        }
예제 #9
0
        public async Task SearchBriefsAsync_DesignatedChannelMappingsExist_ReturnsMatchingBriefs(DesignatedChannelMappingSearchCriteria criteria, long[] resultIds)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.SearchBriefsAsync(criteria);

            result.ShouldNotBeNull();
            result.Select(x => x.Id).ShouldBe(resultIds);
            result.EachShould(x => x.ShouldMatchTestData());
        }
예제 #10
0
        public async Task SearchChannelIdsAsync_DesignatedChannelMappingsExist_ReturnsMatchingIds(DesignatedChannelMappingSearchCriteria criteria, long[] resultIds)
        {
            (var modixContext, var uut) = BuildTestContext();

            var result = await uut.SearchChannelIdsAsync(criteria);

            result.ShouldNotBeNull();
            result.ShouldBe(resultIds.Select(x => DesignatedChannelMappings.Entities.First(y => y.Id == x).ChannelId));
        }
 /// <inheritdoc />
 public Task <bool> AnyAsync(DesignatedChannelMappingSearchCriteria criteria)
 => ModixContext.DesignatedChannelMappings.AsNoTracking()
 .FilterBy(criteria)
 .AnyAsync();