<?xml version="1.0" encoding="utf-8" ?>
<RunSettings>
	<RunConfiguration> 
		<EnvironmentVariables> 
			<JUSTMOCK_INSTANCE>1</JUSTMOCK_INSTANCE>
			<COR_ENABLE_PROFILING>1</COR_ENABLE_PROFILING>
			<COR_PROFILER>{B7ABE522-A68F-44F2-925B-81E7488E9EC0}</COR_PROFILER>		
			<COR_PROFILER_PATH_64>c:\work\client-dependencies\NuGet\repo\justmock.commercial\2024.4.1203.350\runtimes\win-x64\native\Telerik.CodeWeaver.Profiler.dll</COR_PROFILER_PATH_64>
		</EnvironmentVariables> 
	</RunConfiguration> 
</RunSettings>

  /// <summary>
  /// Pregunta la ruta de la carpeta de exportación.
  /// </summary>
  /// <param name="exportPDFDafaultPath">Ruta por defecto para exportar PDF.</param>
  /// <returns>Ruta de la carpeta de exportación.</returns>
  public string AskExportFolderPath(string exportPDFDafaultPath = null)
  {
      this.systemDialogAdapter.ShowFolderBrowserDialog(Environment.NewLine + "Seleccione una ruta.", exportPDFDafaultPath, out string folderPath, true);
      return folderPath;
  }

[Fact]
public void AskExportFolderPath_ShouldReturnFolderPath_WhenDialogResultIsOK()
{
    // Arrange
    var sutAndMocks = GetSutAndMocks();
    var exportSharedServiceSut = sutAndMocks.Sut;
    string folderPath;
    Mock.Arrange(() => sutAndMocks.Mock<ISystemDialogAdapter>().ShowFolderBrowserDialog(Arg.AnyString, Arg.AnyString, out folderPath, Arg.AnyBool, Arg.IsAny<Action<IMessageBoxDialogVM>>(), Arg.IsAny<Action<IMessageBoxDialogVM>>()))
        .DoInstead((string descriptionMessage, string startFolderUbicacion, outstring selectedFolder) =>
        {
            selectedFolder = "test";
        });

    // Act
    var result = exportSharedServiceSut.AskExportFolderPath();

    // Assert
    Assert.Equal("test", result);
}
private static SutAndMocks<ExportSharedService> GetSutAndMocks()
{
   SutAndMocks<ExportSharedService> result = new SutAndMocks<ExportSharedService>();
   result.AddMock(Mock.Create<ISystemDialogAdapter>());
   result.AddMock(Mock.Create<IFileWrapper>());
   result.AddMock(Mock.Create<SaveFileDialog>());
   result.AddMock(Mock.Create<BackgroundWorker>());

   result.Sut = new ExportSharedService(
          result.Mock<ISystemDialogAdapter>(),
          result.Mock<IFileWrapper>(),
          result.Mock<SaveFileDialog>(),
          result.Mock<BackgroundWorker>());
   return result;
}
     
    

 public class SutAndMocks<T>
 {
     private readonly Dictionary<Type, object> mocks = new Dictionary<Type, object>();
     private readonly Dictionary<Type, Dictionary<string, object>> mocksWithName = new Dictionary<Type, Dictionary<string, object>>();

     /// <summary>
     /// System under test.
     /// </summary>
     public T Sut { get; set; }

     /// <summary>
     /// Retorna el Mock de un tipo.
     /// </summary>
     /// <typeparam name="TMock">Tipo de mock.</typeparam>
     public TMock Mock<TMock>()
     {
         return (TMock)mocks[typeof(TMock)];
     }

     /// <summary>
     /// Retorna el Mock con su name.
     /// </summary>
     /// <typeparam name="TMock">Tipo de mock con su name</typeparam>
     public TMock Mock<TMock>(string name)
     {
         return (TMock)mocksWithName[typeof(TMock)][name];
     }

     /// <summary>
     /// Añade un mock.
     /// </summary>
     /// <typeparam name="TMock">Tipo de mock.</typeparam>
     public void AddMock<TMock>(TMock mock)
     {
         this.mocks[typeof(TMock)] = mock;
     }

     /// <summary>
     /// Añade un mock.
     /// </summary>
     /// <typeparam name="TMock">Tipo de mock.</typeparam>>
     /// <param name="name">Nombre de la clase</param>
     public void AddMock<TMock>(TMock mock, string name)
     {
         if (this.mocksWithName.ContainsKey(typeof(TMock)))
         {
             this.mocksWithName[typeof(TMock)][name] = mock;
         }
         else
         {
             this.mocksWithName[typeof(TMock)] = new Dictionary<string, object> { { name, mock } };
         }
     }

 }

