public void ReaderToWriter(
CurratedDocsPayload payload,
SerializationFormat sourceFormat,
SerializationFormat destinationFormat)
{
IJsonReader reader = sourceFormat switch
{
SerializationFormat.Text => JsonReader.Create(payload.Text),
SerializationFormat.Binary => JsonReader.Create(payload.Binary),
SerializationFormat.BinaryWithDictionaryEncoding => JsonReader.Create(
payload.BinaryWithDictionaryEncoding.binary,
payload.BinaryWithDictionaryEncoding.dictionary),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBReader.CreateFromBuffer(payload.Text),
_ => throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: '{sourceFormat}'"),
};
IJsonWriter writer = destinationFormat switch
{
SerializationFormat.Text => JsonWriter.Create(JsonSerializationFormat.Text),
SerializationFormat.Binary => JsonWriter.Create(JsonSerializationFormat.Binary),
SerializationFormat.BinaryWithDictionaryEncoding => JsonWriter.Create(
JsonSerializationFormat.Binary,
new JsonStringDictionary(capacity: 128)),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBWriter.CreateTextWriter(),
_ => throw new ArgumentException($"Unexpected {nameof(destinationFormat)} of type: {destinationFormat}"),
};
writer.WriteAll(reader);
}
public static string ConvertBinaryToText(byte[] binary)
{
IJsonReader binaryReader = JsonReader.Create(binary);
IJsonWriter textWriter = JsonWriter.Create(JsonSerializationFormat.Text);
textWriter.WriteAll(binaryReader);
return(Encoding.UTF8.GetString(textWriter.GetResult().ToArray()));
}
public static ReadOnlyMemory <byte> ConvertTextToBinary(string text)
{
IJsonWriter binaryWriter = JsonWriter.Create(JsonSerializationFormat.Binary);
IJsonReader textReader = JsonReader.Create(Encoding.UTF8.GetBytes(text));
binaryWriter.WriteAll(textReader);
return(binaryWriter.GetResult());
}
public static byte[] ConvertTextToBinary(string text, JsonStringDictionary jsonStringDictionary = null)
{
IJsonWriter binaryWriter = JsonWriter.Create(JsonSerializationFormat.Binary, jsonStringDictionary);
IJsonReader textReader = JsonReader.Create(Encoding.UTF8.GetBytes(text));
binaryWriter.WriteAll(textReader);
return(binaryWriter.GetResult().ToArray());
}
public static string ConvertBinaryToText(ReadOnlyMemory <byte> binary, JsonStringDictionary jsonStringDictionary = null)
{
IJsonReader binaryReader = JsonReader.Create(binary, jsonStringDictionary);
IJsonWriter textWriter = JsonWriter.Create(JsonSerializationFormat.Text);
textWriter.WriteAll(binaryReader);
return(Encoding.UTF8.GetString(textWriter.GetResult().ToArray()));
}
private string FormatJson(string json)
{
// Feed the json through our reader and writer once to remove and formatting and escaping differences
IJsonReader jsonReaderFormatter = JsonReader.Create(Encoding.UTF8.GetBytes(json));
IJsonWriter jsonWriterFormatter = JsonWriter.Create(JsonSerializationFormat.Text);
jsonWriterFormatter.WriteAll(jsonReaderFormatter);
string formattedJson = Encoding.UTF8.GetString(jsonWriterFormatter.GetResult());
return(formattedJson);
}
private void TextRoundTrip(string input)
{
string formattedJson = this.FormatJson(input);
IJsonReader jsonReader = JsonReader.Create(Encoding.UTF8.GetBytes(formattedJson));
IJsonWriter jsonWriter = JsonWriter.Create(JsonSerializationFormat.Text);
jsonWriter.WriteAll(jsonReader);
string jsonFromWriter = Encoding.UTF8.GetString(jsonWriter.GetResult());
Assert.AreEqual(formattedJson, jsonFromWriter);
}
/// <summary>
/// Reads all the tokens from the input string using a JsonReader and writes them to a JsonReader and sees if we get back the same result.
/// </summary>
/// <param name="input">The input to read from.</param>
private void TestReaderToWriter(string input)
{
IJsonReader jsonReader = JsonReader.Create(Encoding.UTF8.GetBytes(input));
IJsonWriter jsonWriter = JsonWriter.Create(JsonSerializationFormat.Text);
jsonWriter.WriteAll(jsonReader);
string output = Encoding.UTF8.GetString(jsonWriter.GetResult());
string inputNoWhitespace = Regex.Replace(input, @"\s+", "");
string outputNoWhitespace = Regex.Replace(output, @"\s+", "");
Assert.AreEqual(inputNoWhitespace, outputNoWhitespace);
}
public async Task ItemQueryStreamSerializationSetting()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(101, randomPartitionKey : true);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("SELECT * FROM toDoActivity t ORDER BY t.taskNum");
CosmosSerializationOptions options = new CosmosSerializationOptions(
ContentSerializationFormat.CosmosBinary.ToString(),
(content) => JsonNavigator.Create(content),
() => JsonWriter.Create(JsonSerializationFormat.Binary));
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
CosmosSerializationOptions = options
};
List <ToDoActivity> resultList = new List <ToDoActivity>();
double totalRequstCharge = 0;
CosmosResultSetIterator setIterator =
this.Container.Items.CreateItemQueryAsStream(sql, maxConcurrency: 5, maxItemCount: 5, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
using (CosmosQueryResponse iter = await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(iter.IsSuccess);
Assert.IsNull(iter.ErrorMessage);
Assert.IsTrue(iter.Count <= 5);
totalRequstCharge += iter.RequestCharge;
IJsonReader reader = JsonReader.Create(iter.Content);
IJsonWriter textWriter = JsonWriter.Create(JsonSerializationFormat.Text);
textWriter.WriteAll(reader);
string json = Encoding.UTF8.GetString(textWriter.GetResult());
Assert.IsNotNull(json);
ToDoActivity[] responseActivities = JsonConvert.DeserializeObject <ToDoActivity[]>(json);
resultList.AddRange(responseActivities);
}
}
Assert.AreEqual(deleteList.Count, resultList.Count);
Assert.IsTrue(totalRequstCharge > 0);
List <ToDoActivity> verifiedOrderBy = deleteList.OrderBy(x => x.taskNum).ToList();
for (int i = 0; i < verifiedOrderBy.Count(); i++)
{
Assert.AreEqual(verifiedOrderBy[i].taskNum, resultList[i].taskNum);
Assert.AreEqual(verifiedOrderBy[i].id, resultList[i].id);
}
}
public async Task DecryptQueryBinaryResponse()
{
TestDoc testDoc = await EncryptionTests.CreateItemAsync(EncryptionTests.containerCore, EncryptionTests.dekId, TestDoc.PathsToEncrypt);
CosmosSerializationFormatOptions options = new CosmosSerializationFormatOptions(
Documents.ContentSerializationFormat.CosmosBinary.ToString(),
(content) => JsonNavigator.Create(content),
() => JsonWriter.Create(JsonSerializationFormat.Binary));
QueryRequestOptions requestOptions = new QueryRequestOptions()
{
CosmosSerializationFormatOptions = options
};
TestDoc expectedDoc = new TestDoc(testDoc);
string query = "SELECT * FROM c";
FeedIterator feedIterator = EncryptionTests.containerCore.GetItemQueryStreamIterator(
query,
requestOptions: requestOptions);
while (feedIterator.HasMoreResults)
{
ResponseMessage response = await feedIterator.ReadNextAsync();
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.IsNull(response.ErrorMessage);
// Copy the stream and check that the first byte is the correct value
MemoryStream memoryStream = new MemoryStream();
response.Content.CopyTo(memoryStream);
byte[] content = memoryStream.ToArray();
response.Content.Position = 0;
// Examine the first buffer byte to determine the serialization format
byte firstByte = content[0];
Assert.AreEqual(128, firstByte);
Assert.AreEqual(JsonSerializationFormat.Binary, (JsonSerializationFormat)firstByte);
IJsonReader reader = JsonReader.Create(content);
IJsonWriter textWriter = JsonWriter.Create(JsonSerializationFormat.Text);
textWriter.WriteAll(reader);
string json = Encoding.UTF8.GetString(textWriter.GetResult().ToArray());
Assert.IsNotNull(json);
Assert.IsTrue(json.Contains(testDoc.Sensitive));
}
}
private static void ExecuteReaderBenchmark(
CurratedDocsPayload payload,
SerializationFormat sourceFormat,
SerializationFormat destinationFormat)
{
IJsonReader reader = sourceFormat switch
{
SerializationFormat.Text => JsonReader.Create(payload.Text),
SerializationFormat.Binary => JsonReader.Create(payload.Binary),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBReader.CreateFromBuffer(payload.Text),
_ => throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: '{sourceFormat}'"),
};
IJsonWriter writer = destinationFormat switch
{
SerializationFormat.Text => JsonWriter.Create(JsonSerializationFormat.Text),
SerializationFormat.Binary => JsonWriter.Create(JsonSerializationFormat.Binary),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBWriter.CreateTextWriter(),
_ => throw new ArgumentException($"Unexpected {nameof(destinationFormat)} of type: {destinationFormat}"),
};
writer.WriteAll(reader);
}
private static ReadOnlyMemory <byte> GetPayload(string filename)
{
string path = string.Format("TestJsons/{0}", filename);
string json = TextFileConcatenation.ReadMultipartFile(path);
IEnumerable <object> documents = null;
try
{
try
{
documents = JsonConvert.DeserializeObject <List <object> >(json);
}
catch (JsonSerializationException)
{
documents = new List <object>
{
JsonConvert.DeserializeObject <object>(json)
};
}
}
catch (Exception ex)
{
Assert.Fail($"Failed to get JSON payload: {json.Substring(0, 128)} {ex}");
}
documents = documents.OrderBy(x => Guid.NewGuid()).Take(100);
json = JsonConvert.SerializeObject(documents);
IJsonReader jsonReader = Microsoft.Azure.Cosmos.Json.JsonReader.Create(Encoding.UTF8.GetBytes(json));
IJsonWriter jsonWriter = Microsoft.Azure.Cosmos.Json.JsonWriter.Create(JsonSerializationFormat.Binary);
jsonWriter.WriteAll(jsonReader);
return(jsonWriter.GetResult());
}
