test: improve tests

Author: paul-fresquet

tests/ByteSync.Client.UnitTests/ViewModels/Sessions/Comparisons/Actions/TargetedActionGlobalViewModelTests.cs

@@ -1,3 +1,5 @@
+using System.Collections;
+using System.Collections.ObjectModel;
 using System.Reactive;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -8,12 +10,16 @@
 using ByteSync.Business.Inventories;
 using ByteSync.Client.UnitTests.Helpers;
 using ByteSync.Common.Business.Actions;
+using ByteSync.Common.Business.EndPoints;
 using ByteSync.Common.Business.Inventories;
+using ByteSync.Common.Business.Misc;
 using ByteSync.Interfaces.Controls.Comparisons;
 using ByteSync.Interfaces.Dialogs;
 using ByteSync.Interfaces.Factories.ViewModels;
 using ByteSync.Interfaces.Services.Localizations;
+using ByteSync.Interfaces.Services.Sessions;
 using ByteSync.Models.Comparisons.Result;
+using ByteSync.Models.Inventories;
 using ByteSync.TestsCommon;
 using ByteSync.ViewModels.Sessions.Comparisons.Actions;
 using FluentAssertions;
@@ -73,10 +79,10 @@ public void SetUp()
             .Returns(mockActionEditViewModel.Object);
     }
 
-    private ComparisonItem CreateMockComparisonItem(FileSystemTypes fileSystemType)
+    private ComparisonItem CreateMockComparisonItem(FileSystemTypes fileSystemType, string linkingKey = "test-file")
     {
         // Create a real ComparisonItem instance since it cannot be mocked (no parameterless constructor)
-        var pathIdentity = new PathIdentity(fileSystemType, "test-file", "test-file", "test-file");
+        var pathIdentity = new PathIdentity(fileSystemType, linkingKey, linkingKey, linkingKey);
         var comparisonItem = new ComparisonItem(pathIdentity);
 
         return comparisonItem;
@@ -546,4 +552,155 @@ public void ValidationFailureSummary_AffectedItemsTooltip_ShouldGenerateCorrectT
         // When FileName is null, it should use LinkingKeyValue
         tooltip.Should().Be("file1.txt\ndirectory1");
     }
