Example #1
0
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_JsonReader_Not_Valid_4()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var reader = new StringReader(JSON_NOT_VALID_4))
                using (var jsonReader = new JsonTextReader(reader))
                {
                    var traktEpisodeWatchedProgresses = await traktJsonReader.ReadArrayAsync(jsonReader);

                    traktEpisodeWatchedProgresses.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(3);

                    var watchedProgress = traktEpisodeWatchedProgresses.ToArray();

                    watchedProgress[0].Number.Should().BeNull();
                    watchedProgress[0].Completed.Should().BeTrue();
                    watchedProgress[0].LastWatchedAt.Should().Be(DateTime.Parse("2011-04-18T01:00:00.000Z").ToUniversalTime());

                    watchedProgress[1].Number.Should().Be(2);
                    watchedProgress[1].Completed.Should().BeNull();
                    watchedProgress[1].LastWatchedAt.Should().Be(DateTime.Parse("2011-04-18T01:00:00.000Z").ToUniversalTime());

                    watchedProgress[2].Number.Should().Be(3);
                    watchedProgress[2].Completed.Should().BeTrue();
                    watchedProgress[2].LastWatchedAt.Should().BeNull();
                }
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Stream_Incomplete_2()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var stream = JSON_INCOMPLETE_2.ToStream())
            {
                var traktEpisodeWatchedProgresses = await traktJsonReader.ReadArrayAsync(stream);

                traktEpisodeWatchedProgresses.Should().NotBeNull().And.NotBeEmpty().And.HaveCount(3);

                var watchedProgress = traktEpisodeWatchedProgresses.ToArray();

                watchedProgress[0].Number.Should().Be(1);
                watchedProgress[0].Completed.Should().BeTrue();
                watchedProgress[0].LastWatchedAt.Should().Be(DateTime.Parse("2011-04-18T01:00:00.000Z").ToUniversalTime());

                watchedProgress[1].Number.Should().Be(2);
                watchedProgress[1].Completed.Should().BeNull();
                watchedProgress[1].LastWatchedAt.Should().Be(DateTime.Parse("2011-04-18T01:00:00.000Z").ToUniversalTime());

                watchedProgress[2].Number.Should().Be(3);
                watchedProgress[2].Completed.Should().BeTrue();
                watchedProgress[2].LastWatchedAt.Should().Be(DateTime.Parse("2011-04-18T01:00:00.000Z").ToUniversalTime());
            }
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Json_String_Empty()
        {
            var jsonReader = new EpisodeWatchedProgressArrayJsonReader();

            var traktEpisodeWatchedProgress = await jsonReader.ReadArrayAsync(string.Empty);

            traktEpisodeWatchedProgress.Should().BeNull();
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Json_String_Empty_Array()
        {
            var jsonReader = new EpisodeWatchedProgressArrayJsonReader();

            var traktEpisodeWatchedProgresses = await jsonReader.ReadArrayAsync(JSON_EMPTY_ARRAY);

            traktEpisodeWatchedProgresses.Should().NotBeNull().And.BeEmpty();
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Stream_Null()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            var traktEpisodeWatchedProgress = await traktJsonReader.ReadArrayAsync(default(Stream));

            traktEpisodeWatchedProgress.Should().BeNull();
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Stream_Empty()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var stream = string.Empty.ToStream())
            {
                var traktEpisodeWatchedProgress = await traktJsonReader.ReadArrayAsync(stream);

                traktEpisodeWatchedProgress.Should().BeNull();
            }
        }
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_Stream_Empty_Array()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var stream = JSON_EMPTY_ARRAY.ToStream())
            {
                var traktEpisodeWatchedProgresses = await traktJsonReader.ReadArrayAsync(stream);

                traktEpisodeWatchedProgresses.Should().NotBeNull().And.BeEmpty();
            }
        }
Example #8
0
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_JsonReader_Empty()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var reader = new StringReader(string.Empty))
                using (var jsonReader = new JsonTextReader(reader))
                {
                    var traktEpisodeWatchedProgress = await traktJsonReader.ReadArrayAsync(jsonReader);

                    traktEpisodeWatchedProgress.Should().BeNull();
                }
        }
Example #9
0
        public async Task Test_EpisodeWatchedProgressArrayJsonReader_ReadArray_From_JsonReader_Empty_Array()
        {
            var traktJsonReader = new EpisodeWatchedProgressArrayJsonReader();

            using (var reader = new StringReader(JSON_EMPTY_ARRAY))
                using (var jsonReader = new JsonTextReader(reader))
                {
                    var traktEpisodeWatchedProgresses = await traktJsonReader.ReadArrayAsync(jsonReader);

                    traktEpisodeWatchedProgresses.Should().NotBeNull().And.BeEmpty();
                }
        }
        public override async Task <ITraktSeasonWatchedProgress> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
        {
            if (jsonReader == null)
            {
                return(await Task.FromResult(default(ITraktSeasonWatchedProgress)));
            }

            if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
            {
                var episodeWatchedProgressArrayReader = new EpisodeWatchedProgressArrayJsonReader();
                ITraktSeasonWatchedProgress traktSeasonWatchedProgress = new TraktSeasonWatchedProgress();

                while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
                {
                    var propertyName = jsonReader.Value.ToString();

                    switch (propertyName)
                    {
                    case JsonProperties.SEASON_WATCHED_PROGRESS_PROPERTY_NAME_NUMBER:
                        traktSeasonWatchedProgress.Number = await jsonReader.ReadAsInt32Async(cancellationToken);

                        break;

                    case JsonProperties.SEASON_WATCHED_PROGRESS_PROPERTY_NAME_AIRED:
                        traktSeasonWatchedProgress.Aired = await jsonReader.ReadAsInt32Async(cancellationToken);

                        break;

                    case JsonProperties.SEASON_WATCHED_PROGRESS_PROPERTY_NAME_COMPLETED:
                        traktSeasonWatchedProgress.Completed = await jsonReader.ReadAsInt32Async(cancellationToken);

                        break;

                    case JsonProperties.SEASON_WATCHED_PROGRESS_PROPERTY_NAME_EPISODES:
                        traktSeasonWatchedProgress.Episodes = await episodeWatchedProgressArrayReader.ReadArrayAsync(jsonReader, cancellationToken);

                        break;

                    default:
                        await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);

                        break;
                    }
                }

                return(traktSeasonWatchedProgress);
            }

            return(await Task.FromResult(default(ITraktSeasonWatchedProgress)));
        }