public PartitionControllerTests()
{
this.lease = Mock.Of <DocumentServiceLease>();
Mock.Get(this.lease)
.Setup(l => l.CurrentLeaseToken)
.Returns("partitionId");
this.partitionProcessor = MockPartitionProcessor();
this.leaseRenewer = MockRenewer();
this.observer = Mock.Of <ChangeFeedObserver>();
this.partitionSupervisorFactory = Mock.Of <PartitionSupervisorFactory>(f => f.Create(this.lease) == new PartitionSupervisorCore(this.lease, this.observer, this.partitionProcessor, this.leaseRenewer));
this.leaseManager = Mock.Of <DocumentServiceLeaseManager>();
Mock.Get(this.leaseManager).Reset(); // Reset implicit/by default setup of properties.
Mock.Get(this.leaseManager)
.Setup(manager => manager.AcquireAsync(this.lease))
.ReturnsAsync(this.lease);
Mock.Get(this.leaseManager)
.Setup(manager => manager.ReleaseAsync(this.lease))
.Returns(Task.CompletedTask);
DocumentServiceLeaseContainer leaseContainer = Mock.Of <DocumentServiceLeaseContainer>();
this.synchronizer = Mock.Of <PartitionSynchronizer>();
this.sut = new PartitionControllerCore(leaseContainer, this.leaseManager, this.partitionSupervisorFactory, this.synchronizer);
}
public PartitionSupervisorCore(DocumentServiceLease lease, ChangeFeedObserver <T> observer, FeedProcessor processor, LeaseRenewer renewer)
{
this.lease = lease;
this.observer = observer;
this.processor = processor;
this.renewer = renewer;
}
public async Task WhenDelegateIsTyped_Manual()
{
bool executed = false;
Task changesHandler(ChangeFeedProcessorContext context, IReadOnlyCollection <dynamic> docs, Func <Task> checkpointAsync, CancellationToken token)
{
Assert.AreEqual(1, docs.Count);
Assert.AreEqual("Test", docs.First().id.ToString());
executed = true;
return(Task.CompletedTask);
}
ChangeFeedObserverFactoryCore <dynamic> changeFeedObserverFactoryCore = new ChangeFeedObserverFactoryCore <dynamic>(changesHandler, this.cosmosSerializerCore);
ChangeFeedObserver changeFeedObserver = changeFeedObserverFactoryCore.CreateObserver();
Assert.IsNotNull(changeFeedObserver);
ResponseMessage responseMessage = this.BuildResponseMessage();
ChangeFeedObserverContextCore context = new ChangeFeedObserverContextCore(this.leaseToken, responseMessage, Mock.Of <PartitionCheckpointer>());
await changeFeedObserver.ProcessChangesAsync(context, responseMessage.Content, CancellationToken.None);
Assert.IsTrue(executed);
}
public async Task WhenDelegateIsStream_Automatic()
{
ResponseMessage responseMessage = this.BuildResponseMessage();
bool executed = false;
Task changesHandler(ChangeFeedProcessorContext context, Stream stream, CancellationToken token)
{
Assert.ReferenceEquals(responseMessage.Content, stream);
executed = true;
return(Task.CompletedTask);
}
ChangeFeedObserverFactoryCore changeFeedObserverFactoryCore = new ChangeFeedObserverFactoryCore(changesHandler);
ChangeFeedObserver changeFeedObserver = changeFeedObserverFactoryCore.CreateObserver();
Assert.IsNotNull(changeFeedObserver);
ChangeFeedObserverContextCore context = new ChangeFeedObserverContextCore(this.leaseToken, responseMessage, Mock.Of <PartitionCheckpointer>());
await changeFeedObserver.ProcessChangesAsync(context, responseMessage.Content, CancellationToken.None);
Assert.IsTrue(executed);
}
public void WhenUsingManualCheckpoint()
{
Mock <ChangeFeedObserverFactory> mockedFactory = new Mock <ChangeFeedObserverFactory>();
mockedFactory.Setup(f => f.CreateObserver()).Returns(Mock.Of <ChangeFeedObserver>());
CheckpointerObserverFactory factory = new CheckpointerObserverFactory(mockedFactory.Object, withManualCheckpointing: true);
ChangeFeedObserver observer = factory.CreateObserver();
Assert.IsInstanceOfType(observer, typeof(ObserverExceptionWrappingChangeFeedObserverDecorator));
}
public void WhenNotUsingManualCheckpoint()
{
Mock <ChangeFeedObserverFactory> mockedFactory = new Mock <ChangeFeedObserverFactory>();
mockedFactory.Setup(f => f.CreateObserver()).Returns(Mock.Of <ChangeFeedObserver>());
CheckpointerObserverFactory factory = new CheckpointerObserverFactory(mockedFactory.Object, withManualCheckpointing: false);
ChangeFeedObserver observer = factory.CreateObserver();
Assert.IsInstanceOfType(observer, typeof(AutoCheckpointer));
}
public PartitionSupervisorTests()
{
this.lease = Mock.Of <DocumentServiceLease>();
Mock.Get(this.lease)
.Setup(l => l.CurrentLeaseToken)
.Returns("partitionId");
this.leaseRenewer = Mock.Of <LeaseRenewer>();
this.partitionProcessor = Mock.Of <FeedProcessor>();
this.observer = Mock.Of <ChangeFeedObserver>();
this.sut = new PartitionSupervisorCore(this.lease, this.observer, this.partitionProcessor, this.leaseRenewer);
}
public override PartitionSupervisor Create(DocumentServiceLease lease)
{
if (lease == null)
{
throw new ArgumentNullException(nameof(lease));
}
ChangeFeedObserver changeFeedObserver = this.observerFactory.CreateObserver();
FeedProcessor processor = this.partitionProcessorFactory.Create(lease, changeFeedObserver);
LeaseRenewerCore renewer = new LeaseRenewerCore(lease, this.leaseManager, this.changeFeedLeaseOptions.LeaseRenewInterval);
return(new PartitionSupervisorCore(lease, changeFeedObserver, processor, renewer));
}
public PartitionSupervisorTests()
{
lease = Mock.Of <DocumentServiceLease>();
Mock.Get(lease)
.Setup(l => l.CurrentLeaseToken)
.Returns("partitionId");
leaseRenewer = Mock.Of <LeaseRenewer>();
partitionProcessor = Mock.Of <FeedProcessor>();
observer = Mock.Of <ChangeFeedObserver <dynamic> >();
sut = new PartitionSupervisorCore <dynamic>(lease, observer, partitionProcessor, leaseRenewer);
}
public AutoCheckPointTests()
{
this.changeFeedObserver = Mock.Of <ChangeFeedObserver>();
this.partitionCheckpointer = new Mock <PartitionCheckpointer>();
this.partitionCheckpointer
.Setup(checkPointer => checkPointer.CheckpointPartitionAsync(It.IsAny <string>()))
.Returns(Task.CompletedTask);
this.sut = new AutoCheckpointer(this.changeFeedObserver);
this.stream = Mock.Of <Stream>();
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.Headers.ContinuationToken = Guid.NewGuid().ToString();
this.observerContext = new ChangeFeedObserverContextCore(Guid.NewGuid().ToString(), feedResponse: responseMessage, this.partitionCheckpointer.Object);
}
public AutoCheckPointTests()
{
changeFeedObserver = Mock.Of <ChangeFeedObserver <dynamic> >();
partitionCheckpointer = Mock.Of <PartitionCheckpointer>();
Mock.Get(partitionCheckpointer)
.Setup(checkPointer => checkPointer.CheckpointPartitionAsync(It.IsAny <string>()))
.Returns(Task.CompletedTask);
checkpointFrequency = new CheckpointFrequency();
sut = new AutoCheckpointer <dynamic>(checkpointFrequency, changeFeedObserver);
documents = Mock.Of <IReadOnlyList <dynamic> >();
observerContext = Mock.Of <ChangeFeedObserverContext>();
Mock.Get(observerContext)
.Setup(context => context.CheckpointAsync())
.Returns(partitionCheckpointer.CheckpointPartitionAsync("token"));
}
