public void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
{
FrameDLRObject v = (FrameDLRObject)value;
BsonDocumentSerializer bs = new BsonDocumentSerializer();
BsonDocument bd = new BsonDocument(v.ToDictionary());
bs.Serialize(context, args, bd);
}
public void ResultSerializer_get_should_return_expected_result()
{
var resultSerializer = new BsonDocumentSerializer();
var subject = new FindOpcodeOperation <BsonDocument>(_collectionNamespace, resultSerializer, _messageEncoderSettings);
var result = subject.ResultSerializer;
result.Should().Be(resultSerializer);
}
public MongoDbRepository()
{
var mongoClient = new MongoClient("mongodb://localhost:27017");
var database = mongoClient.GetDatabase("Game");
_collection = database.GetCollection <Player>("players");
_bsonDocumentCollection = database.GetCollection <BsonDocument>("players");
serializer = new BsonDocumentSerializer();
}
public void DocumentSerializer_should_return_expected_result()
{
var documentSerializer = new BsonDocumentSerializer();
var subject = CreateSubject(documentSerializer: documentSerializer);
var result = subject.DocumentSerializer;
result.Should().BeSameAs(documentSerializer);
}
internal void Save(string saveAs, FileFormat format)
{
if (string.IsNullOrEmpty(saveAs))
{
saveAs = FilePath;
format = FileFormat;
}
if (saveAs == null)
{
throw new InvalidOperationException("File path should be provided either on opening or saving.");
}
if (format == FileFormat.Auto)
{
format = saveAs.EndsWith(".json", StringComparison.OrdinalIgnoreCase) ? FileFormat.Json : FileFormat.Bson;
}
var tmp = File.Exists(saveAs) ? saveAs + ".tmp" : saveAs;
var serializer = new BsonDocumentSerializer();
var args = new BsonSerializationArgs();
args.NominalType = typeof(BsonDocument);
if (format == FileFormat.Json)
{
using (var streamWriter = new StreamWriter(tmp))
using (var jsonWriter = new JsonWriter(streamWriter, Actor.DefaultJsonWriterSettings))
{
var context = BsonSerializationContext.CreateRoot(jsonWriter);
foreach (var document in Documents)
{
serializer.Serialize(context, args, document);
streamWriter.WriteLine();
}
}
}
else
{
using (var fileStream = File.Open(tmp, FileMode.Create, FileAccess.Write, FileShare.None))
using (var bsonWriter = new BsonBinaryWriter(fileStream))
{
var context = BsonSerializationContext.CreateRoot(bsonWriter);
foreach (var document in Documents)
{
serializer.Serialize(context, args, document);
}
}
}
if (!object.ReferenceEquals(tmp, saveAs))
{
File.Replace(tmp, saveAs, null);
}
}
internal void Save(string saveAs, FileFormat format)
{
if (string.IsNullOrEmpty(saveAs))
{
saveAs = FilePath;
format = FileFormat;
}
if (saveAs == null)
{
throw new InvalidOperationException("File path should be provided either on opening or saving.");
}
if (format == FileFormat.Auto)
{
format = saveAs.EndsWith(".json", StringComparison.OrdinalIgnoreCase) ? FileFormat.Json : FileFormat.Bson;
}
var tmp = File.Exists(saveAs) ? saveAs + ".tmp" : saveAs;
var serializer = new BsonDocumentSerializer();
var options = DocumentSerializationOptions.Defaults;
if (format == FileFormat.Json)
{
using (var streamWriter = new StreamWriter(tmp))
{
foreach (var document in Documents)
{
using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture))
using (var bsonWriter = BsonWriter.Create(stringWriter, Actor.DefaultJsonWriterSettings))
{
serializer.Serialize(bsonWriter, typeof(BsonDocument), document, options);
streamWriter.WriteLine(stringWriter.ToString());
}
}
}
}
else
{
using (var fileStream = File.Open(tmp, FileMode.Create, FileAccess.Write, FileShare.None))
using (var bsonWriter = BsonWriter.Create(fileStream))
{
foreach (var document in Documents)
{
serializer.Serialize(bsonWriter, typeof(BsonDocument), document, options);
}
}
}
if (!object.ReferenceEquals(tmp, saveAs))
{
File.Replace(tmp, saveAs, null);
}
}
public void constructor_should_initialize_instance()
{
var document = new BsonDocument();
var documentSerializer = new BsonDocumentSerializer();
var result = new Type0CommandMessageSection <BsonDocument>(document, documentSerializer);
result.Document.Should().BeSameAs(document);
result.DocumentSerializer.Should().BeSameAs(documentSerializer);
result.PayloadType.Should().Be(PayloadType.Type0);
}
public void constructor_should_throw_when_resultSerializer_is_null()
{
var databaseNamespace = new DatabaseNamespace("databaseName");
var command = new BsonDocument("command", 1);
BsonDocumentSerializer resultSerializer = null;
var messageEncoderSettings = new MessageEncoderSettings();
Action action = () => new FakeCommandOperation <BsonDocument>(databaseNamespace, command, resultSerializer, messageEncoderSettings);
action.ShouldThrow <ArgumentNullException>().And.ParamName.Should().Be("resultSerializer");
}
public void constructor_should_initialize_instance_when_messageEncoderSettings_is_null()
{
var databaseNamespace = new DatabaseNamespace("databaseName");
var command = new BsonDocument("command", 1);
var resultSerializer = new BsonDocumentSerializer();
MessageEncoderSettings messageEncoderSettings = null;
var result = new FakeCommandOperation <BsonDocument>(databaseNamespace, command, resultSerializer, messageEncoderSettings);
result.MessageEncoderSettings.Should().BeNull();
}
public void constructor_should_initialize_instance()
{
var identifier = "xyz";
var documents = new BatchableSource <BsonDocument>(new List <BsonDocument>(), canBeSplit: false);
var documentSerializer = new BsonDocumentSerializer();
var result = new Type1CommandMessageSection <BsonDocument>(identifier, documents, documentSerializer);
result.Documents.Should().BeSameAs(documents);
result.DocumentSerializer.Should().BeSameAs(documentSerializer);
result.Identifier.Should().BeSameAs(identifier);
result.PayloadType.Should().Be(PayloadType.Type1);
}
public void constructor_should_initialize_instance()
{
var documentSerializer = new BsonDocumentSerializer();
var result = new ChangeStreamDocumentSerializer <BsonDocument>(documentSerializer);
result._documentSerializer().Should().BeSameAs(documentSerializer);
result._memberSerializationInfo().Count.Should().Be(7);
AssertRegisteredMember(result, "ClusterTime", "clusterTime", BsonTimestampSerializer.Instance);
AssertRegisteredMember(result, "CollectionNamespace", "ns", ChangeStreamDocumentCollectionNamespaceSerializer.Instance);
AssertRegisteredMember(result, "DocumentKey", "documentKey", BsonDocumentSerializer.Instance);
AssertRegisteredMember(result, "FullDocument", "fullDocument", documentSerializer);
AssertRegisteredMember(result, "OperationType", "operationType", ChangeStreamOperationTypeSerializer.Instance);
AssertRegisteredMember(result, "ResumeToken", "_id", BsonDocumentSerializer.Instance);
AssertRegisteredMember(result, "UpdateDescription", "updateDescription", ChangeStreamUpdateDescriptionSerializer.Instance);
}
public void constructor_should_initialize_instance()
{
var databaseNamespace = new DatabaseNamespace("databaseName");
var command = new BsonDocument("command", 1);
var resultSerializer = new BsonDocumentSerializer();
var messageEncoderSettings = new MessageEncoderSettings();
var result = new FakeCommandOperation <BsonDocument>(databaseNamespace, command, resultSerializer, messageEncoderSettings);
result.AdditionalOptions.Should().BeNull();
result.Command.Should().BeSameAs(command);
result.CommandValidator.Should().BeOfType <NoOpElementNameValidator>();
result.Comment.Should().BeNull();
result.DatabaseNamespace.Should().BeSameAs(databaseNamespace);
result.ResultSerializer.Should().BeSameAs(resultSerializer);
result.MessageEncoderSettings.Should().BeSameAs(messageEncoderSettings);
}
public void constructor_should_initialize_instance(
[Values(null, 1, 2)] int?maxBatchCount,
[Values(null, 3, 4)] int?maxDocumentSize)
{
var identifier = "xyz";
var documents = new BatchableSource <BsonDocument>(new List <BsonDocument>(), canBeSplit: false);
var documentSerializer = new BsonDocumentSerializer();
var elementNameValidator = Mock.Of <IElementNameValidator>();
var result = new Type1CommandMessageSection <BsonDocument>(identifier, documents, documentSerializer, elementNameValidator, maxBatchCount, maxDocumentSize);
result.Documents.Should().BeSameAs(documents);
result.DocumentSerializer.Should().BeSameAs(documentSerializer);
result.ElementNameValidator.Should().BeSameAs(elementNameValidator);
result.Identifier.Should().BeSameAs(identifier);
result.PayloadType.Should().Be(PayloadType.Type1);
result.MaxBatchCount.Should().Be(maxBatchCount);
result.MaxDocumentSize.Should().Be(maxDocumentSize);
}
public async Task <GeocodeComponents> LookupGeocode(string query)
{
// build request
var request = new RestRequest("geocode/json");
request.AddQueryParameter("key", _apiKey);
request.AddQueryParameter("address", query);
// get results
var response = await RestClient.ExecuteGetTaskAsync(request);
using (var jsonReader = new MongoDB.Bson.IO.JsonReader(response.Content))
{
// parse to bson
var serializer = new BsonDocumentSerializer();
var bsonDocument = serializer.Deserialize(BsonDeserializationContext.CreateRoot(jsonReader));
// cast to geocode components
var geocode = new GeocodeComponents(bsonDocument);
return(geocode);
}
}
public async Task <List <BsonDocument> > GetUsers(List <BsonDocument> statistics)
{
var users = await Task.WhenAll(statistics.Select(async o =>
{
// get user login
var login = o["author"]["login"].AsString;
// retrieve user
var requestUrl = $"users/{login}";
var response = await GitClient.ExecuteAsGitGetTaskAsync(_token, requestUrl);
// parse and return
using (var jsonReader = new MongoDB.Bson.IO.JsonReader(response.Content))
{
var serializer = new BsonDocumentSerializer();
var bsonDocument = serializer.Deserialize(BsonDeserializationContext.CreateRoot(jsonReader));
return(bsonDocument);
}
}));
return(new List <BsonDocument>(users));
}
