Ejemplo n.º 1
0
        private async void GetById()
        {
            SampleFrameM actual;
            var          expectedFields    = new[] { FieldEnum.StatId, FieldEnum.Name };
            var          expectedPredicate = CreateExpressionGroup();
            var          expected          = new SampleFrame
            {
                Fields      = JsonConvert.SerializeObject(expectedFields),
                Name        = "test",
                Description = "SF test",
                Predicate   = JsonConvert.SerializeObject(expectedPredicate),
                User        = new User {
                    UserName = "******"
                }
            };

            using (var context = InMemoryDb.CreateDbContext())
            {
                context.SampleFrames.Add(expected);
                await context.SaveChangesAsync();

                actual = await new SampleFramesService(context, null).GetById(expected.Id, (await context.Users.FirstOrDefaultAsync()).Id);
            }

            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.Description, actual.Description);
            Assert.Equal(expectedFields[0], actual.Fields.First());
            Assert.Equal(expectedFields[1], actual.Fields.Last());
            Assert.Equal(expectedPredicate.Groups.Count(), actual.Predicate.Groups.Count());
        }
Ejemplo n.º 2
0
        private async void GetAll()
        {
            SearchVm <SampleFrameM> actual;

            using (var context = InMemoryDb.CreateDbContext())
            {
                context.Initialize();
                var userId = (await context.Users.FirstOrDefaultAsync()).Id;
                context.SampleFrames.AddRange(
                    new SampleFrame
                {
                    Fields    = JsonConvert.SerializeObject(new[] { FieldEnum.Name, FieldEnum.ShortName }),
                    Name      = "1",
                    UserId    = userId,
                    Predicate = JsonConvert.SerializeObject(CreateExpressionGroup()),
                },
                    new SampleFrame
                {
                    Fields = JsonConvert.SerializeObject(new[]
                                                         { FieldEnum.StatId, FieldEnum.Name, FieldEnum.ShortName }),
                    Name      = "2",
                    UserId    = userId,
                    Predicate = JsonConvert.SerializeObject(CreateExpressionGroup()),
                });
                await context.SaveChangesAsync();

                actual = await new SampleFramesService(context, null).GetAll(new SearchQueryM {
                    Page = 1, PageSize = 1
                }, (await context.Users.FirstAsync()).Id);
            }

            Assert.Single(actual.Result);
            Assert.Equal(2, actual.TotalCount);
        }
Ejemplo n.º 3
0
        private async Task Create()
        {
            using (var context = InMemoryDb.CreateDbContext())
            {
                context.Initialize();

                await CreateStatisticalUnitsAsync(context);

                await new SampleFramesService(context, null).Create(
                    new SampleFrameM
                {
                    Name      = "Sample frame name",
                    Predicate = CreateExpressionGroup(),
                    Fields    = new[] { FieldEnum.Address }
                },
                    (await context.Users.FirstAsync()).Id);

                Assert.Equal(1, await context.SampleFrames.CountAsync());
            }
        }
Ejemplo n.º 4
0
        private async Task Edit()
        {
            using (var context = InMemoryDb.CreateDbContext())
            {
                context.Initialize();

                await CreateStatisticalUnitsAsync(context);

                var expressionTree = CreateExpressionGroup();

                var service = new SampleFramesService(context, null);
                await service.Create(
                    new SampleFrameM
                {
                    Name      = "Sample frame name",
                    Predicate = expressionTree,
                    Fields    = new[] { FieldEnum.Address }
                },
                    (await context.Users.FirstAsync()).Id);

                Assert.Equal(1, await context.SampleFrames.CountAsync());

                await service.Edit(
                    (await context.SampleFrames.FirstOrDefaultAsync()).Id,
                    new SampleFrameM
                {
                    Id        = (await context.SampleFrames.FirstOrDefaultAsync()).Id,
                    Predicate = expressionTree,
                    Name      = "New sample frame name",
                    Fields    = new[] { FieldEnum.Address }
                },
                    (await context.Users.FirstAsync()).Id);

                Assert.Equal(1, await context.SampleFrames.CountAsync());
                Assert.Equal("New sample frame name", (await context.SampleFrames.FirstOrDefaultAsync()).Name);
            }
        }
Ejemplo n.º 5
0
        private async void Preview()
        {
            using (var context = InMemoryDb.CreateDbContext())
            {
                context.Initialize();

                await CreateStatisticalUnitsAsync(context);

                var service = new SampleFramesService(context, null);

                await service.Create(
                    new SampleFrameM
                {
                    Name      = "Sample frame name",
                    Predicate = CreateExpressionGroup(),
                    Fields    = new[] { FieldEnum.RegId, FieldEnum.Name }
                },
                    (await context.Users.FirstAsync()).Id);

                Assert.Equal(1, await context.SampleFrames.CountAsync());

                var existing = await context.SampleFrames.FirstOrDefaultAsync();

                var units = await context.StatisticalUnits.ToListAsync();

                var expected = new[]
                {
                    new { RegId = units[0].RegId.ToString(), units[0].Name },
                    new { RegId = units[1].RegId.ToString(), units[1].Name }
                };
                var actual = (await service.Preview(existing.Id, (await context.Users.FirstAsync()).Id, 2)).ToArray();

                Assert.Equal(expected.Length, actual.Length);
                Assert.Equal(expected[0].RegId, actual[0][FieldEnum.RegId]);
                Assert.Equal(expected[1].Name, actual[1][FieldEnum.Name]);
            }
        }
Ejemplo n.º 6
0
        private async void Delete()
        {
            using (var context = InMemoryDb.CreateDbContext())
            {
                context.Initialize();

                var service = new SampleFramesService(context, null);
                var userId  = (await context.Users.FirstAsync()).Id;
                await service.Create(
                    new SampleFrameM
                {
                    Predicate = CreateExpressionGroup(),
                    Name      = "Sample frame name",
                    Fields    = new[] { FieldEnum.Address }
                }, userId
                    );

                Assert.Equal(1, await context.SampleFrames.CountAsync());

                await service.Delete((await context.SampleFrames.FirstOrDefaultAsync()).Id, userId);

                Assert.Equal(0, await context.SampleFrames.CountAsync());
            }
        }