diff --git a/src/FrostFS.SDK.Tests/Smoke/ContainerTests/ContainerTests.cs b/src/FrostFS.SDK.Tests/Smoke/ContainerTests/ContainerTests.cs new file mode 100644 index 0000000..ff7ebe8 --- /dev/null +++ b/src/FrostFS.SDK.Tests/Smoke/ContainerTests/ContainerTests.cs @@ -0,0 +1,132 @@ +using System.Diagnostics.CodeAnalysis; +using System.Security.Cryptography; +using FrostFS.SDK.Client; + +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 CreateContanerTest() + { + var options = ClientOptions; + var client = FrostFSClient.GetInstance(options, GrpcChannel); + + await Cleanup(client); + + var ctx = new CallContext(TimeSpan.FromSeconds(20)); + + FrostFsContainerId containerId = await CreateContainer(client, unique: true, backupFactor: 1, selectors: [], filter: [], new FrostFsReplica(3)); + + Assert.NotNull(containerId); + + var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); + Assert.NotNull(container); + + 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(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(3, 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.Equal(Version.Major, container.Version.Major); + Assert.Equal(Version.Minor, container.Version.Minor); + } + + [Theory] + [InlineData(1)] + [InlineData(3 * 1024 * 1024)] // exactly one chunk size - 3MB + [InlineData(6 * 1024 * 1024 + 100)] + public async void SimpleScenarioWithSessionTest(int objectSize) + { + var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); + + var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); + + await Cleanup(client); + + var ctx = new CallContext(TimeSpan.FromSeconds(20)); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo( + new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), + [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), + PrmWait.DefaultParams); + + var container = await client.CreateContainerAsync(createContainerParam, ctx); + + var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx); + Assert.NotNull(containerInfo); + + await AddObjectRules(client, container); + + var bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: container, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + sessionToken: token); + + var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true); + + await stream.WriteAsync(bytes.AsMemory()); + var objectId = await stream.CompleteAsync(); + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default)) + { + hasObject = true; + + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); + Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); + Assert.Equal("fileName", objHeader.Attributes.First().Key); + Assert.Equal("test", objHeader.Attributes.First().Value); + } + + Assert.True(hasObject); + + var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId, token), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } +} diff --git a/src/FrostFS.SDK.Tests/Smoke/NetworkTests/NetworkTests.cs b/src/FrostFS.SDK.Tests/Smoke/NetworkTests/NetworkTests.cs new file mode 100644 index 0000000..f1fce3c --- /dev/null +++ b/src/FrostFS.SDK.Tests/Smoke/NetworkTests/NetworkTests.cs @@ -0,0 +1,111 @@ +using System.Diagnostics.CodeAnalysis; +using FrostFS.SDK.Client; +using FrostFS.SDK.SmokeTests; + +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 SmokeClientTests : SmokeTestsBase +{ + [Fact] + public async void AccountTest() + { + var test = lightWait.Timeout; + + var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); + + var result = await client.GetBalanceAsync(default); + + Assert.NotNull(result); + Assert.True(result.Value == 0); + } + + [Fact] + public async void NodeInfoTest() + { + var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); + + var result = await client.GetNodeInfoAsync(default); + + Assert.Equal(2, result.Version.Major); + Assert.Equal(13, result.Version.Minor); + Assert.Equal(NodeState.Online, result.State); + Assert.Equal(33, result.PublicKey.Length); + Assert.Equal(2, result.Addresses.Count); + Assert.Equal(11, result.Attributes.Count); + } + + [Fact] + public async void NodeInfoStatisticsTest() + { + var options = ClientOptions; + + var callbackContent = string.Empty; + options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"; + + var client = FrostFSClient.GetInstance(options, GrpcChannel); + + var result = await client.GetNodeInfoAsync(default); + + Assert.NotEmpty(callbackContent); + } + + [Fact] + public async void NetworkSettingsTest() + { + var options = ClientOptions; + var client = FrostFSClient.GetInstance(options, GrpcChannel); + + var result = await client.GetNetworkSettingsAsync(default); + + Assert.NotNull(result); + + Assert.True(0u < result.Epoch); + Assert.True(result.HomomorphicHashingDisabled); + Assert.True(result.MaintenanceModeAllowed); + Assert.True(0u < result.MagicNumber); + + Assert.Equal(0u, result.AuditFee); + Assert.Equal(0u, result.BasicIncomeRate); + Assert.Equal(0u, result.ContainerAliasFee); + Assert.Equal(0u, result.ContainerFee); + Assert.Equal(75u, result.EpochDuration); + Assert.Equal(10_000_000_000u, result.InnerRingCandidateFee); + Assert.Equal(12u, result.MaxECDataCount); + Assert.Equal(4u, result.MaxECParityCount); + Assert.Equal(5242880u, result.MaxObjectSize); + Assert.Equal(8000u, result.MsPerBlock); + Assert.Equal(100_000_000u, result.WithdrawFee); + } + + [Fact] + public async void NodeInfoCallbackAndInterceptorTest() + { + bool callbackInvoked = false; + bool interceptorInvoked = false; + + var options = ClientOptions; + options.Value.Callback = (cs) => + { + callbackInvoked = true; + Assert.True(cs.ElapsedMicroSeconds > 0); + }; + + options.Value.Interceptors.Add(new CallbackInterceptor(s => interceptorInvoked = true)); + + var client = FrostFSClient.GetInstance(options, GrpcChannel); + + var result = await client.GetNodeInfoAsync(default); + + Assert.True(callbackInvoked); + Assert.True(interceptorInvoked); + + Assert.Equal(2, result.Version.Major); + Assert.Equal(13, result.Version.Minor); + Assert.Equal(NodeState.Online, result.State); + Assert.Equal(33, result.PublicKey.Length); + Assert.NotNull(result.Addresses); + Assert.True(result.Attributes.Count > 0); + } +} diff --git a/src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs b/src/FrostFS.SDK.Tests/Smoke/ObjectTests/ObjectTests.cs similarity index 70% rename from src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs rename to src/FrostFS.SDK.Tests/Smoke/ObjectTests/ObjectTests.cs index 3dac829..1291932 100644 --- a/src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs +++ b/src/FrostFS.SDK.Tests/Smoke/ObjectTests/ObjectTests.cs @@ -1,79 +1,16 @@ using System.Diagnostics.CodeAnalysis; using System.Security.Cryptography; -using System.Security.Cryptography.X509Certificates; -using System.Text; -using FrostFS.Refs; using FrostFS.SDK.Client; using FrostFS.SDK.Client.Interfaces; using FrostFS.SDK.Cryptography; using FrostFS.SDK.SmokeTests; -using FrostFS.Session; -using Google.Protobuf; -using Microsoft.Extensions.Options; 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 SmokeClientTests : SmokeTestsBase -{ - private static readonly PrmWait lightWait = new(100, 1); - - [Fact] - public async void AccountTest() - { - var test = lightWait.Timeout; - - var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); - - var result = await client.GetBalanceAsync(default); - - Assert.NotNull(result); - Assert.True(result.Value == 0); - } - - [Fact] - public async void NodeInfoTest() - { - var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); - - var result = await client.GetNodeInfoAsync(default); - - Assert.Equal(2, result.Version.Major); - Assert.Equal(13, result.Version.Minor); - Assert.Equal(NodeState.Online, result.State); - Assert.Equal(33, result.PublicKey.Length); - // Assert.Single(result.Addresses); - // Assert.Equal(9, result.Attributes.Count); - } - - [Fact] - public async void NodeInfoStatisticsTest() - { - var options = ClientOptions; - - var callbackContent = string.Empty; - options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"; - - var client = FrostFSClient.GetInstance(options, GrpcChannel); - - var result = await client.GetNodeInfoAsync(default); - - Assert.NotEmpty(callbackContent); - } - - [Fact] - public async void GetSessionTest() - { - var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); - - var token = await client.CreateSessionAsync(new(100), default); - - Assert.NotNull(token); - Assert.NotEqual(Guid.Empty, token.Id); - Assert.Equal(33, token.SessionKey.Length); - } - +public class ObjectTests : SmokeTestsBase +{ [Fact] public async void CreateObjectWithSessionToken() { @@ -83,14 +20,7 @@ public class SmokeClientTests : SmokeTestsBase var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["key1", "value1"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); await AddObjectRules(client, containerId); @@ -132,13 +62,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - lightWait); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); await AddObjectRules(client, containerId); @@ -220,14 +144,7 @@ public class SmokeClientTests : SmokeTestsBase var ctx = new CallContext(TimeSpan.FromSeconds(20)); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["testKey", "testValue"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, ctx); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); Assert.NotNull(container); @@ -300,16 +217,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - var ctx = new CallContext(); - - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["testKey1", "testValue1"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, ctx); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); Assert.NotNull(container); @@ -370,14 +278,6 @@ public class SmokeClientTests : SmokeTestsBase } } - [Fact] - public async void CleanupTest() - { - var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); - - await Cleanup(client); - } - [Fact] public async void PatchTest() { @@ -385,14 +285,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["testKey", "testValue"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); Assert.NotNull(container); @@ -469,14 +362,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["testKey", "testValue"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); Assert.NotNull(container); @@ -522,14 +408,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - PrmWait.DefaultParams, - xheaders: ["testKey", "testValue"]); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(3)); var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default); Assert.NotNull(container); @@ -660,13 +539,7 @@ public class SmokeClientTests : SmokeTestsBase foreach (var rep in replicas) { - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo( - new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(rep)), - [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]), - lightWait); - - var containerId = await client.CreateContainerAsync(createContainerParam, default); + FrostFsContainerId containerId = await CreateContainer(client, unique:true, backupFactor: 1, selectors:[], filter:[], new FrostFsReplica(rep)); var ctx = new CallContext(TimeSpan.FromSeconds(10)); @@ -678,7 +551,7 @@ public class SmokeClientTests : SmokeTestsBase var mb = 1024 * 1024; - int[] objectSizes = [1, 1024, 64 * mb + 1]; //64 * mb, 64 * mb - 1, , 2 * 64 * mb + 256]; + int[] objectSizes = [1, 1024, 6 * mb + 1]; //64 * mb, 64 * mb - 1, , 2 * 64 * mb + 256]; foreach (var objectSize in objectSizes) { @@ -738,92 +611,4 @@ public class SmokeClientTests : SmokeTestsBase Assert.NotNull(result.Addresses); Assert.True(result.Attributes.Count > 0); } - - private static byte[] GetRandomBytes(int size) - { - Random rnd = new(); - var bytes = new byte[size]; - rnd.NextBytes(bytes); - return bytes; - } - - private static IOptions GetClientOptions(string key, string url) - { - return Options.Create(new ClientSettings - { - Key = key, - Host = url - }); - } - - static async Task Cleanup(IFrostFSClient client) - { - await foreach (var cid in client.ListContainersAsync(default, default)) - { - await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default); - } - } - - private static async Task AddContainerRules(IFrostFSClient client, FrostFsContainerId containerId) - { - var addChainPrm = new PrmApeChainAdd( - new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()), - new FrostFsChain - { - ID = Encoding.ASCII.GetBytes("chain-id-test1"), - Rules = [ - new FrostFsRule - { - Status = RuleStatus.Allow, - Actions = new Actions(inverted: false, names: ["*"]), - Resources = new Resource (inverted: false, names: [$"native:container/*"]), - Any = false, - Conditions = [] - } - ], - MatchType = RuleMatchType.DenyPriority - } - ); - - await client.AddChainAsync(addChainPrm, default); - - var listChainPrm = new PrmApeChainList(new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue())); - - while (true) - { - await Task.Delay(1000); - var chains = await client.ListChainAsync(listChainPrm, default); - - if (chains.Length > 0) - break; - } - - await Task.Delay(8000); - } - - private static async Task AddObjectRules(IFrostFSClient client, FrostFsContainerId containerId) - { - var addChainPrm = new PrmApeChainAdd( - new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()), - new FrostFsChain - { - ID = Encoding.ASCII.GetBytes("chain-id-test"), - Rules = [ - new FrostFsRule - { - Status = RuleStatus.Allow, - Actions = new Actions(inverted: false, names: ["*"]), - Resources = new Resource (inverted: false, names: [$"native:object/*"]), - Any = false, - Conditions = [] - } - ], - MatchType = RuleMatchType.DenyPriority - } - ); - - await client.AddChainAsync(addChainPrm, default); - - await Task.Delay(8000); - } } diff --git a/src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs b/src/FrostFS.SDK.Tests/Smoke/PoolTests/PoolSmokeTests.cs similarity index 100% rename from src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs rename to src/FrostFS.SDK.Tests/Smoke/PoolTests/PoolSmokeTests.cs diff --git a/src/FrostFS.SDK.Tests/Smoke/SessionTests/SessionTests.cs b/src/FrostFS.SDK.Tests/Smoke/SessionTests/SessionTests.cs new file mode 100644 index 0000000..ab14d8e --- /dev/null +++ b/src/FrostFS.SDK.Tests/Smoke/SessionTests/SessionTests.cs @@ -0,0 +1,21 @@ +using System.Diagnostics.CodeAnalysis; +using FrostFS.SDK.Client; + +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 SessionTests : SmokeTestsBase +{ + [Fact] + public async void GetSessionTest() + { + var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel); + + var token = await client.CreateSessionAsync(new(100), default); + + Assert.NotNull(token); + Assert.NotEqual(Guid.Empty, token.Id); + Assert.Equal(33, token.SessionKey.Length); + } +} \ No newline at end of file diff --git a/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs b/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs index a524a82..e126677 100644 --- a/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs @@ -1,6 +1,9 @@ -using System.Security.Cryptography; - +using System.Collections.ObjectModel; +using System.Diagnostics.CodeAnalysis; +using System.Security.Cryptography; +using System.Text; using FrostFS.SDK.Client; +using FrostFS.SDK.Client.Interfaces; using FrostFS.SDK.Cryptography; using Grpc.Core; @@ -9,20 +12,21 @@ using Microsoft.Extensions.Options; 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 abstract class SmokeTestsBase { // cluster Ori - internal readonly string url = "http://10.78.128.207:8080"; - internal readonly string keyString = "L4JWLdedUd4b21sriRHtCPGkjG2Mryz2AWLiVqTBSNyxxyAUcc7s"; - + // internal readonly string url = "http://10.78.128.207:8080"; + // internal readonly string keyString = "L4JWLdedUd4b21sriRHtCPGkjG2Mryz2AWLiVqTBSNyxxyAUcc7s"; // cluster - // internal readonly string url = "http://10.78.128.190:8080"; - // internal readonly string keyString = "L47c3bunc6bJd7uEAfPUae2VkyupFR9nizoH6jfPonzQxijqH2Ba"; + internal readonly string url = "http://10.78.128.190:8080"; + internal readonly string keyString = "L47c3bunc6bJd7uEAfPUae2VkyupFR9nizoH6jfPonzQxijqH2Ba"; // WSL2 - //internal readonly string url = "http://172.29.238.97:8080"; - //internal readonly string keyString = "KzPXA6669m2pf18XmUdoR8MnP1pi1PMmefiFujStVFnv7WR5SRmK"; + // internal readonly string url = "http://172.29.238.97:8080"; + // internal readonly string keyString = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq"; // "KzPXA6669m2pf18XmUdoR8MnP1pi1PMmefiFujStVFnv7WR5SRmK"; //"KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq"; @@ -44,4 +48,69 @@ public abstract class SmokeTestsBase protected static Func GrpcChannel => (url) => Grpc.Net.Client.GrpcChannel.ForAddress(new Uri(url)); protected IOptions ClientOptions => Options.Create(new ClientSettings { Key = keyString, Host = url }); + + protected static readonly PrmWait lightWait = new(100, 1); + + protected static byte[] GetRandomBytes(int size) + { + Random rnd = new(); + var bytes = new byte[size]; + rnd.NextBytes(bytes); + return bytes; + } + + protected static async Task CreateContainer(IFrostFSClient client, + bool unique, + uint backupFactor, + Collection selectors, + Collection filter, + params FrostFsReplica[] replicas) + { + var networkSettings = await client.GetNetworkSettingsAsync(default); + + var containerInfo = new FrostFsContainerInfo( + new FrostFsPlacementPolicy(unique, backupFactor, selectors, filter, replicas), + networkSettings.HomomorphicHashingDisabled ? [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")] : []); + + var createContainerParam = new PrmContainerCreate( + containerInfo, + PrmWait.DefaultParams, + xheaders: ["key1", "value1"]); + + return await client.CreateContainerAsync(createContainerParam, default); + } + + protected static async Task Cleanup(IFrostFSClient client) + { + await foreach (var cid in client.ListContainersAsync(default, default)) + { + await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default); + } + } + + protected static async Task AddObjectRules(IFrostFSClient client, FrostFsContainerId containerId) + { + var addChainPrm = new PrmApeChainAdd( + new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()), + new FrostFsChain + { + ID = Encoding.ASCII.GetBytes("chain-id-test"), + Rules = [ + new FrostFsRule + { + Status = RuleStatus.Allow, + Actions = new Actions(inverted: false, names: ["*"]), + Resources = new Resource (inverted: false, names: [$"native:object/*"]), + Any = false, + Conditions = [] + } + ], + MatchType = RuleMatchType.DenyPriority + } + ); + + await client.AddChainAsync(addChainPrm, default); + + await Task.Delay(8000); + } }