Personal/degoswami/newflags

src/Sftp/Sftp.Test/ScenarioTests/CmdletParameterCompatibilityTests.cs

@@ -245,5 +245,168 @@ public void TestParameterSetLogicMatchesAzureCLI()
             var publicKeyParam = publicKeyProp?.GetCustomAttributes(typeof(ParameterAttribute), false)[0] as ParameterAttribute;
             Assert.False(publicKeyParam?.Mandatory ?? true);
         }
+
+        #region BufferSizeInBytes Parameter Tests
+
+        [Fact]
+        public void TestBufferSizeInBytesParameterExists()
+        {
+            // Test that BufferSizeInBytes parameter exists on Connect-AzSftp
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var bufferSizeProp = connectCommand.GetType().GetProperty("BufferSizeInBytes");
+            Assert.NotNull(bufferSizeProp);
+            Assert.Equal(typeof(int), bufferSizeProp.PropertyType);
+        }
+
+        [Fact]
+        public void TestBufferSizeInBytesDefaultValue()
+        {
+            // Test that BufferSizeInBytes has correct default value (256 * 1024 = 262144)
+            var connectCommand = new ConnectAzSftpCommand();
+
+            Assert.Equal(256 * 1024, connectCommand.BufferSizeInBytes);
+            Assert.Equal(262144, connectCommand.BufferSizeInBytes);
+        }
+
+        [Fact]
+        public void TestBufferSizeInBytesHasValidateRangeAttribute()
+        {
+            // Test that BufferSizeInBytes has proper validation
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var bufferSizeProp = connectCommand.GetType().GetProperty("BufferSizeInBytes");
+            var validateAttrs = bufferSizeProp?.GetCustomAttributes(typeof(ValidateRangeAttribute), false);
+
+            Assert.NotNull(validateAttrs);
+            Assert.True(validateAttrs.Length > 0);
+
+            var validateRange = validateAttrs[0] as ValidateRangeAttribute;
+            Assert.NotNull(validateRange);
+            Assert.Equal(1, validateRange.MinRange);  // Minimum should be 1
+        }
+
+        [Fact]
+        public void TestBufferSizeInBytesHasHelpMessage()
+        {
+            // Test that BufferSizeInBytes has helpful documentation
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var bufferSizeProp = connectCommand.GetType().GetProperty("BufferSizeInBytes");
+            var paramAttrs = bufferSizeProp?.GetCustomAttributes(typeof(ParameterAttribute), false);
+
+            Assert.NotNull(paramAttrs);
+            Assert.True(paramAttrs.Length > 0);
+
+            var paramAttr = paramAttrs[0] as ParameterAttribute;
+            Assert.NotNull(paramAttr);
+            Assert.False(string.IsNullOrEmpty(paramAttr.HelpMessage));
+            Assert.Contains("buffer", paramAttr.HelpMessage.ToLower());
+        }
+
+        [Fact]
+        public void TestBufferSizeInBytesIsOptional()
+        {
+            // Test that BufferSizeInBytes is not mandatory (has default value)
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var bufferSizeProp = connectCommand.GetType().GetProperty("BufferSizeInBytes");
+            var paramAttrs = bufferSizeProp?.GetCustomAttributes(typeof(ParameterAttribute), false);
+
+            Assert.NotNull(paramAttrs);
+            Assert.True(paramAttrs.Length > 0);
+
+            var paramAttr = paramAttrs[0] as ParameterAttribute;
+            Assert.NotNull(paramAttr);
+            Assert.False(paramAttr.Mandatory);
+        }
+
+        #endregion
+
+        #region StorageAccountEndpoint Parameter Tests
+
+        [Fact]
+        public void TestStorageAccountEndpointParameterExists()
+        {
+            // Test that StorageAccountEndpoint parameter exists on Connect-AzSftp
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var endpointProp = connectCommand.GetType().GetProperty("StorageAccountEndpoint");
+            Assert.NotNull(endpointProp);
+            Assert.Equal(typeof(string), endpointProp.PropertyType);
+        }
+
+        [Fact]
+        public void TestStorageAccountEndpointDefaultValue()
+        {
+            // Test that StorageAccountEndpoint defaults to null (auto-detect from Azure environment)
+            var connectCommand = new ConnectAzSftpCommand();
+
+            Assert.Null(connectCommand.StorageAccountEndpoint);
+        }
+
+        [Fact]
+        public void TestStorageAccountEndpointHasValidateNotNullOrEmptyAttribute()
+        {
+            // Test that StorageAccountEndpoint has proper validation when provided
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var endpointProp = connectCommand.GetType().GetProperty("StorageAccountEndpoint");
+            var validateAttrs = endpointProp?.GetCustomAttributes(typeof(ValidateNotNullOrEmptyAttribute), false);
+
+            Assert.NotNull(validateAttrs);
+            Assert.True(validateAttrs.Length > 0);
+        }
+
+        [Fact]
+        public void TestStorageAccountEndpointHasHelpMessage()
+        {
+            // Test that StorageAccountEndpoint has helpful documentation
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var endpointProp = connectCommand.GetType().GetProperty("StorageAccountEndpoint");
+            var paramAttrs = endpointProp?.GetCustomAttributes(typeof(ParameterAttribute), false);
+
+            Assert.NotNull(paramAttrs);
+            Assert.True(paramAttrs.Length > 0);
+
+            var paramAttr = paramAttrs[0] as ParameterAttribute;
+            Assert.NotNull(paramAttr);
+            Assert.False(string.IsNullOrEmpty(paramAttr.HelpMessage));
+            Assert.Contains("endpoint", paramAttr.HelpMessage.ToLower());
+        }
+
+        [Fact]
+        public void TestStorageAccountEndpointIsOptional()
+        {
+            // Test that StorageAccountEndpoint is not mandatory (uses auto-detection by default)
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var endpointProp = connectCommand.GetType().GetProperty("StorageAccountEndpoint");
+            var paramAttrs = endpointProp?.GetCustomAttributes(typeof(ParameterAttribute), false);
+
+            Assert.NotNull(paramAttrs);
+            Assert.True(paramAttrs.Length > 0);
+
+            var paramAttr = paramAttrs[0] as ParameterAttribute;
+            Assert.NotNull(paramAttr);
+            Assert.False(paramAttr.Mandatory);
+        }
+
+        [Fact]
+        public void TestStorageAccountEndpointAvailableInAllParameterSets()
+        {
+            // Test that StorageAccountEndpoint is available in all parameter sets
+            var connectCommand = new ConnectAzSftpCommand();
+
+            var endpointProp = connectCommand.GetType().GetProperty("StorageAccountEndpoint");
+            var paramAttrs = endpointProp?.GetCustomAttributes(typeof(ParameterAttribute), false);
+
+            Assert.NotNull(paramAttrs);
+            // Should have multiple Parameter attributes (one for each parameter set)
+            Assert.True(paramAttrs.Length >= 4, "StorageAccountEndpoint should be available in all parameter sets");
+        }
+
+        #endregion
     }
 }

