public void JsonDeserialize_WhenHasLazyStringProperty_ShouldResultInCopy()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext readContext))
{
Command actual;
LazyStringValue expected;
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext writeContext))
using (var writer = new BlittableJsonWriter(writeContext))
{
expected = readContext.GetLazyString("Some Lazy String");
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
jsonSerializer.Converters.Add(LazyStringValueJsonConverter.Instance);
var command = new Command {
LazyString = expected
};
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
var toDeseialize = writer.CreateReader();
using (var reader = new BlittableJsonReader(readContext))
{
reader.Initialize(toDeseialize);
actual = jsonSerializer.Deserialize <Command>(reader);
}
}
Assert.Equal(expected, actual.LazyString);
}
}
public void JsonSerialize_WhenLazyStringValueIsProperty_ShouldSerialize()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
using (var writer = new BlittableJsonWriter(context))
{
var expected = context.GetLazyString("igal");
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
jsonSerializer.Converters.Add(LazyStringValueJsonConverter.Instance);
var command = new Command {
LazyString = expected
};
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
//Assert
var reader = writer.CreateReader();
reader.TryGet(nameof(Command.LazyString), out LazyStringValue actual);
Assert.Equal(expected, actual);
}
}
public void JsonDeserialize_WhenHasBlittableObjectProperty_ShouldResultInCopy()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext readContext))
{
Command actual;
BlittableJsonReaderObject expected;
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext writeContext))
using (var writer = new BlittableJsonWriter(writeContext))
{
var data = new { Property = "Value" };
expected = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, readContext);
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
};
jsonSerializer.Converters.Add(BlittableJsonConverter.Instance);
var command = new Command {
BlittableObject = expected
};
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
var toDeseialize = writer.CreateReader();
using (var reader = new BlittableJsonReader(readContext))
{
reader.Initialize(toDeseialize);
actual = jsonSerializer.Deserialize <Command>(reader);
}
}
Assert.Equal(expected, actual.BlittableObject);
}
}
internal static object ConvertToBlittableForCompareExchangeIfNeeded(
object value,
DocumentConventions conventions,
JsonOperationContext context,
JsonSerializer serializer,
DocumentInfo documentInfo,
bool removeIdentityProperty = true)
{
if (value == null)
{
return(null);
}
if (value is ValueType ||
value is string ||
value is BlittableJsonReaderArray)
{
return(value);
}
if (value is IEnumerable enumerable && !(enumerable is IDictionary))
{
return(enumerable.Cast <object>()
.Select(v => ConvertToBlittableForCompareExchangeIfNeeded(v, conventions, context, serializer, documentInfo, removeIdentityProperty)));
}
using (var writer = new BlittableJsonWriter(context, documentInfo))
return(ConvertEntityToBlittableInternal(value, conventions, context, serializer, writer, removeIdentityProperty));
}
public void JsonSerialize_WhenBlittableObjectIsProperty_ShouldResultInCopy()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
using (var writer = new BlittableJsonWriter(context))
{
var data = new { Property = "Value" };
var expected = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context);
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
jsonSerializer.Converters.Add(BlittableJsonConverter.Instance);
var command = new Command {
BlittableObject = expected
};
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
//Assert
var reader = writer.CreateReader();
reader.TryGet(nameof(Command.BlittableObject), out BlittableJsonReaderObject actual);
Assert.Equal(expected, actual);
}
}
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentInfo documentInfo)
{
//maybe we don't need to do anything..
var blittable = entity as BlittableJsonReaderObject;
if (blittable != null)
{
return(blittable);
}
using (var writer = new BlittableJsonWriter(_session.Context, documentInfo))
{
var serializer = _session.Conventions.CreateSerializer();
serializer.Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
var type = entity.GetType();
var changes = TryRemoveIdentityProperty(reader, type, _session.Conventions);
changes |= TrySimplifyJson(reader);
if (changes)
{
reader = _session.Context.ReadObject(reader, "convert/entityToBlittable");
}
return(reader);
}
}
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentInfo documentInfo)
{
//maybe we don't need to do anything..
if (entity is BlittableJsonReaderObject blittable)
{
return(blittable);
}
if (documentInfo != null)
{
_session.OnBeforeConversionToDocumentInvoke(documentInfo.Id, entity);
}
using (DefaultRavenContractResolver.RegisterExtensionDataGetter(FillMissingProperties))
using (var writer = new BlittableJsonWriter(_session.Context, documentInfo))
{
var document = ConvertEntityToBlittableInternal(entity, _session.Conventions, _session.Context, _session.JsonSerializer, writer);
if (documentInfo != null)
{
_session.OnAfterConversionToDocumentInvoke(documentInfo.Id, entity, ref document);
}
return(document);
}
}
public void JsonSerialize_WhenNestedBlittableObjectIsProperty_ShouldSerialize()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
//TODO To consider if should support direct couple of write on the same context
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context2))
using (var writer = new BlittableJsonWriter(context2))
{
var data = new { ParentProperty = new { NestedProperty = "Some Value" } };
var parentBlittable = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context);
parentBlittable.TryGet(nameof(data.ParentProperty), out BlittableJsonReaderObject expected);
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
jsonSerializer.Converters.Add(BlittableJsonConverter.Instance);
var command = new Command {
BlittableObject = expected
};
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
//Assert
var reader = writer.CreateReader();
reader.TryGet(nameof(Command.BlittableObject), out BlittableJsonReaderObject actual);
Assert.Equal(expected, actual);
}
}
public bool MoveNext()
{
if (_enumerator.MoveNext() == false)
{
return(false);
}
var output = _enumerator.Current;
_parent._indexContext.CachedProperties.NewDocument();
using (_createBlittableResult.Start())
using (var writer = new BlittableJsonWriter(_parent._indexContext))
{
IPropertyAccessor accessor;
if (_parent._isMultiMap == false)
{
accessor = _parent._propertyAccessor ??
(_parent._propertyAccessor = PropertyAccessor.CreateMapReduceOutputAccessor(output.GetType(), output, _groupByFields));
}
else
{
accessor = TypeConverter.GetPropertyAccessorForMapReduceOutput(output, _groupByFields);
}
_reduceKeyProcessor.Reset();
writer.WriteStartObject();
foreach (var property in accessor.GetPropertiesInOrder(output))
{
var value = property.Value;
var blittableValue = TypeConverter.ToBlittableSupportedType(value, context: _parent._indexContext);
writer.WritePropertyName(property.Key);
WriteValue(writer, blittableValue);
if (property.IsGroupByField)
{
var valueForProcessor = property.GroupByField.GetValue(value, blittableValue);
_reduceKeyProcessor.Process(_parent._indexContext.Allocator, valueForProcessor);
}
}
writer.WriteEndObject();
if (_reduceKeyProcessor.ProcessedFields != _groupByFields.Count)
{
ThrowMissingGroupByFieldsInMapOutput(output, _groupByFields, _parent._compiledIndex);
}
var reduceHashKey = _reduceKeyProcessor.Hash;
writer.FinalizeDocument();
Current.Data = writer.CreateReader();
Current.ReduceKeyHash = reduceHashKey;
}
return(true);
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentInfo documentInfo)
{
//maybe we don't need to do anything..
if (entity is BlittableJsonReaderObject blittable)
{
return(blittable);
}
using (DefaultRavenContractResolver.RegisterExtensionDataGetter(FillMissingProperties))
using (var writer = new BlittableJsonWriter(_session.Context, documentInfo))
{
var serializer = _session.Conventions.CreateSerializer();
serializer.Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
var type = entity.GetType();
var changes = TryRemoveIdentityProperty(reader, type, _session.Conventions);
changes |= TrySimplifyJson(reader);
if (changes)
{
reader = _session.Context.ReadObject(reader, "convert/entityToBlittable");
}
return(reader);
}
}
public void ConcurrentWrite_WhenResetCachedPropertiesForNewDocument_ShouldThrowInformativeException()
{
Assert.Throws <InvalidOperationException>(() =>
{
using (var context = JsonOperationContext.ShortTermSingleUse())
using (var writer = new BlittableJsonWriter(context))
using (var secondWriter = new BlittableJsonWriter(context))
{
secondWriter.WriteStartObject();
secondWriter.WritePropertyName("Property1");
secondWriter.WriteValue(4);
secondWriter.WriteEndObject();
context.CachedProperties.NewDocument();
writer.WriteStartObject();
writer.WritePropertyName("ObjectProp");
writer.WriteValue(4);
writer.WriteEndObject();
writer.FinalizeDocument();
var first = writer.CreateReader();
secondWriter.FinalizeDocument();
var second = secondWriter.CreateReader();
}
});
}
private object AddTypeNameToValueIfNeeded(Type propertyType, object value)
{
var typeOfValue = value.GetType();
if (propertyType == typeOfValue || typeOfValue.IsClass == false)
{
return(value);
}
using (var writer = new BlittableJsonWriter(Context))
{
// the type of the object that's being serialized
// is not the same as its declared type.
// so we need to include $type in json
var serializer = Conventions.CreateSerializer();
serializer.TypeNameHandling = TypeNameHandling.Objects;
writer.WriteStartObject();
writer.WritePropertyName("Value");
serializer.Serialize(writer, value);
writer.WriteEndObject();
writer.FinalizeDocument();
var reader = writer.CreateReader();
return(reader["Value"]);
}
}
//Todo To consider if should support direct serialize of BlittableObject
public void JsonSerialize_WhenBlittableIsTheRoot_ShouldResultInCopy()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
using (var writer = new BlittableJsonWriter(context))
{
var data = new DynamicJsonValue
{
["Property"] = "Value"
};
var blittableData = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context);
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
jsonSerializer.Converters.Add(BlittableJsonConverter.Instance);
jsonSerializer.Serialize(writer, blittableData);
writer.FinalizeDocument();
//Assert
var result = writer.CreateReader();
Assert.True(result.TryGet(nameof(data), out object _));
}
}
public void JsonDeserialize_WhenBlittableArrayBlittableObjectAndLazyStringAreNull_ShouldResultInCopy()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext readContext))
{
Command actual;
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext writeContext))
using (var writer = new BlittableJsonWriter(writeContext))
{
var jsonSerializer = new JsonSerializer
{
ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization),
};
jsonSerializer.Converters.Add(BlittableJsonReaderArrayConverter.Instance);
jsonSerializer.Converters.Add(LazyStringValueJsonConverter.Instance);
jsonSerializer.Converters.Add(BlittableJsonConverter.Instance);
var command = new Command();
jsonSerializer.Serialize(writer, command);
writer.FinalizeDocument();
var toDeseialize = writer.CreateReader();
using (var reader = new BlittableJsonReader(readContext))
{
reader.Initialize(toDeseialize);
actual = jsonSerializer.Deserialize <Command>(reader);
}
}
Assert.Null(actual.BlittableArray);
Assert.Null(actual.BlittableObject);
Assert.Null(actual.LazyString);
}
}
public void SerializeAndDeserialize_MergedPutCommandTest()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
//Arrange
var data = new { ParentProperty = new { NestedProperty = "Some Value" } };
var document = EntityToBlittable.ConvertCommandToBlittable(data, context);
var changeVector = context.GetLazyString("Some Lazy String");
var expected = new MergedPutCommand(document, "user/", changeVector, null);
//Action
var jsonSerializer = GetJsonSerializer();
BlittableJsonReaderObject blitCommand;
using (var writer = new BlittableJsonWriter(context))
{
var dto = expected.ToDto(context);
jsonSerializer.Serialize(writer, dto);
writer.FinalizeDocument();
blitCommand = writer.CreateReader();
}
var fromStream = SerializeTestHelper.SimulateSavingToFileAndLoading(context, blitCommand);
MergedPutCommand actual;
using (var reader = new BlittableJsonReader(context))
{
reader.Init(fromStream);
var dto = jsonSerializer.Deserialize <MergedPutCommand.MergedPutCommandDto>(reader);
actual = dto.ToCommand(null, null);
}
//Assert
Assert.Equal(expected, actual, new CustomComparer <MergedPutCommand>(context));
}
}
internal static BlittableJsonReaderObject ConvertCommandToBlittable(
object entity,
JsonOperationContext context
)
{
using (var writer = new BlittableJsonWriter(context))
{
DocumentConventions.Default.CreateSerializer().Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
var type = entity.GetType();
var changes = TrySimplifyJson(reader, type);
if (changes)
{
using (var old = reader)
{
return(context.ReadObject(reader, "convert/entityToBlittable"));
}
}
return(reader);
}
}
public void SerializeAndDeserialize_DeleteDocumentCommandTest()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
//Arrange
var expected = new DeleteDocumentCommand("Some Id", "Some Change Vector", null);
//Action
var jsonSerializer = GetJsonSerializer();
BlittableJsonReaderObject blitCommand;
using (var writer = new BlittableJsonWriter(context))
{
var dto = expected.ToDto(context);
jsonSerializer.Serialize(writer, dto);
writer.FinalizeDocument();
blitCommand = writer.CreateReader();
}
var fromStream = SerializeTestHelper.SimulateSavingToFileAndLoading(context, blitCommand);
DeleteDocumentCommand actual;
using (var reader = new BlittableJsonReader(context))
{
reader.Init(fromStream);
var dto = jsonSerializer.Deserialize <DeleteDocumentCommandDto>(reader);
actual = dto.ToCommand(null, null);
}
//Assert
Assert.Equal(expected, actual, new CustomComparer <DeleteDocumentCommand>(context));
}
}
private static BlittableJsonReaderObject ConvertEntityToBlittableInternal(
object entity,
DocumentConventions conventions,
JsonOperationContext context,
JsonSerializer serializer,
BlittableJsonWriter writer)
{
serializer.Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
var type = entity.GetType();
var changes = TryRemoveIdentityProperty(reader, type, conventions);
changes |= TrySimplifyJson(reader);
if (changes)
{
using (var old = reader)
{
reader = context.ReadObject(reader, "convert/entityToBlittable");
}
}
return(reader);
}
public void SerializeAndDeserialize_MergedPutAttachmentCommand()
{
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
using (var database = CreateDocumentDatabase())
{
//Arrange
var recordFilePath = NewDataPath();
var attachmentStream = new StreamsTempFile(recordFilePath, database);
var stream = attachmentStream.StartNewStream();
const string bufferContent = "Menahem";
var buffer = Encoding.ASCII.GetBytes(bufferContent);
stream.Write(buffer);
var changeVector = context.GetLazyString("Some Lazy String");
var expected = new AttachmentHandler.MergedPutAttachmentCommand
{
DocumentId = "someId",
Name = "someName",
ExpectedChangeVector = changeVector,
ContentType = "someContentType",
Stream = stream,
Hash = "someHash",
};
//Serialize
var jsonSerializer = GetJsonSerializer();
BlittableJsonReaderObject blitCommand;
using (var writer = new BlittableJsonWriter(context))
{
var dto = expected.ToDto(context);
jsonSerializer.Serialize(writer, dto);
writer.FinalizeDocument();
blitCommand = writer.CreateReader();
}
var fromStream = SerializeTestHelper.SimulateSavingToFileAndLoading(context, blitCommand);
//Deserialize
AttachmentHandler.MergedPutAttachmentCommand actual;
using (var reader = new BlittableJsonReader(context))
{
reader.Init(fromStream);
var dto = jsonSerializer.Deserialize <MergedPutAttachmentCommandDto>(reader);
actual = dto.ToCommand(null, null);
}
//Assert
Assert.Equal(expected, actual,
new CustomComparer <AttachmentHandler.MergedPutAttachmentCommand>(context, new [] { typeof(Stream) }));
stream.Seek(0, SeekOrigin.Begin);
var expectedStream = expected.Stream.ReadData();
var actualStream = actual.Stream.ReadData();
Assert.Equal(expectedStream, actualStream);
}
}
protected override void WriteJson(BlittableJsonWriter writer, BlittableJsonReaderArray value, JsonSerializer serializer)
{
writer.WriteStartArray();
foreach (var item in value)
{
serializer.Serialize(writer, item);
}
writer.WriteEndArray();
}
protected override void WriteJson(BlittableJsonWriter writer, Slice value, JsonSerializer serializer)
{
var buffer = new byte[value.Size];
value.CopyTo(buffer);
var strValue = Convert.ToBase64String(buffer);
writer.WriteValue(strValue);
}
internal static BlittableJsonReaderObject ConvertEntityToBlittable(
object entity,
DocumentConventions conventions,
JsonOperationContext context,
JsonSerializer serializer,
DocumentInfo documentInfo)
{
using (var writer = new BlittableJsonWriter(context, documentInfo))
return(ConvertEntityToBlittableInternal(entity, conventions, context, serializer, writer));
}
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentInfo documentInfo)
{
var writer = new BlittableJsonWriter(_session.Context, documentInfo);
var serializer = _session.Conventions.CreateSerializer();
serializer.Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
return(reader);
}
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentConvention documentConvention, JsonOperationContext jsonOperationContext, DocumentInfo documentInfo = null)
{
var writer = new BlittableJsonWriter(jsonOperationContext, documentInfo);
var serializer = documentConvention.CreateSerializer();
serializer.Serialize(writer, entity);
writer.FinalizeDocument();
var reader = writer.CreateReader();
return(reader);
}
internal static BlittableJsonReaderObject ConvertCommandToBlittable(
object entity,
JsonOperationContext context
)
{
using (var writer = new BlittableJsonWriter(context))
{
DocumentConventions.Default.CreateSerializer().Serialize(writer, entity);
writer.FinalizeDocument();
return(writer.CreateReader());
}
}
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentInfo documentInfo)
{
//maybe we don't need to do anything..
if (entity is BlittableJsonReaderObject blittable)
{
return(blittable);
}
using (DefaultRavenContractResolver.RegisterExtensionDataGetter(FillMissingProperties))
using (var writer = new BlittableJsonWriter(_session.Context, documentInfo))
{
return(ConvertEntityToBlittableInternal(entity, _session.Conventions, _session.Context, _session.JsonSerializer, writer));
}
}
public async Task SerializeAndDeserialize_MergedBatchPutCommandTest()
{
using (var database = CreateDocumentDatabase())
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
//Arrange
var data = new { ParentProperty = new { NestedProperty = "Some Value" } };
var expected = new DatabaseDestination.MergedBatchPutCommand(database, BuildVersionType.V4, null);
var document = new DocumentItem
{
Document = new Document
{
ChangeVector = "Some Change Vector",
Data = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context),
Id = context.GetLazyString("Some Id")
}
};
expected.Add(document);
//Action
var jsonSerializer = GetJsonSerializer();
BlittableJsonReaderObject blitCommand;
using (var writer = new BlittableJsonWriter(context))
{
var dto = expected.ToDto(context);
jsonSerializer.Serialize(writer, dto);
writer.FinalizeDocument();
blitCommand = writer.CreateReader();
}
var fromStream = await SerializeTestHelper.SimulateSavingToFileAndLoadingAsync(context, blitCommand);
DatabaseDestination.MergedBatchPutCommand actual;
using (var reader = new BlittableJsonReader(context))
{
reader.Initialize(fromStream);
var dto = jsonSerializer.Deserialize <DatabaseDestination.MergedBatchPutCommandDto>(reader);
actual = dto.ToCommand(context, database);
}
//Assert
var expectedDoc = expected.Documents[0].Document;
var actualDoc = actual.Documents[0].Document;
Assert.Equal(expectedDoc.Id, actualDoc.Id);
Assert.Equal(expectedDoc.ChangeVector, actualDoc.ChangeVector);
Assert.Equal(expectedDoc.Data, actualDoc.Data);
}
}
public async Task SerializeAndDeserialize_MergedInsertBulkCommandTest()
{
using (var database = CreateDocumentDatabase())
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
//Arrange
var data = new { ParentProperty = new { NestedProperty = "Some Value" } };
var commands = new[]
{
new BatchRequestParser.CommandData
{
Type = CommandType.PUT,
Id = "Some Id",
ChangeVector = context.GetLazyString("Some Lazy String"),
Document = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context),
Patch = new PatchRequest("Some Script", PatchRequestType.None)
}
};
var expected = new BulkInsertHandler.MergedInsertBulkCommand
{
NumberOfCommands = commands.Length,
Commands = commands
};
//Action
var jsonSerializer = GetJsonSerializer();
BlittableJsonReaderObject blitCommand;
using (var writer = new BlittableJsonWriter(context))
{
var dto = expected.ToDto(context);
jsonSerializer.Serialize(writer, dto);
writer.FinalizeDocument();
blitCommand = writer.CreateReader();
}
var fromStream = await SerializeTestHelper.SimulateSavingToFileAndLoadingAsync(context, blitCommand);
BulkInsertHandler.MergedInsertBulkCommand actual;
using (var reader = new BlittableJsonReader(context))
{
reader.Initialize(fromStream);
var dto = jsonSerializer.Deserialize <MergedInsertBulkCommandDto>(reader);
actual = dto.ToCommand(context, database);
}
//Assert
Assert.Equal(expected, actual, new CustomComparer <BulkInsertHandler.MergedInsertBulkCommand>(context));
}
}
private static BlittableJsonReaderObject SerializeRecordingCommandDetails(
JsonOperationContext context,
RecordingDetails commandDetails)
{
using (var writer = new BlittableJsonWriter(context))
{
var jsonSerializer = ReplayTxCommandHelper.GetJsonSerializer();
jsonSerializer.Serialize(writer, commandDetails);
writer.FinalizeDocument();
return(writer.CreateReader());
}
}
protected override void WriteJson(BlittableJsonWriter writer, Stream value, JsonSerializer serializer)
{
if (false == value.CanSeek)
{
throw new SerializationException("Try to serialize stream that can't seek");
}
value.Seek(0, SeekOrigin.Begin);
var buffer = value.ReadData();
value.Seek(0, SeekOrigin.Begin);
var strBuffer = Convert.ToBase64String(buffer);
writer.WriteValue(strBuffer);
}
