public async Task GetBucketAsync_Disposed_Exception()
{
// Arrange
var clusterProvider = new Mock <IClusterProvider>();
var provider = new BucketProvider(clusterProvider.Object);
provider.Dispose();
// Act/Assert
var ex = await Assert.ThrowsAsync <ObjectDisposedException>(() => provider.GetBucketAsync("bucket1").AsTask());
Assert.Equal(nameof(BucketProvider), ex.ObjectName);
}
public void Dispose_DisposesBuckets()
{
// Arrange
var bucket1 = new Mock <IBucket>();
bucket1.Setup(m => m.Dispose());
var bucket2 = new Mock <IBucket>();
bucket2.Setup(m => m.Dispose());
var cluster = new Mock <ICluster>();
cluster
.Setup(m => m.OpenBucket("bucket1"))
.Returns(bucket1.Object);
cluster
.Setup(m => m.OpenBucket("bucket2"))
.Returns(bucket2.Object);
cluster
.SetupGet(m => m.Configuration)
.Returns(new ClientConfiguration()
{
BucketConfigs = new Dictionary <string, BucketConfiguration>()
});
var clusterProvider = new Mock <IClusterProvider>();
clusterProvider
.Setup(m => m.GetCluster())
.Returns(cluster.Object);
var provider = new BucketProvider(clusterProvider.Object);
provider.GetBucket("bucket1");
provider.GetBucket("bucket2");
// Act
provider.Dispose();
// Assert
bucket1.Verify(m => m.Dispose(), Times.AtLeastOnce);
bucket2.Verify(m => m.Dispose(), Times.AtLeastOnce);
}
public void GetBucket_WithPassword_OpensBucketWithPasswordNotConfig()
{
// Arrange
var bucket1 = new Mock <IBucket>();
var cluster = new Mock <ICluster>();
cluster
.Setup(m => m.OpenBucket("bucket1"))
.Returns(bucket1.Object);
cluster
.SetupGet(m => m.Configuration)
.Returns(new ClientConfiguration()
{
BucketConfigs = new Dictionary <string, BucketConfiguration>
{
{
"bucket1",
new BucketConfiguration()
{
BucketName = "bucket1",
Password = "******"
}
}
}
});
var clusterProvider = new Mock <IClusterProvider>();
clusterProvider
.Setup(m => m.GetCluster())
.Returns(cluster.Object);
var provider = new BucketProvider(clusterProvider.Object);
// Act
provider.GetBucket("bucket1", "password");
// Assert
cluster.Verify(m => m.OpenBucket("bucket1", "password"), Times.Once);
}
public async Task GetBucket_FirstTimeFails_OpensAgain()
{
// Arrange
var bucket1 = new Mock <IBucket>();
var cluster = new Mock <ICluster>();
cluster
.SetupSequence(m => m.BucketAsync("bucket1"))
.Returns(() => new ValueTask <IBucket>(Task.Run(async Task <IBucket> () =>
{
await Task.Delay(10);
throw new InvalidOperationException("test");
})))
.ReturnsAsync(bucket1.Object);
var clusterProvider = new Mock <IClusterProvider>();
clusterProvider
.Setup(m => m.GetClusterAsync())
.ReturnsAsync(cluster.Object);
var provider = new BucketProvider(clusterProvider.Object);
var firstEx = await Assert.ThrowsAsync <InvalidOperationException>(() =>
{
return(provider.GetBucketAsync("bucket1").AsTask());
});
Assert.Equal("test", firstEx.Message);
// Act
var result = await provider.GetBucketAsync("bucket1");
// Assert
Assert.Equal(bucket1.Object, result);
cluster.Verify(m => m.BucketAsync("bucket1"), Times.Exactly(2));
}
public async Task DisposeAsync_DisposesBuckets()
{
// Arrange
var bucket1 = new Mock <IBucket>();
bucket1.Setup(m => m.Dispose());
var bucket2 = new Mock <IBucket>();
bucket2.Setup(m => m.Dispose());
var cluster = new Mock <ICluster>();
cluster
.Setup(m => m.BucketAsync("bucket1"))
.ReturnsAsync(bucket1.Object);
cluster
.Setup(m => m.BucketAsync("bucket2"))
.ReturnsAsync(bucket2.Object);
var clusterProvider = new Mock <IClusterProvider>();
clusterProvider
.Setup(m => m.GetClusterAsync())
.ReturnsAsync(cluster.Object);
var provider = new BucketProvider(clusterProvider.Object);
await provider.GetBucketAsync("bucket1");
await provider.GetBucketAsync("bucket2");
// Act
await provider.DisposeAsync();
// Assert
bucket1.Verify(m => m.DisposeAsync(), Times.AtLeastOnce);
bucket2.Verify(m => m.DisposeAsync(), Times.AtLeastOnce);
}
public void GetBucket_MultipleTimes_ReturnsFirstOpenBucket()
{
// Arrange
var bucket1 = new Mock <IBucket>();
var cluster = new Mock <ICluster>();
cluster
.Setup(m => m.OpenBucket("bucket1"))
.Returns(bucket1.Object);
cluster
.SetupGet(m => m.Configuration)
.Returns(new ClientConfiguration()
{
BucketConfigs = new Dictionary <string, BucketConfiguration>()
});
var clusterProvider = new Mock <IClusterProvider>();
clusterProvider
.Setup(m => m.GetCluster())
.Returns(cluster.Object);
var provider = new BucketProvider(clusterProvider.Object);
// Act
provider.GetBucket("bucket1");
var result = provider.GetBucket("bucket1");
// Assert
Assert.Equal(bucket1.Object, result);
cluster.Verify(m => m.OpenBucket("bucket1"), Times.Once);
}
public void ShouldCallIsItemContainedWithinBucket([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item item)
{
current.IsItemContainedWithinBucket(item).Returns(true);
sut.IsItemContainedWithinBucket(item).Should().BeTrue();
}
public void ShouldCallGetFacets([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, List <SearchStringModel> searchQuery, string locationFilter, IList <IEnumerable <SitecoreUIFacet> > expected)
{
current.GetFacets(searchQuery, locationFilter).Returns(expected);
sut.GetFacets(searchQuery, locationFilter).Should().BeSameAs(expected);
}
public void SwitchBucketProvider([Frozen] BucketProvider provider, BucketProviderSwitcher switcher, Item source, Item target)
{
BucketManager.MoveItemIntoBucket(source, target);
provider.Received().MoveItemIntoBucket(source, target);
}
public void ShouldCallCopyItem([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item source, Item target, bool deep)
{
sut.CopyItem(source, target, deep);
current.Received().CopyItem(source, target, deep);
}
public void ShouldCallCloneItem([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item source, Item target, bool deep, Item expected)
{
current.CloneItem(source, target, deep).Returns(expected);
sut.CloneItem(source, target, deep).Should().BeSameAs(expected);
}
public void ShouldCallAddSearchTabToItem([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item item)
{
sut.AddSearchTabToItem(item);
current.Received().AddSearchTabToItem(item);
}
public void ShouldCallSyncBucket([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item item)
{
sut.SyncBucket(item);
current.Received().SyncBucket(item);
}
public void ShouldCallMoveItemIntoBucket([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item source, Item target)
{
sut.MoveItemIntoBucket(source, target);
current.Received().MoveItemIntoBucket(source, target);
}
public void ShouldCallIsTemplateBucketable([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, ID templateId, Database database)
{
current.IsTemplateBucketable(templateId, database).Returns(true);
sut.IsTemplateBucketable(templateId, database).Should().BeTrue();
}
public void ShouldCallCreateBucket([Frozen] BucketProvider current, BucketProviderSwitcher switcher, SwitchingBucketProvider sut, Item item, Action <Item> callBack)
{
sut.CreateBucket(item, callBack);
current.Received().CreateBucket(item, callBack);
}
public void SutSwitchesSwitcherCurrentValue([Frozen] BucketProvider provider, BucketProviderSwitcher sut)
{
BucketProviderSwitcher.CurrentValue.Should().BeSameAs(provider);
}
