public async void UpdateLegacyRelease()
        {
            var id            = Guid.NewGuid();
            var publicationId = Guid.NewGuid();

            using (var context = InMemoryApplicationDbContext())
            {
                context.Add(new Publication
                {
                    Id             = publicationId,
                    LegacyReleases = new List <LegacyRelease>
                    {
                        new LegacyRelease
                        {
                            Id          = id,
                            Description = "Test description",
                            Url         = "http://test.com",
                            Order       = 2,
                        },
                    }
                });

                context.SaveChanges();

                var legacyReleaseService = new LegacyReleaseService(
                    context,
                    AdminMapper(),
                    MockUtils.AlwaysTrueUserService().Object,
                    new PersistenceHelper <ContentDbContext>(context)
                    );

                // Service method under test
                var result = await legacyReleaseService.UpdateLegacyRelease(
                    id,
                    new UpdateLegacyReleaseViewModel()
                {
                    Description   = "Updated test description",
                    Url           = "http://updated-test.com",
                    Order         = 1,
                    PublicationId = publicationId,
                });

                Assert.Equal("Updated test description", result.Right.Description);
                Assert.Equal("http://updated-test.com", result.Right.Url);
                Assert.Equal(1, result.Right.Order);
                Assert.Equal(publicationId, result.Right.PublicationId);

                var savedLegacyRelease = context.LegacyReleases.Single(release => release.Id == result.Right.Id);

                Assert.Equal("Updated test description", savedLegacyRelease.Description);
                Assert.Equal("http://updated-test.com", savedLegacyRelease.Url);
                Assert.Equal(1, savedLegacyRelease.Order);
                Assert.Equal(publicationId, savedLegacyRelease.PublicationId);
            }
        }
        public async void CreateLegacyRelease_WithExisting()
        {
            var publicationId = Guid.NewGuid();

            using (var context = InMemoryApplicationDbContext())
            {
                context.Add(new Publication
                {
                    Id             = publicationId,
                    LegacyReleases = new List <LegacyRelease>
                    {
                        new LegacyRelease
                        {
                            Id            = Guid.NewGuid(),
                            Description   = "Test description 1",
                            Url           = "http://test1.com",
                            Order         = 1,
                            PublicationId = publicationId,
                        }
                    }
                });

                context.SaveChanges();

                var legacyReleaseService = new LegacyReleaseService(
                    context,
                    AdminMapper(),
                    MockUtils.AlwaysTrueUserService().Object,
                    new PersistenceHelper <ContentDbContext>(context)
                    );

                // Service method under test
                var result = await legacyReleaseService.CreateLegacyRelease(
                    new CreateLegacyReleaseViewModel()
                {
                    Description   = "Test description 2",
                    Url           = "http://test2.com",
                    PublicationId = publicationId
                });

                var legacyRelease = context.LegacyReleases.Single(release => release.Id == result.Right.Id);

                Assert.Equal("Test description 2", legacyRelease.Description);
                Assert.Equal("http://test2.com", legacyRelease.Url);
                Assert.Equal(2, legacyRelease.Order);
                Assert.Equal(publicationId, legacyRelease.PublicationId);
            }
        }
        public async void DeleteLegacyRelease()
        {
            var id            = Guid.NewGuid();
            var publicationId = Guid.NewGuid();

            using (var context = InMemoryApplicationDbContext())
            {
                context.Add(new Publication
                {
                    Id             = publicationId,
                    LegacyReleases = new List <LegacyRelease>
                    {
                        new LegacyRelease
                        {
                            Id          = id,
                            Description = "Test description",
                            Url         = "http://test.com",
                            Order       = 2,
                        },
                    }
                });

                context.SaveChanges();

                var legacyReleaseService = new LegacyReleaseService(
                    context,
                    AdminMapper(),
                    MockUtils.AlwaysTrueUserService().Object,
                    new PersistenceHelper <ContentDbContext>(context)
                    );

                // Service method under test
                var result = await legacyReleaseService.DeleteLegacyRelease(id);

                Assert.Empty(context.LegacyReleases);
                Assert.Empty(
                    context.Publications
                    .Single(publication => publication.Id == publicationId)
                    .LegacyReleases
                    );
            }
        }
        public async void DeleteLegacyRelease_ReordersWithExisting()
        {
            var id            = Guid.NewGuid();
            var publicationId = Guid.NewGuid();

            using (var context = InMemoryApplicationDbContext())
            {
                context.Add(new Publication
                {
                    Id             = publicationId,
                    LegacyReleases = new List <LegacyRelease>
                    {
                        new LegacyRelease
                        {
                            Id          = id,
                            Description = "Test description 1",
                            Url         = "http://test1.com",
                            Order       = 1,
                        },
                        new LegacyRelease
                        {
                            Id          = Guid.NewGuid(),
                            Description = "Test description 2",
                            Url         = "http://test2.com",
                            Order       = 2,
                        },
                        new LegacyRelease
                        {
                            Id          = Guid.NewGuid(),
                            Description = "Test description 3",
                            Url         = "http://test3.com",
                            Order       = 3,
                        }
                    }
                });

                context.SaveChanges();

                var legacyReleaseService = new LegacyReleaseService(
                    context,
                    AdminMapper(),
                    MockUtils.AlwaysTrueUserService().Object,
                    new PersistenceHelper <ContentDbContext>(context)
                    );

                // Service method under test
                var result = await legacyReleaseService.DeleteLegacyRelease(id);

                var legacyReleases = context.LegacyReleases
                                     .OrderBy(release => release.Order)
                                     .ToList();

                Assert.Equal(2, legacyReleases.Count);
                Assert.Equal(2,
                             context.Publications
                             .Single(publication => publication.Id == publicationId)
                             .LegacyReleases
                             .Count
                             );

                Assert.Equal("Test description 2", legacyReleases[0].Description);
                Assert.Equal(1, legacyReleases[0].Order);

                Assert.Equal("Test description 3", legacyReleases[1].Description);
                Assert.Equal(2, legacyReleases[1].Order);
            }
        }