public LibrarySynchronization(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, ITraktCache traktCache, IFileOperations fileOperations)
 {
     _mediaPortalServices = mediaPortalServices;
     _traktClient         = traktClient;
     _traktCache          = traktCache;
     _fileOperations      = fileOperations;
 }
        public void MarkMovieAsUnwatchedIfMediaLibraryAvailable(List <MediaItem> databaseMovies, List <Movie> traktMovies, int expectedMoviesCount)
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = GetMockMediaPortalServices(databaseMovies);
            ITraktClient         traktClient         = Substitute.For <ITraktClient>();

            traktClient.AddCollectionItems(Arg.Any <ITraktSyncCollectionPost>()).Returns(new TraktSyncCollectionPostResponse());
            traktClient.AddWatchedHistoryItems(Arg.Any <ITraktSyncHistoryPost>()).Returns(new TraktSyncHistoryPostResponse());
            TraktAuthorization authorization = Substitute.For <TraktAuthorization>();

            authorization.AccessToken = "ValidToken";
            traktClient.TraktAuthorization.Returns(authorization);
            ITraktCache traktCache = Substitute.For <ITraktCache>();

            traktCache.RefreshMoviesCache().Returns(new TraktMovies {
                UnWatched = traktMovies, Watched = new List <MovieWatched>(), Collected = new List <MovieCollected>()
            });
            IFileOperations         fileOperations         = Substitute.For <IFileOperations>();
            ILibrarySynchronization librarySynchronization = new LibrarySynchronization(mediaPortalServices, traktClient, traktCache, fileOperations);

            // Act
            TraktSyncMoviesResult result = librarySynchronization.SyncMovies();

            // Assert
            Assert.Equal(expectedMoviesCount, result.MarkedAsUnWatchedInLibrary);
        }
Exemple #3
0
        private ITraktClient GetMockedTraktClientWithValidAuthorization()
        {
            ITraktClient traktClient = Substitute.For <ITraktClient>();

            traktClient.TraktAuthorization.Returns(new TraktAuthorization
            {
                RefreshToken = "ValidToken",
                AccessToken  = "ValidToken",
            });

            traktClient.RefreshAuthorization(Arg.Any <string>()).Returns(new TraktAuthorization
            {
                RefreshToken = "ValidToken"
            });
            traktClient.StartScrobbleMovie(Arg.Any <ITraktMovie>(), Arg.Any <float>()).Returns(
                new TraktMovieScrobblePostResponse
            {
                Movie = new TraktMovie
                {
                    Ids = new TraktMovieIds {
                        Imdb = "tt1431045", Tmdb = 67890
                    },
                    Title = "Movie1",
                    Year  = 2012
                },
                Action   = TraktScrobbleActionType.Start,
                Progress = 10
            });

            return(traktClient);
        }
Exemple #4
0
        public void ShouldFailToAuthorizeUserWhenTraktAuthorizationThrowsException()
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>();

            mediaPortalServices.GetTraktUserHomePath().Returns(DataPath);
            ITraktClient traktClient = Substitute.For <ITraktClient>();

            traktClient.GetAuthorization(Arg.Any <string>()).Throws(new TraktException("Pin code is not valid"));
            ILibrarySynchronization librarySynchronization = Substitute.For <ILibrarySynchronization>();
            IFileOperations         fileOperations         = Substitute.For <IFileOperations>();

            fileOperations.DirectoryExists(DataPath).Returns(true);
            string expectedStatus = "[Trakt.AuthorizationFailed]";

            TraktSetupModel setupModel = new TraktSetupModel(mediaPortalServices, traktClient, librarySynchronization, fileOperations);

            // Act
            setupModel.AuthorizeUser();
            string actualStatus = setupModel.TestStatus;

            // Assert
            Assert.Equal(expectedStatus, actualStatus);
            Assert.False(setupModel.IsUserAuthorized);
        }
        public void AddWatchedEpisodeToTraktIfMediaLibraryAvailable(IList <MediaItem> databaseEpisodes, IList <EpisodeWatched> traktEpisodes, int?expectedEpisodesCount)
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = GetMockMediaPortalServices(databaseEpisodes);
            ITraktClient         traktClient         = Substitute.For <ITraktClient>();

            traktClient.AddCollectionItems(Arg.Any <ITraktSyncCollectionPost>()).Returns(new TraktSyncCollectionPostResponse());
            traktClient.AddWatchedHistoryItems(Arg.Any <ITraktSyncHistoryPost>()).Returns(
                new TraktSyncHistoryPostResponse {
                Added = new TraktSyncPostResponseGroup {
                    Episodes = expectedEpisodesCount
                }
            });
            TraktAuthorization authorization = Substitute.For <TraktAuthorization>();

            authorization.AccessToken = "ValidToken";
            traktClient.TraktAuthorization.Returns(authorization);
            ITraktCache traktCache = Substitute.For <ITraktCache>();

            traktCache.RefreshSeriesCache().Returns(new TraktEpisodes {
                Watched = traktEpisodes, UnWatched = new List <Episode>(), Collected = new List <EpisodeCollected>()
            });
            IFileOperations         fileOperations         = Substitute.For <IFileOperations>();
            ILibrarySynchronization librarySynchronization = new LibrarySynchronization(mediaPortalServices, traktClient, traktCache, fileOperations);

            // Act
            TraktSyncEpisodesResult result = librarySynchronization.SyncSeries();

            // Assert
            Assert.Equal(expectedEpisodesCount, result.AddedToTraktWatchedHistory);
        }
