public void Should_Be_Able_To_Deserialize_Objects()
{
/* Setup */
var expected = new AdvancedTestClass
{
IntProp = 3,
ListProp = new List <string> {
"One", "Two"
},
ObjectRef = new SerializerTestClass
{
StringProp = "Sub-object property"
}
};
var input = JsonConvert.SerializeObject(expected);
/* Test */
var result = _serializer.Deserialize <AdvancedTestClass>(input);
/* Assert */
Assert.That(result.IntProp, Is.EqualTo(expected.IntProp));
Assert.That(result.ObjectRef.StringProp, Is.EqualTo(expected.ObjectRef.StringProp));
Assert.That(result.ListProp[0], Is.EqualTo(expected.ListProp[0]));
Assert.That(result.ListProp[1], Is.EqualTo(expected.ListProp[1]));
}
public void ReferenceLoopHandling_Test_Should_Succeed()
{
var options = A.Fake <IOptions <EasyCachingJsonSerializerOptions> >();
A.CallTo(() => options.Value).Returns(new EasyCachingJsonSerializerOptions()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
var serializer = new DefaultJsonSerializer(options);
Employee joe = new Employee {
Name = "Joe User"
};
Employee mike = new Employee {
Name = "Mike Manager"
};
joe.Manager = mike;
mike.Manager = mike;
var joe_byte = serializer.Serialize(joe);
var joe_obj = serializer.Deserialize <Employee>(joe_byte);
Assert.Equal(joe.Name, joe_obj.Name);
Assert.Equal(joe.Manager, mike);
}
/// <summary>
/// Method that performs an HTTP POST 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>
/// <param name="message">The message to be passed as content of the call.</param>
/// <param name="json">A flag indicating whether the message has a Json format or not.
/// In the first case the message is posted as a serialization of the Json.
/// In the second case the messge is serialized to query string.</param>
/// <returns>Json deserialization of the content returned from the call.</returns>
public Dictionary <string, object> PostUrlContent(WebRequest webRequest, OIDClientSerializableMessage message, bool json = false)
{
webRequest.Method = "POST";
string postData = "";
if (message != null)
{
if (json)
{
postData = message.serializeToJsonString();
}
else
{
postData = message.serializeToQueryString();
}
}
byte[] postBytes = Encoding.UTF8.GetBytes(postData);
webRequest.ContentType = "application/x-www-form-urlencoded";
webRequest.ContentLength = postBytes.Length;
Stream postStream = webRequest.GetRequestStream();
postStream.Write(postBytes, 0, postBytes.Length);
postStream.Close();
HttpWebResponse response = (HttpWebResponse)webRequest.GetResponse();
StreamReader rdr = new StreamReader(response.GetResponseStream());
IJsonSerializer JsonSerializer = new DefaultJsonSerializer();
return(JsonSerializer.Deserialize <Dictionary <string, object> >(rdr.ReadToEnd()));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var tenant = Environment.GetEnvironmentVariable(EnvKeys.Tenant);
var clientId = Environment.GetEnvironmentVariable(EnvKeys.ClientId);
var clientSecret = Environment.GetEnvironmentVariable(EnvKeys.ClientSecret);
var webHookUrl = "https://" + Environment.GetEnvironmentVariable("WEBSITE_HOSTNAME") + "/api/Notify";
var authId = clientId;
var jwt = await fetchAuthToken(clientId, clientSecret, tenant);
var json = JsonWebToken.Decode(jwt, "", false);
var JsonSerializer = new DefaultJsonSerializer();
var token = JsonSerializer.Deserialize <Dictionary <string, string> >(json);
var tenantId = token["tid"];
try
{
await subscribe(log, webHookUrl, authId, tenantId, jwt, "Audit.SharePoint");
await subscribe(log, webHookUrl, authId, tenantId, jwt, "Audit.Exchange");
await subscribe(log, webHookUrl, authId, tenantId, jwt, "Audit.AzureActiveDirectory");
await subscribe(log, webHookUrl, authId, tenantId, jwt, "Audit.General");
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
log.Error(e.ToString());
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public static Account DecryptAccount(string encryptAccount, string key)
{
var jsonAccount = EncryptHelper.AesDecryString(encryptAccount, password: key);
IJsonSerializer serializer = new DefaultJsonSerializer();
var account = serializer.Deserialize <Account>(jsonAccount);
return(account);
}
public async Task <DataFile> DeserializeLabelFile(string path)
{
var result = await serializer.Deserialize <DataFile>(path);
// set source on annotation objects
result.SourceInfo = new SourceInfo(path);
return(result);
}
/// <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 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 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 static bool TryGetValue <TItem>(this IDistributedCache cache, string key, DefaultJsonSerializer jsonSerializer, out TItem?value)
{
if (cache.Get(key) is { } data)
{
value = jsonSerializer.Deserialize <TItem?>(data);
return(true);
}
value = default;
return(false);
}
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 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 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 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 void DefaultJsonSerializer_Test()
{
var o1 = new TestSerializeClass()
{
Id = 1,
Name = "zhang",
Age = 19
};
IJsonSerializer jsonSerializer = new DefaultJsonSerializer();
var json1 = jsonSerializer.Serialize(o1);
var o2 = jsonSerializer.Deserialize <TestSerializeClass>(json1);
Assert.Equal(o1.Id, o2.Id);
Assert.Equal(o1.Name, o2.Name);
Assert.Equal(o1.Age, o2.Age);
var o3 = (TestSerializeClass)jsonSerializer.Deserialize(json1, typeof(TestSerializeClass));
Assert.Equal(o1.Id, o3.Id);
Assert.Equal(o1.Name, o3.Name);
Assert.Equal(o1.Age, o3.Age);
}
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 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 NullValueHandling_Test_Should_Succeed()
{
var options = A.Fake <IOptions <EasyCachingJsonSerializerOptions> >();
A.CallTo(() => options.Value).Returns(new EasyCachingJsonSerializerOptions()
{
NullValueHandling = NullValueHandling.Ignore
});
var serializer = new DefaultJsonSerializer(options);
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 DateOnly_Iss338_Test_Should_Succeed()
{
var serializer = new DefaultJsonSerializer("json", new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
Converters = new List <JsonConverter>()
{
new DateOnlyJsonConverter()
}
});
var dateTime = DateTime.Parse("2021-12-21 12:12:12");
var date = DateOnly.FromDateTime(dateTime);
DateOnlyModel m = new DateOnlyModel {
Name = "Joe User", Date = date
};
var @byte = serializer.Serialize(m);
var @obj = serializer.Deserialize <DateOnlyModel>(@byte);
Assert.Equal(date, obj.Date);
}
public static async Task <string> fetchAuthToken(string clientId, string clientSecret, string tenant)
{
var url = "https://login.microsoftonline.com/" + tenant + "/oauth2/token";
using (var http = new HttpClient())
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "client_credentials"),
new KeyValuePair <string, string>("client_id", clientId),
new KeyValuePair <string, string>("client_secret", clientSecret),
new KeyValuePair <string, string>("resouce", "https://manage.office.com"),
});
var resp = await http.PostAsync(url, formContent);
var body = await resp.Content.ReadAsStringAsync();
var JsonSerializer = new DefaultJsonSerializer();
var json = JsonSerializer.Deserialize <Dictionary <string, string> >(body);
return(json["access_token"]);
}
}
public void ReferenceLoopHandling_Test_Should_Succeed()
{
var serializer = new DefaultJsonSerializer("json", new JsonSerializerOptions()
{
ReferenceHandler = ReferenceHandler.Preserve
});
Employee joe = new Employee {
Name = "Joe User"
};
Employee mike = new Employee {
Name = "Mike Manager"
};
joe.Manager = mike;
mike.Manager = mike;
var joe_byte = serializer.Serialize(joe);
var joe_obj = serializer.Deserialize <Employee>(joe_byte);
Assert.Equal(joe.Name, joe_obj.Name);
Assert.Equal(joe.Manager, mike);
}
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");
}
/// <summary>
/// 将一个JSON字符串反序列化为对象
/// </summary>
/// <typeparam name="T">反序列的对象类型参数</typeparam>
/// <param name="json">JSON字符串</param>
/// <returns>反序列化得到的结果</returns>
public static T FromJson <T>(this string json)
{
DefaultJsonSerializer serializer = ObjectFactory.New <DefaultJsonSerializer>();
return(serializer.Deserialize <T>(json));
}
/// <summary>
/// 将一个JSON字符串反序列化为对象
/// </summary>
/// <param name="json">JSON字符串</param>
/// <param name="destType">反序列的对象类型参数</param>
/// <returns>反序列化得到的结果</returns>
public static object FromJson(this string json, Type destType)
{
DefaultJsonSerializer serializer = ObjectFactory.New <DefaultJsonSerializer>();
return(serializer.Deserialize(json, destType));
}
public IActionResult SSOAuthorizeAsync([FromQuery, BindRequired] Guid uuid, [FromServices] NexusModsAPIKeyProvider apiKeyProvider, [FromServices] DefaultJsonSerializer jsonSerializer, CancellationToken ct)
{
async IAsyncEnumerable <SSEMessage> SSEEvents()
{
var client = new ClientWebSocket();
using var cts = new CancellationTokenSource(60000);
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, ct);
var timeoutToken = linkedCts.Token;
var connectionToken = null as string;
yield return(new SSEMessage(Event: "connecting"));
var receivedAPIKey = false;
async Task ReceiveLoop()
{
var buffer = new ArraySegment <byte>(new byte[1024]);
var sb = new StringBuilder();
while (!timeoutToken.IsCancellationRequested && client.State == WebSocketState.Open)
{
var received = await client.ReceiveAsync(buffer, timeoutToken);
if (received.MessageType == WebSocketMessageType.Close)
{
break;
}
sb.Append(Encoding.UTF8.GetString(buffer.AsSpan(0, received.Count)));
if (received.EndOfMessage)
{
var text = sb.ToString();
sb.Clear();
var response = jsonSerializer.Deserialize <SSOResponse?>(text);
if (response is not null && response.Success && response.Data is not null)
{
if (response.Data.ConnectionToken is not null)
{
connectionToken = response.Data.ConnectionToken;
}
if (response.Data.ApiKey is not null)
{
receivedAPIKey = true;
apiKeyProvider.Override(response.Data.ApiKey);
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Bye", timeoutToken);
}
}
}
}
}
await client.ConnectAsync(new Uri("wss://sso.nexusmods.com"), timeoutToken);
var receiveTask = ReceiveLoop();
var request = jsonSerializer.SerializeToUtf8Bytes(new SSORequest(uuid, connectionToken, 2));
await client.SendAsync(request, WebSocketMessageType.Text, true, timeoutToken);
yield return(new SSEMessage(Event: "connected"));
await receiveTask;
if (!receivedAPIKey)
{
yield return(new SSEMessage(Event: "api-key-failed-to-get"));
}
else
{
yield return(new SSEMessage(Event: "api-key-received"));
}
yield return(new SSEMessage(Event: "finished"));
}
return(new SSEActionResult(SSEEvents()));
}
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(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");
}
