public void Setup()
{
_testCommand = A.Fake<ICommand>();
_publisher = A.Fake<IPublisher>();
_compositeApp = A.Fake<ICompositeApp>();
_registry = A.Fake<ICommandRegistry>();
_formatter = A.Fake<IResponseFormatter>();
_publicationRecord = A.Fake<ICommandPublicationRecord>();
_jsonSerializer = new DefaultJsonSerializer();
_xmlSerializer = new DefaultXmlSerializer();
A.CallTo(() => _testCommand.Created).Returns(DateTime.MaxValue);
A.CallTo(() => _testCommand.CreatedBy).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _testCommand.Identifier).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _formatter.Serializers).Returns(new List<ISerializer> { _jsonSerializer, _xmlSerializer });
A.CallTo(() => _publicationRecord.Dispatched).Returns(true);
A.CallTo(() => _publicationRecord.Error).Returns(false);
A.CallTo(() => _publicationRecord.Completed).Returns(true);
A.CallTo(() => _publicationRecord.Created).Returns(DateTime.MinValue);
A.CallTo(() => _publicationRecord.MessageLocation).Returns(new Uri("http://localhost/fake/message"));
A.CallTo(() => _publicationRecord.MessageType).Returns(typeof(IPublicationRecord));
A.CallTo(() => _publicationRecord.CreatedBy).Returns(Guid.Empty);
A.CallTo(() => _compositeApp.GetCommandForInputModel(A.Dummy<IInputModel>())).Returns(_testCommand);
A.CallTo(() => _publisher.PublishMessage(A.Fake<ICommand>())).Returns(_publicationId);
A.CallTo(() => _registry.GetPublicationRecord(_publicationId)).Returns(_publicationRecord);
_euclidApi = new ApiModule(_compositeApp, _registry, _publisher);
}
/// <summary>
/// Method that performs an HTTP GET and returns the Json deserialization
/// of the content returned from the call.
/// </summary>
/// <param name="webRequest">The WebRequest object to be used for the call.</param>
/// <returns>Json deserialization of the content returned from the call.</returns>
public static Dictionary <string, object> GetUrlContent(WebRequest webRequest)
{
Stream content = webRequest.GetResponse().GetResponseStream();
string returnedText = new StreamReader(content).ReadToEnd();
IJsonSerializer JsonSerializer = new DefaultJsonSerializer();
return(JsonSerializer.Deserialize <Dictionary <string, object> >(returnedText));
}
public ModQueries(ILogger <ModQueries> logger, IGameQueries nexusModsGameQueries, IDistributedCache cache, IHttpClientFactory httpClientFactory, DefaultJsonSerializer jsonSerializer)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_nexusModsGameQueries = nexusModsGameQueries ?? throw new ArgumentNullException(nameof(nexusModsGameQueries));
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
_jsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer));
}
public void Can_deserialize_to_dynamic_single()
{
var serializer = new DefaultJsonSerializer();
var response = new RestResponse<dynamic>();
response.SetContent(SingleInput);
var proxy = serializer.DeserializeDynamic(response);
Assert.IsNotNull(proxy);
}
public void Can_deserialize_to_dynamic_collection()
{
var serializer = new DefaultJsonSerializer();
var response = new RestResponse<JsonObject>();
response.SetContent(DoubleInput);
var proxy = serializer.DeserializeDynamic(response);
Assert.IsNotNull(proxy);
}
public void EmptyConstructorCreatesDefaultValues()
{
var serializer = new DefaultJsonSerializer();
serializer.Name.Should().Be("default");
serializer.JsonSerializer.Should().NotBeNull();
serializer.JsonSerializer.Formatting.Should().Be(Formatting.None);
}
public void SerializeToStringSerializesCorrectly()
{
var serializer = new DefaultJsonSerializer();
var json = serializer.SerializeToString(_expectedItem, typeof(TypeForJsonSerializer));
json.Should().Be(_expectedJson);
}
public JsonSerializerTest()
{
var options = A.Fake <IOptions <EasyCachingJsonSerializerOptions> >();
A.CallTo(() => options.Value).Returns(new EasyCachingJsonSerializerOptions());
_serializer = new DefaultJsonSerializer(options);
}
public void SerializeObject_without_type_serializes_to_json_using_DefaultSerializerSettings()
{
// If Default is being used then there should be new lines
var dog = new Dog(5, "spud", FurColor.Brindle);
var json = DefaultJsonSerializer.SerializeObject(dog);
Assert.That(json, Is.EqualTo("{\r\n \"name\": \"spud\",\r\n \"furColor\": \"brindle\",\r\n \"dogTag\": \"my name is spud\",\r\n \"nickname\": null,\r\n \"age\": 5\r\n}"));
}
/// <summary>
/// Initializes a new instance of the <see cref="Startup"/> class.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="env">The hosting environment.</param>
public Startup(IConfiguration configuration, IHostingEnvironment env)
{
Configuration = configuration;
HostingEnvironment = env;
AppInfo = new AppInfoFactory().Create(typeof(Program));
Serializer = new DefaultJsonSerializer();
Configuration.GetSection("ApiOptions").Bind(ApiOptions);
}
public void DerializeJson_WithNeoErrors_ReturnsErrors()
{
var deserializer = new DefaultJsonSerializer(new DictionaryEntityCache());
var retval = deserializer.Deserialize <CypherResponse <DeserializationTestClass> >(ErrorJson);
Assert.IsNull(retval.Results);
Assert.IsTrue(retval.Errors.Any());
}
public void Should_Decode_Token_To_Json_Encoded_String()
{
var jsonSerializer = new DefaultJsonSerializer();
var expectedPayload = jsonSerializer.Serialize(customer);
string decodedPayload = JsonWebToken.Decode(token, "ABC", false);
Assert.Equal(expectedPayload, decodedPayload);
}
public void DeserializeFromStringDeserializesCorrectly()
{
var serializer = new DefaultJsonSerializer();
var item = serializer.DeserializeFromString(_expectedJson, typeof(TypeForJsonSerializer)) as TypeForJsonSerializer;
item.Should().NotBeNull();
item.Should().BeEquivalentTo(_expectedItem);
}
public void PostUserDescription()
{
var container = AppBuilder.CreateContainer();
using (WebApp.Start(Settings.Current.BaseURL, app => AppBuilder.BuildWithContainer(app, container, false))) {
var repository = container.GetInstance <IEventRepository>();
repository.RemoveAll();
const string referenceId = "fda94ff32921425ebb08b73df1d1d34c";
const string badReferenceId = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
var statsCounter = container.GetInstance <IAppStatsClient>() as InMemoryAppStatsClient;
Assert.NotNull(statsCounter);
EnsureSampleData(container);
var events = new List <Event> {
new Event {
Message = "Testing", ReferenceId = referenceId
}
};
var configuration = GetClient().Configuration;
var serializer = new DefaultJsonSerializer();
var client = new DefaultSubmissionClient();
var description = new UserDescription {
EmailAddress = "*****@*****.**", Description = "Some description."
};
statsCounter.WaitForCounter(StatNames.EventsUserDescriptionErrors, work: () => {
var response = client.PostUserDescription(referenceId, description, configuration, serializer);
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
});
statsCounter.WaitForCounter(StatNames.EventsUserDescriptionProcessed, work: () => {
var response = client.PostEvents(events, configuration, serializer);
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
});
container.GetInstance <IElasticClient>().Refresh();
var ev = repository.GetByReferenceId("537650f3b77efe23a47914f4", referenceId).FirstOrDefault();
Assert.NotNull(ev);
Assert.NotNull(ev.GetUserDescription());
Assert.Equal(description.ToJson(), ev.GetUserDescription().ToJson());
Assert.Equal(2, statsCounter.GetCount(StatNames.EventsUserDescriptionErrors));
statsCounter.WaitForCounter(StatNames.EventsUserDescriptionErrors, work: () => {
var response = client.PostUserDescription(badReferenceId, description, configuration, serializer);
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
});
Assert.Equal(2, statsCounter.GetCount(StatNames.EventsUserDescriptionErrors));
}
}
public void DeserializeString_IfJsonCanBeDeserialized_ReturnsCorrectObject <T>(string dateFormat, string json, T expected)
{
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
var actual = serializer.Deserialize <T>(json);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void Can_deserialize_to_dynamic_single()
{
var serializer = new DefaultJsonSerializer();
var response = new RestResponse <JsonObject>();
response.SetContent(SingleInput);
var proxy = serializer.DeserializeDynamic(response);
Assert.IsNotNull(proxy);
}
public void Serialize_ReturnsCorrectJson <T>(string dateFormat, NamingStrategy enumNamingStrategy, T item, string expected)
{
var serializer = new DefaultJsonSerializer(enumNamingStrategy)
{
DateFormat = dateFormat
};
var actual = serializer.Serialize(item);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public async Task StartAsync(string port)
{
if (_isDisposed)
throw new ObjectDisposedException(nameof(NetGameServer));
if (_rpcServer != null)
throw new InvalidOperationException();
var serializer = new DefaultJsonSerializer(typeof(NetGameServer).GetTypeInfo().Assembly, Serialization.JsonSerializationSettings);
_rpcServer = await RpcServer.StartAsync(port, this, serializer);
}
public void DeserializeObject_without_type_deserializes_json_into_JObject_using_DefaultSerializerSettings()
{
var dogJson = "{\"name\":\"Barney\",\"furColor\":\"brindle\",\"age\":10}";
var dog = DefaultJsonSerializer.DeserializeObject(dogJson) as JObject;
Assert.That(dog.Properties().Count(), Is.EqualTo(3));
Assert.That(dog["name"].ToString(), Is.EqualTo("Barney"));
Assert.That(dog["age"].ToString(), Is.EqualTo("10"));
Assert.That(dog["furColor"].ToString(), Is.EqualTo("brindle"));
}
public void ConstructorPassesValuesCorrectly()
{
var serializer = new DefaultJsonSerializer("notdefault", new JsonSerializerSettings()
{
Formatting = Formatting.Indented
});
serializer.Name.Should().Be("notdefault");
serializer.JsonSerializer.Should().NotBeNull();
serializer.JsonSerializer.Formatting.Should().Be(Formatting.Indented);
}
public void DeserializeString_IfJsonCannotBeDeserialized_ThrowsException <T>(string dateFormat, string json, T defaultWithDeserializedType)
{
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
Assert.Catch(() =>
{
var actual = serializer.Deserialize <T>(json);
});
}
public void CanRoundtripToJson()
{
var serializer = new DefaultJsonSerializer();
var originalData = new Data { Message = "test", Number = 42, Assertion = true };
string serializedData = serializer.Serialize(originalData);
var deserializedData = serializer.Deserialize<Data>(serializedData);
Assert.That(deserializedData.Message, Is.EqualTo(originalData.Message));
Assert.That(deserializedData.Number, Is.EqualTo(originalData.Number));
Assert.That(deserializedData.Assertion, Is.EqualTo(originalData.Assertion));
}
public void DerializeJson_EntitiesOnly_ReturnsCollectionOfEntities()
{
var deserializer = new DefaultJsonSerializer(new DictionaryEntityCache());
var retval = deserializer.Deserialize <CypherResponse <DeserializationTestClass> >(Json);
Assert.AreEqual(retval.Results.Count(), 2);
dynamic actor = retval.Results.Select(r => r.Actor).First();
Assert.AreEqual(actor.age, 33);
Assert.AreEqual(actor.name, "mark");
}
public void DeserializeRestResponse_IfJsonCanBeDeserialized_ReturnsCorrectObject <T>(string dateFormat, string json, T expected)
{
var response = new RestResponse <T> {
Content = json
};
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
var actual = serializer.Deserialize <T>(response);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public DefaultJsonSerializerTests()
{
var environment =
new DefaultNancyEnvironment();
environment.Tracing(
enabled: true,
displayErrorTraces: true);
environment.Json();
environment.Globalization(new[] { "en-US" });
this.jsonSerializer = new DefaultJsonSerializer(environment);
}
public async Task JoinAsync(NetGameServerInfo serverInfo)
{
var serializer = new DefaultJsonSerializer(typeof(NetGameClient).GetTypeInfo().Assembly, Serialization.JsonSerializationSettings);
_rpcClient = await RpcClient.ConnectAsync(serverInfo.RemoteAddress, serverInfo.RemotePort, this, serializer);
JoinResult joinResult = await _rpcClient.Server.JoinAsync(PlayerInfo);
var serverStub = new ClientSideServerProxy(_rpcClient.Connection);
if (joinResult.IsSuccessful)
await InitializeAsync(joinResult.SpawnPosition, serverStub);
else
throw new InvalidOperationException("Failed to join game server");
}
public DefaultJsonSerializerTests()
{
var environment =
new DefaultNancyEnvironment();
environment.Tracing(
enabled: true,
displayErrorTraces: true);
environment.Json();
environment.Globalization(new[] { "en-US" });
this.jsonSerializer = new DefaultJsonSerializer(environment);
}
public void DeserializeObject_with_type_deserializes_json_using_DefaultSerializerSettings()
{
// If Default is being used then strict constructor matching will result in a Dog and not a Mouse
var dogJson = "{\"name\":\"Barney\",\"furColor\":\"brindle\",\"age\":10}";
var dog = DefaultJsonSerializer.DeserializeObject(dogJson, typeof(Animal)) as Dog;
Assert.That(dog, Is.Not.Null);
Assert.That(dog.Name, Is.EqualTo("Barney"));
Assert.That(dog.Age, Is.EqualTo(10));
Assert.That(dog.FurColor, Is.EqualTo(FurColor.Brindle));
Assert.That(dog.DogTag, Is.EqualTo("my name is Barney"));
}
public void SerializeToStreamSerializesCorrectly()
{
var serializer = new DefaultJsonSerializer();
using var stream = new MemoryStream();
serializer.SerializeToStream(stream, _expectedItem, typeof(TypeForJsonSerializer));
using var streamReader = new StreamReader(stream);
stream.Seek(0, SeekOrigin.Begin);
var json = streamReader.ReadToEnd();
json.Should().Be(_expectedJson);
}
public void Can_deserialize_all_test_cases()
{
var serializer = new DefaultJsonSerializer();
var files = Directory.GetFiles("Json", "*.json");
foreach(var file in files)
{
var json = File.ReadAllText(file);
var response = new RestResponse<dynamic>();
response.SetContent(json);
var proxy = serializer.DeserializeDynamic(response);
Assert.IsNotNull(proxy);
}
}
public void GetSettingsAsync()
{
using (WebApp.Start(Settings.Current.BaseURL, AppBuilder.Build)) {
var configuration = ExceptionlessConfiguration.CreateDefault();
var serializer = new DefaultJsonSerializer();
var client = new DefaultSubmissionClient();
var response = client.GetSettings(configuration, serializer);
Assert.True(response.Success, response.Message);
Assert.NotEqual(-1, response.SettingsVersion);
Assert.NotNull(response.Settings);
Assert.Null(response.Message);
}
}
/// <summary>
/// 将对象序列化成缩进结构的JSON，便于日志记录
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string ToDumpJson(this object obj)
{
if (obj == null)
{
return("null");
}
DefaultJsonSerializer serializer = ObjectFactory.New <DefaultJsonSerializer>();
JsonSerializerSettings settings = serializer.GetJsonSerializerSettings(true);
// 设置为缩进格式
settings.Formatting = Formatting.Indented;
return(serializer.Serialize(obj, settings));
}
public void Should_camel_case_property_names_by_default()
{
// Given
var sut = new DefaultJsonSerializer();
var input = new { FirstName = "Joe", lastName = "Doe" };
// When
var output = new MemoryStream();
sut.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"firstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void DeserializeRestResponse_IfJsonCannotBeDeserialized_ThrowsException <T>(string dateFormat, string json, T defaultWithDeserializedType)
{
var response = new RestResponse <T> {
Content = json
};
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
Assert.Catch(() =>
{
var actual = serializer.Deserialize <T>(response);
});
}
public void Should_camel_case_field_names_by_default()
{
// Given
var input = new PersonWithFields { FirstName = "Joe", LastName = "Doe" };
var serializer = new DefaultJsonSerializer(GetTestableEnvironment());
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"firstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void Should_camel_case_property_names_by_default()
{
// Given
var input = new { FirstName = "Joe", lastName = "Doe" };
var serializer = new DefaultJsonSerializer(GetTestableEnvironment());
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"firstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void Can_deserialize_all_test_cases()
{
var serializer = new DefaultJsonSerializer();
var files = Directory.GetFiles("Json", "*.json");
foreach (var file in files)
{
var json = File.ReadAllText(file);
var response = new RestResponse <JsonObject>();
response.SetContent(json);
var proxy = serializer.DeserializeDynamic(response);
Assert.IsNotNull(proxy);
}
}
public async Task ConnectViaAppServicesAsync(string packageFamilyName)
{
try
{
var serializer = new DefaultJsonSerializer(GetType().GetTypeInfo().Assembly);
var result = await ASConnection.ConnectLocallyAsync("Chat", packageFamilyName, serializer);
Client = new RpcClient(result.Connection, this);
RaisePropertyChanged(nameof(Client));
}
catch
{
Messages.Add($"Failed to connect to app service in package {packageFamilyName}");
}
}
/// <summary>
/// Adds a application/json request body to the <see cref="Browser"/>.
/// </summary>
/// <param name="browserContext">The <see cref="BrowserContext"/> that the data should be added to.</param>
/// <param name="model">The model to be serialized to json.</param>
/// <param name="serializer">Optionally opt in to using a different JSON serializer.</param>
public static void JsonBody <TModel>(this BrowserContext browserContext, TModel model, ISerializer serializer = null)
{
if (serializer == null)
{
serializer = new DefaultJsonSerializer(browserContext.Environment);
}
var contextValues =
(IBrowserContextValues)browserContext;
contextValues.Body = new MemoryStream();
serializer.Serialize("application/json", model, contextValues.Body);
browserContext.Header("Content-Type", "application/json");
}
public void Should_not_change_casing_when_retain_casing_is_true()
{
// Given
var input = new {FirstName = "Joe", lastName = "Doe"};
var environment = GetTestableEnvironment(x => x.Json(retainCasing: true));
var serializer = new DefaultJsonSerializer(environment);
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"FirstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void NullValueHandling_Test_Should_Succeed()
{
var serializer = new DefaultJsonSerializer("json", new JsonSerializerOptions
{
IgnoreNullValues = true
});
Employee joe = new Employee {
Name = "Joe User"
};
var joe_byte = serializer.Serialize(joe);
var joe_obj = serializer.Deserialize <Employee>(joe_byte);
Assert.Null(joe.Manager);
}
public void Should_not_change_casing_when_retain_casing_is_true()
{
// Given
var input = new { FirstName = "Joe", lastName = "Doe" };
var environment = GetTestableEnvironment(x => x.Json(retainCasing: true));
var serializer = new DefaultJsonSerializer(environment);
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"FirstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void Should_camel_case_dictionary_keys_by_default()
{
// Given
var input = new Dictionary<string, object>
{
{ "Joe", new PersonWithFields { FirstName = "Joe" } },
{ "John", new PersonWithFields { FirstName = "John" } }
};
var serializer = new DefaultJsonSerializer(GetTestableEnvironment());
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"joe\":{\"firstName\":\"Joe\",\"lastName\":null},\"john\":{\"firstName\":\"John\",\"lastName\":null}}");
}
public void Should_not_change_casing_when_retain_casing_is_true()
{
JsonSettings.RetainCasing = true;
try
{
// Given
var sut = new DefaultJsonSerializer();
var input = new {FirstName = "Joe", lastName = "Doe"};
// When
var output = new MemoryStream();
sut.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"FirstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
finally
{
JsonSettings.RetainCasing = false;
}
}
static GlobalSettings()
{
JsonSerializer = new DefaultJsonSerializer();
RequiredTokenSettings = new RequiredTokenSettings();
}
public void SerializeCypherRequest__IsValid()
{
var request =
CypherQueryRequest.Create(
@"START x=node(1), y=node(2) CREATE x-[r:OWNS {""name"":""mark""}]->y<-[r2:IS_OWNED_BY {""age"": 33}]");
var serializer = new DefaultJsonSerializer();
var result = serializer.Serialize(request);
Console.WriteLine(result);
}
public void DerializeJson_EntitiesOnly_ReturnsCollectionOfEntities()
{
const string json =
@"{
""commit"":""http://localhost:7474/db/data/transaction/6/commit"",
""results"":[
{
""columns"":[
""Actor"",
""Actor__Id"",
""Actor__Labels"",
""ActedIn"",
""ActedIn__Id"",
""ActedIn__Type"",
""Movie"",
""Movie__Id"",
""Movie__Labels""
],
""data"":[
[
{
""age"":33,
""name"":""mark""
},
3745,
[""person""],
{
},
39490,
""IS_A"",
{
""title"":""developer""
},
3746,
[]
],[
{
""age"":21,
""name"":""John""
},
3747,
[""person""],
{
},
39491,
""IS_A"",
{
""title"":""leg""
},
3748,
[]
]
]
}
],
""transaction"":{
""expires"":""Tue, 30 Jul 2013 15:57:59 +0000""
},
""errors"":[
]
}";
var deserializer = new DefaultJsonSerializer();
var retval = deserializer.Deserialize<CypherResponse<DeserializationTestClass>>(json);
Assert.AreEqual(retval.Results.Count(), 2);
dynamic actor = retval.Results.Select(r => r.Actor).First();
Assert.AreEqual(actor.age, 33);
Assert.AreEqual(actor.name, "mark");
}
public void Should_camel_case_property_names_if_local_override_is_set()
{
JsonSettings.RetainCasing = true;
try
{
// Given
var sut = new DefaultJsonSerializer { RetainCasing = false };
var input = new { FirstName = "Joe", lastName = "Doe" };
// When
var output = new MemoryStream();
sut.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"firstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
finally
{
JsonSettings.RetainCasing = false;
}
}
public DefaultJsonSerializerTest()
{
_serializer = new DefaultJsonSerializer();
}
public void Should_use_iso8601_datetimes_by_default()
{
// Given
var serializer = new DefaultJsonSerializer(GetTestableEnvironment());
var input = new
{
UnspecifiedDateTime = new DateTime(2014, 3, 9, 17, 03, 25).AddMilliseconds(234),
LocalDateTime = new DateTime(2014, 3, 9, 17, 03, 25, DateTimeKind.Local).AddMilliseconds(234),
UtcDateTime = new DateTime(2014, 3, 9, 16, 03, 25, DateTimeKind.Utc).AddMilliseconds(234)
};
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual(string.Format(@"{{""unspecifiedDateTime"":""2014-03-09T17:03:25.2340000{0}"",""localDateTime"":""2014-03-09T17:03:25.2340000{0}"",""utcDateTime"":""2014-03-09T16:03:25.2340000Z""}}",
GetTimezoneSuffix(input.LocalDateTime, ":")));
}
public DefaultJsonSerializerFixture()
{
this.serializer = new DefaultJsonSerializer();
}
public void Should_camel_case_property_names_if_local_override_is_set()
{
// Given
var environment = GetTestableEnvironment(x => x.Json(retainCasing: true));
var serializer = new DefaultJsonSerializer(environment) { RetainCasing = false };
var input = new { FirstName = "Joe", lastName = "Doe" };
// When
var output = new MemoryStream();
serializer.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
actual.ShouldEqual("{\"firstName\":\"Joe\",\"lastName\":\"Doe\"}");
}
public void Should_use_wcf_datetimeformat_when_iso8601dateformat_local_override_is_false()
{
// Given
var environment = GetTestableEnvironment(x => x.Json());
var sut = new DefaultJsonSerializer(environment) { ISO8601DateFormat = false };
var input = new
{
UnspecifiedDateTime = new DateTime(2014, 3, 9, 17, 03, 25).AddMilliseconds(234),
LocalDateTime = new DateTime(2014, 3, 9, 17, 03, 25, DateTimeKind.Local).AddMilliseconds(234),
UtcDateTime = new DateTime(2014, 3, 9, 16, 03, 25, DateTimeKind.Utc).AddMilliseconds(234)
};
// When
var output = new MemoryStream();
sut.Serialize("application/json", input, output);
var actual = Encoding.UTF8.GetString(output.ToArray());
// Then
var ticks = (input.LocalDateTime.ToUniversalTime().Ticks - InitialJavaScriptDateTicks) / (long)10000;
actual.ShouldEqual(string.Format(@"{{""unspecifiedDateTime"":""\/Date({0}{1})\/"",""localDateTime"":""\/Date({0}{1})\/"",""utcDateTime"":""\/Date(1394381005234)\/""}}",
ticks, GetTimezoneSuffix(input.LocalDateTime)));
}
