286 lines
10 KiB
C#
286 lines
10 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using FrostFS.SDK.Client;
|
|
using Grpc.Core;
|
|
|
|
namespace FrostFS.SDK.Tests.Smoke;
|
|
|
|
[SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
|
|
[SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")]
|
|
public class ContainerTests : SmokeTestsBase
|
|
{
|
|
[Fact]
|
|
public async void FailCreateContainerByTimeoutTest()
|
|
{
|
|
var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
|
|
try
|
|
{
|
|
_ = await CreateContainer(client,
|
|
ctx: new CallContext(TimeSpan.FromMilliseconds(1)),
|
|
token: null,
|
|
unique: true,
|
|
backupFactor: 1,
|
|
selectors: [],
|
|
filter: [],
|
|
containerAttributes: [new("testKey1", "testValue1")],
|
|
new FrostFsReplica(1));
|
|
|
|
Assert.Fail("Exception is expected");
|
|
}
|
|
catch (RpcException ex)
|
|
{
|
|
Assert.Equal(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async void CreateContainerTest1()
|
|
{
|
|
var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
await Cleanup(client);
|
|
|
|
client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
|
|
FrostFsContainerId containerId = await CreateContainer(client,
|
|
ctx: default,
|
|
token: null,
|
|
unique: true,
|
|
backupFactor: 1,
|
|
selectors: [],
|
|
filter: [],
|
|
containerAttributes: [new("testKey1", "testValue1")],
|
|
new FrostFsReplica(3));
|
|
|
|
Assert.NotNull(containerId);
|
|
|
|
var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
|
|
|
|
Assert.NotNull(container);
|
|
|
|
Assert.NotNull(container.Attributes);
|
|
Assert.Equal("testKey1", container.Attributes[0].Key);
|
|
Assert.Equal("testValue1", container.Attributes[0].Value);
|
|
|
|
//Assert.Equal("true", container.Attributes[1].Value);
|
|
|
|
// for cluster
|
|
//Assert.Equal(2, container.Attributes.Count);
|
|
//Assert.Equal("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", container.Attributes[1].Key);
|
|
|
|
Assert.True(container.PlacementPolicy.HasValue);
|
|
|
|
Assert.Equal(1u, container.PlacementPolicy.Value.BackupFactor);
|
|
Assert.True(container.PlacementPolicy.Value.Unique);
|
|
Assert.Empty(container.PlacementPolicy.Value.Selectors);
|
|
Assert.Empty(container.PlacementPolicy.Value.Filters);
|
|
|
|
Assert.Single(container.PlacementPolicy.Value.Replicas);
|
|
Assert.Equal(3u, container.PlacementPolicy.Value.Replicas[0].Count);
|
|
Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcParityCount);
|
|
Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcDataCount);
|
|
Assert.Equal("", container.PlacementPolicy.Value.Replicas[0].Selector);
|
|
|
|
Assert.Equal(OwnerId!.ToString(), container.Owner!.Value);
|
|
|
|
Assert.NotNull(container.Version);
|
|
|
|
Assert.Equal(Version!.Major, container.Version.Major);
|
|
Assert.Equal(Version.Minor, container.Version.Minor);
|
|
}
|
|
|
|
[Fact]
|
|
public async void CreateContainerTest2()
|
|
{
|
|
var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
|
|
await Cleanup(client);
|
|
|
|
client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
|
|
Collection<FrostFsFilter> filters = [
|
|
new ("filter1", "filterKey1", 1, "testValue1", []),
|
|
new ("filter2", "filterKey2", 2, "testValue2", [new ("subFilter2", "subFilterKey2", 3, "testValue3",[])])
|
|
];
|
|
|
|
Collection<FrostFsSelector> selectors = [
|
|
new ("selector1") {
|
|
Count = 1,
|
|
Clause = 1,
|
|
Attribute = "attribute1",
|
|
Filter = "filter1"
|
|
},
|
|
new ("selector2") {
|
|
Count = 2,
|
|
Clause = 2,
|
|
Attribute = "attribute2",
|
|
Filter = "filter2"
|
|
},
|
|
];
|
|
|
|
FrostFsContainerId containerId = await CreateContainer(client,
|
|
ctx: default,
|
|
token: null,
|
|
unique: false,
|
|
backupFactor: 2,
|
|
selectors,
|
|
filter: filters,
|
|
containerAttributes: [],
|
|
new FrostFsReplica(1));
|
|
|
|
Assert.NotNull(containerId);
|
|
|
|
var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
|
|
|
|
Assert.NotNull(container);
|
|
|
|
Assert.NotNull(container.Attributes);
|
|
//Assert.Single(container.Attributes);
|
|
//Assert.Equal("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", container.Attributes[0].Key);
|
|
//Assert.Equal("true", container.Attributes[0].Value);
|
|
|
|
Assert.True(container.PlacementPolicy.HasValue);
|
|
|
|
Assert.Equal(2u, container.PlacementPolicy.Value.BackupFactor);
|
|
Assert.False(container.PlacementPolicy.Value.Unique);
|
|
|
|
Assert.NotEmpty(container.PlacementPolicy.Value.Selectors);
|
|
|
|
Assert.Equal(2, container.PlacementPolicy.Value.Selectors.Count);
|
|
|
|
var selector1 = container.PlacementPolicy.Value.Selectors[0];
|
|
Assert.Equal("selector1", selector1.Name);
|
|
Assert.Equal(1, selector1.Clause);
|
|
Assert.Equal(1u, selector1.Count);
|
|
Assert.Equal("attribute1", selector1.Attribute);
|
|
Assert.Equal("filter1", selector1.Filter);
|
|
|
|
var selector2 = container.PlacementPolicy.Value.Selectors[1];
|
|
Assert.Equal("selector2", selector2.Name);
|
|
Assert.Equal(2, selector2.Clause);
|
|
Assert.Equal(2u, selector2.Count);
|
|
Assert.Equal("attribute2", selector2.Attribute);
|
|
Assert.Equal("filter2", selector2.Filter);
|
|
|
|
Assert.NotEmpty(container.PlacementPolicy.Value.Filters);
|
|
|
|
Assert.Equal(2, container.PlacementPolicy.Value.Filters.Count);
|
|
|
|
var filter1 = container.PlacementPolicy.Value.Filters[0];
|
|
Assert.Equal("filter1", filter1.Name);
|
|
Assert.Equal("filterKey1", filter1.Key);
|
|
Assert.Equal("testValue1", filter1.Value);
|
|
Assert.Equal(1, filter1.Operation);
|
|
Assert.Empty(filter1.Filters);
|
|
|
|
var filter2 = container.PlacementPolicy.Value.Filters[1];
|
|
Assert.Equal("filter2", filter2.Name);
|
|
Assert.Equal("filterKey2", filter2.Key);
|
|
Assert.Equal("testValue2", filter2.Value);
|
|
Assert.Equal(2, filter2.Operation);
|
|
Assert.NotEmpty(filter2.Filters);
|
|
|
|
Assert.Single(filter2.Filters);
|
|
|
|
var subFilter = filter2.Filters.First();
|
|
Assert.Equal("subFilter2", subFilter.Name);
|
|
Assert.Equal("subFilterKey2", subFilter.Key);
|
|
Assert.Equal("testValue3", subFilter.Value);
|
|
Assert.Equal(3, subFilter.Operation);
|
|
Assert.Empty(subFilter.Filters);
|
|
|
|
Assert.Single(container.PlacementPolicy.Value.Replicas);
|
|
Assert.Equal(1u, container.PlacementPolicy.Value.Replicas[0].Count);
|
|
Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcParityCount);
|
|
Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcDataCount);
|
|
Assert.Equal("", container.PlacementPolicy.Value.Replicas[0].Selector);
|
|
|
|
Assert.Equal(OwnerId!.ToString(), container.Owner!.Value);
|
|
|
|
Assert.NotNull(container.Version);
|
|
|
|
Assert.Equal(Version!.Major, container.Version.Major);
|
|
Assert.Equal(Version.Minor, container.Version.Minor);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1)]
|
|
[InlineData(10)]
|
|
public async void ListAndDeleteContainersTest(int countainerCount)
|
|
{
|
|
var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
|
|
|
|
await Cleanup(client);
|
|
|
|
var tasks = new Task[countainerCount];
|
|
|
|
var createdContainers = new ConcurrentDictionary<string, int>();
|
|
|
|
for (int i = 0; i < countainerCount; i++)
|
|
{
|
|
int index = i;
|
|
tasks[i] = Task.Run(async () =>
|
|
{
|
|
FrostFsContainerId containerId = await CreateContainer(client,
|
|
ctx: default,
|
|
token: null,
|
|
unique: true,
|
|
backupFactor: 1,
|
|
selectors: [],
|
|
filter: [],
|
|
containerAttributes: [new($"testKey{index}", $"testValue{index}")],
|
|
new FrostFsReplica(3));
|
|
|
|
createdContainers.TryAdd(containerId.ToString(), index);
|
|
});
|
|
}
|
|
|
|
#pragma warning disable xUnit1031 // Timeout is used
|
|
if (!Task.WaitAll(tasks, 20000))
|
|
{
|
|
Assert.Fail("cannot create containers");
|
|
}
|
|
#pragma warning restore xUnit1031
|
|
|
|
var containers = client.ListContainersAsync(new PrmContainerGetAll(), default);
|
|
|
|
var receivedContainers = new List<string>();
|
|
await foreach (var cntr in containers)
|
|
{
|
|
receivedContainers.Add(cntr.ToString());
|
|
}
|
|
|
|
Assert.Equal(countainerCount, receivedContainers.Count);
|
|
|
|
foreach (var cntrId in receivedContainers)
|
|
{
|
|
if (!createdContainers.TryGetValue(cntrId, out var index))
|
|
{
|
|
Assert.Fail("Cannot find corresponding container");
|
|
}
|
|
|
|
FrostFsContainerId container = new(cntrId);
|
|
var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), default);
|
|
|
|
Assert.NotNull(containerInfo);
|
|
Assert.NotNull(containerInfo.Attributes);
|
|
|
|
Assert.Contains(new FrostFsAttributePair($"testKey{index}", $"testValue{index}"), containerInfo.Attributes);
|
|
}
|
|
|
|
tasks = new Task[countainerCount];
|
|
|
|
for (int i = 0; i < receivedContainers.Count; i++)
|
|
{
|
|
tasks[i] = client.DeleteContainerAsync(new PrmContainerDelete(new FrostFsContainerId(receivedContainers[i]), lightWait), default);
|
|
}
|
|
|
|
await Task.WhenAll(tasks);
|
|
|
|
await foreach (var _ in client.ListContainersAsync(default, default))
|
|
{
|
|
Assert.Fail("Containers exist");
|
|
}
|
|
}
|
|
}
|