ISystemDialogAdapter sa = sutAndMocks.Mock<ISystemDialogAdapter>();
Mock.Arrange(() => sa.ShowFolderBrowserDialog(Arg.AnyString, Arg.AnyString, out folderPath, Arg.AnyBool, Arg.IsAny<Action<IMessageBoxDialogVM>>(), Arg.IsAny<Action<IMessageBoxDialogVM>>()))
        .DoInstead((string descriptionMessage, string startFolderUbicacion, outstring selectedFolder) =>
        {
            selectedFolder = "test";
        });

            ItemCollection itemCollection_Single = Mock.Create<ItemCollection>(Behavior.Strict);
            Mock.Arrange(() => itemCollection_Single.Count).Returns(2).Occurs(3, nameof(itemCollection_Single.Count));

            RadComboBox radComboBox_Single = Mock.Create<RadComboBox>(Behavior.Strict);
            Mock.Arrange(() => radComboBox_Single.Items).Returns(itemCollection_Single).Occurs(3, nameof(radComboBox_Single.Items));

            mockSelectionChangedEventArgs = Mock.Create<SelectionChangedEventArgs>(Behavior.Strict);
            Mock.Arrange(() => mockSelectionChangedEventArgs.AddedItems).Returns(new List<ParameterValue>() { selectionRuleRow.AllowedValues[0] }).Occurs(2, nameof(mockSelectionChangedEventArgs.AddedItems));
            Mock.Arrange(() => mockSelectionChangedEventArgs.OriginalSource).Returns(radComboBox_Single).Occurs(1, nameof(mockSelectionChangedEventArgs.OriginalSource));

            selectionRuleRow.MultipleEnumSelectionChanged.Execute(mockSelectionChangedEventArgs);

            Assert.AreEqual(expected: "Yes", actual: selectionRuleRow.Value);
            Assert.IsTrue(selectionRuleRow.CanApply);

            Mock.Assert(mockSelectionChangedEventArgs); // ==> fails because of set expectations on itemCollection_Single and radComboBox_Single 
            //Mock.Assert(() => mockSelectionChangedEventArgs.AddedItems, Occurs.Exactly(1));
            //Mock.Assert(() => mockSelectionChangedEventArgs.OriginalSource, Occurs.Exactly(1));

dotnet test my.sln --configuration Release --no-build --no-restore --settings test-coverage.runsettings

<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
  <RunConfiguration>
    <ResultsDirectory>\CodeCoverageTestResults</ResultsDirectory>
    <TestAdaptersPaths>C:\JustMock\Libraries\DataCollectors;C:\Users\GitHubRunner\.nuget\packages\microsoft.codecoverage\17.11.0\build\netstandard2.0</TestAdaptersPaths>
  </RunConfiguration>

  <DataCollectionRunSettings>
    <DataCollectors>
      <DataCollector friendlyName="Code Coverage Wrapper">
        <Configuration>
          <JustMockSettings>
            <ProfilerPath32>C:\JustMock\Libraries\32\Telerik.CodeWeaver.Profiler.dll</ProfilerPath32>
            <ProfilerPath64>C:\JustMock\Libraries\64\Telerik.CodeWeaver.Profiler.dll</ProfilerPath64>
          </JustMockSettings>
          <SinkDataCollector friendlyName="Code Coverage" uri="datacollector://Microsoft/CodeCoverage/2.0" isLinked="true">
            <!-- Exclude DLLs with ".tests." in the name -->
            <CodeCoverage>
              <Exclude>
                <ModuleFilePattern>*\.Tests\.*</ModuleFilePattern>
              </Exclude>
            </CodeCoverage>
          </SinkDataCollector>
        </Configuration>
      </DataCollector>
      <DataCollector friendlyName="JustMockDataCollector" />
    </DataCollectors>
  </DataCollectionRunSettings>
</RunSettings>

public class MyClass
{
    // Event.
    public event Func<EventArgs, Task>? MyEventAsync;
}

// Event handler.
private Task OnMyEventAsync(EventArgs args) => Task.CompletedTask;

// Create mock.
var mockClass = Mock.Create<MyClass>(Behavior.Strict);

// Register event handler.
mockClass.MyEventAsync += OnMyEventAsync;

// Raise event on mock.
Mock.Raise(() => mockClass.MyEventAsync += null, EventArgs.Empty);

<RunSettings>
    <RunConfiguration>
      <EnvironmentVariables>
        <JUSTMOCK_INSTANCE>1</JUSTMOCK_INSTANCE>
        <CORECLR_ENABLE_PROFILING>1</CORECLR_ENABLE_PROFILING>
        <CORECLR_PROFILER>{B7ABE522-A68F-44F2-925B-81E7488E9EC0}</CORECLR_PROFILER>
        <CORECLR_PROFILER_PATH>..\packages\justmock.commercial\2024.2.514.325\runtimes\win-x64\native\Telerik.CodeWeaver.Profiler.dll</CORECLR_PROFILER_PATH>
      </EnvironmentVariables>
    </RunConfiguration>
</RunSettings>

Telerik.JustMock.Core.ElevatedMockingException: Cannot mock 'System.ServiceModel.ServiceSecurityContext'. The profiler must be enabled to mock, arrange or execute the specified target.
Detected active third-party profilers:
* {865fc36f-7fab-44b6-bbb7-c2baea8d9ad2} (from process environment)
Disable the profilers or link them from the JustMock configuration utility. Restart the test runner and, if necessary, Visual Studio after linking.

private Object _object;

public virtual async Task<Object> GetObject(string token,string url)
{
    var client = new HttpClient();
    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
    var response = await client.GetStringAsync(url);
    client.Dispose();
    _object = JsonConvert.DeserializeObject<Object>(response);
    
    return _object;
}