public async Task TestGetAsync()
{
var osc = MongoDatabaseFactory.GetObjectStorageContext();
var collection = osc.GetCollection <Contact>();
var contact = await collection.AddAsync(new Contact
{
FirstName = "David",
LastName = "Lebee"
});
// make sure you can retreive it easily.
var fetchedUsingGetAsync = await collection.GetAsync(contact.Id);
Assert.NotNull(fetchedUsingGetAsync);
Assert.True(await collection.AnyAsync(t => t.Id == contact.Id), "Any async does not work");
Assert.NotNull(await collection.FirstOrDefaultAsync(t => t.Id == contact.Id));
// does not crash.
await collection.FirstAsync(t => t.Id == contact.Id);
// now delete it.
await collection.DeleteAsync(fetchedUsingGetAsync);
}
public async Task CreateUpdateThenDelete()
{
var osc = MongoDatabaseFactory.GetObjectStorageContext();
var collection = osc.GetCollection <Contact>();
var contact = await collection.AddAsync(new Contact
{
FirstName = "Chuck",
LastName = "Not Norris"
});
Assert.NotNull(contact);
contact.LastName = "Norris";
var updatedContact = await collection.UpdateAsync(contact);
Assert.Equal("Norris", updatedContact.LastName);
// update name back to not norris
await collection.UpdateOneAsync(t => t.Id == contact.Id, t => t.LastName, "Not Norris");
var updatedContact2 = await collection.FirstAsync(t => t.Id == contact.Id);
Assert.Equal("Not Norris", updatedContact2.LastName);
// delete the test.
await collection.DeleteAsync(updatedContact);
// check that it was deleted.
var shouldBeNull = collection.AsQueryable().FirstOrDefault(t => t.Id == updatedContact.Id);
Assert.Null(shouldBeNull);
}
public void SubscribeTwoMessageTypesShouldCreateTwoDifferentSubscriptions(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Subscriber subscriber,
ContextBag context,
string messageTypeString1,
string messageTypeString2)
{
var sut = storage as ISubscriptionStorage;
var messageType1 = new MessageType(messageTypeString1, "1.0.0.0");
var messageType2 = new MessageType(messageTypeString2, "1.0.0.0");
sut.Subscribe(subscriber, messageType1, context).Wait();
sut.Subscribe(subscriber, messageType2, context).Wait();
var subscriptions = storage.GetSubscription(messageType1).Result.ToList();
subscriptions.Should().HaveCount(1);
var subscription = subscriptions.First();
subscription.Id.TypeName.Should().Be(messageType1.TypeName);
subscription.Subscribers.Should().HaveCount(1);
subscriptions = storage.GetSubscription(messageType2).Result.ToList();
subscriptions.Should().HaveCount(1);
subscription = subscriptions.First();
subscription.Id.TypeName.Should().Be(messageType2.TypeName);
subscription.Subscribers.Should().HaveCount(1);
}
public void UpdatingSagaWithoutDocumentVersion(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithoutUniqueProperties sagaData)
{
sut.Invoking(s => s.Update(sagaData)).ShouldThrow <InvalidOperationException>();
}
public void UnsubscribeWhenThereAreSubscriptionsShouldRemoveClientsAddress(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Address client,
Address otherClient1,
Address otherClient2,
string messageTypeString1)
{
var sut = storage as ISubscriptionStorage;
var messageTypes = new List <MessageType>()
{
new MessageType(messageTypeString1, "1.0.0.0"),
};
sut.Subscribe(client, messageTypes);
sut.Subscribe(otherClient1, messageTypes);
sut.Subscribe(otherClient2, messageTypes);
sut.GetSubscriberAddressesForMessage(messageTypes).Should().HaveCount(3);
sut.Unsubscribe(client, messageTypes);
var clients = sut.GetSubscriberAddressesForMessage(messageTypes).ToList();
clients.Should().HaveCount(2);
clients.First().Should().Be(otherClient1);
clients.Last().Should().Be(otherClient2);
}
public void UnsubscribeWhenThereAreSubscriptionsShouldRemoveClientsAddress(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Subscriber subscriber,
Subscriber otherSubscriber1,
Subscriber otherSubscriber2,
ContextBag context,
string messageTypeString)
{
var sut = storage as ISubscriptionStorage;
var messageType = new MessageType(messageTypeString, "1.0.0.0");
sut.Subscribe(subscriber, messageType, context).Wait();
sut.Subscribe(otherSubscriber1, messageType, context).Wait();
sut.Subscribe(otherSubscriber2, messageType, context).Wait();
sut.GetSubscriberAddressesForMessage(new List <MessageType>()
{
messageType
}, context)
.Result.Should()
.HaveCount(3);
sut.Unsubscribe(subscriber, messageType, context).Wait();
var clients =
sut.GetSubscriberAddressesForMessage(new List <MessageType>()
{
messageType
}, context).Result.ToList();
clients.Should().HaveCount(2);
clients.First().ShouldBeEquivalentTo(otherSubscriber1);
clients.Last().ShouldBeEquivalentTo(otherSubscriber2);
}
public void SameClientSubscribesTwiceShouldOnlyCreateOneSubscribtion(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
string messageTypeString)
{
var client = new Address("testqueue.publisher", "localhost");
var sut = storage as ISubscriptionStorage;
var messageTypes = new List <MessageType>()
{
new MessageType(messageTypeString, "1.0.0.0")
};
sut.Subscribe(client, messageTypes);
sut.Subscribe(client, messageTypes);
var subscriptions = storage.GetSubscriptions(messageTypes).ToList();
subscriptions.Should().HaveCount(messageTypes.Count);
var subscription = subscriptions.First();
subscription.MessageType.Should().Be(messageTypes.First());
subscription.Clients.Should().HaveCount(1);
subscription.Clients.First().Should().Be(client);
}
public void SavingSagaWithoutDocumentVersionShouldThrowException(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithoutDocumentVersion sagaData)
{
sut.Invoking(s => s.Save(sagaData)).ShouldThrow <InvalidOperationException>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MongoTimeoutPersister"/> class.
/// </summary>
/// <param name="mongoFactory">
/// The mongo factory.
/// </param>
public MongoTimeoutPersister(MongoDatabaseFactory mongoFactory)
{
Contract.Requires <ArgumentNullException>(mongoFactory != null);
this.mongoDatabase = mongoFactory.GetDatabase();
this.EnsureTimeoutIndexes();
}
public MongoDatabaseCollectionProvider(
IEntityPropertyResolver <TContext> propertyResolver,
MongoDatabaseFactory <TContext> factory)
{
_propertyResolver = propertyResolver ?? throw new ArgumentNullException(nameof(propertyResolver));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
}
public void SameClientSubscribesTwiceShouldOnlyCreateOneSubscribtion(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Subscriber subscriber,
ContextBag context,
string messageTypeString)
{
var sut = storage as ISubscriptionStorage;
var messageType = new MessageType(messageTypeString, "1.0.0.0");
sut.Subscribe(subscriber, messageType, context).Wait();
sut.Subscribe(subscriber, messageType, context).Wait();
var subscriptions = storage.GetSubscription(messageType).Result.ToList();
subscriptions.Should().HaveCount(1);
var subscription = subscriptions.First();
subscription.Id.TypeName.Should().Be(messageType.TypeName);
subscription.Subscribers.Should().HaveCount(1);
var firstSubscriber = subscription.Subscribers.First();
firstSubscriber.ShouldBeEquivalentTo(subscriber);
}
public async Task UpdateMany()
{
var osc = MongoDatabaseFactory.GetObjectStorageContext();
var collection = osc.GetCollection <Contact>();
var a = await collection.AddAsync(new Contact
{
LastName = "A",
FirstName = "A"
});
var b = await collection.AddAsync(new Contact
{
LastName = "B",
FirstName = "B"
});
await collection.UpdateManyAsync(t => t.LastName == "A" || t.LastName == "B", t => t.LastName, "C");
var howManyCs = await collection.GetAllAsync(t => t.LastName == "C");
var howManyCs2 = await collection.LongCountAsync(t => t.LastName == "C");
Assert.Equal(2, howManyCs.Count);
Assert.Equal(2, howManyCs2);
// clean up.
await collection.DeleteAsync(a);
await collection.DeleteAsync(b);
}
public void UnsubscribeWhenClientSubscriptionIsTheOnlyOneShouldRemoveOnlyClient(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Subscriber subscriber,
ContextBag context,
string messageTypeString)
{
var sut = storage as ISubscriptionStorage;
var messageType = new MessageType(messageTypeString, "1.0.0.0");
sut.Subscribe(subscriber, messageType, context).Wait();
storage.GetSubscription(messageType).Result.Should().HaveCount(1);
sut.GetSubscriberAddressesForMessage(new List <MessageType>()
{
messageType
}, context)
.Result.Should()
.HaveCount(1);
sut.Unsubscribe(subscriber, messageType, context).Wait();
storage.GetSubscription(messageType).Result.Should().HaveCount(1);
sut.GetSubscriberAddressesForMessage(new List <MessageType>()
{
messageType
}, context)
.Result.Should()
.HaveCount(0);
}
public MongoFhirStoreOther(string mongoUrl, IFhirStore mongoFhirStoreOther)
{
_mongoFhirStoreOther = mongoFhirStoreOther;
_database = MongoDatabaseFactory.GetMongoDatabase(mongoUrl);
_collection = _database.GetCollection <BsonDocument>(Collection.RESOURCE);
//this.transaction = new MongoSimpleTransaction(collection);
}
public void SaveSagaData(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
DeviceCommandSagaState state)
{
sut.Save(state);
}
public void SubscribeTwoMessageTypesShouldCreateTwoSubscriptions(
MongoSubscriptionPersister storage,
MongoDatabaseFactory factory,
Address client,
string messageTypeString1,
string messageTypeString2)
{
var sut = storage as ISubscriptionStorage;
var messageTypes = new List <MessageType>()
{
new MessageType(messageTypeString1, "1.0.0.0"),
new MessageType(messageTypeString2, "1.0.0.0")
};
sut.Subscribe(client, messageTypes);
var subscriptions = storage.GetSubscriptions(messageTypes).ToList();
subscriptions.Should().HaveCount(messageTypes.Count);
subscriptions.ForEach(s =>
{
s.Clients.Should().HaveCount(1);
s.Clients.First().Should().Be(client);
});
}
public void TestingGetCollection()
{
var objectStorageClient = MongoDatabaseFactory.GetObjectStorageContext();
var collection = objectStorageClient.GetCollection <Contact>();
Assert.NotNull(collection);
Assert.NotNull(collection.CollectionName);
}
public void InterleavedSavingSagaShouldThrowException(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithUniqueProperty sagaData)
{
sut.Save(sagaData);
sut.Invoking(s => s.Save(sagaData)).ShouldThrow <MongoDuplicateKeyException>();
}
public static IEnumerable <TimeoutData> RetrieveAllTimeouts(this MongoDatabaseFactory factor)
{
var timeouts = from t in factor.GetDatabase()
.GetCollection <TimeoutData>(MongoTimeoutPersister.TimeoutDataName).AsQueryable()
select t;
return(timeouts);
}
public void SavingSagaWithNullUniquePropertyShouldThrowException(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithUniqueProperty sagaData)
{
sagaData.UniqueProperty = null;
sut.Invoking(s => s.Save(sagaData)).ShouldThrow <ArgumentNullException>();
}
public static void ResetTimeoutCollection(this MongoDatabaseFactory factory)
{
var database = factory.GetDatabase();
database.GetCollection <TimeoutEntity>(MongoTimeoutPersister.TimeoutEntityName)
.DeleteManyAsync(Builders <TimeoutEntity> .Filter.Empty)
.Wait();
}
public void UpdatingNonExistantSagaWithUniqueProperty(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithUniqueProperty sagaData)
{
sut.Invoking(s => s.Update(sagaData)).ShouldThrow <InvalidOperationException>();
factory.RetrieveSagaData(sagaData).Should().BeNull();
}
public static T RetrieveSagaData <T>(this MongoDatabaseFactory factory, T sagaData)
where T : IContainSagaData
{
var query = Builders <T> .Filter.Eq(e => e.Id, sagaData.Id);
var entity = factory.GetDatabase().GetCollection <T>(typeof(T).Name).FindAsync(query).Result.ToList();
return(entity.Any() ? entity.First() : default(T));
}
/// <summary>
/// Initializes a new instance of the <see cref="MongoTimeoutPersister"/> class.
/// </summary>
/// <param name="mongoFactory">
/// The mongo factory.
/// </param>
/// <param name="endpointName">
/// The endpoint Name.
/// </param>
public MongoTimeoutPersister(MongoDatabaseFactory mongoFactory, string endpointName)
{
Contract.Requires <ArgumentNullException>(mongoFactory != null);
this.collection = mongoFactory.GetDatabase().GetCollection <TimeoutEntity>(TimeoutEntityName);
this.endpointName = endpointName;
this.EnsureTimeoutIndexes().Wait();
}
public void UpdatingSagaWithoutDocumentVersion(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithUniqueProperty sagaData,
SagaCorrelationProperty correlationProperty,
SynchronizedStorageSession session,
ContextBag context)
{
sut.Invoking(s => s.Update(sagaData, session, context).Wait()).ShouldThrow <InvalidOperationException>();
}
public void CompletingSagaShouldRemoveDocument(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithoutUniqueProperties sagaData)
{
sut.Save(sagaData);
sut.Complete(sagaData);
factory.RetrieveSagaData(sagaData).Should().BeNull();
}
public static T RetrieveSagaData <T>(this MongoDatabaseFactory factory, T sagaData)
where T : IContainSagaData
{
var query = Query <T> .EQ(e => e.Id, sagaData.Id);
var entity = factory.GetDatabase()
.GetCollection <T>(typeof(T).Name)
.FindOne(query);
return(entity);
}
public static List <TimeoutEntity> RetrieveAllTimeouts(this MongoDatabaseFactory factor)
{
var timeouts =
from t in
factor.GetDatabase()
.GetCollection <TimeoutEntity>(MongoTimeoutPersister.TimeoutEntityName)
.AsQueryable()
select t;
return(timeouts.ToList());
}
public void RemoveTimeoutByIdOnEmptyTimeoutCollection(
MongoTimeoutPersister sut,
MongoDatabaseFactory factory,
Timeout.Core.TimeoutData timeoutData)
{
factory.ResetTimeoutCollection();
sut.RemoveTimeoutBy(timeoutData.SagaId);
factory.RetrieveAllTimeouts().Should().HaveCount(0);
}
public void SavingSagaWithoutUniqueProperty(
MongoSagaPersister sut,
MongoDatabaseFactory factory,
SagaWithoutUniqueProperties sagaData)
{
sut.Save(sagaData);
var entity = factory.RetrieveSagaData(sagaData);
entity.Id.Should().Be(sagaData.Id);
entity.NonUniqueProperty.Should().Be(sagaData.NonUniqueProperty);
}