+    
+    [Test]
+    public void Save_WithValidAction_ShouldLogConsistencySuccess()
+    {
+        var comparisonItems = new List<ComparisonItem>
+        {
+            CreateMockComparisonItem(FileSystemTypes.File, "file1"),
+            CreateMockComparisonItem(FileSystemTypes.File, "file2")
+        };
+        
+        var dataPartIndexer = BuildDataPartIndexer();
+        var actionEditViewModel = new AtomicActionEditViewModel(FileSystemTypes.File, false, comparisonItems, dataPartIndexer);
+        
+        _mockActionEditViewModelFactory.Setup(x => x.BuildAtomicActionEditViewModel(
+                It.IsAny<FileSystemTypes>(), It.IsAny<bool>(), It.IsAny<AtomicAction>(), It.IsAny<List<ComparisonItem>>()))
+            .Returns(actionEditViewModel);
+        
+        var viewModel = new TargetedActionGlobalViewModel(
+            comparisonItems,
+            _mockDialogService.Object,
+            _mockLocalizationService.Object,
+            _mockTargetedActionsService.Object,
+            _mockAtomicActionConsistencyChecker.Object,
+            _mockActionEditViewModelFactory.Object,
+            _mockLogger.Object,
+            _mockFailureReasonService.Object
+        );
+        
+        ConfigureValidAction(actionEditViewModel);
+        
+        var result = new AtomicActionConsistencyCheckCanAddResult(comparisonItems);
+        _mockAtomicActionConsistencyChecker.Setup(x => x.CheckCanAdd(It.IsAny<AtomicAction>(), comparisonItems))
+            .Returns(result);
+        
+        viewModel.SaveCommand.Execute(Unit.Default).Subscribe();
+        
+        _mockLogger.Verify(
+            x => x.Log(
+                LogLevel.Information,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) =>
+                    v.ToString()!.Contains("Targeted action created.")
+                    && v.ToString()!.Contains("Items=file1, file2")),
+                It.IsAny<Exception?>(),
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+    
+    private static void ConfigureValidAction(AtomicActionEditViewModel actionEditViewModel)
+    {
+        var actions = GetInternalEnumerable(actionEditViewModel, "Actions");
+        var sources = GetInternalEnumerable(actionEditViewModel, "Sources");
+        var destinations = GetInternalEnumerable(actionEditViewModel, "Destinations");
+        
+        var selectedAction = GetActionByOperator(actions, ActionOperatorTypes.Copy);
+        
+        SetInternalProperty(actionEditViewModel, "SelectedAction", selectedAction);
+        SetInternalProperty(actionEditViewModel, "SelectedSource", FirstItem(sources));
+        SetInternalProperty(actionEditViewModel, "SelectedDestination", FirstItem(destinations));
+    }
+    
+    private sealed class TestDataPartIndexer : IDataPartIndexer
+    {
+        private readonly ReadOnlyCollection<DataPart> _dataParts;
+        
+        public TestDataPartIndexer(IReadOnlyCollection<DataPart> dataParts)
+        {
+            _dataParts = new ReadOnlyCollection<DataPart>(dataParts.ToList());
+        }
+        
+        public void BuildMap(List<Inventory> inventories)
+        {
+        }
+        
+        public ReadOnlyCollection<DataPart> GetAllDataParts()
+        {
+            return _dataParts;
+        }
+        
+        public DataPart? GetDataPart(string? dataPartName)
+        {
+            return _dataParts.FirstOrDefault(dp => dp.Name == dataPartName);
+        }
+        
+        public void Remap(ICollection<SynchronizationRule> synchronizationRules)
+        {
+        }
+    }
+    
+    private static IDataPartIndexer BuildDataPartIndexer()
+    {
+        var endpoint = new ByteSyncEndpoint
+        {
+            ClientId = "c",
+            ClientInstanceId = "ci",
+            Version = "v",
+            OSPlatform = OSPlatforms.Windows,
+            IpAddress = "127.0.0.1"
+        };
+        
+        var inventoryA = new Inventory { InventoryId = "INV_A", Code = "A", Endpoint = endpoint, MachineName = "M" };
+        var inventoryB = new Inventory { InventoryId = "INV_B", Code = "B", Endpoint = endpoint, MachineName = "M" };
+        var partA = new InventoryPart(inventoryA, "c:\\a", FileSystemTypes.Directory) { Code = "A1" };
+        var partB = new InventoryPart(inventoryB, "c:\\b", FileSystemTypes.Directory) { Code = "B1" };
+        
+        var dataParts = new List<DataPart>
+        {
+            new("A", partA),
+            new("B", partB)
+        };
+        
+        return new TestDataPartIndexer(dataParts);
+    }
+    
+    private static IEnumerable GetInternalEnumerable(object target, string propertyName)
+    {
+        var property = target.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.NonPublic);
+        
+        return (IEnumerable)property!.GetValue(target)!;
+    }
+    
+    private static object FirstItem(IEnumerable items)
+    {
+        foreach (var item in items)
+        {
+            return item!;
+        }
+        
+        throw new InvalidOperationException("Empty collection");
+    }
+    
+    private static void SetInternalProperty(object target, string propertyName, object? value)
+    {
+        var property = target.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.NonPublic);
+        property!.SetValue(target, value);
+    }
+    
+    private static object GetActionByOperator(IEnumerable actions, ActionOperatorTypes operatorType)
+    {
+        foreach (var action in actions)
+        {
+            var property = action!.GetType().GetProperty("ActionOperatorType", BindingFlags.Instance | BindingFlags.Public);
+            var value = (ActionOperatorTypes)property!.GetValue(action)!;
+            if (value == operatorType)
+            {
+                return action;
+            }
+        }
+        
+        throw new InvalidOperationException("Action not found");
+    }
 }