public Api(string accessToken)
{
_accessToken = accessToken;
_uri = @"https://api.telegram.org/bot" + _accessToken + "/";
_fileUri = @"https://api.telegram.org/file/bot" + _accessToken + "/";
_responseParser = new ResponseParser();
}
public static ServerInfoResult Parse(byte[] data)
{
var parser = new ResponseParser(data);
parser.CurrentPosition += 5; //Header
var result = new ServerInfoResult();
result.Protocol = parser.GetByte();
result.Name = parser.GetStringToTermination();
result.Map = parser.GetStringToTermination();
result.Folder = parser.GetStringToTermination();
result.Game = parser.GetStringToTermination();
result.ID = parser.GetShort();
result.Players = parser.GetByte();
result.MaxPlayers = parser.GetByte();
result.Bots = parser.GetByte();
result.ServerType = parser.GetStringOfByte();
result.Environment = parser.GetStringOfByte();
result.Visibility = parser.GetByte();
result.VAC = parser.GetByte();
result.Version = parser.GetStringToTermination();
//get EDF
uint edf = parser.GetByte();
if ((edf & 0x80) != 0) //has port number
{
result.Port = parser.GetShort();
}
return result;
}
public void can_deserialise_response_user_cards()
{
var xmlParser = new ResponseParser<AddCard>();
var deserializedCards = xmlParser.Parse(response);
Assert.That(deserializedCards, Is.Not.Null);
}
public void can_deserialise_response_user_cards()
{
var xmlParser = new ResponseParser(new ApiResponseDetector());
var deserializedCards = xmlParser.Parse<AddCard>(response);
Assert.That(deserializedCards, Is.Not.Null);
}
public void SubscribeReplyExtranonceCanHaveDifferentLengths(string dummyReply, string sessionId, byte[] extraNonce1, int extraNonce2sz)
{
var uglee = JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JArray>(dummyReply);
var response = ResponseParser.MiningSubscribe(uglee);
Assert.Equal(sessionId, response.sessionId);
Assert.Equal(extraNonce1, response.extraNonceOne);
Assert.Equal(extraNonce2sz, response.extraNonceTwoByteCount);
}
public void ReaderNextEntityWithRootEntityWrongName()
{
MemoryStream input = new MemoryStream(UTF8Encoding.UTF8.GetBytes(Properties.Resources.ResponseWithBlob));
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(input, XmlDictionaryReaderQuotas.Max);
ResponseParser<Z> parser = new ResponseParser<Z>();
Z mapStudioFile = parser.ReadNextEntity(reader);
}
public async Task ParseTokenResponse_post_binding_sp_initiated()
{
//ARRANGE
var inResponseTo = Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponseSuccess(inResponseTo, StatusCodes.Success);
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var xmlSignatureManager = new XmlSignatureManager();
var document = new XmlDocument();
document.LoadXml(serialised);
var cert = AssertionFactroryMock.GetMockCertificate();
xmlSignatureManager.SignXml(document, response.ID, cert.PrivateKey, null);
var base64Encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(document.DocumentElement.OuterXml));
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser;
var relayState = await relayStateSerialiser.Serialize(new Dictionary <string, object> {
{ "Key", "Value" }
});
var form = new SAMLForm();
form.SetResponse(base64Encoded);
form.SetRelatState(relayState);
Func <Type, IMetadataHandler> metadataHandlerFactory = t => new MetadataEntitityDescriptorHandler();
var certManager = new CertificateManager(logger);
var signatureManager = new XmlSignatureManager();
Func <IEnumerable <ResponseValidationRule> > rulesResolver = () => new[] { new ResponseSignatureRule(logger, certManager, signatureManager) };
var validator = new Federation.Protocols.Response.Validation.ResponseValidator(logger, new RuleFactory(rulesResolver));
var configurationRetrieverMock = new ConfigurationRetrieverMock();
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configurationManger = new ConfigurationManager <MetadataBase>(federationPartyContextBuilderMock, configurationRetrieverMock);
var relayStateHandler = new RelayStateHandler(relayStateSerialiser, logger);
var responseParser = new ResponseParser(metadataHandlerFactory, t => new SamlTokenResponseParser(logger),
configurationManger, relayStateHandler, logger, validator);
var postBindingDecoder = new PostBindingDecoder(logger);
var message = await postBindingDecoder.Decode(form.HiddenControls.ToDictionary(k => k.Key, v => v.Value));
var context = new SamlInboundContext
{
Message = message,
DescriptorResolver = m => metadataHandlerFactory(typeof(object)).GetIdentityProviderSingleSignOnDescriptor(m).Single().Roles.Single()
};
//ACT
var result = await responseParser.Parse(context);
//ASSERT
Assert.IsTrue(result.IsValidated);
}
public void ErrorResponse_Deserialization_ThrowsApplicationException()
{
var messageContents = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<Response>
<Status>ERROR</Status>
<ErrorDescription>A detailed explanation of the error</ErrorDescription>
</Response>";
Assert.Throws <ApplicationException>(() => ResponseParser.Deserialize <ErrorResponse>(messageContents));
}
public List <SimpleMessage> listReceivedSMS()
{
this.validateAccountAndPassword();
base.ContentType = BaseServiceSending.CONTENT_TYPE_APP_URLENCODED;
StringBuilder parameters = getParameters();
Stream stream = sendMoRequest(parameters.ToString());
List <SimpleMessage> messages = ResponseParser.getMessagesFromStream(stream);
return(messages);
}
public void ShouldRiseErrorIfLeverageBelowZero()
{
var parameters = "--open 1.2 --close 2 --volume 1.5 --contract-size 100000 --leverage -2";
var response = ResponseParser.Parse(new FileStarter().LaunchProcess(parameters));
Assert.That(response[0].Errors.Count == 1, "wrong errors count");
Assert.That(response[0].Errors[0].Contains("Leverage must be greater than 0"),
"Wrong error: " + response[0].Errors[0]);
}
static bool CheckCertificate(IOcesCertificate certificate)
{
var environment = RootCertificates.GetEnvironment(certificate.IssuingCa);
string serverUrl = certificate.OcspUrl;
var reqAndId = RequestGenerator.CreateOcspRequest(certificate);
OcspResp resp = Requester.Send(reqAndId.Request, serverUrl);
return(ResponseParser.CertificateIsValid(reqAndId.Id, resp, certificate));
}
public void CanImplicitlyDeserializeHelloMessage()
{
var messageContent = @"{""type"":""hello""}";
var parser = new ResponseParser();
var result = parser.DeserializeEvent(messageContent) as Hello;
Assert.NotNull(result);
Assert.Equal(EventType.Hello, result.Type);
}
public void ExtractFlights_ShouldReturnFlights_WhenHtmlContainsData()
{
var path =
@"C:\dev\projects\perso\app1\ConsoleApplication2\TestProject1\Files\InboundFlight.html";
var fileInfo = new FileInfo(path);
var res = new ResponseParser(fileInfo).ExtractFlights();
Assert.That(res[0].Number, Is.EqualTo("TO4011"));
Assert.That(res[1].Number, Is.EqualTo("HV5193"));
}
public void Test1(string response, int processed, int failed, int total, decimal secondsSpent)
{
var parser = new ResponseParser();
var parsed = parser.Parse(response);
Assert.Equal(processed, parsed.Processed);
Assert.Equal(failed, parsed.Failed);
Assert.Equal(secondsSpent, parsed.SecondsSpent);
Assert.Equal(total, parsed.Total);
}
public void ParsingGoodSubscribeReply(string dummyReply, string sessionId, byte[] extraNonce1, int extraNonce2sz)
{
// That's how it comes out from the parsing. I don't like it at all but that's it.
var uglee = JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JArray>(dummyReply);
var response = ResponseParser.MiningSubscribe(uglee);
Assert.Equal(sessionId, response.sessionId);
Assert.Equal(extraNonce1, response.extraNonceOne);
Assert.Equal(extraNonce2sz, response.extraNonceTwoByteCount);
}
/// <summary>
/// List the parts of an incomplete large file upload.
/// </summary>
/// <param name="fileId"></param>
/// <param name="startPartNumber"></param>
/// <param name="maxPartCount"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2LargeFileParts> ListPartsForIncompleteFile(string fileId, int startPartNumber, int maxPartCount, CancellationToken cancelToken = default(CancellationToken))
{
var request = LargeFileRequestGenerators.ListParts(_options, fileId, startPartNumber, maxPartCount);
// Send the request
var response = await _client.SendAsync(request, cancelToken);
// Create B2File from response
return(await ResponseParser.ParseResponse <B2LargeFileParts>(response, _api));
}
/// <summary>
/// Cancel a large file upload
/// </summary>
/// <param name="fileId"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2CancelledFile> CancelLargeFile(string fileId, CancellationToken cancelToken = default(CancellationToken))
{
var request = LargeFileRequestGenerators.Cancel(_options, fileId);
// Send the request
var response = await _client.SendAsync(request, cancelToken);
// Create B2File from response
return(await ResponseParser.ParseResponse <B2CancelledFile>(response, _api));
}
/// <summary>
/// Get an upload url for use with one Thread.
/// </summary>
/// <param name="bucketId"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2UploadPartUrl> GetUploadPartUrl(string fileId, CancellationToken cancelToken = default(CancellationToken))
{
var request = LargeFileRequestGenerators.GetUploadPartUrl(_options, fileId);
var uploadUrlResponse = await _client.SendAsync(request, cancelToken);
var uploadUrl = await ResponseParser.ParseResponse <B2UploadPartUrl>(uploadUrlResponse, _api);
return(uploadUrl);
}
/// <summary>
/// Downloads one file by providing the name of the bucket and the name of the file.
/// </summary>
/// <param name="fileId"></param>
/// <param name="fileName"></param>
/// <param name="bucketId"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2File> FinishLargeFile(string fileId, string[] partSHA1Array, CancellationToken cancelToken = default(CancellationToken))
{
var request = LargeFileRequestGenerators.Finish(_options, fileId, partSHA1Array);
// Send the request
var response = await _client.SendAsync(request, cancelToken);
// Create B2File from response
return(await ResponseParser.ParseResponse <B2File>(response, _api));
}
public void should_deserialize_emtpy_release_type_to_unknown()
{
var responseXml = File.ReadAllText("StubResponses/ArtistReleases.xml");
var response = new Response(HttpStatusCode.OK, responseXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var release = xmlParser.Parse <ArtistReleases>(response).Releases.First();
Assert.That(release.Type, Is.EqualTo(ReleaseType.Unknown));
}
/// <summary>
/// List all the incomplete large file uploads for the supplied bucket
/// </summary>
/// <param name="bucketId"></param>
/// <param name="startFileId"></param>
/// <param name="maxFileCount"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2IncompleteLargeFiles> ListIncompleteFiles(string bucketId, string startFileId = "", string maxFileCount = "", CancellationToken cancelToken = default(CancellationToken))
{
var request = LargeFileRequestGenerators.IncompleteFiles(_options, bucketId, startFileId, maxFileCount);
// Send the request
var response = await _client.SendAsync(request, cancelToken);
// Create B2File from response
return(await ResponseParser.ParseResponse <B2IncompleteLargeFiles>(response, _api));
}
public void should_deserialize_emtpy_release_type_to_unknown()
{
var responseXml = File.ReadAllText("StubResponses/ArtistReleases.xml");
var response = new Response(HttpStatusCode.OK, responseXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var release = xmlParser.Parse<ArtistReleases>(response).Releases.First();
Assert.That(release.Type,Is.EqualTo(ReleaseType.Unknown));
}
public void CanImplicitlyDeserializeHelloMessage()
{
var messageContent = @"{""type"":""hello""}";
var parser = new ResponseParser();
var result = parser.DeserializeEvent(messageContent) as Hello;
Assert.NotNull(result);
Assert.Equal(EventType.Hello, result.Type);
}
public void ParseNotificationMultiple()
{
var r = (FsResult <IEnumerable <FsNotification> >)ResponseParser.Parse(Verb.GetNotify, null, Xml.NotificationMultiple);
Assert.IsTrue(r.Succeeded);
Assert.AreEqual(2, r.Value.Count());
Assert.AreEqual("netremote.play.info.name", r.Value.ElementAt(0).Name);
Assert.AreEqual("Lounge FM Vienna", r.Value.ElementAt(0).GetValue <string>());
Assert.AreEqual("netremote.play.info.text", r.Value.ElementAt(1).Name);
Assert.AreEqual("Coralie Clément - L'Ombre Et La Lumiere", r.Value.ElementAt(1).GetValue <string>());
}
public void Can_Deserialise_ok_response_without_body__as_DeleteCard()
{
const string ResponseXml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><response status=\"ok\" version=\"1.2\" />";
var response = new Response(HttpStatusCode.OK, ResponseXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var result = xmlParser.Parse<DeleteCard>(response);
Assert.That(result, Is.Not.Null);
}
public virtual IJob HandleResponse(IMpdResponse response)
{
if (response.IsErrorResponse)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetJobInformation());
}
public ISticker HandleResponse(IMpdResponse response)
{
if (response.IsErrorResponse)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetListedSticker(Path, StickerType).FirstOrDefault());
}
public virtual IEnumerable <ISticker> HandleResponse(IMpdResponse response)
{
if (response.IsErrorResponse)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetListedSticker(Path, StickerType));
}
public void can_deseralize_card_types()
{
var xmlParser = new ResponseParser(new ApiResponseDetector());
var result = xmlParser.Parse<PaymentCardTypes>(stubResponse);
Assert.That(result.CardTypes.Count(),Is.EqualTo(4));
var lastCard = result.CardTypes.Last();
Assert.That(lastCard.Type, Is.EqualTo("American Express"));
Assert.That(lastCard.Id, Is.EqualTo("AMEX"));
}
public virtual IEnumerable <string> HandleResponse(IMpdResponse response)
{
if (response.IsErrorResponse)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetValueList(Key));
}
/// <summary>
/// Handles the response and returns an item DTO or null if none is found
/// </summary>
/// <param name="response">MPD response</param>
/// <returns>item DTO with metadata</returns>
public IItem HandleResponse(IMpdResponse response)
{
if (!response.HasContent)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetListedTracks().ToList().FirstOrDefault());
}
private List <NotificationTrigger> GetNotificationTriggersInternal(int objectId, CancellationToken token)
{
var xmlResponse = ObjectEngine.GetObjectsXml(new NotificationTriggerParameters(objectId), token: token);
var parsed = ResponseParser.ParseNotificationTriggerResponse(objectId, xmlResponse);
UpdateTriggerChannels(parsed, token);
UpdateTriggerActions(parsed, token);
return(parsed);
}
public JsonRpcClient Build()
{
IJsonConverter jsonConverter = new JsonConverter();
IRequestComposer requestComposer = new RequestComposer(new RequestFactory(), jsonConverter);
IResponseParser responseParser = new ResponseParser(jsonConverter);
INotificationHandler notificationHandler = new NotificationHandler(responseParser, _notificationBaseType);
IResultHandler resultHandler = new ResultHandler(responseParser, _logger);
IReceiverHandler receiverHandler = new ReceiverHandler(_connection, responseParser, notificationHandler, resultHandler);
return(new JsonRpcClient(_connection, requestComposer, resultHandler, notificationHandler));
}
public IEnumerable <IPlaylist> HandleResponse(IMpdResponse response)
{
if (response.HasContent)
{
return(null);
}
var parser = new ResponseParser(response);
return(parser.GetListedPlaylists());
}
private async Task UpdateTriggerActionsAsync(List <NotificationTrigger> triggers, CancellationToken token)
{
var actions = ResponseParser.GroupTriggerActions(triggers);
var parameters = new NotificationActionParameters(actions.Select(a => a.Key).ToArray());
var tasks = actions.Select(g => GetNotificationActionPropertiesAsync(g.Key, token));
var normal = await ObjectEngine.GetObjectsXmlAsync(parameters, token : token).ConfigureAwait(false);
//All the properties of all desired notifications
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
//For each different notification action
for (int i = 0; i < actions.Count; i++)
{
var xDoc = RequestParser.ExtractActionXml(normal, results[i], actions[i].Key);
//Foreach notification action with the same ID
foreach (var action in actions[i])
{
action.LazyXml = new Lazy <XDocument>(() => xDoc);
}
}
var list = ResponseParser.GroupActionSchedules(actions.SelectMany(g => g).ToList()).ToList();
List <Schedule> schedules = new List <Schedule>();
if (list.Count > 0)
{
schedules = await GetSchedulesAsync(Property.Id, list.Select(l => l.Key).ToArray(), token).ConfigureAwait(false);
}
foreach (var group in actions)
{
foreach (var action in group)
{
if (action.lazyScheduleStr != null)
{
var id = PrtgObject.GetId(action.lazyScheduleStr);
if (id != -1)
{
action.schedule = new Lazy <Schedule>(() => schedules.First(s => s.Id == id));
}
else
{
action.schedule = new Lazy <Schedule>(() => new Schedule(action.lazyScheduleStr));
}
}
}
}
}
public int HandleResponse(IMpdResponse response)
{
if (response.IsErrorResponse)
{
return(0);
}
var parser = new ResponseParser(response);
return(parser.GetItemId());
}
public void Can_Deserialise_ok_response_without_body__as_DeleteCard()
{
const string ResponseXml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><response status=\"ok\" version=\"1.2\" />";
var response = new Response(HttpStatusCode.OK, ResponseXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var result = xmlParser.Parse <DeleteCard>(response);
Assert.That(result, Is.Not.Null);
}
/// <summary>
/// Update an existing bucket. bucketId is only optional if you are persisting a bucket for this client.
/// </summary>
/// <param name="bucketType"></param>
/// <param name="bucketId"></param>
/// <param name="cancelToken"></param>
/// <returns></returns>
public async Task <B2Bucket> Update(BucketTypes bucketType, string bucketId = "", CancellationToken cancelToken = default(CancellationToken))
{
var operationalBucketId = Utilities.DetermineBucketId(_options, bucketId);
var client = HttpClientFactory.CreateHttpClient();
var requestMessage = BucketRequestGenerators.UpdateBucket(_options, operationalBucketId, bucketType.ToString());
var response = await client.SendAsync(requestMessage, cancelToken);
return(await ResponseParser.ParseResponse <B2Bucket>(response));
}
public async Task <List <B2Bucket> > GetList(CancellationToken cancelToken = default(CancellationToken))
{
var client = HttpClientFactory.CreateHttpClient();
var requestMessage = BucketRequestGenerators.GetBucketList(_options);
var response = await client.SendAsync(requestMessage, cancelToken);
var bucketList = ResponseParser.ParseResponse <B2BucketListDeserializeModel>(response).Result;
return(bucketList.Buckets);
}
public void CanImplicitlyDeserializeMeMessage()
{
var messageContent = @"{""type"":""message"",""subtype"":""me_message""}";
var parser = new ResponseParser();
var result = parser.DeserializeEvent(messageContent) as MeMessage;
Assert.NotNull(result);
Assert.Equal(EventType.Message, result.Type);
Assert.Equal(MessageSubType.MeMessage, result.Subtype);
}
public void CanDeserializeEventWithExtraData()
{
var messageContent = @"{""type"":""message"",""subtype"":""me_message"",""something"":""extra""}";
var parser = new ResponseParser();
var result = parser.Deserialize<MeMessage>(messageContent);
Assert.NotNull(result);
Assert.Equal(EventType.Message, result.Type);
Assert.Equal(MessageSubType.MeMessage, result.Subtype);
Assert.Equal("extra", result.UnmatchedAdditionalJsonData["something"]);
}
public async void SetUp()
{
var requestBuilder = A.Fake<IRequestBuilder>();
var httpClient = A.Fake<IHttpClient>();
var responseParser = new ResponseParser(new ApiResponseDetector());
var responseXml = File.ReadAllText("StubResponses/Playlists.xml");
var validPlaylistsResponse = new Response(HttpStatusCode.OK, responseXml);
A.CallTo(() => httpClient.Send(null)).WithAnyArguments().Returns(Task.FromResult(validPlaylistsResponse));
var fluentApi = new FluentApi<UserPlaylists>(httpClient, requestBuilder, responseParser);
_userPlaylists = await fluentApi.Please();
}
public void Can_deserialize_object_without_xml_declaration()
{
const string xml = "<response status=\"ok\"><testObject id=\"1\"> <name>A big test object</name><listOfThings><string>one</string><string>two</string><string>three</string></listOfThings><listOfInnerObjects><InnerObject id=\"1\"><Name>Trevor</Name></InnerObject><InnerObject id=\"2\"><Name>Bill</Name></InnerObject></listOfInnerObjects></testObject></response>";
var stubResponse = new Response(HttpStatusCode.OK, xml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
Assert.DoesNotThrow(() => xmlParser.Parse<TestObject>(stubResponse));
var testObject = xmlParser.Parse<TestObject>(stubResponse);
Assert.That(testObject.Id, Is.EqualTo(1));
}
public void ReadNextEntityBlob()
{
MemoryStream input = new MemoryStream(UTF8Encoding.UTF8.GetBytes(Properties.Resources.ResponseWithBlob));
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(input, XmlDictionaryReaderQuotas.Max);
ResponseParser<MapStudioFiles> parser = new ResponseParser<MapStudioFiles>();
MapStudioFiles mapStudioFile = parser.ReadNextEntity(reader);
Assert.AreEqual(3, mapStudioFile.SomeStringArray.Length);
Assert.AreEqual("item 1", mapStudioFile.SomeStringArray[0]);
Assert.AreEqual("item 2", mapStudioFile.SomeStringArray[1]);
Assert.AreEqual("last item", mapStudioFile.SomeStringArray[2]);
}
public void Should_throw_invalid_resource_exception_for_2001_error_code_with_ok_http_status_code()
{
const string errorXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error code=\"2001\"><errorMessage>Test error</errorMessage></error></response>";
var response = new Response(HttpStatusCode.OK, errorXml);
var xmlParser = new ResponseParser<TestObject>();
var ex = Assert.Throws<InvalidResourceException>(() => xmlParser.Parse(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.ResponseBody, Is.EqualTo(errorXml));
Assert.That(ex.Message, Is.EqualTo("Test error"));
Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.ResourceNotFound));
}
public void Should_throw_input_parameter_exception_for_1001_error_code_with_error_http_status_code()
{
const string errorXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error code=\"1001\"><errorMessage>Test error</errorMessage></error></response>";
var response = new Response(HttpStatusCode.InternalServerError, errorXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<InputParameterException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.ResponseBody, Is.EqualTo(errorXml));
Assert.That(ex.Message, Is.EqualTo("Test error"));
Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.RequiredParameterMissing));
}
public void Can_deserialize_object()
{
const string xml = "<?xml version=\"1.0\"?><response xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" status=\"ok\"><testObject id=\"1\"> <name>A big test object</name><listOfThings><string>one</string><string>two</string><string>three</string></listOfThings><listOfInnerObjects><InnerObject id=\"1\"><Name>Trevor</Name></InnerObject><InnerObject id=\"2\"><Name>Bill</Name></InnerObject></listOfInnerObjects></testObject></response>";
var stubResponse = new Response(HttpStatusCode.OK, xml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
Assert.DoesNotThrow(() => xmlParser.Parse<TestObject>(stubResponse));
var testObject = xmlParser.Parse<TestObject>(stubResponse);
Assert.That(testObject.Id, Is.EqualTo(1));
}
public void can_deserialise_response_user_cards()
{
var xmlParser = new ResponseParser(new ApiResponseDetector());
var deserializedCards = xmlParser.Parse<Cards>(response);
var firstCard = deserializedCards.UserCards[0];
Assert.That(deserializedCards.UserCards.Count(), Is.EqualTo(1));
Assert.That(firstCard.Id, Is.EqualTo(8154430));
Assert.That(firstCard.CardHolderName, Is.EqualTo("MR I HUNT"));
Assert.That(firstCard.Type, Is.EqualTo("Visa"));
Assert.That(firstCard.Last4Digits, Is.EqualTo("5485"));
Assert.That(firstCard.IsoTwoLetterCountryCode, Is.EqualTo("NZ"));
Assert.That(firstCard.ExpiryDate, Is.EqualTo("201202"));
Assert.That(firstCard.FormatedExpiryDate, Is.EqualTo(new DateTime(2012, 02, 29, 23, 59, 59, 999)));
}
public void Should_throw_exception_when_deserialize_with_missing_status()
{
const string MissingStatusXmlResponse = "<?xml version=\"1.0\"?><response version=\"1.2\"></response>";
var response = new Response(HttpStatusCode.OK, MissingStatusXmlResponse);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<UnrecognisedStatusException>(() => xmlParser.Parse<TestEmptyObject>(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.EqualTo(UnrecognisedStatusException.DEFAULT_ERROR_MESSAGE));
Assert.That(ex.ResponseBody, Is.EqualTo(MissingStatusXmlResponse));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Should_handle_plaintext_oauth_fail_with_ok_status()
{
const string ErrorText = "OAuth authentication error: Not found";
var response = new Response(HttpStatusCode.OK, ErrorText);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<OAuthException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.EqualTo(ErrorText));
Assert.That(ex.ResponseBody, Is.EqualTo(response.Body));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Should_throw_non_xml_response_exception_for_content_that_appears_XML_but_is_not()
{
const string badXml = @"<?xml version=""1.0"" encoding=""utf-8"" ?><response status=""ok"">LOL!</hah>";
var response = new Response(HttpStatusCode.OK, badXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<NonXmlResponseException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.EqualTo("Response is not xml"));
Assert.That(ex.ResponseBody, Is.EqualTo(badXml));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Should_throw_non_xml_response_exception_for_html_ok_response()
{
const string badXml = "<html><head>Error</head><body>Some random html page<br><hr></body></html>";
var response = new Response(HttpStatusCode.OK, badXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<NonXmlResponseException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.EqualTo("Response is not xml"));
Assert.That(ex.ResponseBody, Is.EqualTo(badXml));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Error_captures_http_status_code_from_html()
{
const string badXml = "<html><head>Error</head><body>It did not work<br><hr></body></html>";
var response = new Response(HttpStatusCode.InternalServerError, badXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<NonXmlResponseException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
}
public void Detects_html_as_not_xml()
{
const string badXml = "<html><head>Error</head><body>It did not work<br><hr></body></html>";
var response = new Response(HttpStatusCode.InternalServerError, badXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<NonXmlResponseException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex, Is.Not.Null);
Assert.That(ex.Message, Is.EqualTo("Response is not xml"));
Assert.That(ex.ResponseBody, Is.EqualTo(badXml));
}
public void Should_throw_unrecognised_error_exception_if_xml_is_missing_error_message()
{
const string validXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error code=\"123\"></error></response>";
var response = new Response(HttpStatusCode.OK, validXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<UnrecognisedErrorException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex.ResponseBody, Is.EqualTo(response.Body));
Assert.That(ex.Message, Is.EqualTo(UnrecognisedErrorException.DEFAULT_ERROR_MESSAGE));
}
public void SerializeValidMessage()
{
var message = new OutputMessage { Id = 1, Channel = "CHANID", Text = "MSG" };
var parser = new ResponseParser();
var result = parser.SerializeMessage(message);
var expected = @"{""id"":1,""type"":""message"",""channel"":""CHANID"",""text"":""MSG""}";
Assert.Equal(expected, result);
}
public void Should_throw_unrecognised_error_exception_for_error_code_out_of_range_with_ok_http_status_code()
{
const string errorXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><response status=\"error\" version=\"1.2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://api.7digital.com/1.2/static/7digitalAPI.xsd\" ><error code=\"42\"><errorMessage>Test error</errorMessage></error></response>";
var response = new Response(HttpStatusCode.OK, errorXml);
var xmlParser = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<UnrecognisedErrorException>(() => xmlParser.Parse<TestObject>(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.ResponseBody, Is.EqualTo(errorXml));
Assert.That(ex.Message, Is.EqualTo("Test error"));
}
public void Should_throw_argument_null_exception_when_reponse_is_null()
{
var apiXmlDeserializer = new ResponseParser(new ApiResponseDetector());
Assert.Throws<ArgumentNullException>(() => apiXmlDeserializer.Parse<TestObject>(null));
}
public void Should_throw_non_xml_response_exception_when_response_body_is_empty()
{
var response = new Response(HttpStatusCode.OK, string.Empty);
var xmlSerializer = new ResponseParser(new ApiResponseDetector());
var ex = Assert.Throws<NonXmlResponseException>(() => xmlSerializer.Parse<TestObject>(response));
Assert.That(ex.StatusCode, Is.EqualTo(response.StatusCode));
Assert.That(ex.ResponseBody, Is.Empty);
}
public void ShouldRemapMessagesToConcreteTypes()
{
var meMessage = new MeMessage
{
Type = EventType.Message,
Subtype = MessageSubType.MeMessage,
Text = "me",
Team = "team1"
};
var topicMessage = new ChannelTopic
{
Type = EventType.Message,
Subtype = MessageSubType.ChannelTopic,
Topic = "topic"
};
var plainMessage = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "text"
};
var parser = new ResponseParser();
var messages = new List<MessageBase>
{
parser.Deserialize<MessageBase>(parser.SerializeMessage(meMessage)),
parser.Deserialize<MessageBase>(parser.SerializeMessage(topicMessage)),
parser.Deserialize<MessageBase>(parser.SerializeMessage(plainMessage))
};
var concreteMessages = parser.RemapMessagesToConcreteTypes(messages).ToList();
Assert.IsType<MeMessage>(concreteMessages[0]);
Assert.IsType<ChannelTopic>(concreteMessages[1]);
Assert.IsType<PlainMessage>(concreteMessages[2]);
Assert.Equal(EventType.Message, concreteMessages[0].Type);
Assert.Equal(MessageSubType.MeMessage, concreteMessages[0].Subtype);
Assert.Equal("me", concreteMessages[0].Text);
Assert.Equal("team1", concreteMessages[0].Team);
Assert.Equal(EventType.Message, concreteMessages[1].Type);
Assert.Equal("topic", ((ChannelTopic)concreteMessages[1]).Topic);
}
