Exemplo n.º 1
0
 public LibraryManager(MetadataAccessor accessor, IEnumerable<DataManager> dataManagers)
 {
     m_libraryPaths = new List<string>();
     m_movies = new MovieLibrary();
     m_accessor = accessor;
     m_dataManagers = new List<DataManager>(dataManagers);
 }
Exemplo n.º 2
0
        public void Before_Each_Test()
        {
            _critic = MockRepository.GenerateMock<IMovieCritic>();

            // By default a dynamic mock returns false
            _movie1 = MockRepository.GenerateMock<IMovie>();
            _movie2 = MockRepository.GenerateMock<IMovie>();
            _movie3 = MockRepository.GenerateMock<IMovie>();

            _sut = new MovieLibrary(_critic);
        }
        /// <summary>
        /// Setup the movie
        /// </summary>
        protected override void GivenThat()
        {
            base.GivenThat();

            // Create all the dependencies
            this._critic = new MockMovieCritic();

            this._notifier = new MockSocialMediaNotifier();

            // Initialize the SUT
            this.Sut = new MovieLibrary(this._critic, this._notifier);

            this._movie = new MockMovie();
        }
Exemplo n.º 4
0
        private ILibrary GetLibrary(Directory dir, CancellationToken token)
        {
            var      type = GetTypeFromString(dir.Type);
            ILibrary library;

            switch (type)
            {
            case LibraryType.Movie:
                library = new MovieLibrary
                {
                    GetMoviesAsync      = (cancellationToken) => GetMoviesAsync(dir.Key, cancellationToken),
                    GetCollectionsAsync = (cancellationToken) => GetCollectionsAsync(dir.Key, cancellationToken)
                };
                break;

            case LibraryType.Music:
                library = new MusicLibrary
                {
                    GetAlbumsAsync      = (cancellationToken) => GetAlbumsAsync(dir.Key, cancellationToken),
                    GetCollectionsAsync = (cancellationToken) => GetCollectionsSimpleAsync(dir.Key, cancellationToken)
                };
                break;

            default:
                library = new OtherLibrary
                {
                    GetCollectionsAsync = (cancellationToken) => GetCollectionsAsync(dir.Key, cancellationToken)
                };
                break;
            }
            library.Id        = dir.Key;
            library.Poster    = $"{Configuration.ServerAddress}{dir.Art}?{Configuration.QueryStringPlexToken}";
            library.Thumbnail = $"{Configuration.ServerAddress}{dir.Thumb}?{Configuration.QueryStringPlexToken}";
            library.Title     = dir.Title;
            return(library);
        }
Exemplo n.º 5
0
        public void When_ListingNV_Should_Throw_Exception_If_Missing_Critic()
        {
            // Create the library without critic
            _sut = new MovieLibrary(null);

            Assert.Throws<MissingCriticException>(() => _sut.ListNonViolent(), "Critic Exception");
        }
