Merge branch 'Joseph-Refactor' into dev

ActiveDirectoryQuerier.Tests/AdCommandParametersTests.cs → ActiveDirectoryQuerier.Tests/ADCommandParametersTests.cs

@@ -3,7 +3,8 @@
 
 namespace ActiveDirectoryQuerier.Tests;
 
-public class AdCommandParametersTests
+// ReSharper disable once InconsistentNaming
+public class ADCommandParametersTests
 {
     [Fact]
     public void AvailableParameters_AvailableParametersNotPopulated_NoValidCommandProvided()
@@ -16,7 +17,7 @@ public void AvailableParameters_AvailableParametersNotPopulated_NoValidCommandPr
     }
 
     [Fact]
-    public async Task LoadParametersAsync_PopulatesAvailableParameters_IsNotEmpty()
+    public async Task LoadAvailableParametersAsync_PopulatesAvailableParameters_IsNotEmpty()
     {
         // Arrange
         ADCommandParameters adCommandParameters = new();
@@ -30,7 +31,7 @@ public async Task LoadParametersAsync_PopulatesAvailableParameters_IsNotEmpty()
     }
 
     [Fact]
-    public async Task LoadParametersAsync_CheckAvailableParameters_ContainsNameAndId()
+    public async Task LoadAvailableParametersAsync_CheckAvailableParameters_ContainsNameAndId()
     {
         // Arrange
         ADCommandParameters adCommandParameters = new();

ActiveDirectoryQuerier.Tests/ADCommandsFetcherTests.cs

@@ -0,0 +1,32 @@
+using System.Collections.ObjectModel;
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+// ReSharper disable once InconsistentNaming
+public class ADCommandsFetcherTests
+{
+    [Fact]
+    public async Task GetADCommands_ReturnsCommandList_IsNotEmpty()
+    {
+        // Act
+        ObservableCollection<Command> adCommands = await ADCommandsFetcher.GetADCommands();
+
+        // Assert
+        Assert.NotEmpty(adCommands);
+    }
+
+    [Theory]
+    [InlineData("Get-ADUser")]
+    [InlineData("Get-ADGroup")]
+    [InlineData("Get-ADComputer")]
+    public async Task GetADCommands_ReturnsCommandList_ContainsCommand(string commandName)
+    {
+        // Act
+        ObservableCollection<Command> adCommands = await ADCommandsFetcher.GetADCommands();
+
+        // Assert
+        Assert.Contains(adCommands, command => command.CommandText == commandName);
+    }
+}

ActiveDirectoryQuerier.Tests/PsExecutorTests.cs → ActiveDirectoryQuerier.Tests/PSExecutorTests.cs

@@ -3,20 +3,21 @@
 
 namespace ActiveDirectoryQuerier.Tests;
 
-public class PsExecutorTests
+// ReSharper disable once InconsistentNaming
+public class PSExecutorTests
 {
     [Theory]
     [InlineData("Get-Command", "Module", "ActiveDirectory")]
     [InlineData("Get-Process", "Name", "explorer")]
-    public void Execute_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd, string paramName, string paramValue)
+    public void Execute_WhenGivenValidCommand_ReturnsExpectedOutput(string command, string parameter, string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
         PSExecutor psExecutor = new();
 
         // Act
-        PSOutput result = psExecutor.Execute(command);
+        PSOutput result = psExecutor.Execute(psCommand);
 
         // Assert
         Assert.False(result.HadErrors);
@@ -45,17 +46,15 @@ public void Execute_CheckIfOutputChanged_ReturnsDifferentOutput()
     [Theory]
     [InlineData("Get-Command", "Module", "ActiveDirectory")]
     [InlineData("Get-Process", "Name", "explorer")]
-    public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd,
-                                                                               string paramName,
-                                                                               string paramValue)
+    public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string command, string parameter, string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
         PSExecutor psExecutor = new();
 
         // Act
-        PSOutput result = await psExecutor.ExecuteAsync(command);
+        PSOutput result = await psExecutor.ExecuteAsync(psCommand);
 
         // Assert
         Assert.False(result.HadErrors);
@@ -66,15 +65,15 @@ public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(strin
     [Theory]
     [InlineData("Get-ADUser", "InvalidParameter", "*")]
     [InlineData("InvalidCommand", "Filter", "*")]
-    public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd, string paramName, string paramValue)
+    public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string command, string parameter, string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
         PSExecutor psExecutor = new();
 
         // Act
-        PSOutput result = psExecutor.Execute(command);
+        PSOutput result = psExecutor.Execute(psCommand);
 
         // Assert
         Assert.True(result.HadErrors);
@@ -85,17 +84,15 @@ public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd, st
     [Theory]
     [InlineData("Get-ADUser", "InvalidParameter", "*")]
     [InlineData("InvalidCommand", "Filter", "*")]
-    public async Task ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd,
-                                                                                 string paramName,
-                                                                                 string paramValue)
+    public async Task ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string command, string parameter, string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
         PSExecutor psExecutor = new();
 
         // Act
