/// <summary>
/// Simply post a daata
/// </summary>
public static WebResult <T> WebSimplePost <T>(
HttpWebRequest req,
byte[] sendbytes,
StreamConverter <T> streamconv = null,
ResponseConverter <T> responseconv = null)
{
try
{
req.Method = "POST";
req.ContentLength = sendbytes.Length;
using (var rs = req.GetRequestStream())
{
rs.Write(sendbytes, 0, sendbytes.Length);
rs.Flush();
}
return(TreatWebResponse((HttpWebResponse)req.GetResponse(), streamconv, responseconv));
}
catch (SocketException e)
{
return(new WebResult <T>(req.RequestUri, e));
}
catch (IOException e)
{
return(new WebResult <T>(req.RequestUri, e));
}
catch (WebException e)
{
return(new WebResult <T>(req.RequestUri, e));
}
}
public async void ExceptionWrapped()
{
Exception ex = null;
try
{
throw new NotImplementedException();
}
catch (Exception e)
{
ex = e;
}
var converter = new ResponseConverter();
var response = new RemoteResponse(ex);
object result = converter.Convert(response, typeof(int));
var castedResult = result.ShouldBeAssignableTo <Task <int> >();
castedResult.IsFaulted.ShouldBe(true);
castedResult.Exception.ShouldNotBeNull();
var targetInvocationException = castedResult.Exception.InnerExceptions.First().ShouldBeAssignableTo <TargetInvocationException>();
targetInvocationException.GetBaseException().ShouldBeAssignableTo <NotImplementedException>();
await Assert.ThrowsAsync <TargetInvocationException>(() => castedResult);
}
public IL.ISeoResponse GetSearchResponsePositions(IL.ISeoRequest request)
{
if (request != null)
{
var urlToExecute = _urlConstructor.ConstructUrl(StringLiteralConstants.MICROSOFT_BASE_URL, request.NumberOfRecords, request.SearchText);
if (!string.IsNullOrWhiteSpace(urlToExecute))
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(urlToExecute);
WebRequest.DefaultWebProxy.Credentials = CredentialCache.DefaultNetworkCredentials;
var htmlString = _requestProcessor.ExecuteSearchRequest(webRequest);
if (!string.IsNullOrWhiteSpace(htmlString))
{
var filteredHtml = _parserUtility.ParseAsXml(htmlString, StringLiteralConstants.TagsToRemove);
if (!string.IsNullOrWhiteSpace(filteredHtml))
{
object seoType;
if (Enum.TryParse(typeof(EnumSeoEngineType), request.SeoEngineType, out seoType))
{
var position = _positions.GetUrlPositionsImplementation((EnumSeoEngineType)seoType);
List <int> positions = position.GetPositionOfOccurence(filteredHtml, request.UrlFilter);
return(ResponseConverter.ConvertIntToResponses(positions, request));
}
}
}
}
}
return(ResponseConverter.ConvertIntToResponses(null, request));
}
public void ThrowsOnIncorrectType(object responseData, Type targetType)
{
var converter = new ResponseConverter();
var response = new RemoteResponse(responseData);
Assert.Throws <InvalidCastException>(() => converter.Convert(response, targetType));
}
public void ConvertResponse_WithGetImageResponse_ReturnsImage()
{
var responseConverter = new ResponseConverter();
var response = responseConverter.ConvertResponse <Image>(Mocks.MockImageResponses.GetImage);
Assert.NotNull(response);
Assert.IsType <Image>(response);
Assert.Equal("mvWNMH4", response.Id);
Assert.Equal("Epic Fail", response.Title);
Assert.Equal("That's got to hurt", response.Description);
Assert.Equal(1596483255, response.DateTime);
Assert.Equal("video/mp4", response.Type);
Assert.True(response.Animated);
Assert.Equal(854, response.Width);
Assert.Equal(482, response.Height);
Assert.Equal(7701069, response.Size);
Assert.Equal(915460, response.Views);
Assert.Equal(7050020626740, response.Bandwidth);
Assert.Equal("ups", response.Vote);
Assert.True(response.Favorite);
Assert.True(response.Nsfw);
Assert.Equal("viral", response.Section);
Assert.Equal("https://imgur.com/user/Sarah", response.AccountUrl);
Assert.Equal(12345679, response.AccountId);
Assert.True(response.IsAd);
Assert.True(response.InMostViral);
Assert.Contains(response.Tags, e => e == "funny");
Assert.Equal(1, response.AdType);
Assert.Equal("http://imgur.com", response.AdUrl);
Assert.True(response.InGallery);
Assert.Equal("https://i.imgur.com/mvWNMH4.mp4", response.Link);
Assert.Equal("ABCDEFGH1234", response.DeleteHash);
Assert.Equal("ouch.mp4", response.Name);
}
public void ConvertResponse_WithGetImagePublicResponse_ReturnsImage()
{
var responseConverter = new ResponseConverter();
var response = responseConverter.ConvertResponse <Image>(Mocks.MockImageResponses.GetImagePublc);
Assert.NotNull(response);
Assert.IsType <Image>(response);
Assert.Equal("PdvlRWc", response.Id);
Assert.Null(response.Title);
Assert.StartsWith("After years of playing around", response.Description);
Assert.Equal(1596966065, response.DateTime);
Assert.Equal("image/jpeg", response.Type);
Assert.False(response.Animated);
Assert.Equal(1600, response.Width);
Assert.Equal(1312, response.Height);
Assert.Equal(150117, response.Size);
Assert.Equal(20625, response.Views);
Assert.Equal(3096163125, response.Bandwidth);
Assert.Null(response.Vote);
Assert.False(response.Favorite);
Assert.False(response.Nsfw);
Assert.Null(response.Section);
Assert.Null(response.AccountUrl);
Assert.Null(response.AccountId);
Assert.False(response.IsAd);
Assert.False(response.InMostViral);
Assert.Empty(response.Tags);
Assert.Equal(0, response.AdType);
Assert.True(string.IsNullOrWhiteSpace(response.AdUrl));
Assert.False(response.InGallery);
Assert.Equal("https://i.imgur.com/PdvlRWc.jpg", response.Link);
Assert.Null(response.DeleteHash);
Assert.Null(response.Name);
}
private void DrawPredictions(Dictionary <string, string> restoredPredictions)
{
var predictionsToDraw = ResponseConverter.ConvertResponsePredictions(restoredPredictions);
var lineToDraw = new DiagrammBuilder().CreateLineSeriesRange(predictionsToDraw);
DiagrammPainter.AddLine(lineToDraw.ElementAt(0));
}
public void ConvertOAuth2TokenResponse_WithOAuth2TokenResponse_ReturnsOAuth2Token()
{
var responseConverter = new ResponseConverter();
var oauth2Token = responseConverter.ConvertOAuth2TokenResponse(Mocks.MockOAuth2Responses.GetTokenResponse);
Assert.NotNull(oauth2Token);
Assert.IsType <OAuth2Token>(oauth2Token);
}
public void ConvertResponse_WithDeleteImageResponse_ReturnsBoolean()
{
var responseConverter = new ResponseConverter();
var response = responseConverter.ConvertResponse <bool>(Mocks.MockImageResponses.DeleteImage);
Assert.IsType <bool>(response);
Assert.True(response);
}
public void TaskOfExpectedTypeReturned(object responseData, Type targetType)
{
var converter = new ResponseConverter();
var response = new RemoteResponse(responseData);
object result = converter.Convert(response, targetType);
result.ShouldBeAssignableTo(typeof(Task <>).MakeGenericType(targetType));
}
public void ConvertResponse_WithFavoriteImageResponse_ReturnsString()
{
var responseConverter = new ResponseConverter();
var response = responseConverter.ConvertResponse <string>(Mocks.MockImageResponses.FavoriteImage);
Assert.NotNull(response);
Assert.IsType <string>(response);
Assert.Equal("favorited", response);
}
public void ResponseConverterShouldConvertBenchMarkResultIntoBenchMarkData()
{
#region Arrange
var cloudProvider = CloudProvider.Azure;
var hostingEnvironment = HostEnvironment.Windows;
var runtime = Runtime.Csharp;
var benchMarkResults = new List <BenchMarkResult>()
{
new BenchMarkResult()
{
Id = 0,
CloudProvider = (int)cloudProvider,
HostingEnvironment = (int)hostingEnvironment,
Runtime = (int)runtime,
Success = true,
CreatedAt = DateTimeOffset.Now,
RequestDuration = 200,
IsColdRequest = true
},
new BenchMarkResult()
{
Id = 0,
CloudProvider = (int)cloudProvider,
HostingEnvironment = (int)hostingEnvironment,
Runtime = (int)runtime,
Success = true,
CreatedAt = DateTimeOffset.Now,
RequestDuration = 200,
IsColdRequest = true
}
};
var responseConverter = new ResponseConverter();
#endregion
#region Act
var benchMarkData = responseConverter.ConvertToBenchMarkData(benchMarkResults);
#endregion
#region Assert
Assert.NotNull(benchMarkData);
Assert.True(benchMarkData.ColdDataPoints.Count == 2);
Assert.True(benchMarkData.WarmDataPoints.Count == 0);
Assert.True(benchMarkData.CloudProvider == cloudProvider.ToString());
Assert.True(benchMarkData.HostingEnvironment == hostingEnvironment.ToString());
Assert.True(benchMarkData.Runtime == runtime.ToString());
#endregion
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override IContinentRepository ForDefaultCulture()
{
var continentConverter = new ContinentConverter();
var identifiersConverter = new ResponseConverter <ICollection <int>, ICollection <int> >(new ConverterAdapter <ICollection <int> >());
var responseConverter = new ResponseConverter <ContinentDTO, Continent>(continentConverter);
var pageResponseConverter = new CollectionPageResponseConverter <ContinentDTO, Continent>(continentConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <ContinentDTO, int, Continent>(continentConverter, cont => cont.ContinentId);
return(new ContinentRepository(this.serviceClient, identifiersConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
public override IFileRepository ForDefaultCulture()
{
var assetConverter = new AssetConverter();
var identifiersConverter = new CollectionResponseConverter <string, string>(new ConverterAdapter <string>());
var responseConverter = new ResponseConverter <FileDTO, Asset>(assetConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <FileDTO, string, Asset>(assetConverter, value => value.Identifier);
var pageResponseConverter = new CollectionPageResponseConverter <FileDTO, Asset>(assetConverter);
return(new FileRepository(this.serviceClient, identifiersConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override IWorldRepository ForDefaultCulture()
{
var worldConverter = new WorldConverter();
var identifiersResponseConverter = new CollectionResponseConverter <int, int>(new ConverterAdapter <int>());
var responseConverter = new ResponseConverter <WorldDTO, World>(worldConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <WorldDTO, int, World>(worldConverter, value => value.WorldId);
var pageResponseConverter = new CollectionPageResponseConverter <WorldDTO, World>(worldConverter);
return(new WorldRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
public void ResponseConverterShouldHandleStartDiscoveryStatus()
{
var status = MobileConnectStatus.StartDiscovery();
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("discovery", actual.Action);
}
public void ResponseConverterShouldHandleOperatorSelectionStatus()
{
var status = MobileConnectStatus.OperatorSelection(OPERATOR_SELECTION_URL);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("operator_selection", actual.Action);
Assert.AreEqual(OPERATOR_SELECTION_URL, actual.Url);
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override IMapRepository ForDefaultCulture()
{
var rectangleConverter = new RectangleConverter(new Vector2DConverter());
var mapConverter = new MapConverter(rectangleConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <int>, ICollection <int> >(new ConverterAdapter <ICollection <int> >());
var responseConverter = new ResponseConverter <MapDTO, Map>(mapConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <MapDTO, int, Map>(mapConverter, map => map.MapId);
var pageResponseConverter = new CollectionPageResponseConverter <MapDTO, Map>(mapConverter);
return(new MapRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
public void ResponseConverterShouldHandleTokenRevokedStatus()
{
var response = new RevokeTokenResponse(_responses["token-revoked"]);
var status = MobileConnectStatus.TokenRevoked(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("token_revoked", actual.Action);
}
public void ResponseConverterShouldHandleCompleteStatus()
{
var response = new RequestTokenResponse(_responses["token"]);
var status = MobileConnectStatus.Complete(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("complete", actual.Action);
Assert.AreEqual(status.TokenResponse.ResponseData, actual.Token);
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override IColorRepository ForDefaultCulture()
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <int>, ICollection <int> >(new ConverterAdapter <ICollection <int> >());
var responseConverter = new ResponseConverter <ColorPaletteDTO, ColorPalette>(colorPaletteConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <ColorPaletteDTO, int, ColorPalette>(colorPaletteConverter, color => color.ColorId);
var pageResponseConverter = new CollectionPageResponseConverter <ColorPaletteDTO, ColorPalette>(colorPaletteConverter);
return(new ColorRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
/// <summary>
/// Parse web response
/// </summary>
private static WebResult <T> TreatWebResponse <T>
(HttpWebResponse res, StreamConverter <T> strconv, ResponseConverter <T> resconv)
{
if (!(strconv == null ^ resconv == null))
{
throw new ArgumentException("StreamConverter or ResponseConverter is must set.");
}
try
{
switch (res.StatusCode)
{
case HttpStatusCode.OK:
case HttpStatusCode.Accepted:
case HttpStatusCode.Created:
case HttpStatusCode.NoContent:
case HttpStatusCode.ResetContent:
case HttpStatusCode.PartialContent:
if (resconv != null)
{
return(new WebResult <T>(
res.ResponseUri,
res.StatusCode,
resconv(res)));
}
else if (strconv != null)
{
using (var s = res.GetResponseStream())
{
return(new WebResult <T>(
res.ResponseUri,
res.StatusCode,
strconv(s)));
}
}
else
{
throw new InvalidOperationException("StreamConverter or ResponseConverter is must set.");
}
default:
return(new WebResult <T>(
res.ResponseUri,
null,
res.StatusCode));
}
}
catch (Exception e)
{
return(new WebResult <T>(
res.ResponseUri, e));
}
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override ICharacterRepository ForDefaultCulture()
{
var genderConverter = new GenderConverter();
var professionConverter = new ProfesionConverter();
var raceConverter = new RaceConverter();
var characterConverter = new CharacterConverter(genderConverter, professionConverter, raceConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <string>, ICollection <string> >(new ConverterAdapter <ICollection <string> >());
var responseConverter = new ResponseConverter <CharacterDTO, Character>(characterConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <CharacterDTO, string, Character>(characterConverter, c => c.Name);
var pageResponseConverter = new CollectionPageResponseConverter <CharacterDTO, Character>(characterConverter);
return(new CharacterRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
public void ThrowImgurExceptionIfResponseIsInvalid_WithInvalidResponse_ThrowsImgurException()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
responseConverter.ThrowImgurExceptionIfResponseIsInvalid("x");
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("invalid", exception.Message);
}
public void ThrowImgurExceptionIfResponseDataContainsRawError_WithRawError_ThrowsImgurException()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
responseConverter.ThrowImgurExceptionIfResponseContainsRawError(Mocks.MockResponses.RawError);
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("An error occurred", exception.Message);
}
public void ThrowImgurExceptionIfResponseDataContainsErrorMessage_WithErrorMessage_ThrowsImgurException()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
responseConverter.ThrowImgurExceptionIfResponseContainsErrorMessage(Mocks.MockResponses.ErrorMessage);
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("Could not complete request", exception.Message);
}
public void ThrowImgurExceptionIfResponseNotSuccess_WithUnsuccessfulMessage_ThrowsImgurException()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
responseConverter.ThrowImgurExceptionIfResponseNotSuccess(Mocks.MockResponses.Error);
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("Imgur is over capacity", exception.Message);
}
public void ThrowImgurExceptionIfResponseIsNull_WithNullResponse_ThrowsImgurException()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
responseConverter.ThrowImgurExceptionIfResponseIsNull(null);
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("missing", exception.Message);
}
public void ConvertResponse_WithGetTokenResponseError_ReturnsOAuth2Token()
{
var responseConverter = new ResponseConverter();
var exception = Record.Exception(() =>
{
return(responseConverter.ConvertOAuth2TokenResponse(Mocks.MockOAuth2Responses.GetTokenResponseError));
});
Assert.NotNull(exception);
Assert.IsType <ImgurException>(exception);
Assert.Contains("Refresh token", exception.Message);
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override ISkinRepository ForDefaultCulture()
{
var skinConverterFactory = new SkinConverterFactory();
var itemRestrictionCollectionConverter = new ItemRestrictionCollectionConverter(new ItemRestrictionConverter());
var skinFlagCollectionConverter = new SkinFlagCollectionConverter(new SkinFlagConverter());
var skinConverter = new SkinConverter(skinConverterFactory, itemRestrictionCollectionConverter, skinFlagCollectionConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <int>, ICollection <int> >(new ConverterAdapter <ICollection <int> >());
var responseConverter = new ResponseConverter <SkinDTO, Skin>(skinConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <SkinDTO, int, Skin>(skinConverter, skin => skin.SkinId);
var pageResponseConverter = new CollectionPageResponseConverter <SkinDTO, Skin>(skinConverter);
return(new SkinRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
