/// <summary>
/// Gets a custom exception that wraps the SOAP exception thrown
/// by the server.
/// </summary>
/// <param name="ex">SOAPException that was thrown by the server.</param>
/// <returns>A custom exception object that wraps the SOAP exception.
/// </returns>
protected override Exception GetCustomException(SoapException exception)
{
string defaultNs = GetDefaultNamespace();
if (!string.IsNullOrEmpty(defaultNs) && exception.Detail != null)
{
// Extract the ApiExceptionFault node.
XmlElement faultNode = GetFaultNode(exception, defaultNs, "ApiExceptionFault");
if (faultNode != null)
{
try {
AdWordsApiException awapiException = new AdWordsApiException(
SerializationUtilities.DeserializeFromXmlTextCustomRootNs(
faultNode.OuterXml, Assembly.GetExecutingAssembly().GetType(
this.GetType().Namespace + ".ApiException"), defaultNs, "ApiExceptionFault"),
AdWordsErrorMessages.AnApiExceptionOccurred, exception);
if (AdWordsErrorHandler.IsOAuthTokenExpiredError(awapiException))
{
return(new AdWordsCredentialsExpiredException(
(string)ContextStore.GetValue("OAuthHeader")));
}
else
{
return(awapiException);
}
} catch (Exception) {
// deserialization failed, but we can safely ignore it.
}
}
}
return(new AdWordsApiException(null, AdWordsErrorMessages.AnApiExceptionOccurred, exception));
}
/// <summary>
/// Handles the message.
/// </summary>
/// <param name="soapMessage">The SOAP message.</param>
/// <param name="service">The service.</param>
/// <param name="direction">The direction.</param>
public void HandleMessage(XmlDocument soapMessage, AdsClient service,
SoapMessageDirection direction)
{
XmlNamespaceManager xmlnt = new XmlNamespaceManager(soapMessage.NameTable);
xmlnt.AddNamespace(SOAP_PREFIX, SOAP_NAMESPACE);
if (direction == SoapMessageDirection.OUT)
{
UserToken token = (UserToken)ContextStore.GetValue("Token");
RequestHeader requestHeader = (RequestHeader)ContextStore.GetValue("RequestHeader");
if (token != null || requestHeader != null)
{
XmlElement soapHeader = GetSoapHeaderNode(soapMessage, xmlnt, true);
if (token != null)
{
AddSecurityHeader(soapHeader, token);
}
if (requestHeader != null)
{
AddRequestHeader(soapHeader, requestHeader);
}
}
}
else
{
ContextStore.AddKey("ResponseHeader", ParseResponseHeader(soapMessage, xmlnt));
}
}
/// <summary>
/// Handles the SOAP message.
/// </summary>
/// <param name="soapMessage">The SOAP message.</param>
/// <param name="service">The SOAP service.</param>
/// <param name="direction">The direction of message.</param>
public void HandleMessage(XmlDocument soapMessage, AdsClient service,
SoapMessageDirection direction)
{
if (direction == SoapMessageDirection.IN)
{
AdWordsUser user = service.User as AdWordsUser;
string methodName = (string)ContextStore.GetValue("SoapMethod");
RecordApiOperationCount(user, service, methodName, GetApiUnitsForCall(soapMessage));
}
}
/// <summary>
/// Cleans up the service after MakeApiCall.
/// </summary>
/// <param name="methodName">Name of the method.</param>
/// <param name="parameters">The method parameters.</param>
protected override void CleanupAfterCall(string methodName, object[] parameters)
{
this.ResponseHeader = (ResponseHeader)ContextStore.GetValue("ResponseHeader");
ContextStore.RemoveKey("OAuthHeader");
ContextStore.RemoveKey("RequestHeader");
ContextStore.RemoveKey("ResponseHeader");
ContextStore.RemoveKey("Token");
base.CleanupAfterCall(methodName, parameters);
}
/// <summary>
/// Creates a WebRequest instance for the specified url.
/// </summary>
/// <param name="uri">The Uri to use when creating the WebRequest.</param>
/// <returns>
/// The WebRequest instance.
/// </returns>
protected override WebRequest GetWebRequest(Uri uri)
{
WebRequest request = base.GetWebRequest(uri);
string oAuthHeader = (string)ContextStore.GetValue("OAuthHeader");
if (!string.IsNullOrEmpty(oAuthHeader))
{
request.Headers["Authorization"] = oAuthHeader;
}
return(request);
}
public void TestCleanupAfterCall()
{
listener = new MockTraceListener(config);
ContextStore.AddKey("SoapRequest", "SoapRequest");
ContextStore.AddKey("SoapResponse", "SoapResponse");
ContextStore.AddKey("FormattedSoapLog", "FormattedSoapLog");
ContextStore.AddKey("FormattedRequestLog", "FormattedRequestLog");
listener.CleanupAfterCall();
Assert.Null(ContextStore.GetValue("SoapRequest"));
Assert.Null(ContextStore.GetValue("SoapResponse"));
Assert.Null(ContextStore.GetValue("FormattedSoapLog"));
Assert.Null(ContextStore.GetValue("FormattedRequestLog"));
}
/// <summary>
/// Handles the SOAP message.
/// </summary>
/// <param name="soapMessage">The SOAP message.</param>
/// <param name="service">The SOAP service.</param>
/// <param name="direction">The direction of message.</param>
public void HandleMessage(XmlDocument soapMessage, AdsClient service,
SoapMessageDirection direction)
{
if (direction == SoapMessageDirection.OUT)
{
ContextStore.AddKey("SoapRequest", soapMessage.OuterXml);
}
else
{
ContextStore.AddKey("SoapResponse", soapMessage.OuterXml);
}
if (direction == SoapMessageDirection.IN)
{
PerformLogging(service, (string)ContextStore.GetValue("SoapRequest"),
(string)ContextStore.GetValue("SoapResponse"));
}
}
public void TestHandleMessageNoClient()
{
config.SetPropertyFieldForTests("MaskCredentials", true);
listener = new MockTraceListener(config);
XmlDocument xOutgoing = XmlUtilities.CreateDocument(Resources.XmlRequest);
listener.HandleMessage(xOutgoing, null, SoapMessageDirection.OUT);
Assert.AreEqual(xOutgoing.OuterXml, ContextStore.GetValue("SoapRequest"));
XmlDocument xIncoming = XmlUtilities.CreateDocument(Resources.XmlResponse);
listener.HandleMessage(xIncoming, null, SoapMessageDirection.IN);
Assert.AreEqual(xIncoming.OuterXml, ContextStore.GetValue("SoapResponse"));
Assert.IsNull(ContextStore.GetValue("FormattedSoapLog"));
Assert.IsNull(ContextStore.GetValue("FormattedRequestLog"));
}
/// <summary>
/// Deserialize the object from xml.
/// </summary>
/// <param name="reader">The xml reader for reading the serialized xml.
/// </param>
public override void ReadXml(XmlReader reader)
{
object service = ContextStore.GetValue("SoapService");
if (service != null)
{
PropertyInfo propInfo = service.GetType().GetProperty("RequestHeader");
if (propInfo != null)
{
RequestHeader reqHeader = (RequestHeader)propInfo.GetValue(service, null);
if (reqHeader != null)
{
// When deserializing, namespace is not relevant, just the version
// is.
this.Version = reqHeader.Version;
}
}
}
base.ReadXml(reader);
}
public void TestHandleMessage()
{
config.SetPropertyFieldForTests("MaskCredentials", true);
listener = new MockTraceListener(config);
XmlDocument xOutgoing = new XmlDocument();
xOutgoing.LoadXml(Resources.XmlRequest);
listener.HandleMessage(xOutgoing, adsClient, SoapMessageDirection.OUT);
Assert.AreEqual(xOutgoing.OuterXml, ContextStore.GetValue("SoapRequest"));
XmlDocument xIncoming = new XmlDocument();
xIncoming.LoadXml(Resources.XmlResponse);
listener.HandleMessage(xIncoming, adsClient, SoapMessageDirection.IN);
Assert.AreEqual(xIncoming.OuterXml, ContextStore.GetValue("SoapResponse"));
Assert.AreEqual(Resources.SoapLog.Replace("\r\n", "\n"),
((string)ContextStore.GetValue("FormattedSoapLog")).Replace("\r\n", "\n"));
Assert.AreEqual(Resources.ResponseLog.Replace("\r\n", "\n"),
((string)ContextStore.GetValue("FormattedRequestLog")).Replace("\r\n", "\n"));
}
public void TestHandleMessage()
{
config.SetPropertyFieldForTests("MaskCredentials", true);
listener = new MockTraceListener(config);
WebHeaderCollection requestHeaders = new WebHeaderCollection();
requestHeaders["TestRequestKey"] = "TestRequestValue";
RequestInfo request = new RequestInfo()
{
Body = Resources.XmlRequest,
Headers = requestHeaders,
Uri = new Uri("https://localhost"),
HttpMethod = "POST",
Service = TestServiceName
};
WebHeaderCollection responseHeaders = new WebHeaderCollection();
responseHeaders["TestResponseKey"] = "TestResponseValue";
ResponseInfo response = new ResponseInfo()
{
Body = Resources.XmlResponse,
Headers = responseHeaders,
StatusCode = HttpStatusCode.OK
};
listener.HandleMessage(request, response);
string expected = Resources.SoapLog.Replace("\r\n", "\n").Trim();
string actual = (ContextStore.GetValue("FormattedSoapLog").ToString())
.Replace("\r\n", "\n").Trim();
Assert.AreEqual(expected, actual);
expected = Resources.ResponseLog.Replace("\r\n", "\n").Trim();
actual = (ContextStore.GetValue("FormattedRequestLog").ToString())
.Replace("\r\n", "\n").Trim();
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Tests that a given request/response pair generate the expected summary and detail logs.
/// </summary>
/// <param name="requestBody">A sample request.</param>
/// <param name="responseBody">A sample response.</param>
/// <param name="expectedSummary">The expected summary log entry.</param>
/// <param name="expectedDetails">The expected detail log entry.</param>
private void TestResponseSummary(string requestBody, string responseBody,
string expectedSummary, string expectedDetails)
{
WebHeaderCollection requestHeaders = new WebHeaderCollection();
requestHeaders["TestRequestKey"] = "TestRequestValue";
RequestInfo request = new RequestInfo()
{
Body = requestBody,
Headers = requestHeaders,
Uri = new Uri("https://localhost"),
HttpMethod = "POST",
Service = TestServiceName
};
WebHeaderCollection responseHeaders = new WebHeaderCollection();
responseHeaders["TestResponseKey"] = "TestResponseValue";
ResponseInfo response = new ResponseInfo()
{
Body = responseBody,
Headers = responseHeaders,
StatusCode = HttpStatusCode.OK
};
listener.HandleMessage(request, response);
string expected = expectedSummary.Replace("\r\n", "\n").Trim();
string actual = (ContextStore.GetValue("FormattedRequestLog").ToString())
.Replace("\r\n", "\n").Trim();
Assert.AreEqual(expected, actual);
expected = expectedDetails.Replace("\r\n", "\n").Trim();
actual = (ContextStore.GetValue("FormattedSoapLog").ToString())
.Replace("\r\n", "\n").Trim();
Assert.AreEqual(expected, actual);
}