-        PSOutput result = await psExecutor.ExecuteAsync(command);
+        PSOutput result = await psExecutor.ExecuteAsync(psCommand);
 
         // Assert
         Assert.True(result.HadErrors);

ActiveDirectoryQuerier.Tests/PSOutputTest.cs

@@ -0,0 +1,39 @@
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+// ReSharper disable once InconsistentNaming
+public class PSOutputTest
+{
+    [Fact]
+    public void HadErrors_StdErrHasEntries_ReturnsTrue()
+    {
+        // Arrange
+        PSOutput psOutput = new();
+        psOutput.StdErr.Add("Error");
+
+        // Act
+        bool result = psOutput.HadErrors;
+
+        // Assert
+        Assert.True(result);
+        Assert.NotEmpty(psOutput.StdErr);
+        Assert.Empty(psOutput.StdOut);
+    }
+
+    [Fact]
+    public void NoErrors_StdOutHasEntries_ReturnsFalse()
+    {
+        // Arrange
+        PSOutput psOutput = new();
+        psOutput.StdOut.Add("Output");
+
+        // Act
+        var result = psOutput.HadErrors;
+
+        // Assert
+        Assert.False(result);
+        Assert.Empty(psOutput.StdErr);
+        Assert.NotEmpty(psOutput.StdOut);
+    }
+}

ActiveDirectoryQuerier/MainWindowViewModel.cs

@@ -8,8 +8,8 @@
 using System.Windows.Controls;
 using System.Windows.Input;
 using ActiveDirectoryQuerier.PowerShell;
+using ActiveDirectoryQuerier.Queries;
 using Microsoft.Win32;
-using static ActiveDirectoryQuerier.PowerShell.CustomQueries;
 
 namespace ActiveDirectoryQuerier;
 
@@ -27,7 +27,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged
     private string _queryDescription;
     private AppConsole _queryBuilderConsoleOutput;
     private AppConsole _activeDirectoryInfoConsoleOutput;
-    private Command? _selectedComboBoxCommandInQueryBuilder; // TODO: Change the name of this field?
+    private Command? _selectedComboBoxCommandInQueryBuilder;
     private ObservableCollection<Button>? _buttons;
 
     // [[ Other fields ]] ----------------------------------------------------------- //
@@ -281,7 +281,7 @@ private void EditCustomQuery(object sender)
 
         // Fill in the commandName
         Command chosenCommand =
-            ADCommands.FirstOrDefault(item => item.CommandText == currentQuery.CommandName)!;
+            ADCommands.FirstOrDefault(item => item.CommandText == currentQuery.PSCommandName)!;
         SelectedComboBoxCommandInQueryBuilder = chosenCommand;
 
         // Load the Possible Parameters Synchronously
@@ -298,17 +298,17 @@ private void EditCustomQuery(object sender)
         }
 
         // Fill in Parameters and values
