public void Should_Includ_A_Currectly_Structured_Channel_Url()
{
var channels = new List <YouTubeChannelDto>
{
new YouTubeChannelDto {
id = "testchannelid",
snippet = new YouTubeChannelSnippetDto {
title = "testchannel",
thumbnails = new YouTubeChannelSnippetThumbnailsDto
{
@default = new YouTubeChannelSnippetThumbnailDto
{
url = "http://thumbnail.url"
}
}
}
}
};
var channelResults = MaybeResult <IEnumerable <YouTubeChannelDto>, StreamProviderError> .Success(channels);
var channel = new YouTubeChannelMapper(youtubeWebUrl)
.Map(channelResults)
.GetOrElse(new PlatformChannelDto());
Assert.AreEqual(channel.ChannelName, "testchannel");
Assert.AreEqual(channel.AvatarUrl, "http://thumbnail.url");
Assert.AreEqual(channel.StreamPlatformName, StreamPlatform.YouTube);
Assert.AreEqual(channel.ChannelUrl, "http://youtube.com/channel/testchannelid");
}
public void Should_Be_Success_With_A_Just_Value()
{
var successResult = MaybeResult <int, TestErrorType> .Success(1);
Assert.IsTrue(successResult.IsSuccess);
Assert.IsTrue(successResult.Value.IsSome);
Assert.IsFalse(successResult.IsFailure);
Assert.AreEqual(successResult.Error, TestErrorType.None);
}
public void Should_Return_An_Empty_List_Of_Streams_When_No_Streams_Where_Returned_From_The_Streaming_Platform()
{
var emptySearchResults = MaybeResult <IEnumerable <DLiveStreamItemDto>, StreamProviderError>
.Success(new List <DLiveStreamItemDto>());
var streams = dliveStreamMapper.Map(emptySearchResults, pageSize, pageOffset);
Assert.IsTrue(streams.IsEmpty());
Assert.IsEmpty(streams.NextPageToken);
}
public void Should_Return_An_Empty_Next_Page_Token_When_The_Number_Of_Streams_Is_Less_Than_The_Page_Size()
{
var emptySearchResults = MaybeResult <IEnumerable <DLiveStreamItemDto>, StreamProviderError>
.Success(new List <DLiveStreamItemDto>());
var streams = dliveStreamMapper.Map(emptySearchResults, pageSize, pageOffset);
Assert.IsTrue(streams.IsEmpty());
Assert.IsEmpty(streams.NextPageToken);
}
public void Should_Return_Back_Nothing_When_No_Matching_Channel_Was_Found()
{
var channels = new List <TwitchChannelDto> {
anotherChannel
};
var channelResults = MaybeResult <IEnumerable <TwitchChannelDto>, StreamProviderError> .Success(channels);
var channel = TwitchChannelSelector.Select(expectedChannel.display_name, channelResults);
Assert.IsTrue(channel.IsNothing);
}
public void Should_Return_Back_The_Matching_Channel()
{
var channels = new List <TwitchChannelDto> {
expectedChannel, anotherChannel
};
var channelResults = MaybeResult <IEnumerable <TwitchChannelDto>, StreamProviderError> .Success(channels);
var channel = TwitchChannelSelector.Select(expectedChannel.display_name, channelResults);
Assert.AreEqual(channel.GetOrElse(new TwitchChannelDto()), expectedChannel);
}
public void Should_Be_Success_With_A_Maybe_Value()
{
var maybeValue = Maybe <int> .Some(1);
var successResult = MaybeResult <int, TestErrorType> .Success(maybeValue);
Assert.IsTrue(successResult.IsSuccess);
Assert.AreEqual(successResult.Value, maybeValue);
Assert.IsFalse(successResult.IsFailure);
Assert.AreEqual(successResult.Error, TestErrorType.None);
}
public static async Task <MaybeResult <T, StreamProviderError> > GetOrError <T>(this Task <IFlurlResponse> responseTask)
{
var response = await responseTask;
if (response.StatusCode >= 400)
{
return(MaybeResult <T, StreamProviderError> .Fail(StreamProviderError.ProviderNotAvailable));
}
var payload = await response.GetJsonAsync <T>();
return(MaybeResult <T, StreamProviderError> .Success(payload));
}
public void Should_Map_A_DLive_Channel_To_A_PlatformChannel()
{
var mapper = new DLiveChannelMapper(dliveUrl);
var dliveUser = new DLiveUserDto
{
displayName = "testuser",
avatar = "http://avatar.url"
};
var userSearchResults = MaybeResult <DLiveUserDto, StreamProviderError> .Success(dliveUser);
var platformChannl = mapper.Map(userSearchResults).GetOrElse(new PlatformChannelDto());
Assert.AreEqual(platformChannl.ChannelName, "testuser");
Assert.AreEqual(platformChannl.AvatarUrl, "http://avatar.url");
Assert.AreEqual(platformChannl.StreamPlatformName, StreamPlatform.DLive);
Assert.AreEqual(platformChannl.ChannelUrl, "http://dlive.com/testuser");
}
public void Should_Map_The_Channel_Exactly_Matching_The_Channel_Name_To_PlatformChannel()
{
var twitchChannelDto = new TwitchChannelDto
{
display_name = "test channel",
logo = "http://logo.url",
url = "http://channel.url",
};
var twitchChannelResult = MaybeResult <TwitchChannelDto, StreamProviderError> .Success(twitchChannelDto);
var platformChannel = new TwitchChannelMapper().Map(twitchChannelResult).GetOrElse(new PlatformChannelDto());
Assert.AreEqual(platformChannel.ChannelName, "test channel");
Assert.AreEqual(platformChannel.AvatarUrl, "http://logo.url");
Assert.AreEqual(platformChannel.ChannelUrl, "http://channel.url");
Assert.AreEqual(platformChannel.StreamPlatformName, StreamPlatform.Twitch);
}
public void Setup()
{
var dliveStreams = new List <DLiveStreamItemDto>
{
new DLiveStreamItemDto
{
title = "test stream",
thumbnailUrl = "http://thunmbnail.url",
watchingCount = 1,
creator = new DLiveUserDto {
displayName = "TestUserA", avatar = "http://avatar.url"
}
},
};
streamSearchResults = MaybeResult <IEnumerable <DLiveStreamItemDto>, StreamProviderError> .Success(dliveStreams);
dliveStreamMapper = new DLiveStreamMapper(dliveUrl);
}
public MaybeResult <IEnumerable <TwitchStreamDto>, StreamProviderError> Build()
{
return(MaybeResult <IEnumerable <TwitchStreamDto>, StreamProviderError> .Success(twitchStreams));
}
public MaybeResult <IEnumerable <YouTubeVideoDto>, StreamProviderError> Build()
{
return(MaybeResult <IEnumerable <YouTubeVideoDto>, StreamProviderError> .Success(youTubeVideoDtos));
}
