コード例 #1
0
        // ReSharper disable once InconsistentNaming
        public async Task PopulateActorsAsync_should_add_existing_actors()
        {
            var repository = Substitute.For<IActorsRepository>();
            var client = Substitute.For<ISeriesClient>();

            var response = new TvDbResponse<ActorData[]>();

            var data = new List<ActorData>();

            for (int i = 0; i < 5; i++)
            {
                data.Add(new ActorData
                {
                    Id = i,
                    Name = $"Actor {i}",
                    LastUpdated = $"0001-02-0{i + 1}",
                    Image = $"Image {i}"
                });
            }

            response.Data = data.ToArray();

            var show = new Show
            {
                TheTvDbId = 42
            };

            var actors = response.Data.Select(x => new Actor
                                 {
                                     TheTvDbId = x.Id
                                 }).ToArray();

            RigRepository(repository, actors);
            RigClient(client, show.TheTvDbId, response);

            var fetcher = new ActorFetcher(repository, client);

            await fetcher.PopulateActorsAsync(show);

            var relationships = show.ShowsActors.ToArray();

            Assert.Equal(response.Data.Length, relationships.Length);

            for (int i = 0; i < response.Data.Length; i++)
            {
                Assert.Equal(actors[i], relationships[i].Actor);
                Assert.Equal(response.Data[i].Role, relationships[i].Role);

                Assert.Equal(response.Data[i].Id, actors[i].TheTvDbId);
                Assert.Equal(response.Data[i].Name, actors[i].Name);
                Assert.Equal(response.Data[i].Image, actors[i].Image);
                Assert.Equal(response.Data[i].LastUpdated, actors[i].LastUpdated.ToString("yyyy-MM-dd"));
            }
        }
コード例 #2
0
        // ReSharper disable once InconsistentNaming
        public async Task PopulateActorsAsync_should_update_role_on_existing_actor()
        {
            var repository = Substitute.For<IActorsRepository>();
            var client = Substitute.For<ISeriesClient>();

            var response = new TvDbResponse<ActorData[]>
            {
                Data = new[]
                {
                    new ActorData
                    {
                        Id = 1,
                        Name = "Actor 1",
                        LastUpdated = "0001-02-01",
                        Image = "Image 1",
                        Role = "Role 1"
                    }
                }
            };

            var actor = new Actor
            {
                TheTvDbId = 1
            };

            var show = new Show
            {
                TheTvDbId = 42,
                ShowsActors = {
                    new ShowsActors
                    {
                        Actor = actor
                    }
                }
            };

            var actors = new List<Actor>
            {
                actor
            };

            RigRepository(repository, actors.ToArray());
            RigClient(client, show.TheTvDbId, response);

            var fetcher = new ActorFetcher(repository, client);

            await fetcher.PopulateActorsAsync(show);

            Assert.Equal(response.Data.First().Role, show.ShowsActors.First().Role);
        }
コード例 #3
0
        // ReSharper disable once InconsistentNaming
        public async Task PopulateActorsAsync_should_query_actors_from_the_repository()
        {
            var repository = Substitute.For<IActorsRepository>();
            var client = Substitute.For<ISeriesClient>();

            var expectedIds = new[]
            {
                1,
                2,
                3
            };

            var actors = new Actor[0];

            var show = new Show
            {
                TheTvDbId = 42
            };

            var actorsResponse = new TvDbResponse<ActorData[]>
            {
                Data = new[]
                {
                    new ActorData
                    {
                        Id = 1,
                        LastUpdated = DefaultLastUpdated
                    },
                    new ActorData
                    {
                        Id = 2,
                        LastUpdated = DefaultLastUpdated
                    },
                    new ActorData
                    {
                        Id = 3,
                        LastUpdated = DefaultLastUpdated
                    }
                }
            };

            RigRepository(repository, actors, expectedIds);
            RigClient(client, show.TheTvDbId, actorsResponse);

            var fetcher = new ActorFetcher(repository, client);
            await fetcher.PopulateActorsAsync(show);

            await repository.Received().GetActorsByTheTvDbIdsAsync(Arg.Is<int[]>(x => x.All(expectedIds.Contains)));
        }