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);
}