private static async Task <Error> TryGetErrorAsync(HttpResponseMessage httpResponseMessage)
{
if (!httpResponseMessage.IsSuccessStatusCode)
{
try
{
var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
var deserializedContent = await SystemTextJsonSerializer.DeserializeAsync <Error>(contentStream).ConfigureAwait(false);
if (deserializedContent == null)
{
throw new Exception("Could not deserialize JSON response");
}
return(deserializedContent);
}
catch (Exception)
{
// Intentionally left empty
}
}
return(Error.Empty);
}
public static async Task <TResult> PostAsync <TRequest, TResult>(this HttpClient httpClient, string url, TRequest request)
{
var requestJson = SystemTextJsonSerializer.Serialize(request);
var requestContent = GetJsonStringContent(requestJson);
HttpResponseMessage httpResponseMessage;
try
{
httpResponseMessage = await httpClient.PostAsync(url, requestContent).ConfigureAwait(false);
}
catch (HttpRequestException e)
{
throw BankIdApiException.Unknown(e);
}
await BankIdApiErrorHandler.EnsureSuccessAsync(httpResponseMessage).ConfigureAwait(false);
var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
var deserializedContent = await SystemTextJsonSerializer.DeserializeAsync <TResult>(contentStream).ConfigureAwait(false);
if (deserializedContent == null)
{
throw new Exception("Could not deserialize JSON response");
}
return(deserializedContent);
}
private BankIdLoginViewModel GetLoginViewModel(string returnUrl, string loginOptions, BankIdLoginOptions unprotectedLoginOptions, AntiforgeryTokenSet antiforgeryTokens)
{
var initialStatusMessage = GetInitialStatusMessage(unprotectedLoginOptions);
var loginScriptOptions = new BankIdLoginScriptOptions(
Url.Action("Initialize", "BankIdApi") ?? throw new Exception("Could not get URL for BankIdApi.Initialize"),
Url.Action("Status", "BankIdApi") ?? throw new Exception("Could not get URL for BankIdApi.Status"),
Url.Action("Cancel", "BankIdApi") ?? throw new Exception("Could not get URL for BankIdApi.Cancel")
)
{
RefreshIntervalMs = BankIdDefaults.StatusRefreshIntervalMs,
InitialStatusMessage = _bankIdUserMessageLocalizer.GetLocalizedString(initialStatusMessage),
UnknownErrorMessage = _bankIdUserMessageLocalizer.GetLocalizedString(MessageShortName.RFA22),
UnsupportedBrowserErrorMessage = _localizer["UnsupportedBrowser_ErrorMessage"]
};
return(new BankIdLoginViewModel(
returnUrl,
Url.Content(unprotectedLoginOptions.CancelReturnUrl),
unprotectedLoginOptions.IsAutoLogin(),
unprotectedLoginOptions.PersonalIdentityNumber?.To12DigitString() ?? string.Empty,
loginOptions,
unprotectedLoginOptions,
loginScriptOptions,
SystemTextJsonSerializer.Serialize(loginScriptOptions),
antiforgeryTokens.RequestToken ?? throw new ArgumentNullException(nameof(antiforgeryTokens.RequestToken))
));
}
public void MapConvertersShouldBehaveConsistent()
{
const string json = @"{
""array"": [
""some stuff"",
""something else""
],
""string"": ""this is a string"",
""boolean"": true,
""number"": 1234.567,
""nested object"": {
""prop1"": false
},
""arrayOfObjects"": [
{""number"": 1234.567},
{""number"": 567.8}
]
}";
var newtonsoftSerializer = new NewtonsoftJsonSerializer();
var systemTextJsonSerializer = new SystemTextJsonSerializer();
var newtonsoftMap = JsonConvert.DeserializeObject <Map>(json, newtonsoftSerializer.JsonSerializerSettings);
var systemTextJsonMap = System.Text.Json.JsonSerializer.Deserialize <Map>(json, systemTextJsonSerializer.Options);
using (new AssertionScope())
{
CompareMaps(newtonsoftMap, systemTextJsonMap);
}
newtonsoftMap.Should().BeEquivalentTo(systemTextJsonMap, options => options
.RespectingRuntimeTypes());
}
public static ClusterOptions GetClusterOptions()
{
var settings = GetSettings();
var options = new ConfigurationBuilder()
.AddJsonFile("config.json")
.Build()
.GetSection("couchbase")
.Get <ClusterOptions>();
if (settings.EnableLogging)
{
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder
.AddFilter(level => level >= LogLevel.Debug)
);
var loggerFactory = serviceCollection.BuildServiceProvider().GetService <ILoggerFactory>();
loggerFactory.AddFile("Logs/myapp-{Date}.txt", LogLevel.Debug);
options.WithLogging(loggerFactory);
}
if (settings.SystemTextJson)
{
options.WithSerializer(SystemTextJsonSerializer.Create());
}
return(options);
}
public void IsJson(string strInput, bool expectedValue)
{
IJsonSerializer serializer = new SystemTextJsonSerializer();
bool result = serializer.IsJson(strInput);
Assert.AreEqual(expectedValue, result);
}
public void SystemTextJsonTest()
{
var serializer = new SystemTextJsonSerializer();
var now = DateTimeOffset.Now;
Assert.Equal(now, serializer.Deserialize <DateTimeOffset>(serializer.Serialize(now)));
}
public SystemJsonQueueServiceIntegrationTest()
{
_queueConfig = GetConfiguration(QueueMessageSerializer.SystemTextJson);
_queueService = new QueueService(_queueConfig);
_queueName = "system-json-test-queue";
_queueServiceClient = GetQueueServiceClient();
_serializeTestValidator = new SystemTextJsonSerializer(_queueConfig.OptionalSerializeSettings as JsonSerializerOptions);
}
public SerializationTests(RedfishFixture fixture)
{
_fixture = fixture;
_faker = new PersonFaker();
_protobufSerializer = new ProtobufSerializer();
_systemTextJsonSerializer = new SystemTextJsonSerializer();
_newtonsoftJsonSerializer = new NewtonsoftJsonSerializer();
}
public void NullOptionsDoesNotThrowException()
{
IJsonSerializer serializer = new SystemTextJsonSerializer();
Car car = Car.Dacia;
string result = serializer.Serialize(car, null);
Assert.IsTrue(!string.IsNullOrEmpty(result));
}
public void DeserializeWorks()
{
string json = System.Text.Json.JsonSerializer.Serialize(Car.Dacia);
IJsonSerializer serializer = new SystemTextJsonSerializer();
string result = serializer.Serialize(Car.Dacia);
Assert.AreEqual(json, result);
}
static TimeSpan RunTest(int numberOfMessages, PipelineStepProfilerStats profilerStats)
{
using (var adapter = new BuiltinHandlerActivator())
{
var network = new InMemNetwork();
Configure.With(adapter)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, "perftest"))
.Options(o =>
{
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(1);
o.Decorate <IPipeline>(c => new PipelineStepProfiler(c.Get <IPipeline>(), profilerStats));
o.Register <IPipelineInvoker>(c => new DefaultPipelineInvoker(c.Get <IPipeline>()));
})
.Start();
var serializer = new SystemTextJsonSerializer(new SimpleAssemblyQualifiedMessageTypeNameConvention());
var boy = new SomeMessage("hello there!");
for (var counter = 0; counter < numberOfMessages; counter++)
{
var headers = new Dictionary <string, string> {
{ Headers.MessageId, Guid.NewGuid().ToString() }
};
var message = new Message(headers, boy);
var transportMessage = serializer.Serialize(message).Result;
var inMemTransportMessage = transportMessage.ToInMemTransportMessage();
network.Deliver("perftest", inMemTransportMessage);
}
;
var numberOfReceivedMessages = 0;
var gotAllMessages = new ManualResetEvent(false);
adapter.Handle <SomeMessage>(async m =>
{
Interlocked.Increment(ref numberOfReceivedMessages);
if (Volatile.Read(ref numberOfReceivedMessages) == numberOfMessages)
{
gotAllMessages.Set();
}
});
var stopwatch = Stopwatch.StartNew();
adapter.Bus.Advanced.Workers.SetNumberOfWorkers(1);
gotAllMessages.WaitOrDie(TimeSpan.FromSeconds(30));
return(stopwatch.Elapsed);
}
}
public void ObjectIsFormattedAsJson()
{
IJsonSerializer serializer = new SystemTextJsonSerializer();
Car car = Car.Dacia;
string result = serializer.Serialize(car, null);
car = System.Text.Json.JsonSerializer.Deserialize <Car>(result);
Assert.IsNotNull(car);
}
protected override void SetUp()
{
var nameConvention = new SimpleAssemblyQualifiedMessageTypeNameConvention();
_newtonsoft = new JsonSerializer(nameConvention);
_microsoft = new SystemTextJsonSerializer(nameConvention, new JsonSerializerOptions
{
AllowTrailingCommas = true,
PropertyNameCaseInsensitive = true,
ReadCommentHandling = JsonCommentHandling.Skip,
});
}
public ContainsKey()
{
var mockOptions = new Mock <IOptions <LocalStorageOptions> >();
var jsonOptions = new JsonSerializerOptions();
jsonOptions.Converters.Add(new TimespanJsonConverter());
mockOptions.Setup(u => u.Value).Returns(new LocalStorageOptions());
IJsonSerializer serializer = new SystemTextJsonSerializer(mockOptions.Object);
IStorageProvider storageProvider = new InMemoryStorageProvider();
_sut = new LocalStorageService(storageProvider, serializer);
}
public void DeserializeAndFlattenWorks()
{
DirectoryInfo testDataDir = CommonTestHelpers.FindTestDataDirectory();
IJsonSerializer serializer = new SystemTextJsonSerializer();
foreach (var file in testDataDir.EnumerateFiles("*.json"))
{
string json = File.ReadAllText(file.FullName);
List <KeyValuePair <string, object> > result = serializer.DeserializeAndFlatten(json).ToList();
}
}
public void Deserialize_Stream_Success()
{
// arrange
using var stream = File.OpenRead(@"Data\card1.json");
var serializer = new SystemTextJsonSerializer();
// act
var result = serializer.Deserialize <RootCardDto>(stream);
// assert
Assert.Equal("Abundance", result.Card.Name);
}
public async Task CheckEncodingBug()
{
var utf32Serializer = new SystemTextJsonSerializer(new SimpleAssemblyQualifiedMessageTypeNameConvention(), encoding: Encoding.UTF32);
var utf8Serializer = new SystemTextJsonSerializer(new SimpleAssemblyQualifiedMessageTypeNameConvention(), encoding: Encoding.UTF8);
var transportMessage = await utf8Serializer.Serialize(new Message(new Dictionary <string, string>(), new Something("hej")));
var roundtripped = await utf32Serializer.Deserialize(transportMessage);
var something = roundtripped.Body as Something ?? throw new AssertionException($"Message body {roundtripped.Body} was not Something");
Assert.That(something.Text, Is.EqualTo("hej"));
}
public void Deserialize_String_Success()
{
// arrange
var jsonString = File.ReadAllText(@"Data\card1.json");
var serializer = new SystemTextJsonSerializer();
// act
var result = serializer.Deserialize <RootCardDto>(jsonString);
// assert
Assert.Equal("Abundance", result.Card.Name);
}
public void WriteIndentedOption(bool writeIndented)
{
IJsonSerializer serializer = new SystemTextJsonSerializer();
Car car = Car.Dacia;
string result = serializer.Serialize(car, new JsonSerializeOptions {
WriteIndented = writeIndented
});
string expectedResult = System.Text.Json.JsonSerializer.Serialize(car, new System.Text.Json.JsonSerializerOptions {
WriteIndented = writeIndented
});
Assert.AreEqual(expectedResult, result);
}
internal static ClusterOptions GetClusterOptions()
{
var settings = GetSettings();
var options = new ConfigurationBuilder()
.AddJsonFile("config.json")
.Build()
.GetSection("couchbase")
.Get <ClusterOptions>();
if (settings.SystemTextJson)
{
options.WithSerializer(SystemTextJsonSerializer.Create());
}
return(options);
}
public void Test1Byte()
{
var seriazlier = new SystemTextJsonSerializer();
byte[] messageBytes = Encoding.UTF8.GetBytes(LONG_STRING + "xyz");
var result = seriazlier.Serialize(new object[]
{
new
{
Code = 404,
Message = messageBytes
}
});
Assert.AreEqual("[{\"Code\":404,\"Message\":{\"_placeholder\":true,\"num\":0}}]", result.Json);
Assert.AreEqual(messageBytes.Length, result.Bytes[0].Length);
Assert.AreEqual(LONG_STRING + "xyz", Encoding.UTF8.GetString(result.Bytes[0]));
}
public void Serialize_NotImplemented()
{
// arrange
var serializer = new SystemTextJsonSerializer();
var obj = new
{
Prop1 = "Value1",
Prop2 = "Value2",
Prop3 = "Value3",
};
// act
var result = serializer.Serialize(obj);
// assert
Assert.NotEmpty(result);
Assert.Contains("Value", result);
}
public void Use_JsonNet_For_Response()
{
var expected = Fixture.Create <TestClass>();
using var server = HttpServerFixture.StartServer(
(request, response) =>
{
var serializer = new SystemTextJsonSerializer();
response.ContentType = "application/json";
response.ContentEncoding = Encoding.UTF8;
response.OutputStream.WriteStringUtf8(serializer.Serialize(expected));
}
);
var client = new RestClient(server.Url).UseSystemTextJson();
var actual = client.Get <TestClass>(new RestRequest()).Data;
actual.Should().BeEquivalentTo(expected);
}
public void Use_JsonNet_For_Requests()
{
using var server = HttpServerFixture.StartServer(CaptureBody);
_body = null;
var serializer = new SystemTextJsonSerializer();
var testData = Fixture.Create <TestClass>();
var client = new RestClient(server.Url).UseSystemTextJson();
var request = new RestRequest().AddJsonBody(testData);
var expected = testData;
client.Post(request);
var actual = serializer.Deserialize <TestClass>(new RestResponse {
Content = _body
});
actual.Should().BeEquivalentTo(expected);
void CaptureBody(HttpListenerRequest req, HttpListenerResponse response) => _body = req.InputStream.StreamToString();
}
public RedcacheServiceTests(RedfishFixture fixture)
{
_fixture = fixture;
_serializer = new SystemTextJsonSerializer();
}
public void DeserializeAndFlattenDoesNotThrowExceptionForNullOrInvalidJson(string json)
{
IJsonSerializer serializer = new SystemTextJsonSerializer();
List <KeyValuePair <string, object> > result = serializer.DeserializeAndFlatten(json).ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceModelGrpcSwaggerOptions"/> class with <see cref="SystemTextJsonSerializer"/>.
/// </summary>
public ServiceModelGrpcSwaggerOptions()
{
JsonSerializer = new SystemTextJsonSerializer();
}
public SystemTextJsonSerializationFactory(JsonSerializerOptions options)
{
_serializer = new SystemTextJsonSerializer(options);
}
private static ITypeSerializer GetSerializer(bool systemTextJson = false) =>
systemTextJson
? SystemTextJsonSerializer.Create()
: DefaultSerializer.Instance;