-        for (int i = 0; i < currentQuery.CommandParameters.Length; i++)
+        for (int i = 0; i < currentQuery.PSCommandParameters.Length; i++)
         {
-            Trace.WriteLine(currentQuery.CommandParameters[i]);
+            Trace.WriteLine(currentQuery.PSCommandParameters[i]);
 
             // Adds the Parameters boxes
             object temp = new();
             AddParameterComboBox(temp);
 
             // Fill in the parameter boxes
-            DynamicParameterComboBoxes[i].SelectedParameter = currentQuery.CommandParameters[i];
-            DynamicParameterValueTextBoxes[i].SelectedParameterValue = currentQuery.CommandParametersValues[i];
+            DynamicParameterComboBoxes[i].SelectedParameter = currentQuery.PSCommandParameters[i];
+            DynamicParameterValueTextBoxes[i].SelectedParameterValue = currentQuery.PSCommandParameterValues[i];
         }
     }
 
@@ -355,7 +355,7 @@ private void DeleteCustomQuery(object _)
 
         QueryButtonStackPanel.Remove(currentButton);
         _customQuery.Queries.Remove((Query)currentButton.Tag);
-        _customQuery.SerializeMethod();
+        _customQuery.SaveQueriesToJson();
     }
 
     /// <summary>
@@ -398,7 +398,7 @@ private async void ExecuteSelectedCommandAsync(object _)
     /// </summary>
     private async Task InitializeActiveDirectoryCommandsAsync()
     {
-        ObservableCollection<Command> list = await ADCommandsFetcher.GetActiveDirectoryCommands();
+        ObservableCollection<Command> list = await ADCommandsFetcher.GetADCommands();
         ADCommands = new ObservableCollection<Command>(list);
         OnPropertyChanged(nameof(ADCommands));
     }
@@ -642,20 +642,18 @@ private void GetCurrentQuery()
 
                 _currentQuery.QueryDescription = QueryDescription;
                 _currentQuery.QueryName = QueryName;
-
-                _currentQuery.CommandName = SelectedComboBoxCommandInQueryBuilder.CommandText;
-
-                // TODO: Possibly convert foreach into a for loop...
+                _currentQuery.PSCommandName = SelectedComboBoxCommandInQueryBuilder.CommandText;
+
                 for (int i = 0; i < SelectedComboBoxCommandInQueryBuilder.Parameters.Count; i++)
                 {
                     CommandParameter commandParameter = SelectedComboBoxCommandInQueryBuilder.Parameters[i];
 
                     commandParameters[i] = commandParameter.Name;
                     commandParameterValues[i] = commandParameter.Value.ToString()!;
-                    i++;
+                    i++;  // TODO: Remove this line!
                 }
-                _currentQuery.CommandParameters = commandParameters;
-                _currentQuery.CommandParametersValues = commandParameterValues;
+                _currentQuery.PSCommandParameters = commandParameters;
+                _currentQuery.PSCommandParameterValues = commandParameterValues;
             }
         }
         catch (Exception ex)
@@ -706,7 +704,7 @@ private void SaveCustomQueries(object commandParameter)
             GetCurrentQuery();
             Trace.WriteLine(_customQuery.Queries.IndexOf(_isEditing));
             _customQuery.Queries[_customQuery.Queries.IndexOf(_isEditing)] = _currentQuery;
-            _customQuery.SerializeMethod();
+            _customQuery.SaveQueriesToJson();
             _isEditing = null;
             EditingEnabled = false;
         }
@@ -774,7 +772,7 @@ private Button CreateCustomButton(Query? query = null)
         if (query != null)
         {
             newButton.Height = 48;
-            newButton.Content = (string.IsNullOrEmpty(query.QueryName) ? query.CommandName : query.QueryName);
+            newButton.Content = (string.IsNullOrEmpty(query.QueryName) ? query.PSCommandName : query.QueryName);
             newButton.Tag = query;
         }
         else

ActiveDirectoryQuerier/PowerShell/ADCommandsFetcher.cs

@@ -8,8 +8,8 @@ namespace ActiveDirectoryQuerier.PowerShell;
 // ReSharper disable once InconsistentNaming
 public static class ADCommandsFetcher
 {
-    // TODO: Possibly rename this method to GetADCommandList...
-    public static async Task<ObservableCollection<Command>> GetActiveDirectoryCommands()
+    // ReSharper disable once InconsistentNaming
+    public static async Task<ObservableCollection<Command>> GetADCommands()
     {
         Command psCommand = new("Get-Command");
         psCommand.Parameters.Add("Module", "ActiveDirectory");