public async Task GetServerSettingsAsync_WithValidParams_ShouldCallRequestAsyncWithValidRequest()
{
// 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> >();
plexBasicHeadersConstructor
.ConstructRequestHeaders(Arg.Any <PlexBasicRequestHeaders>())
.Returns((request) => new Dictionary <string, string>
{
{ "X-Plex-Client-Identifier", "test header" }
});
var instance = new PlexServerPreferencesProviderService(httpService, plexBasicHeadersConstructor, config);
var authToken = "test auth token";
string endpointUrl = Endpoint.ServerPreferences.Description(config.ServerAddress);
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpointUrl);
HttpRequest httpRequest = httpRequestMessage.ToHttpRequest();
var expectedSettings = new BasePlexResponse <ServerPreferences>
{
MediaContainer = new ServerPreferences
{
Size = 1,
Setting = new List <Setting>
{
new Setting()
}
}
};
var expectedHttpResponse = new HttpResponse <BasePlexResponse <ServerPreferences> >();
var expectedHttpResponseMessage = new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(expectedSettings))
};
// 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);
Assert.True(requestContext?.Request.Headers.Contains("X-Plex-Client-Identifier"));
Assert.True(requestContext?.Request.Headers.Contains("X-Plex-Token"));
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.Equal(actual.Size, expectedSettings.MediaContainer.Size);
Assert.Equal(actual.Setting.Count(), expectedSettings.MediaContainer.Setting.Count());
}
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);
}