src/Sftp/Sftp.Test/ScenarioTests/ConnectAzSftpTests.ps1

@@ -146,3 +146,80 @@ function Test-ConnectAzSftpParameterValidation
     # Test certificate authentication requires both certificate and private key
     Assert-Throws { Connect-AzSftp -StorageAccount "test" -CertificateFile "cert.pub" } "CertificateFile requires PrivateKeyFile"
 }
+
+<#
+.SYNOPSIS
+Test Connect-AzSftp with BufferSizeInBytes parameter
+#>
+function Test-ConnectAzSftpWithBufferSizeInBytes
+{
+    $storageAccountName = Get-StorageAccountName
+    $resourceGroupName = Get-ResourceGroupName
+
+    try {
+        # Skip test in playback mode for now
+        if (IsPlayback) {
+            return
+        }
+
+        # Create test storage account
+        $storageAccount = New-TestStorageAccount -ResourceGroupName $resourceGroupName -StorageAccountName $storageAccountName
+
+        # Test connection with custom buffer size (will fail in test environment but validates parameter parsing)
+        try {
+            $result = Connect-AzSftp -StorageAccount $storageAccountName -BufferSizeInBytes 524288 -SftpArg "-o", "ConnectTimeout=1"
+        }
+        catch {
+            # Expected to fail in test environment - this is acceptable
+            Write-Host "Connection failed as expected in test environment: $($_.Exception.Message)"
+        }
+
+        # Test with default buffer size (256*1024 = 262144)
+        try {
+            $result = Connect-AzSftp -StorageAccount $storageAccountName -SftpArg "-o", "ConnectTimeout=1"
+        }
+        catch {
+            Write-Host "Connection failed as expected in test environment: $($_.Exception.Message)"
+        }
+    }
+    finally {
+        # Cleanup
+        Remove-TestStorageAccount -ResourceGroupName $resourceGroupName -StorageAccountName $storageAccountName
+        Remove-AzResourceGroup -Name $resourceGroupName -Force -ErrorAction SilentlyContinue
+    }
+}
+
+<#
+.SYNOPSIS
+Test Connect-AzSftp with StorageAccountEndpoint parameter
+#>
+function Test-ConnectAzSftpWithStorageAccountEndpoint
+{
+    $storageAccountName = Get-StorageAccountName
+    $resourceGroupName = Get-ResourceGroupName
+    $customEndpoint = "blob.core.custom.endpoint.net"
+
+    try {
+        # Skip test in playback mode for now
+        if (IsPlayback) {
+            return
+        }
+
+        # Create test storage account
+        $storageAccount = New-TestStorageAccount -ResourceGroupName $resourceGroupName -StorageAccountName $storageAccountName
+
+        # Test connection with custom storage account endpoint (will fail in test environment but validates parameter parsing)
+        try {
+            $result = Connect-AzSftp -StorageAccount $storageAccountName -StorageAccountEndpoint $customEndpoint -SftpArg "-o", "ConnectTimeout=1"
+        }
+        catch {
+            # Expected to fail in test environment - this is acceptable
+            Write-Host "Connection failed as expected in test environment: $($_.Exception.Message)"
+        }
+    }
+    finally {
+        # Cleanup
+        Remove-TestStorageAccount -ResourceGroupName $resourceGroupName -StorageAccountName $storageAccountName
+        Remove-AzResourceGroup -Name $resourceGroupName -Force -ErrorAction SilentlyContinue
+    }
+}