Exemple #6
0
        public void GetCollectedMovies(List <ITraktCollectionMovie> onlineCollectedMovies, ITraktSyncLastActivities onlineLastSyncActivities, int expectedCollectedMoviesCount)
        {
            // Arrange
            ITraktClient traktClient = Substitute.For <ITraktClient>();

            traktClient.GetCollectedMovies().Returns(onlineCollectedMovies);
            traktClient.GetLastActivities().Returns(onlineLastSyncActivities);

            IFileOperations fileOperations = Substitute.For <IFileOperations>();

            SetFileOperationsForFile(fileOperations, DataPath, FileName.LastActivity.Value);
            SetFileOperationsForFile(fileOperations, DataPath, FileName.CollectedMovies.Value);
            SetFileOperationsForFile(fileOperations, DataPath, FileName.WatchedMovies.Value);

            IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>();

            mediaPortalServices.GetTraktUserHomePath().Returns(DataPath);

            // Act
            ITraktCache traktCache  = new TraktCache(mediaPortalServices, traktClient, fileOperations);
            TraktMovies traktMovies = traktCache.RefreshMoviesCache();

            // Assert
            int actualCollectedMoviesCount = traktMovies.Collected.Count();

            Assert.Equal(expectedCollectedMoviesCount, actualCollectedMoviesCount);
        }
        private ITraktClient GetMockedTraktClientWithValidAuthorization()
        {
            ITraktClient traktClient = Substitute.For <ITraktClient>();

            traktClient.TraktAuthorization.Returns(new TraktAuthorization
            {
                RefreshToken = "ValidToken",
                AccessToken  = "ValidToken"
            });

            traktClient.RefreshAuthorization(Arg.Any <string>()).Returns(new TraktAuthorization
            {
                RefreshToken = "ValidToken"
            });
            traktClient.StartScrobbleEpisode(Arg.Any <ITraktEpisode>(), Arg.Any <ITraktShow>(), Arg.Any <float>()).Returns(
                new TraktEpisodeScrobblePostResponse
            {
                Show = new TraktShow
                {
                    Title = "Title_1"
                },
                Episode = new TraktEpisode
                {
                    Ids = new TraktEpisodeIds {
                        Imdb = "tt12345", Tvdb = 289590
                    },
                    Number       = 2,
                    SeasonNumber = 2
                },
                Action   = TraktScrobbleActionType.Start,
                Progress = 10
            });

            return(traktClient);
        }
        public void StartScrobble(TraktPluginSettings settings, MediaItem mediaItem, ITraktClient traktClient, ITraktNotification notification)
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>();

            mediaPortalServices.GetTraktUserHomePath().Returns(DataPath);
            SetSettings(mediaPortalServices, settings);
            SetPlayerAndContentDirForMovie(mediaPortalServices, mediaItem);

            IAsynchronousMessageQueue messageQueue = GetMockedMsgQueue(mediaPortalServices);

            IFileOperations fileOperations = Substitute.For <IFileOperations>();

            fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true);

            TraktScrobbleHandlerManager      traktScrobbleHandler = new TraktScrobbleHandlerManager(mediaPortalServices, traktClient, fileOperations);
            TraktScrobbleStartedNotification expectedNotification = (TraktScrobbleStartedNotification)notification;

            // Act
            // start the player
            messageQueue.MessageReceivedProxy += Raise.Event <MessageReceivedHandler>(new AsynchronousMessageQueue(new object(), new[] { "PlayerManager" }),
                                                                                      GetSystemMessageForMessageType(PlayerManagerMessaging.MessageType.PlayerStarted));

            // Assert
            mediaPortalServices.GetTraktNotificationModel().Received()
            .ShowNotification(Arg.Is <TraktScrobbleStartedNotification>(x => x.IsSuccess == expectedNotification.IsSuccess &&
                                                                        x.Message == expectedNotification.Message &&
                                                                        x.ActionType == expectedNotification.ActionType &&
                                                                        x.Progress == expectedNotification.Progress &&
                                                                        x.SuperLayerScreenName == expectedNotification.SuperLayerScreenName),
                              Arg.Any <TimeSpan>());
        }
        public void EnableTraktScrobbleHandlerWhenUserChanged()
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>();

            mediaPortalServices.GetTraktUserHomePath().Returns(DataPath);
            TraktPluginSettings settings = new TraktPluginSettings
            {
                IsScrobbleEnabled = false
            };
            ITraktSettingsChangeWatcher settingsChangeWatcher = Substitute.For <ITraktSettingsChangeWatcher>();

            settingsChangeWatcher.TraktSettings.Returns(settings);
            mediaPortalServices.GetTraktSettingsWatcher().Returns(settingsChangeWatcher);

            IUserMessageHandler userMessageHandler = Substitute.For <IUserMessageHandler>();

            mediaPortalServices.GetUserMessageHandler().Returns(userMessageHandler);

            ITraktClient    traktClient    = Substitute.For <ITraktClient>();
            IFileOperations fileOperations = Substitute.For <IFileOperations>();

            fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true);

            TraktScrobbleHandlerManager traktScrobbleHandler = new TraktScrobbleHandlerManager(mediaPortalServices, traktClient, fileOperations);

            // Act
            settings.IsScrobbleEnabled           = true;
            userMessageHandler.UserChangedProxy += Raise.Event();

            // Assert
            Assert.True(traktScrobbleHandler.IsActive);
        }
 public TraktSetupModel(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, ILibrarySynchronization librarySynchronization, IFileOperations fileOperations)
 {
     _mediaPortalServices    = mediaPortalServices;
     _traktClient            = traktClient;
     _fileOperations         = fileOperations;
     _librarySynchronization = librarySynchronization;
 }
