1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
//-----------------------------------------------------------------------
// <copyright file="MessageSerializerTests.cs" company="Andrew Arnott">
// Copyright (c) Andrew Arnott. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
namespace DotNetOAuth.Test.Messaging {
using System;
using System.Collections.Generic;
using DotNetOAuth.Messaging;
using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// Tests for the <see cref="MessageSerializer"/> class.
/// </summary>
[TestClass()]
public class MessageSerializerTests : TestBase {
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void SerializeNull() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
serializer.Serialize(null);
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void SerializeNullFields() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
serializer.Serialize(null, new Mocks.TestMessage());
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void SerializeNullMessage() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
serializer.Serialize(new Dictionary<string, string>(), null);
}
[TestMethod, ExpectedException(typeof(ArgumentException))]
public void GetInvalidMessageType() {
MessageSerializer.Get(typeof(string));
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void GetNullType() {
MessageSerializer.Get(null);
}
[TestMethod]
public void GetReturnsSameSerializerTwice() {
Assert.AreSame(MessageSerializer.Get(typeof(Mocks.TestMessage)), MessageSerializer.Get(typeof(Mocks.TestMessage)));
}
[TestMethod, ExpectedException(typeof(ProtocolException))]
public void SerializeInvalidMessage() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
Dictionary<string, string> fields = new Dictionary<string, string>(StringComparer.Ordinal);
Mocks.TestMessage message = new Mocks.TestMessage();
message.EmptyMember = "invalidvalue";
serializer.Serialize(message);
}
[TestMethod()]
public void SerializeTest() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var message = new Mocks.TestMessage { Age = 15, Name = "Andrew", Location = new Uri("http://localhost") };
IDictionary<string, string> actual = serializer.Serialize(message);
Assert.AreEqual(3, actual.Count);
// Test case sensitivity of generated dictionary
Assert.IsFalse(actual.ContainsKey("Age"));
Assert.IsTrue(actual.ContainsKey("age"));
// Test contents of dictionary
Assert.AreEqual("15", actual["age"]);
Assert.AreEqual("Andrew", actual["Name"]);
Assert.AreEqual("http://localhost/", actual["Location"]);
Assert.IsFalse(actual.ContainsKey("EmptyMember"));
}
[TestMethod]
public void SerializeToExistingDictionary() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var message = new Mocks.TestMessage { Age = 15, Name = "Andrew" };
var fields = new Dictionary<string, string>();
fields["someExtraField"] = "someValue";
serializer.Serialize(fields, message);
Assert.AreEqual(3, fields.Count);
Assert.AreEqual("15", fields["age"]);
Assert.AreEqual("Andrew", fields["Name"]);
Assert.AreEqual("someValue", fields["someExtraField"]);
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void DeserializeNull() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
serializer.Deserialize(null);
}
[TestMethod]
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";
var actual = (Mocks.TestMessage)serializer.Deserialize(fields);
Assert.AreEqual(15, actual.Age);
Assert.AreEqual("Andrew", actual.Name);
Assert.IsNull(actual.EmptyMember);
}
/// <summary>
/// This tests deserialization of a message that is comprised of [DataMember]'s
/// that are defined in multiple places in the inheritance tree.
/// </summary>
/// <remarks>
/// The element sorting rules are first inheritance order, then alphabetical order.
/// This test validates correct behavior on both.
/// </remarks>
[TestMethod]
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 = (Mocks.TestDerivedMessage)serializer.Deserialize(fields);
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);
}
[TestMethod]
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";
// 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 = (Mocks.TestMessage)serializer.Deserialize(fields);
Assert.AreEqual(15, actual.Age);
Assert.AreEqual("Andrew", actual.Name);
Assert.IsNull(actual.EmptyMember);
}
[TestMethod, ExpectedException(typeof(ProtocolException))]
public void DeserializeEmpty() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
var fields = new Dictionary<string, string>(StringComparer.Ordinal);
serializer.Deserialize(fields);
}
[TestMethod, ExpectedException(typeof(ProtocolException))]
public void DeserializeInvalidMessage() {
var serializer = MessageSerializer.Get(typeof(Mocks.TestMessage));
Dictionary<string, string> fields = new Dictionary<string, string>(StringComparer.Ordinal);
// Set an disallowed value.
fields["age"] = "-1";
serializer.Deserialize(fields);
}
}
}
|
