public void WithAuthToken_WithValidConfig_ShouldAppendPlexTokenHeader() { // Setup var request = new HttpRequestMessage(); var config = new PlexMediaServerConfig { PlexAuthenticatedUser = new User { AuthToken = "Test Token" }, PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "test" }; // Perform request.WithAuthToken(config); var header = request .Headers .FirstOrDefault(h => h.Key == "X-Plex-Token"); // Assert Assert.NotNull(header); Assert.Equal(config.PlexAuthenticatedUser.AuthToken, header.Value.FirstOrDefault()); }
public void Constructor_WithInvalidAuthHeaderConstructor_ShouldThrowArgumentNullException() { // Setup var config = new PlexMediaServerConfig { PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400" }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); IHeaderConstructor <BasicAuthRequest> basicAuthHeadersConstructor = null; // Perform action 'Constructor' var exception = Assert.Throws <ArgumentNullException>(() => { var instance = new PlexTvAuthenticator(httpService, plexBasicHeadersConstructor, basicAuthHeadersConstructor, config); }); // Assert that 'ShouldThrowArgumentNullException' = 'WithInvalidConfig' Assert.Equal("basicAuthHeadersConstructor", exception.ParamName); }
public async Task GetAllLibrariesAsync_WithValidParams_ShouldCallAndReturnMediaProviderLibraries() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>(); var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); var mediaProvider = Substitute.For <IPlexMediaProvider>(); var instance = new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider); mediaProvider .GetAllLibrariesAsync(Arg.Any <CancellationToken>()) .Returns(info => new List <Library> { new Library() }); // Perform var actual = await instance.GetAllLibrariesAsync(CancellationToken.None); // Assert Assert.True(actual.Any()); }
public async Task InitializeAsync_WithInvalidAuthResponse_ShouldReturnUnauthorised() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>(); var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); var mediaProvider = Substitute.For <IPlexMediaProvider>(); var instance = new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider); authenticator .AuthenticateAsync(Arg.Any <CancellationToken>()) .Returns(info => new UserAuthenticationResponse()); // Perform InitializationStatus actual = await instance.InitializeAsync((servers) => servers.First().PublicAddress, CancellationToken.None); // Assert Assert.Equal(InitializationStatus.Unauthorised, actual); }
public async Task GetServerSettingsAsync_WithInvalidHttpResponse_ShouldReturnNullResponse() { // Setup var config = new PlexMediaServerConfig { PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400", PlexAuthenticatedUser = new User { AuthToken = "Test token" } }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var instance = new PlexServerPreferencesProviderService(httpService, plexBasicHeadersConstructor, config); string endpointUrl = Endpoint.ServerPreferences.Description(config.ServerAddress); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedHttpResponse = new HttpResponse <BasePlexResponse <ServerPreferences> >(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(new object())) }; // Mocks httpService .RequestAsync <BasePlexResponse <ServerPreferences> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); return(expectedHttpResponse); }); await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); // Perform ServerPreferences actual = await instance.GetServerSettingsAsync(CancellationToken.None); // Assert httpService .Received() .RequestAsync <BasePlexResponse <ServerPreferences> >(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Null(actual); }
public async Task AuthenticateAsync_WithInvalidHttpResponse_ShouldReturnDefaultResponseWithNullUser() { // Setup var config = new PlexMediaServerConfig { PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400" }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var basicAuthHeadersConstructor = Substitute.For <IHeaderConstructor <BasicAuthRequest> >(); var instance = new PlexTvAuthenticator(httpService, plexBasicHeadersConstructor, basicAuthHeadersConstructor, config); var username = "******"; var password = "******"; string endpointUrl = Endpoint.SignIn.Description(); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedHttpResponse = new HttpResponse <UserAuthenticationResponse>(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(new object())) }; // Mocks httpService .RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); return(expectedHttpResponse); }); await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); // Perform UserAuthenticationResponse actual = await instance.AuthenticateAsync(CancellationToken.None); // Assert httpService .Received() .RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Null(actual.User); }
public void WithAuthToken_WithInvalidConfig_ShouldThrowArgumentNullException() { // Setup var request = new HttpRequestMessage(); PlexMediaServerConfig config = null; // Perform var exception = Assert.Throws <ArgumentNullException>(() => { request .WithAuthToken(config); }); }
public async Task InitializeAsync_WithSettings_ShouldSetSettings() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>(); var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); var mediaProvider = Substitute.For <IPlexMediaProvider>(); var instance = new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider); var expectedUser = new User { Email = "*****@*****.**" }; authenticator .GetAllServers(Arg.Any <CancellationToken>()) .Returns(info => new List <Device>() { new Device() }); authenticator .AuthenticateAsync(Arg.Any <CancellationToken>()) .Returns(info => new UserAuthenticationResponse { User = expectedUser }); settingsProvider .GetServerSettingsAsync(Arg.Any <CancellationToken>()) .Returns(info => new ServerPreferences { Setting = new List <Setting>() { new Setting() } }); // Perform InitializationStatus actual = await instance.InitializeAsync((servers) => servers.First().PublicAddress, CancellationToken.None); // Assert Assert.True(instance.Configuration.ServerPreferences.Setting.Any()); }
/// <summary> /// Overloaded constructor to pass configuration. /// </summary> /// <param name="httpService">Instance of static http service to use in making web requests.</param> /// <param name="plexBasicHeadersConstructor">Constructor for Plex headers.</param> /// <param name="configuration">Media server specific configuration.</param> public PlexMediaProviderService(IHttpService httpService, IHeaderConstructor <PlexBasicRequestHeaders> plexBasicHeadersConstructor, PlexMediaServerConfig configuration) { _configuration = configuration .ThrowIfNull(nameof(configuration)) .ThrowIfInvalid(nameof(configuration)); _httpService = httpService .ThrowIfNull(nameof(httpService)); _plexBasicHeaders = plexBasicHeadersConstructor .ThrowIfNull(nameof(plexBasicHeadersConstructor)) .ConstructRequestHeaders(configuration.BasicPlexHeaders); }
public void WithAuthToken_WithInvalidToken_ShouldThrowValidationException() { // Setup var request = new HttpRequestMessage(); var config = new PlexMediaServerConfig(); // Perform action 'WithAuthToken' Assert.Throws <ValidationException>(() => { request .WithAuthToken(config); }); // Assert that 'ShouldThrowValidationException' = 'WithInvalidToken' }
public void Constructor_WithInvalidConfig_ShouldThrowArgumentNullException() { // Setup PlexMediaServerConfig config = null; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>(); var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); // Perform var exception = Assert.Throws <ArgumentNullException>(() => new PlexMediaService(config, httpService, authenticator, settingsProvider, )); // Assert Assert.Equal("configuration", exception.ParamName); }
public void Constructor_WithInvalidConfig_ShouldThrowArgumentNullException() { // Setup PlexMediaServerConfig config = null; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); // Perform action 'Constructor' var exception = Assert.Throws <ArgumentNullException>(() => { var instance = new PlexServerPreferencesProviderService(httpService, plexBasicHeadersConstructor, config); }); // Assert that 'ShouldThrowArgumentNullException' = 'WithInvalidConfig' Assert.Equal("configuration", exception.ParamName); }
/// <summary> /// Overloaded constructor to pass configuration. /// </summary> /// <param name="httpService">Instance of static http service to use in making web requests.</param> /// <param name="plexBasicHeadersConstructor">Constructor for Plex headers.</param> /// <param name="basicAuthHeadersConstructor">Constructor for Plex headers.</param> /// <param name="configuration">Media server specific configuration.</param> public PlexTvAuthenticator(IHttpService httpService, IHeaderConstructor <PlexBasicRequestHeaders> plexBasicHeadersConstructor, IHeaderConstructor <BasicAuthRequest> basicAuthHeadersConstructor, PlexMediaServerConfig configuration) { _configuration = configuration .ThrowIfNull(nameof(configuration)) .ThrowIfInvalid(nameof(configuration)); _httpService = httpService .ThrowIfNull(nameof(httpService)); _plexBasicHeaders = plexBasicHeadersConstructor .ThrowIfNull(nameof(plexBasicHeadersConstructor)) .ConstructRequestHeaders(configuration.BasicPlexHeaders); _basicAuthConstructor = basicAuthHeadersConstructor .ThrowIfNull(nameof(basicAuthHeadersConstructor)); }
public async Task InitializeAsync_WithValidServers_ShouldSetDiscoveredServersContext() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>(); var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); var mediaProvider = Substitute.For <IPlexMediaProvider>(); var instance = new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider); var expectedUser = new User { Email = "*****@*****.**" }; var expectedDevice = new Device { Id = "some_server" }; authenticator .GetAllServers(Arg.Any <CancellationToken>()) .Returns(info => new List <Device>() { expectedDevice }); authenticator .AuthenticateAsync(Arg.Any <CancellationToken>()) .Returns(info => new UserAuthenticationResponse { User = expectedUser }); // Perform InitializationStatus actual = await instance.InitializeAsync((servers) => servers.First().PublicAddress, CancellationToken.None); // Assert Assert.NotNull(instance.Configuration?.DiscoveredServers); Assert.Equal(expectedDevice.Id, instance.Configuration.DiscoveredServers.First().Id); }
public void Constructor_WithValidParams_ShouldConstruct() { // Setup var config = new PlexMediaServerConfig { PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400" }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); // Perform action 'Constructor' var instance = new PlexServerPreferencesProviderService(httpService, plexBasicHeadersConstructor, config); // Assert that 'ShouldThrowArgumentNullException' = 'WithInvalidConfig' Assert.NotNull(instance); }
public void Constructor_WithValidParams_ShouldConstruct() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>();; var settingsProvider = Substitute.For <IPlexServerSettingsProvider>(); var mediaProvider = Substitute.For <IPlexMediaProvider>(); // Perform var actual = new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider); // Assert Assert.NotNull(actual); }
public void Constructor_WithInvalidSettingsService_ShouldThrowArgumentNullException() { // Setup PlexMediaServerConfig config = new PlexMediaServerConfig { ServerAddress = "http://192.168.0.5:32400", PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" } }; var httpService = Substitute.For <IHttpService>(); var authenticator = Substitute.For <IPlexAuthenticator>();; IPlexServerSettingsProvider settingsProvider = null; var mediaProvider = Substitute.For <IPlexMediaProvider>(); // Perform var exception = Assert.Throws <ArgumentNullException>(() => new PlexMediaService(config, httpService, authenticator, settingsProvider, mediaProvider)); // Assert Assert.Equal("serverSettingsProvider", exception.ParamName); }
public async Task AuthenticateAsync_WithValidParams_ShouldCallRequestAsyncWithValidRequest() { // Setup var config = new PlexMediaServerConfig { PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400" }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var basicAuthHeadersConstructor = Substitute.For <IHeaderConstructor <BasicAuthRequest> >(); plexBasicHeadersConstructor .ConstructRequestHeaders(Arg.Any <PlexBasicRequestHeaders>()) .Returns((request) => new Dictionary <string, string> { { "X-Plex-Client-Identifier", "test header" } }); basicAuthHeadersConstructor .ConstructRequestHeaders(Arg.Any <BasicAuthRequest>()) .Returns((request) => new Dictionary <string, string> { { "Authorization", "test header" } }); var instance = new PlexTvAuthenticator(httpService, plexBasicHeadersConstructor, basicAuthHeadersConstructor, config); var username = "******"; var password = "******"; string endpointUrl = Endpoint.SignIn.Description(); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedUser = new User { AuthToken = "test token", Email = "test email" }; var expectedResponseBody = new UserAuthenticationResponse { User = expectedUser }; var expectedHttpResponse = new HttpResponse <UserAuthenticationResponse>(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedResponseBody)) }; // Mocks httpService .RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); Assert.True(requestContext?.Request.Headers.Contains("X-Plex-Client-Identifier")); Assert.True(requestContext?.Request.Headers.Contains("Authorization")); return(expectedHttpResponse); }); await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); // Perform UserAuthenticationResponse actual = await instance.AuthenticateAsync(CancellationToken.None); // Assert httpService .Received() .RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Equal(expectedUser.AuthToken, actual.User.AuthToken); Assert.Equal(expectedUser.Email, actual.User.Email); }
public async Task GetAllLibrariesAsync_WithResult_ShouldCallHttpRequestWithCorrectParamsAndReturnEmptyMoviesList() { // Setup var plexConfig = new PlexMediaServerConfig { PlexAuthenticatedUser = new User { AuthToken = "Test Token" }, PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400", }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var instance = new PlexMediaProviderService(httpService, plexBasicHeadersConstructor, plexConfig); string endpointUrl = Endpoint.Libraries.Description(plexConfig.ServerAddress); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedMediaContainer = new BasePlexResponse <Libraries> { MediaContainer = new Libraries { Size = 1, Directory = new List <Directory> { new Directory { Title = "Test Movie Title", Key = "123", Art = "test-art", Thumb = "test-thumb", Type = "movie" } } } }; var expectedHttpResponse = new HttpResponse <BasePlexResponse <Libraries> >(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedMediaContainer)) }; await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); httpService .RequestAsync <BasePlexResponse <Libraries> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); return(expectedHttpResponse); }); // Get movies for library var expectedMoviesMediaContainer = new BasePlexResponse <MediaContainer> { MediaContainer = new MediaContainer() }; var expectedMoviesHttpResponse = new HttpResponse <BasePlexResponse <MediaContainer> >(); var expectedMoviesHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedMoviesMediaContainer)) }; await expectedMoviesHttpResponse.SetResponseAsync(Guid.NewGuid(), expectedMoviesHttpResponseMessage, CancellationToken.None); httpService .RequestAsync <BasePlexResponse <MediaContainer> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(Endpoint.LibraryMovies.Description(plexConfig.ServerAddress, expectedMediaContainer.MediaContainer.Directory.First().Key), requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, HttpMethod.Get); return(expectedMoviesHttpResponse); }); // Perform action IEnumerable <Library> result = await instance.GetAllLibrariesAsync(CancellationToken.None); IEnumerable <Movie> movies = await result.First().GetMoviesAsync; // Assert httpService .Received() .RequestAsync <BasePlexResponse <MediaContainer> >(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Empty(movies); }
public async Task GetAllLibrariesAsync_WithResult_ShouldCallHttpRequestWithCorrectParamsAndReturnCorrectlyCastedMovies() { // Setup var plexConfig = new PlexMediaServerConfig { PlexAuthenticatedUser = new User { AuthToken = "Test Token" }, PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400", }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var instance = new PlexMediaProviderService(httpService, plexBasicHeadersConstructor, plexConfig); string endpointUrl = Endpoint.Libraries.Description(plexConfig.ServerAddress); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedMediaContainer = new BasePlexResponse <Libraries> { MediaContainer = new Libraries { Size = 1, Directory = new List <Directory> { new Directory { Title = "Test Movie Title", Key = "123", Art = "test-art", Thumb = "test-thumb", Type = "movie" } } } }; var expectedHttpResponse = new HttpResponse <BasePlexResponse <Libraries> >(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedMediaContainer)) }; await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); httpService .RequestAsync <BasePlexResponse <Libraries> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); return(expectedHttpResponse); }); // Get movies for library var expectedMetadata = new Metadata { Media = new List <Media> { new Media { AudioChannels = 6, AudioCodec = "aac", Bitrate = 128, Container = "mp4", Height = 1080, Width = 1920, Part = new List <Part> { new Part { Key = "test_key" } }, VideoCodec = "test_vid_codec" } }, Summary = "Test summary", Duration = 999, Art = "test_art", Rating = 9.5, Studio = "Marvel", Title = "test_title", ViewCount = 10, Year = 2010 }; var expectedMoviesMediaContainer = new BasePlexResponse <MediaContainer> { MediaContainer = new MediaContainer { Metadata = new List <Metadata> { expectedMetadata } } }; var expectedMoviesHttpResponse = new HttpResponse <BasePlexResponse <MediaContainer> >(); var expectedMoviesHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedMoviesMediaContainer)) }; await expectedMoviesHttpResponse.SetResponseAsync(Guid.NewGuid(), expectedMoviesHttpResponseMessage, CancellationToken.None); httpService .RequestAsync <BasePlexResponse <MediaContainer> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(Endpoint.LibraryMovies.Description(plexConfig.ServerAddress, expectedMediaContainer.MediaContainer.Directory.First().Key), requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, HttpMethod.Get); return(expectedMoviesHttpResponse); }); // Perform action IEnumerable <Library> result = await instance.GetAllLibrariesAsync(CancellationToken.None); IEnumerable <Movie> movies = await result.First().GetMoviesAsync; var actual = movies.First(); // Assert httpService .Received() .RequestAsync <BasePlexResponse <MediaContainer> >(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Equal(expectedMetadata.Media.First().AudioChannels, actual.AudioChannels); Assert.Equal(expectedMetadata.Media.First().AudioCodec, actual.AudioCodec); Assert.Equal(expectedMetadata.Media.First().Bitrate, actual.Bitrate); Assert.Equal(expectedMetadata.Media.First().Container, actual.Container); Assert.Equal(expectedMetadata.Summary, actual.Description); Assert.Equal(expectedMetadata.Duration, actual.Duration); Assert.Equal(expectedMetadata.Media.First().Height, actual.Height); Assert.Equal(expectedMetadata.Media.First().Width, actual.Width); Assert.Equal($"{plexConfig.ServerAddress}{expectedMetadata.Art}?{plexConfig.QueryStringPlexToken}", actual.Poster); Assert.Equal(expectedMetadata.Rating, actual.Rating); Assert.Equal($"{plexConfig.ServerAddress}{expectedMetadata.Media.First().Part.First().Key}?{plexConfig.QueryStringPlexToken}", actual.StreamingUrl); Assert.Equal(expectedMetadata.Studio, actual.Studio); Assert.Equal($"{plexConfig.ServerAddress}{expectedMetadata.Thumb}?{plexConfig.QueryStringPlexToken}", actual.Thumbnail); Assert.Equal(expectedMetadata.Title, actual.Title); Assert.Equal(expectedMetadata.Media.First().VideoCodec, actual.VideoCodec); Assert.Equal(expectedMetadata.ViewCount, actual.ViewCount); Assert.Equal(expectedMetadata.Year, actual.Year); }
public async Task GetAllLibrariesAsync_WithValidParamsAndResponse_ShouldCallCorrectHttpEndpoint() { // Setup var plexConfig = new PlexMediaServerConfig { PlexAuthenticatedUser = new User { AuthToken = "Test Token" }, PlexAuthenticationRequestUser = new BasicAuth { Username = "******", Password = "******" }, ServerAddress = "http://192.168.0.5:32400" }; var httpService = Substitute.For <IHttpService>(); var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >(); var instance = new PlexMediaProviderService(httpService, plexBasicHeadersConstructor, plexConfig); string endpointUrl = Endpoint.Libraries.Description(plexConfig.ServerAddress); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpointUrl); HttpRequest httpRequest = httpRequestMessage.ToHttpRequest(); var expectedMediaContainer = new BasePlexResponse <Libraries> { MediaContainer = new Libraries { Size = 5, Directory = new List <Directory>() } }; var expectedHttpResponse = new HttpResponse <BasePlexResponse <Libraries> >(); var expectedHttpResponseMessage = new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(expectedMediaContainer)) }; await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None); httpService .RequestAsync <BasePlexResponse <Libraries> >(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>()) .Returns((request) => { // Assert the details of the request to be correct var requestContext = request.Args()[0] as HttpRequest; Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri); Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method); return(expectedHttpResponse); }); // Perform action 'WithValidParamsAndResponse' await instance.GetAllLibrariesAsync(CancellationToken.None); // Assert that 'GetAllLibrariesAsync' = 'ShouldCallCorrectHttpEndpoint' httpService .Received() .RequestAsync <BasePlexResponse <Libraries> >(Arg.Any <HttpRequest>(), CancellationToken.None); Assert.Equal(httpRequest.Identifier, expectedHttpResponse.RequestIdentifier); }
/// <summary> /// Add a Plex authentication token to the request message headers. /// </summary> /// <param name="request">Original request message.</param> /// <param name="config">Plex server configuration.</param> /// <returns>The ammended request message.</returns> public static HttpRequestMessage WithAuthToken(this HttpRequestMessage request, PlexMediaServerConfig config) { config.ThrowIfInvalid(nameof(config)); request.Headers.Add("X-Plex-Token", config.PlexAuthenticatedUser.AuthToken); return(request); }