Exemple #11
0
 public TraktScrobbleHandlerManager(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, IFileOperations fileOperations)
 {
     _mediaPortalServices = mediaPortalServices;
     _traktClient         = traktClient;
     _fileOperations      = fileOperations;
     _mediaPortalServices.GetTraktSettingsWatcher().TraktSettingsChanged += ConfigureHandler;
     _mediaPortalServices.GetUserMessageHandler().UserChangedProxy       += ConfigureHandler;
     ConfigureHandler();
 }
        public TraktSetupModel()
        {
            _mediaPortalServices = new MediaPortalServices();
            _traktClient         = new TraktClientProxy(ApplicationId, SecretId, _mediaPortalServices.GetLogger());
            _fileOperations      = new FileOperations();
            ITraktCache traktCache = new TraktCache(_mediaPortalServices, _traktClient, _fileOperations);

            _librarySynchronization = new LibrarySynchronization(_mediaPortalServices, _traktClient, traktCache, _fileOperations);
        }
        private void ValidateAuthorization(ITraktClient _traktClient, IFileOperations _fileOperations)
        {
            if (!_traktClient.TraktAuthorization.IsValid)
            {
                string authFilePath           = Path.Combine(HomeUserPath, FileName.Authorization.Value);
                string savedAuthorization     = _fileOperations.FileReadAllText(authFilePath);
                ITraktAuthorization savedAuth = TraktSerializationService.DeserializeAsync <ITraktAuthorization>(savedAuthorization).Result;

                if (!savedAuth.IsRefreshPossible)
                {
                    throw new Exception("Saved authorization is not valid.");
                }

                ITraktAuthorization refreshedAuth = _traktClient.RefreshAuthorization(savedAuth.RefreshToken);
                string serializedAuth             = TraktSerializationService.SerializeAsync(refreshedAuth).Result;
                _fileOperations.FileWriteAllText(authFilePath, serializedAuth, Encoding.UTF8);
            }
        }
Exemple #14
0
        public void ShouldAuthorizeUserForValidData()
        {
            // Arrange
            IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>();

            mediaPortalServices.GetTraktUserHomePath().Returns(DataPath);
            ITraktClient            traktClient            = Substitute.For <ITraktClient>();
            ILibrarySynchronization librarySynchronization = Substitute.For <ILibrarySynchronization>();
            IFileOperations         fileOperations         = Substitute.For <IFileOperations>();

            fileOperations.DirectoryExists(DataPath).Returns(true);
            string expectedStatus = "[Trakt.AuthorizationSucceed]";

            TraktSetupModel setupModel = new TraktSetupModel(mediaPortalServices, traktClient, librarySynchronization, fileOperations);

            // Act
            setupModel.AuthorizeUser();
            string actualStatus = setupModel.TestStatus;

            // Assert
            Assert.Equal(expectedStatus, actualStatus);
            Assert.True(setupModel.IsUserAuthorized);
        }
Exemple #15
0
 public TraktCache(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, IFileOperations fileOperations)
 {
     _mediaPortalServices = mediaPortalServices;
     _traktClient         = traktClient;
     _fileOperations      = fileOperations;
 }