public void SerializeDeserializeJson()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var message = GetStandardTestMessage(FieldFill.CompleteBeforeBindings);
var ms = new MemoryStream();
var writer = JsonReaderWriterFactory.CreateJsonWriter(ms, Encoding.UTF8);
MessageSerializer.Serialize(this.MessageDescriptions.GetAccessor(message), writer);
writer.Flush();
string actual = Encoding.UTF8.GetString(ms.ToArray());
string expected = @"{""age"":15,""Name"":""Andrew"",""Location"":""http:\/\/localtest\/path"",""Timestamp"":""2008-09-19T08:00:00Z""}";
Assert.AreEqual(expected, actual);
ms.Position = 0;
var deserialized = new Mocks.TestDirectedMessage();
var reader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max);
MessageSerializer.Deserialize(this.MessageDescriptions.GetAccessor(deserialized), reader);
Assert.AreEqual(message.Age, deserialized.Age);
Assert.AreEqual(message.EmptyMember, deserialized.EmptyMember);
Assert.AreEqual(message.Location, deserialized.Location);
Assert.AreEqual(message.Name, deserialized.Name);
Assert.AreEqual(message.Timestamp, deserialized.Timestamp);
}
public void DeserializeVerifyElementOrdering()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestDerivedMessage));
Dictionary <string, string> fields = new Dictionary <string, string>(StringComparer.Ordinal);
// We deliberately do this OUT of order,
// since DataContractSerializer demands elements to be in
// 1) inheritance then 2) alphabetical order.
// Proper xml element order would be: Name, age, Second..., TheFirst...
fields["TheFirstDerivedElement"] = "first";
fields["age"] = "15";
fields["Name"] = "Andrew";
fields["SecondDerivedElement"] = "second";
fields["explicit"] = "explicitValue";
fields["private"] = "privateValue";
var actual = new Mocks.TestDerivedMessage();
serializer.Deserialize(fields, this.MessageDescriptions.GetAccessor(actual));
Assert.AreEqual(15, actual.Age);
Assert.AreEqual("Andrew", actual.Name);
Assert.AreEqual("first", actual.TheFirstDerivedElement);
Assert.AreEqual("second", actual.SecondDerivedElement);
Assert.AreEqual("explicitValue", ((Mocks.IBaseMessageExplicitMembers)actual).ExplicitProperty);
Assert.AreEqual("privateValue", actual.PrivatePropertyAccessor);
}
/// <summary>
/// Serializes the <see cref="DataBag"/> instance to a buffer.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>The buffer containing the serialized data.</returns>
protected override byte[] SerializeCore(T message)
{
var fields = MessageSerializer.Get(message.GetType()).Serialize(MessageDescriptions.GetAccessor(message));
string value = MessagingUtilities.CreateQueryString(fields);
return(Encoding.UTF8.GetBytes(value));
}
public void DeserializeInvalidMessage()
{
IProtocolMessage message = new Mocks.TestDirectedMessage();
var serializer = MessageSerializer.Get(message.GetType());
var fields = GetStandardTestFields(FieldFill.AllRequired);
fields["age"] = "-1"; // Set an disallowed value.
serializer.Deserialize(fields, this.MessageDescriptions.GetAccessor(message));
}
/// <summary>
/// Deserializes the <see cref="DataBag"/> instance from a buffer.
/// </summary>
/// <param name="message">The message instance to initialize with data from the buffer.</param>
/// <param name="data">The data buffer.</param>
protected override void DeserializeCore(T message, byte[] data)
{
string value = Encoding.UTF8.GetString(data);
// Deserialize into message newly created instance.
var serializer = MessageSerializer.Get(message.GetType());
var fields = MessageDescriptions.GetAccessor(message);
serializer.Deserialize(HttpUtility.ParseQueryString(value).ToDictionary(), fields);
}
/// <summary>
/// Prepares a message for sending based on the rules of this channel binding element.
/// </summary>
/// <param name="message">The message to prepare for sending.</param>
/// <returns>
/// True if the <paramref name="message"/> applied to this binding element
/// and the operation was successful. False otherwise.
/// </returns>
/// <remarks>
/// Implementations that provide message protection must honor the
/// <see cref="MessagePartAttribute.RequiredProtection"/> properties where applicable.
/// </remarks>
public bool PrepareMessageForSending(IProtocolMessage message)
{
ErrorUtilities.VerifyArgumentNotNull(message, "message");
var extendableMessage = message as IProtocolMessageWithExtensions;
if (extendableMessage != null)
{
Protocol protocol = Protocol.Lookup(message.Version);
MessageDictionary baseMessageDictionary = new MessageDictionary(message);
// We have a helper class that will do all the heavy-lifting of organizing
// all the extensions, their aliases, and their parameters.
var extensionManager = ExtensionArgumentsManager.CreateOutgoingExtensions(protocol);
foreach (IExtensionMessage protocolExtension in extendableMessage.Extensions)
{
var extension = protocolExtension as IOpenIdMessageExtension;
if (extension != null)
{
// Give extensions that require custom serialization a chance to do their work.
var customSerializingExtension = extension as IMessageWithEvents;
if (customSerializingExtension != null)
{
customSerializingExtension.OnSending();
}
// OpenID 2.0 Section 12 forbids two extensions with the same TypeURI in the same message.
ErrorUtilities.VerifyProtocol(!extensionManager.ContainsExtension(extension.TypeUri), OpenIdStrings.ExtensionAlreadyAddedWithSameTypeURI, extension.TypeUri);
var extensionDictionary = MessageSerializer.Get(extension.GetType()).Serialize(extension);
extensionManager.AddExtensionArguments(extension.TypeUri, extensionDictionary);
}
else
{
Logger.WarnFormat("Unexpected extension type {0} did not implement {1}.", protocolExtension.GetType(), typeof(IOpenIdMessageExtension).Name);
}
}
// We use a cheap trick (for now at least) to determine whether the 'openid.' prefix
// belongs on the parameters by just looking at what other parameters do.
// Technically, direct message responses from Provider to Relying Party are the only
// messages that leave off the 'openid.' prefix.
bool includeOpenIdPrefix = baseMessageDictionary.Keys.Any(key => key.StartsWith(protocol.openid.Prefix, StringComparison.Ordinal));
// Add the extension parameters to the base message for transmission.
extendableMessage.AddExtraParameters(extensionManager.GetArgumentsToSend(includeOpenIdPrefix));
return(true);
}
return(false);
}
public void ParameterNames()
{
this.response.ErrorMessage = "Some Error";
this.response.Contact = "Andrew Arnott";
this.response.Reference = "http://blog.nerdbank.net/";
MessageSerializer serializer = MessageSerializer.Get(this.response.GetType());
var fields = this.MessageDescriptions.GetAccessor(this.response).Serialize();
Assert.AreEqual(Protocol.OpenId2Namespace, fields["ns"]);
Assert.AreEqual("Some Error", fields["error"]);
Assert.AreEqual("Andrew Arnott", fields["contact"]);
Assert.AreEqual("http://blog.nerdbank.net/", fields["reference"]);
}
public void DeserializeSimple()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
Dictionary <string, string> fields = new Dictionary <string, string>(StringComparer.Ordinal);
fields["Name"] = "Andrew";
fields["age"] = "15";
fields["Timestamp"] = "1990-01-01T00:00:00";
var actual = new Mocks.TestDirectedMessage();
serializer.Deserialize(fields, this.MessageDescriptions.GetAccessor(actual));
Assert.AreEqual(15, actual.Age);
Assert.AreEqual("Andrew", actual.Name);
Assert.AreEqual(DateTime.Parse("1/1/1990"), actual.Timestamp);
Assert.IsNull(actual.EmptyMember);
}
public void ParameterNames()
{
this.response.AssociationHandle = "HANDLE";
this.response.AssociationType = "HMAC-SHA1";
this.response.SessionType = "DH-SHA1";
this.response.ExpiresIn = 50;
MessageSerializer serializer = MessageSerializer.Get(this.response.GetType());
var fields = this.MessageDescriptions.GetAccessor(this.response).Serialize();
Assert.AreEqual(Protocol.OpenId2Namespace, fields["ns"]);
Assert.AreEqual("HANDLE", fields["assoc_handle"]);
Assert.AreEqual("HMAC-SHA1", fields["assoc_type"]);
Assert.AreEqual("DH-SHA1", fields["session_type"]);
Assert.AreEqual("50", fields["expires_in"]);
}
public void DeserializeWithExtraFields()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
Dictionary <string, string> fields = new Dictionary <string, string>(StringComparer.Ordinal);
fields["age"] = "15";
fields["Name"] = "Andrew";
fields["Timestamp"] = XmlConvert.ToString(DateTime.UtcNow, XmlDateTimeSerializationMode.Utc);
// Add some field that is not recognized by the class. This simulates a querystring with
// more parameters than are actually interesting to the protocol message.
fields["someExtraField"] = "asdf";
var actual = new Mocks.TestDirectedMessage();
serializer.Deserialize(fields, this.MessageDescriptions.GetAccessor(actual));
Assert.AreEqual(15, actual.Age);
Assert.AreEqual("Andrew", actual.Name);
Assert.IsNull(actual.EmptyMember);
}
internal static UnauthorizedTokenRequest CreateTestRequestTokenMessageNoOAuthVersion(MessageDescriptionCollection messageDescriptions, MessageReceivingEndpoint endpoint)
{
endpoint = endpoint ?? new MessageReceivingEndpoint("https://www.google.com/accounts/OAuthGetRequestToken", HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.GetRequest);
var parts = new Dictionary <string, string>();
parts["oauth_consumer_key"] = "nerdbank.org";
parts["oauth_timestamp"] = "1222665749";
parts["oauth_nonce"] = "fe4045a3f0efdd1e019fa8f8ae3f5c38";
parts["scope"] = "http://www.google.com/m8/feeds/";
parts["oauth_signature_method"] = "HMAC-SHA1";
parts["oauth_signature"] = "anything non-empty";
UnauthorizedTokenRequest message = new UnauthorizedTokenRequest(endpoint, Protocol.V10.Version);
MessageDictionary dictionary = messageDescriptions.GetAccessor(message);
MessageSerializer.Get(typeof(UnauthorizedTokenRequest)).Deserialize(parts, dictionary);
return(message);
}
public void SerializeTest()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var message = GetStandardTestMessage(FieldFill.CompleteBeforeBindings);
var expected = GetStandardTestFields(FieldFill.CompleteBeforeBindings);
IDictionary <string, string> actual = serializer.Serialize(this.MessageDescriptions.GetAccessor(message));
Assert.AreEqual(4, actual.Count);
// Test case sensitivity of generated dictionary
Assert.IsFalse(actual.ContainsKey("Age"));
Assert.IsTrue(actual.ContainsKey("age"));
// Test contents of dictionary
Assert.AreEqual(expected["age"], actual["age"]);
Assert.AreEqual(expected["Name"], actual["Name"]);
Assert.AreEqual(expected["Location"], actual["Location"]);
Assert.AreEqual(expected["Timestamp"], actual["Timestamp"]);
Assert.IsFalse(actual.ContainsKey("EmptyMember"));
}
/// <summary>
/// Queues a message for sending in the response stream where the fields
/// are sent in the response stream in querystring style.
/// </summary>
/// <param name="response">The message to send as a response.</param>
/// <returns>
/// The pending user agent redirect based message to be sent as an HttpResponse.
/// </returns>
/// <remarks>
/// This method implements spec V1.0 section 5.3.
/// </remarks>
protected override UserAgentResponse SendDirectMessageResponse(IProtocolMessage response)
{
ErrorUtilities.VerifyArgumentNotNull(response, "response");
var serializer = MessageSerializer.Get(response.GetType());
var fields = serializer.Serialize(response);
byte[] keyValueEncoding = KeyValueFormEncoding.GetBytes(fields);
UserAgentResponse preparedResponse = new UserAgentResponse();
preparedResponse.Headers.Add(HttpResponseHeader.ContentType, KeyValueFormContentType);
preparedResponse.OriginalMessage = response;
preparedResponse.ResponseStream = new MemoryStream(keyValueEncoding);
IHttpDirectResponse httpMessage = response as IHttpDirectResponse;
if (httpMessage != null)
{
preparedResponse.Status = httpMessage.HttpStatusCode;
}
return(preparedResponse);
}
/// <summary>
/// Queues a message for sending in the response stream where the fields
/// are sent in the response stream in querystring style.
/// </summary>
/// <param name="response">The message to send as a response.</param>
/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
/// <remarks>
/// This method implements spec V1.0 section 5.3.
/// </remarks>
protected override UserAgentResponse SendDirectMessageResponse(IProtocolMessage response)
{
ErrorUtilities.VerifyArgumentNotNull(response, "response");
MessageSerializer serializer = MessageSerializer.Get(response.GetType());
var fields = serializer.Serialize(response);
string responseBody = MessagingUtilities.CreateQueryString(fields);
UserAgentResponse encodedResponse = new UserAgentResponse {
Body = responseBody,
OriginalMessage = response,
Status = HttpStatusCode.OK,
Headers = new System.Net.WebHeaderCollection(),
};
IHttpDirectResponse httpMessage = response as IHttpDirectResponse;
if (httpMessage != null)
{
encodedResponse.Status = httpMessage.HttpStatusCode;
}
return(encodedResponse);
}
public void GetInvalidMessageType()
{
MessageSerializer.Get(typeof(string));
}
public void GetNullType()
{
MessageSerializer.Get(null);
}
public void DeserializeNull()
{
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
MessageSerializer.Deserialize(null, null);
}