src/Sftp/Sftp.Test/ScenarioTests/SftpUtilsTests.cs

@@ -381,5 +381,141 @@ public void AttemptConnection_WithInvalidCommand_ReturnsFalseWithError()
             Assert.NotNull(result.Item3); // Error message
             Assert.Contains("Failed to start", result.Item3);
         }
+
+        #region BufferSize Tests
+
+        [Fact]
+        public void BuildSftpCommand_WithDefaultBufferSize_DoesNotIncludeBufferFlag()
+        {
+            // Arrange - default buffer size is 256 * 1024 = 262144
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22,
+                publicKeyFile: null,
+                privateKeyFile: null,
+                certFile: null,
+                sftpArgs: null,
+                sshClientFolder: null,
+                sshProxyFolder: null,
+                credentialsFolder: null,
+                yesWithoutPrompt: false,
+                bufferSizeBytes: 256 * 1024  // Default value
+            );
+
+            // Act
+            var command = SftpUtils.BuildSftpCommand(session);
+
+            // Assert - should NOT contain -B flag when using default buffer size
+            Assert.DoesNotContain("-B", command);
+        }
+
+        [Fact]
+        public void BuildSftpCommand_WithCustomBufferSize_IncludesBufferFlag()
+        {
+            // Arrange - custom buffer size
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22,
+                publicKeyFile: null,
+                privateKeyFile: null,
+                certFile: null,
+                sftpArgs: null,
+                sshClientFolder: null,
+                sshProxyFolder: null,
+                credentialsFolder: null,
+                yesWithoutPrompt: false,
+                bufferSizeBytes: 524288  // 512 KB - non-default value
+            );
+
+            // Act
+            var command = SftpUtils.BuildSftpCommand(session);
+
+            // Assert - should contain -B flag with custom buffer size
+            Assert.Contains("-B", command);
+            Assert.Contains("524288", command);
+        }
+
+        [Fact]
+        public void BuildSftpCommand_WithSmallBufferSize_IncludesBufferFlag()
+        {
+            // Arrange - smaller buffer size
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22,
+                publicKeyFile: null,
+                privateKeyFile: null,
+                certFile: null,
+                sftpArgs: null,
+                sshClientFolder: null,
+                sshProxyFolder: null,
+                credentialsFolder: null,
+                yesWithoutPrompt: false,
+                bufferSizeBytes: 32768  // 32 KB
+            );
+
+            // Act
+            var command = SftpUtils.BuildSftpCommand(session);
+
+            // Assert
+            Assert.Contains("-B", command);
+            Assert.Contains("32768", command);
+        }
+
+        [Fact]
+        public void SFTPSession_BufferSizeBytes_DefaultValue_Is256KB()
+        {
+            // Arrange & Act
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22
+            );
+
+            // Assert - default buffer size should be 256 * 1024 = 262144
+            Assert.Equal(256 * 1024, session.BufferSizeBytes);
+        }
+
+        [Fact]
+        public void SFTPSession_BufferSizeBytes_CanBeSetViaConstructor()
+        {
+            // Arrange & Act
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22,
+                bufferSizeBytes: 1048576  // 1 MB
+            );
+
+            // Assert
+            Assert.Equal(1048576, session.BufferSizeBytes);
+        }
+
+        [Fact]
+        public void SFTPSession_BufferSizeBytes_CanBeSetViaProperty()
+        {
+            // Arrange
+            var session = new SFTPSession(
+                storageAccount: "testaccount",
+                username: "testuser",
+                host: "testaccount.blob.core.windows.net",
+                port: 22
+            );
+
+            // Act
+            session.BufferSizeBytes = 2097152;  // 2 MB
+
+            // Assert
+            Assert.Equal(2097152, session.BufferSizeBytes);
+        }
+
+        #endregion
     }
 }