Exemplo n.º 6
0
        /// <summary>
        /// Get Libraries
        /// </summary>
        /// <param name="filter">Library Filter (Optional)</param>
        /// <exception cref="ApplicationException">Invalid Library Exception</exception>
        /// <returns>List of Library Objects</returns>
        public async Task <List <LibraryBase> > Libraries(LibraryFilter filter = null)
        {
            var libraries = new List <LibraryBase>();
            var summary   = await this.plexServerClient.GetLibrariesAsync(this.AccessToken, this.Uri.ToString());

            foreach (var library in summary.Libraries)
            {
                switch (library.Type.ToUpper(CultureInfo.InvariantCulture))
                {
                case "MOVIE":
                    var movieLibrary = new MovieLibrary(this.plexServerClient, this.plexLibraryClient, this);
                    ObjectMapper.Mapper.Map(library, movieLibrary);
                    var movieFilterContainer = await this.plexLibraryClient.GetLibraryFilters(this.AccessToken, this.Uri.ToString(),
                                                                                              library.Key);

                    libraries.Add(movieLibrary);
                    break;

                case "SHOW":
                    var showLibrary = new ShowLibrary(this.plexServerClient, this.plexLibraryClient, this);
                    ObjectMapper.Mapper.Map(library, showLibrary);
                    var showFilterContainer = await this.plexLibraryClient.GetLibraryFilters(this.AccessToken, this.Uri.ToString(),
                                                                                             showLibrary.Key);

                    libraries.Add(showLibrary);
                    break;

                case "ARTIST":
                    var musicLibrary = new MusicLibrary(this.plexServerClient, this.plexLibraryClient, this);
                    ObjectMapper.Mapper.Map(library, musicLibrary);
                    var musicFilterContainer = await this.plexLibraryClient.GetLibraryFilters(this.AccessToken, this.Uri.ToString(),
                                                                                              musicLibrary.Key);

                    libraries.Add(musicLibrary);
                    break;

                case "PHOTO":
                    var photoLibrary = new PhotoLibrary(this.plexServerClient, this.plexLibraryClient, this);
                    ObjectMapper.Mapper.Map(library, photoLibrary);
                    var photoFilterContainer = await this.plexLibraryClient.GetLibraryFilters(this.AccessToken, this.Uri.ToString(),
                                                                                              photoLibrary.Key);

                    libraries.Add(photoLibrary);
                    break;

                default:
                    throw new ApplicationException("Invalid Library Type");
                }
            }

            if (filter != null)
            {
                if (filter.Keys.Count > 0)
                {
                    libraries = libraries
                                .Where(c => filter.Keys.Contains(c.Key, StringComparer.OrdinalIgnoreCase))
                                .ToList();
                }

                if (filter.Titles.Count > 0)
                {
                    libraries = libraries
                                .Where(c => filter.Titles.Contains(c.Title, StringComparer.OrdinalIgnoreCase))
                                .ToList();
                }

                if (filter.Types.Count > 0)
                {
                    libraries = libraries
                                .Where(c => filter.Types.Contains(c.Type, StringComparer.OrdinalIgnoreCase))
                                .ToList();
                }
            }

            return(libraries);
        }
Exemplo n.º 7
0
        public void WhenListingNonViolentMoviesTheCriticShouldBeAsked()
        {
            this._library = new MovieLibrary(_critic);

            var movie1 = _mockery.StrictMock<IMovie>();
            var movie2 = _mockery.StrictMock<IMovie>();
            var movie3 = _mockery.StrictMock<IMovie>();

            using (_mockery.Record())
            {
                SetupResult.For(_critic.IsViolent(movie1)).Return(true);
                SetupResult.For(_critic.IsViolent(movie2)).Return(false);
                SetupResult.For(_critic.IsViolent(movie3)).Return(false);
            }

            using (_mockery.Playback())
            {
                _library.Add(movie1);
                _library.Add(movie2);
                _library.Add(movie3);
                var actual = _library.ListNonViolent();

                Assert.AreEqual(2, actual.Count());
                Assert.DoesNotContain(actual, movie1);
                Assert.Contains(actual, movie2);
                Assert.Contains(actual, movie3);
            }
        }
Exemplo n.º 8
0
 public void BeforeEachTest()
 {
     this._mockery = new MockRepository();
     this._critic = _mockery.StrictMock<IMovieCritic>();
     this._library = new MovieLibrary(this._critic);
 }
Exemplo n.º 9
0
        public void WhenListingNonViolentWeShouldNotGetACriticException()
        {
            this._library = new MovieLibrary(_critic);

            var movie = _mockery.StrictMock<IMovie>();

            using( _mockery.Record() )
            {
                SetupResult.For(_critic.IsViolent(null))
                    .IgnoreArguments()
                    .Throw(new NotImplementedException("Critic Exception"));
            }

            using( _mockery.Playback())
            {
                _library.Add(movie);

                var actual = _library.ListNonViolent();

                Assert.IsTrue(actual.Count( ) > 0, "The collection should be empty");
            }
        }