Modern Configuration Builder (v16.x) Part 1 #2241

…n management ✨ (config): introduce appsettings.json for centralized configuration 📝 (docs): update MigrationTools.xml with new version and branch information Adding `appsettings.json` to the solution items ensures that configuration settings are centralized and easily manageable. This file includes logging levels and migration tool settings, which enhances the flexibility and maintainability of the application. The `MigrationTools.xml` documentation is updated to reflect the latest version and branch information, ensuring that the documentation is current and accurate. ♻️ (MigrationToolHost.cs): refactor configuration and logging setup for better readability and maintainability Refactor the configuration and logging setup to improve code readability and maintainability. The changes include: - Adding missing using directives for `System.Configuration` and `NuGet.Protocol.Plugins`. - Removing unnecessary whitespace. - Aligning the indentation for better readability. - Changing the way `EngineConfiguration` options are configured to use a more concise and readable approach with `AddOptions<EngineConfiguration>().Configure`. - Ensuring consistent formatting and spacing throughout the file. These changes make the code easier to read and maintain, reducing the likelihood of errors and improving overall code quality.

… add new field mappings, and enhance logging 📝 (MigrationTools.xml): update Git metadata for documentation ✨ (launchSettings.json): add new launch profile for executing without config The project names in the configuration are updated to "myProjectName" for consistency. The authentication mode is changed to "Prompt" to enhance security. New field mappings are added to support various field transformations and enrichments. The logging level is set to "Information" for better clarity. Git metadata in the documentation is updated to reflect the latest commit details. A new launch profile is added to allow execution without configuration, improving flexibility in running the project. 🔧 (MigrationToolHost.cs): add support for environment variables in configuration 💡 (MigrationToolHost.cs): add spacing for better readability Add support for environment variables to allow configuration via environment settings, enhancing flexibility and deployment options. Improve code readability by adding spacing around variable declarations and method calls.

…nfigurations - Add `configuration3.json` to support new migration scenarios. - Update `appsettings.json` to include `WorkItemFieldMapping`. - Enable `WorkItemMigrationConfig` in `configuration.json`. - Update `MigrationTools.sln` to include `configuration3.json`. - Update `MigrationTools.xml` to reflect the latest commit details. - Add `ConfigurationSectionName` constant in `TfsAttachmentEnricherOptions`. - Modify `TfsNodeStructure` constructor to use `IOptions<TfsNodeStructureOptions>`. These changes enhance the flexibility and configurability of the migration tools, allowing for more detailed and specific migration scenarios. The updates to the solution and configuration files ensure that new features are properly integrated and can be easily managed. ✨ (ProcessorEnrichers): add configuration section names for various options 🔧 (ServiceCollectionExtensions): bind configuration sections to options 📝 (launchSettings.json): add new launch configuration for configuration3.json 📝 (csproj): include configuration3.json in the project Adding `ConfigurationSectionName` constants to various options classes improves the maintainability and readability of the code by centralizing the configuration section names. Binding these configuration sections in `ServiceCollectionExtensions` ensures that the options are correctly configured from the appsettings. Including `configuration3.json` and updating `launchSettings.json` allows for easier testing and execution of different configurations. ✨ (MigrationTools): add support for new configuration format and command line arguments Add support for a new configuration format to improve flexibility and future-proofing. Introduce command line argument parsing to enhance configurability. Implement a version check to ensure compatibility with older configurations, providing a warning for deprecated formats. Add utility methods to dynamically load processor configurations and enrichers from the new format. Remove the workaround for the query SOAP bug as it is no longer needed.

…xtensions.cs, MigrationToolHost.cs): refactor endpoint configuration and processor binding Refactor endpoint configuration methods to use a more descriptive naming convention, changing `AddEndpoint` to `AddMigrationToolsEndpoint` and `ConfigureEndpoint` to `ConfigureMigrationToolsEndpoint`. This improves code readability and clarity. Simplify processor binding logic in `MigrationToolHost.cs` by removing redundant code and using a more concise approach. This reduces complexity and potential errors in processor configuration. ♻️ (EndpointFactoryServiceCollectionExtensions.cs): rename methods to improve clarity and consistency 🔧 (ServiceCollectionExtensions.cs): update method calls to match renamed methods 💡 (WorkItemMigrationContext.cs): add spacing for better readability Renaming methods in `EndpointFactoryServiceCollectionExtensions.cs` to `AddMigrationToolsEndpoint` and `AddMigrationToolsEndPoints` improves clarity by making it explicit that these methods are related to Migration Tools. This change enhances code readability and maintainability. The corresponding method calls in `ServiceCollectionExtensions.cs` are updated to reflect these changes. Additionally, a minor formatting improvement is made in `WorkItemMigrationContext.cs` for better readability.

Refactor the configuration structure to improve clarity and maintainability. The changes include: - Moving and renaming configuration sections for better organization. - Updating the configuration keys to reflect the new structure. - Simplifying the retrieval of configuration values in the code. - Removing redundant and outdated configuration sections. These changes aim to make the configuration files more intuitive and easier to manage, reducing the risk of errors and improving the overall maintainability of the project. ✨ (MigrationTools): add AppDomainExtensions and TypeExtensions for better type handling and configuration Introduce `AppDomainExtensions` to fetch types from assemblies related to MigrationTools. Add `TypeExtensions` to filter types by interface, configuration section name, and name string. Update `ConfigurationSectionExtensions` to utilize these new extensions for improved configuration handling. These changes enhance the flexibility and maintainability of the configuration system by modularizing type retrieval and filtering logic, making it easier to extend and debug.

…Exist" processor type 🔧 (MigrationToolHost.cs): update configuration loading logic for processors and enrichers ♻️ (ConfigurationSectionExtensions.cs): refactor configuration section extension methods for better error handling and logging The new processor configuration for "DoesNotExist" is added to support additional processing types. The configuration loading logic in `MigrationToolHost.cs` is updated to use a more flexible and robust method for loading processor and enricher configurations. The refactoring in `ConfigurationSectionExtensions.cs` improves error handling and logging, making it easier to diagnose configuration issues.

… source and target options Improve the readability and maintainability of the code by refactoring the configuration section parsing for the `Source` and `Target` options. This change ensures that the `Source` and `Target` options are correctly populated from the configuration, enhancing the flexibility and correctness of the migration tool's configuration handling.

The "DoesNotExist" processor type is removed because it is not a valid processor and could cause errors or unexpected behavior in the application. This cleanup ensures that only valid and functional processors are configured, improving the reliability and maintainability of the configuration file.

📝 (docs): update MigrationTools.xml with new commit metadata 🔧 (csproj): ensure appsettings.json is always copied to output directory The new Test settings in appsettings.json allow for additional configuration options under CommonEnrichers. The MigrationTools.xml documentation is updated to reflect the latest commit metadata, ensuring accurate reference information. The csproj file is modified to always copy appsettings.json to the output directory, ensuring the configuration file is available during runtime.

Remove the "Test" settings under "CommonEnrichers" and redundant "FieldMaps" entries under "TfsFieldMappings". This cleanup reduces clutter and potential confusion in the configuration file, ensuring only relevant settings are maintained.

…lease The next-version is updated from 15.0.1 to 16.0.0 to reflect significant changes or new features that warrant a major version increment. This ensures proper versioning and helps in tracking the evolution of the project.

…onToolHost.cs): integrate Serilog for enhanced logging and update configuration Add Serilog configuration to appsettings.json and configuration3.json to improve logging capabilities. Update the logging levels for Microsoft and Microsoft.Hosting.Lifetime to Debug for more detailed logs. Refactor MigrationToolHost.cs to use Serilog for logging, including setting up log levels and output templates. This change enhances the application's logging capabilities, making it easier to debug and monitor the application. Additionally, update the version in configuration.json to 16.0 to reflect the new configuration changes.

…agement ♻️ (MigrationToolHost.cs): refactor logging setup and add method to retrieve all services 📝 (MigrationTools.xml): update auto-generated documentation with new commit details The logging configuration in `appsettings.json` is updated to include `rollingInterval` and `shared` properties, which improve log file management by creating new log files daily and allowing shared access. The `MigrationToolHost.cs` file is refactored to streamline the logging setup and includes a new method to retrieve all services from the service provider, enhancing code readability and maintainability. The `MigrationTools.xml` documentation is updated to reflect the latest commit details, ensuring accurate and up-to-date information.

…nt settings ♻️ (MigrationToolHost.cs): refactor logging setup to include separate log files for verbose and error logs The logging configuration in `appsettings.json` is updated to include `Microsoft.Hosting.Lifetime` at the `Debug` level for better debugging information. Redundant logging settings are removed to streamline the configuration. In `MigrationToolHost.cs`, the logging setup is refactored to create separate log files for verbose and error logs, improving log management and readability. The logs are now stored in a dynamically created path, enhancing the flexibility of the logging system.

♻️ (MigrationToolHost.cs): refactor logging setup for better maintainability 📝 (MigrationTools.xml): update generated documentation with new commit details The redundant logging configuration in `appsettings.json` is removed to simplify the settings file. The logging setup in `MigrationToolHost.cs` is refactored to centralize the output template and add missing enrichers for better log context. The generated documentation in `MigrationTools.xml` is updated to reflect the latest commit details.

… to Verbose ♻️ (MigrationToolHost.cs): remove redundant log level restriction in Serilog configuration Changing the log level for `Microsoft.Hosting.Lifetime` to `Verbose` provides more detailed logging information, which can be useful for debugging and monitoring. The redundant `restrictedToMinimumLevel` parameter is removed from the Serilog configuration to simplify the logging setup and ensure all log levels are captured as intended.

♻️ (MigrationToolHost.cs): refactor configuration version handling and logging 📝 (MigrationTools.xml): update generated documentation with new commit details The Serilog minimum level is updated to "Information" to reduce log verbosity. The configuration version handling in `MigrationToolHost.cs` is refactored to use a new `MigrationConfigVersion` enum, improving code readability and maintainability. The generated documentation is updated to reflect the latest commit details.

…tra commands support Add detailed descriptions and examples for the `execute` and `init` commands to improve user understanding. Introduce an optional `extraCommands` parameter to `CreateDefaultBuilder` to allow additional commands to be configured. This enhances the flexibility and usability of the migration tool. Additionally, minor refactoring and cleanup are performed to improve code readability and maintainability.

…ration file creation and editing 🔧 (MigrationTools.sln): include appsettings.json in the solution items ♻️ (launchSettings.json): reorganize and rename profiles for better clarity 📝 (MigrationTools.xml): update XML documentation with new commit details The MigrationConfigCommand is introduced to facilitate the creation and editing of configuration files, improving the flexibility and usability of the tool. The appsettings.json file is added to the solution items for better configuration management. The launchSettings.json file is reorganized and profiles are renamed for better clarity and usability. The XML documentation is updated to reflect the latest commit details, ensuring accurate and up-to-date information.

♻️ (MigrationConfigCommand): change telemetry event name to "MigrationConfigCommand" for better clarity 🐛 (MigrationConfigCommand): throw exception if config file already exists to prevent unsupported edits 💡 (MigrationToolHost): uncomment and update service configurations for better clarity The MigrationTools.xml file is updated to reflect the latest commit details, ensuring documentation accuracy. The telemetry event name in MigrationConfigCommand is changed to "MigrationConfigCommand" for better clarity. An exception is now thrown if the configuration file already exists, preventing unsupported edits. Service configurations in MigrationToolHost are uncommented and updated for better clarity and maintainability.

…hers - Change "Teams" from null to an empty array to avoid null reference issues. - Correct "MaxRevisions" to "MaxAttachmentSize" for clarity. - Disable several enrichers (TfsUserMappingEnricher, TfsWorkItemTypeMapping, TfsGitRepoMappings, TfsFieldMappings, TfsChangeSetMapping) to streamline configuration. 📝 (MigrationTools.xml): add documentation for new WorkItemTypeMappingEnricher options - Document new properties `MaxStringLength` and `Manipulators` for WorkItemTypeMappingEnricher. - Update Git metadata to reflect the latest commit and version information. ♻️ (MigrationToolHost.cs): pass configuration to AddMigrationToolServices - Modify `AddMigrationToolServices` to accept configuration, ensuring proper initialization. ✨ (WorkItemTypeMappingEnricher.cs): introduce WorkItemTypeMappingEnricher - Add a new enricher to process string fields of work items, applying regex replacements and limiting field lengths. ♻️ (StringManipulatorEnricher.cs): inject options via IOptions - Refactor constructor to use `IOptions<StringManipulatorEnricherOptions>` for better configuration management. These changes improve configuration clarity, enhance documentation, and introduce a new enricher for better data processing. ✨ (WorkItemTypeMappingEnricher): add WorkItemTypeMappingEnricher and its options Introduce a new enricher, `WorkItemTypeMappingEnricher`, to handle work item type mappings. This includes creating a new options class `WorkItemTypeMappingEnricherOptions` to configure the enricher. The options class supports setting a maximum string length and a list of regex-based string manipulators. Update `ServiceCollectionExtensions` to register the new enricher and bind its options from the configuration. Modify `WorkItemMigrationContext` to include the new enricher and pull its configuration. These changes enhance the flexibility and configurability of the migration tool by allowing custom work item type mappings and string manipulations.

…ase conditions Add inputs to force the `src` and `docs` folders to be considered changed. Improve the release conditions by introducing a `RunRelease` flag to control when releases should be executed. This enhances the flexibility and control over the CI/CD pipeline, allowing for more granular and conditional execution based on specific folder changes or forced inputs. 🔧 (main.yml): update release conditions and simplify folder decision logic Simplifies the release condition by checking a single output variable `nkdAgility_RunRelease` instead of multiple conditions. Removes the redundant folder decision logic and directly uses the `nkdAgility_DocsDeployFolder` output for the SFTP upload path. This streamlines the workflow and reduces potential points of failure. ♻️ (TfsWorkItemEmbededLinkEnricher.cs, TfsWorkItemMigrationClient.cs, WorkItemMigrationClientMock.cs, IWorkItemMigrationClient.cs, WorkItemMigrationClientBase.cs): add stopOnError parameter to GetWorkItem methods Introduce a `stopOnError` parameter to the `GetWorkItem` methods to provide more control over error handling. This change allows the caller to decide whether the application should exit on error or continue execution. This improves the flexibility and robustness of the error handling mechanism in the work item migration process.

🔧 (tests): inject configuration into service provider helpers Update the MigrationTools.xml documentation to reflect the latest git metadata, ensuring the documentation is current and accurate. Inject configuration into service provider helpers across various test projects to ensure that services are correctly configured and can be customized via configuration settings. This change improves the flexibility and maintainability of the test setup.

🔧 (configuration.json): update configuration structure for clarity The changes remove unused enrichers and processors to streamline the configuration file, making it easier to maintain and understand. The configuration structure is updated to improve clarity and ensure that only necessary settings are included, which helps in reducing potential configuration errors and enhances readability.

♻️ (launchSettings.json): remove redundant configurations and add new ones ✨ (MigrationToolHost.cs): update field map configuration section Corrects the typo in the "FieldMapType" values from "FieldToFieledMap" to "FieldtoFieldMap" to ensure proper configuration parsing. Removes redundant configurations in `launchSettings.json` and adds new configurations for better clarity and usability. Updates the field map configuration section in `MigrationToolHost.cs` to use the correct configuration path, ensuring the application reads the correct settings.

…ion for better modularity Refactor the script to replace inline git operations with a call to the Get-GitChanges function. This improves code modularity and readability, making it easier to maintain and extend in the future. The new function encapsulates the logic for fetching git changes based on the specified mode, reducing redundancy and potential errors. ✨ (Get-ReleaseDescription.ps1): add new function Get-ReleaseDescription2 for enhanced release descriptions ♻️ (Get-ReleaseDescription.ps1): refactor existing functions to improve modularity and readability 🔧 (Get-ReleaseDescription.ps1): add new configuration options for OpenAI API integration Introduce a new function `Get-ReleaseDescription2` to generate detailed release descriptions using OpenAI's API. Refactor existing code to improve modularity, making it easier to maintain and extend. Add new configuration options to support different modes and environment variables, enhancing the script's flexibility and usability. 🔧 (Get-ReleaseDescription.ps1): switch from Write-Host to Write-Debug for better logging The change replaces `Write-Host` with `Write-Debug` to improve logging practices. Using `Write-Debug` allows for more controlled and conditional output, which is useful for debugging without cluttering standard output. Additionally, the elapsed time for the operation is now logged, providing better insights into performance. ✨ (build): add test.ps1 script for generating release descriptions 📝 (docs): update MigrationTools.xml with new Git metadata Add a new PowerShell script `test.ps1` to the build process to generate release descriptions using the `Get-ReleaseDescription2` function. This script helps automate the release note generation, improving the release workflow. Update `MigrationTools.xml` to reflect the latest Git metadata, including commit hashes, commit dates, and version tags. This ensures that the documentation is up-to-date with the current state of the repository.

…enerate PR descriptions using OpenAI 🔧 (Get-ReleaseDescription.ps1): update documentation globs to exclude generated reference files 🔧 (test.ps1): update test script to use Get-PullRequestData for generating descriptions The new `Get-PullRequestData` function leverages OpenAI to generate detailed pull request descriptions, improving the quality and consistency of PR documentation. The documentation globs are updated to exclude generated reference files, ensuring cleaner documentation. The test script is updated to use the new function, enhancing the testing process.

Add documentation for new members in MigrationTools.xml to ensure comprehensive reference material for developers. 🔧 (csproj): ensure configuration files are copied to output directory Update MigrationTools.ConsoleFull.csproj to always copy configuration files to the output directory. This ensures that the necessary configuration files are available at runtime. 🔧 (csproj): remove redundant configuration file from test project Remove configuration2.json from MigrationTools.Host.Tests.csproj as it is no longer needed. This reduces clutter and potential confusion in the project configuration. These changes improve the documentation for new features, ensure that configuration files are correctly handled during the build process, and clean up unnecessary files from the test project.

Add missing class names, full class names, and configuration samples to the YAML files for various processor enrichers. Update the corresponding Markdown files to reflect these changes. These updates provide more comprehensive documentation, making it easier for users to understand and configure the processor enrichers. The added configuration samples offer practical examples, improving usability and reducing potential configuration errors. 📝 (docs): update TfsWorkItemEmbededLinkEnricher documentation and add WorkItemTypeMappingEnricher documentation Update the TfsWorkItemEmbededLinkEnricher documentation to include missing options and configuration samples. Add new documentation for WorkItemTypeMappingEnricher to provide details on its usage, options, and configuration samples. This improves the comprehensiveness and usability of the documentation for developers and users.

Change the script path from Get-ReleaseDescription.ps1 to Get-ReleaseDescription2.ps1 to ensure the correct script is executed. This change is necessary to align with the updated script naming conventions or to use the latest version of the script.

…mapping 📝 (docs): update MigrationTools.xml with new commit details ✅ (tests): add ProjectReference and update test categories ♻️ (EngineConfigurationBuilder): switch from InMemory to FileSystem clients Adding `workItemTypeName` to `FieldMaps` in `configuration.json` improves the flexibility of field mappings. The documentation is updated to reflect the latest commit details. Test configurations are enhanced by adding a new project reference and updating test categories to better organize and identify tests. The `EngineConfigurationBuilder` is refactored to use `FileSystem` clients instead of `InMemory` clients, aligning with the current project requirements.

…tion command and interactive configuration editor Add a new "Config" command in launchSettings.json to allow running the configuration command with specific arguments. Enhance MigrationConfigCommand.cs to include an interactive configuration editor that loads configuration files and allows users to select and edit different sections, including processors. This improves user experience by providing a more flexible and user-friendly way to manage configuration settings.

Fixes the script name from `Get-ReleaseDescription2.ps1` to `Get-ReleaseDescription.ps1` to ensure the correct script is executed. This change is necessary to avoid errors in the workflow and ensure the release description is generated correctly.

…to gpt-4o-mini The model used in the OpenAI API request is updated to "gpt-4o-mini" to align with the latest available model or specific project requirements. This change ensures that the script uses the most appropriate model for generating responses.

Corrects a syntax error in the GitHub Actions workflow file by adjusting the placement of the "@" symbol. This ensures the workflow runs correctly without syntax-related interruptions.

Corrects a syntax error in the GitHub Actions workflow file by adjusting the placement of the "@" symbol. This ensures the workflow runs correctly and avoids potential issues during the execution of the CI/CD pipeline.

Allowing the nkdagility-summery step to continue on error ensures that the workflow does not fail entirely if this step encounters an issue. This change improves the robustness of the CI/CD pipeline by allowing subsequent steps to execute even if the summary generation fails.

Rename the job from "Create Summery" to "Show Summery" for clarity. Add a new step to display the release description in the GitHub Actions workflow. This improves the readability and provides more detailed information about the release directly in the workflow summary.

…t metadata The generated XML documentation is updated to reflect the latest git metadata, including commit hash, commit date, and other related fields. This ensures that the documentation is accurate and up-to-date with the current state of the repository.

…ing value 💡 (TfsNodeStructure.cs): improve log message clarity by adding a newline 🐛 (WorkItemMigrationContext.cs): fix and enhance logging and query replacement logic The IsDirtyString value in the documentation is updated to "true" to reflect the current state. The log message in TfsNodeStructure.cs is improved by adding a newline for better readability. In WorkItemMigrationContext.cs, the log message is enhanced to include the count of source work items, and the query replacement logic is fixed to ensure the project name is correctly replaced before running the query.

Grouping the workflow steps in the GitHub Actions configuration file improves the readability and organization of the logs. This makes it easier to debug and understand the workflow execution by clearly separating different setup phases.

Corrects the script name from Get-ReleaseDescription2 to Get-ReleaseDescription. This ensures the correct script is executed, preventing potential errors in the release description generation process.

…dAgility_ReleaseDescription steps Removing `continue-on-error: true` ensures that the workflow fails if these steps encounter errors, improving the reliability and robustness of the CI/CD pipeline. This change helps catch issues early and prevents incomplete or incorrect summaries and release descriptions from being generated.

…ichers 🔧 (ServiceCollectionExtensions): register TfsEnricherGroup in the service collection Introduce the `TfsEnricherGroup` class to encapsulate and manage related enrichers for TFS (Team Foundation Server) operations. This change improves code organization and maintainability by grouping related enrichers together. Additionally, register the `TfsEnricherGroup` in the service collection to ensure it is available for dependency injection, enhancing the modularity and configurability of the application. ♻️ (WorkItemMigrationContext): refactor enrichers into TfsEnricherGroup for better organization and maintainability Consolidate multiple individual enrichers into a single `TfsEnricherGroup` object. This change improves code readability and maintainability by grouping related enrichers together, reducing the number of parameters in the constructor, and simplifying the configuration and usage of enrichers throughout the `WorkItemMigrationContext` class. ♻️ (WorkItemMigrationContext): refactor to use TfsEnrichers namespace for consistency Refactor the code to replace direct usage of private fields (_revisionManager, _attachmentEnricher, _workItemLinkEnricher) with the TfsEnrichers namespace. This change improves code readability and consistency by centralizing the enrichment logic under a single namespace, making it easier to manage and understand the codebase.

📝 (docs): update MigrationTools.xml with new commit details ♻️ (ServiceCollectionExtensions): replace TfsEnricherGroup with TfsStaticEnrichers Introduce `TfsStaticEnrichers` and `StaticEnrichers` classes to encapsulate various enrichers, improving code organization and maintainability. Update `ServiceCollectionExtensions` to register these new classes, ensuring proper dependency injection. Update `MigrationTools.xml` to reflect the latest commit details, maintaining accurate documentation. ♻️ (WorkItemMigrationContext): refactor enrichers to use more specific naming conventions Refactor the enrichers to use more specific and descriptive names such as `TfsStaticEnrichers` and `StaticEnrichers`. This change improves code readability and maintainability by making the purpose and scope of each enricher more explicit. The refactor also removes unused enrichers, streamlining the codebase. ♻️ (WorkItemMigrationContext): update namespace from TfsEnrichers to TfsStaticEnrichers The namespace TfsEnrichers is updated to TfsStaticEnrichers to reflect the new naming convention. This change improves code clarity and consistency, making it easier to understand and maintain.

…tion mode and add string manipulator enricher 💡 (MigrationTools.xml): update XML documentation for work item type mappings ♻️ (TfsValidateRequiredField.cs): refactor to use WorkItemTypeMappingEnricher Change the authentication mode from "Prompt" to "AccessToken" to enhance security by using tokens instead of prompts. Add a string manipulator enricher to remove invalid characters from strings, improving data integrity. Update XML documentation to reflect changes in work item type mappings. Refactor TfsValidateRequiredField to use the new WorkItemTypeMappingEnricher for better code maintainability and clarity. ♻️ (ServiceCollectionExtensions): refactor singleton registrations to support multiple config versions ✨ (MigrationToolHost): add support for multiple migration config versions ♻️ (ConfigurationSectionExtensions): move and refactor GetMigrationConfigVersion method Refactor singleton registrations in ServiceCollectionExtensions to support different configuration versions (v15 and v16). This change improves flexibility and allows the application to handle different configuration formats. In MigrationToolHost, add support for multiple migration config versions by using the new GetMigrationConfigVersion method. This ensures the application can correctly interpret and process different configuration formats. Move and refactor the GetMigrationConfigVersion method to ConfigurationSectionExtensions for better modularity and reuse. This change centralizes configuration version handling, making the codebase cleaner and more maintainable. ♻️ (MigrationTools): refactor and remove TypeDefinitionMapContainer and related code - Remove `TypeDefinitionMapContainer` and its references from `IMigrationEngine`, `MigrationEngine`, and `ServiceCollectionExtensions`. - Rename `WorkItemTypeDefinition` to `Mappings` in `WorkItemTypeMappingEnricherOptions`. - Add `Mappings` property to `WorkItemTypeMappingEnricher`. - Update configuration binding logic to support different migration config versions. - Remove `IWitdMapper` interface as it is no longer needed. The changes streamline the codebase by removing the unused `TypeDefinitionMapContainer` and related code, reducing complexity. The renaming of `WorkItemTypeDefinition` to `Mappings` improves clarity and consistency. The configuration binding logic update ensures compatibility with different migration config versions. ♻️ (MigrationTools): remove TypeDefinitionMapContainer and WitdMapper, refactor common enrichers configuration - Remove `TypeDefinitionMapContainer.cs` and `WitdMapper.cs` as they are no longer needed. - Comment out `PullCommonEnrichersConfig` method in `MigrationProcessorBase.cs` and its invocations in various migration contexts. - Replace direct access to `Engine.TypeDefinitionMaps` with `WorkItemTypeMappingEnricher` service in `WorkItemMigrationContext.cs`. The changes are made to simplify the codebase by removing obsolete classes and refactoring the configuration of common enrichers. This improves maintainability and aligns with the new architecture using `WorkItemTypeMappingEnricher`.

…Definition to Mappings for clarity 🔧 (configuration-classic.json): update project names and fix typo in AuthenticationMode 🔧 (configuration-classic.json): add PersonalAccessTokenVariableName for better security 🔧 (configuration-classic.json): add WorkItemTypeMappingEnricherOptions to CommonEnrichersConfig ♻️ (TfsValidateRequiredField.cs): add null check for workItemTypeMappingTool.Mappings ♻️ (ServiceCollectionExtensions.cs): refactor to use IOptions for configuration binding Renaming WorkItemTypeDefinition to Mappings improves clarity and consistency. Updating project names and fixing the typo in AuthenticationMode ensures correct configuration. Adding PersonalAccessTokenVariableName enhances security by using environment variables. Including WorkItemTypeMappingEnricherOptions in CommonEnrichersConfig centralizes configuration. Adding a null check in TfsValidateRequiredField.cs prevents potential null reference errors. Refactoring ServiceCollectionExtensions.cs to use IOptions improves dependency injection and configuration management. 🐛 (TfsWorkItemMigrationClient.cs): handle null project scenario ♻️ (ConfigurationSectionExtensions.cs): refactor configuration binding logic ♻️ (ServiceCollectionExtensions.cs): refactor service registration for v15 config ✨ (WorkItemMigrationContext.cs): add support for PAT from environment variable In `TfsWorkItemMigrationClient.cs`, change from `Single` to `SingleOrDefault` to handle cases where the project does not exist, and add logging and exit if the project is not found. This prevents a NullReferenceException and provides clearer error messages. In `ConfigurationSectionExtensions.cs`, refactor the configuration binding logic to handle multiple configuration sections and merge their values. This ensures that the configuration is more flexible and can handle overrides. In `ServiceCollectionExtensions.cs`, refactor the service registration for v15 configuration to use `IOptions` for better dependency injection practices. This improves the maintainability and readability of the code. In `WorkItemMigrationContext.cs`, add support for retrieving the Personal Access Token (PAT) from an environment variable. This allows for more secure and flexible configuration management, especially in different deployment environments.

… enhanced change set mapping - Rename "TfsChangeSetMapping" to "TfsChangeSetMappingTool" in appsettings.json. - Update MigrationTools.xml with new commit details. - Modify TfsGitRepositoryEnricher to use TfsChangeSetMappingTool. - Create TfsChangeSetMappingTool and TfsChangeSetMappingToolOptions classes. - Remove obsolete ChangeSetMappingFile references from MigrationToolHost. The changes introduce a new TfsChangeSetMappingTool to improve the handling of change set mappings. This tool provides a more structured and maintainable approach to manage change set mappings, enhancing the flexibility and scalability of the migration process. ♻️ (MigrationTools): remove ChangeSetMappingContainer and related code The ChangeSetMappingContainer and its related interfaces and classes are removed to simplify the codebase. This container is no longer needed, and its removal helps in reducing complexity and potential maintenance overhead. The associated configuration and service registrations are also cleaned up to reflect this change.

🔧 (config): update migration config version from v15 to before16 📝 (docs): update MigrationTools.xml with new commit details ✨ (logging): add Serilog for improved logging 🔧 (config): add warning for deprecated config version The TfsGitRepoMappings and TfsFieldMappings sections are removed from the configuration as they are no longer used. The migration config version is updated from v15 to before16 to better reflect its status. Documentation is updated to reflect the latest commit details. Serilog is added to improve logging capabilities. A warning is added to notify users about the deprecated configuration version, urging them to update to v16.

…ure for consistency ♻️ (TfsStaticEnrichers.cs, TfsChangeSetMappingToolOptions.cs, ServiceCollectionExtensions.cs): refactor code for better readability and maintainability 📝 (MigrationTools.xml): update generated documentation to reflect recent changes 💡 (MigrationHostTests.cs): comment out FieldMaps clearing for future review The configuration structure is updated to ensure consistency across different files. The refactoring in the code improves readability and maintainability by aligning the naming conventions and formatting. The generated documentation is updated to reflect the recent changes in the codebase. Commenting out the FieldMaps clearing in the tests is done to review its necessity in future updates. ♻️ (MigrationTools): refactor field mapping logic and remove deprecated tests - Remove `FieldMapContainer` and related configurations. - Replace `FieldMapContainer` with `FieldMappingTool`. - Update `StaticEnrichers` to include `FieldMappingTool`. - Delete outdated test files `EngineConfigurationBuilderTests.cs` and `EngineConfigurationTests.cs`. - Update `FieldMapContainerTests` to use `FieldMappingToolOptions`. The changes streamline the field mapping logic by replacing the `FieldMapContainer` with a more cohesive `FieldMappingTool`. This reduces redundancy and improves maintainability. Outdated tests are removed to reflect the new configuration structure, ensuring the codebase remains clean and relevant. ✨ (FieldMappingTool): add FieldMappingTool and its configuration options Introduce a new `FieldMappingTool` class to handle field mappings for work items. This tool allows for the configuration and application of field mappings based on work item types. The `FieldMappingToolOptions` class is also added to manage the configuration settings for the `FieldMappingTool`. 🔧 (ServiceCollectionExtensions): register FieldMappingTool and its options Update the `ServiceCollectionExtensions` to register the `FieldMappingTool` and its configuration options. This ensures that the tool is available for dependency injection and properly configured. ♻️ (EngineConfiguration): remove FieldMaps from EngineConfiguration Remove the `FieldMaps` property from the `EngineConfiguration` class as it is now managed by the `FieldMappingToolOptions`. This refactor centralizes the field mapping logic and configuration, making the codebase cleaner and more maintainable. These changes are done to modularize the field mapping functionality, making it easier to manage and extend. The new `FieldMappingTool` provides a dedicated place for field mapping logic, improving code organization and maintainability. ♻️ (EngineConfigurationBuilder.cs): remove FieldMaps initialization and comment out example field maps 💡 (IFieldMap.cs): mark Configure method as obsolete ♻️ (MigrationProcessorBase.cs, StaticProcessorBase.cs): inject StaticEnrichers dependency FieldMaps initialization is removed to streamline the configuration process. Example field maps are commented out to reduce clutter and potential confusion. The Configure method in IFieldMap.cs is marked as obsolete to indicate it should not be used in future implementations. StaticEnrichers dependency is injected into MigrationProcessorBase and StaticProcessorBase to enhance the flexibility and extensibility of the processors. ♻️ (refactor): update migration context classes to use TfsMigrationProcessorBase and enrichers Refactor migration context classes to inherit from TfsMigrationProcessorBase instead of MigrationProcessorBase. This change improves code consistency and leverages the new base class functionalities. Additionally, update constructors to include TfsStaticEnrichers and StaticEnrichers for better extensibility and maintainability. Remove the obsolete TestRunsMigrationContext class to clean up the codebase. ♻️ (MigrationContext): refactor migration contexts to use TfsMigrationProcessorBase and TfsStaticProcessorBase Refactor migration contexts to inherit from `TfsMigrationProcessorBase` and `TfsStaticProcessorBase` for better code organization and consistency. This change also integrates `TfsStaticEnrichers` and `StaticEnrichers` into the constructors, ensuring that enrichers are properly utilized across different migration contexts. This improves the maintainability and extensibility of the codebase by centralizing common functionality and reducing redundancy. ♻️ (refactor): extend StaticProcessorBase to TfsStaticProcessorBase Refactor multiple classes to inherit from the new TfsStaticProcessorBase instead of StaticProcessorBase. This change introduces a new base class, TfsStaticProcessorBase, which includes additional enrichers specific to TFS (Team Foundation Server) migrations. This refactor aims to improve code modularity and maintainability by separating TFS-specific logic from the general static processor logic. ✨ (TfsStaticProcessorBase): add new abstract class TfsStaticProcessorBase Introduce a new abstract class `TfsStaticProcessorBase` to serve as a base for TFS-specific static processors. This class extends `StaticProcessorBase` and includes additional dependencies specific to TFS, such as `TfsStaticEnrichers`. This change aims to modularize and encapsulate TFS-specific logic, making the codebase more maintainable and extensible.

♻️ (refactor): replace TfsGitRepoMappings with GitRepoMappingTool 📝 (docs): update documentation for GitRepoMappingTool 🔧 (config): remove deprecated GitRepoMapContainer Introduce a new configuration section `GitRepoMappingTool` to handle repository mappings, replacing the old `TfsGitRepoMappings`. This change centralizes repository mapping logic, making it more maintainable and easier to configure. Updated the documentation to reflect these changes and removed the deprecated `GitRepoMapContainer` to clean up the codebase. ✨ (GitRepoMappingTool): add GitRepoMappingTool and its options for work item processing Introduce a new `GitRepoMappingTool` class to process string fields of work items, allowing for data cleanup and regex replacements. This tool is configurable via `GitRepoMappingToolOptions`. ♻️ (ServiceCollectionExtensions): register GitRepoMappingTool in service collection Update `ServiceCollectionExtensions` to register the new `GitRepoMappingTool` and its options, ensuring it is available for dependency injection. 🔥 (EngineConfiguration, Containers): remove deprecated GitRepoMapContainer and UserMapContainer Remove the old `GitRepoMapContainer` and `UserMapContainer` classes, along with the `GitRepoMapping` property from `EngineConfiguration`. These are replaced by the new `GitRepoMappingTool`. The changes introduce a more flexible and maintainable way to handle Git repository mappings within the migration tools, replacing the older container-based approach with a more modern and configurable tool.

Refactor the processor configuration and container handling to improve modularity and maintainability. The changes include: 1. **ProcessorContainer**: Introduce a new `ProcessorContainer` class to manage processor instances. 2. **ProcessorContainerOptions**: Add a new `ProcessorContainerOptions` class to handle processor configuration options. 3. **MigrationToolHost**: Remove direct processor configuration handling and delegate it to `ProcessorContainer`. 4. **MigrationEngine**: Update the processor iteration to use the new `ProcessorContainer`. 5. **Tests**: Update tests to reflect the new configuration and container handling. These changes aim to decouple processor management from the main configuration, making the codebase more modular and easier to extend or modify in the future. ♻️ (ServiceCollectionExtensions.cs): add ProcessorContainer singleton for better configuration management ♻️ (EngineConfiguration.cs): remove Processors property to simplify configuration 💡 (EngineConfigurationBuilder.cs): comment out processor additions to streamline configuration ✅ (MigrationEngineTests.cs): remove redundant clearing of Processors in test The ProcessorContainer singleton is added to centralize processor configuration. The Processors property is removed from EngineConfiguration to simplify the configuration structure. Processor additions in EngineConfigurationBuilder are commented out to streamline the configuration process. The test is updated to remove redundant clearing of Processors, ensuring it aligns with the new configuration structure.

… mappings ♻️ (ProcessorContainer): refactor processor loading to use lazy initialization ✅ (ProcessorContainerTests): update tests to use ServiceProviderHelper for processor creation 🔧 (ServiceCollectionExtensions): remove redundant ProcessorContainer registration 📝 (MigrationTools.xml): update generated documentation with new commit details Enable the WorkItemTypeMappingEnricher to map "User Story" to "Product Backlog Item" for better alignment with target system terminology. Refactor ProcessorContainer to use lazy initialization for improved performance and resource management. Update tests to use a helper method for creating service providers, ensuring consistency and reducing code duplication. Remove redundant ProcessorContainer registration from ServiceCollectionExtensions to avoid unnecessary singleton instances. Update generated documentation to reflect the latest commit details.

…o VersionOptions class - Move `MigrationConfigVersion` enum and `GetMigrationConfigVersion` method from `ConfigurationSectionExtensions` to `VersionOptions`. - Update references to `MigrationConfigVersion` and `GetMigrationConfigVersion` in other files. This change centralizes the configuration version logic within the `VersionOptions` class, improving code organization and maintainability. It also ensures that version-related logic is encapsulated within a single class, making it easier to manage and update in the future. ♻️ (ServiceCollectionExtensions.cs): refactor configuration version handling and add VersionOptions 💡 (IProcessor.cs): mark Configure method as obsolete Refactor the configuration version handling to use `VersionOptions.ConfigureOptions.GetMigrationConfigVersion` for better encapsulation and maintainability. Add `VersionOptions` to the service collection to support this change. Mark the `Configure` method in `IProcessor` as obsolete to indicate that it will be deprecated in future versions, encouraging the use of newer configuration methods.

✅ (tests): uncomment and ignore a test in MigrationEngineTests.cs The MigrationTools.xml file is updated to reflect the latest commit details, ensuring the documentation is current. The test in MigrationEngineTests.cs is uncommented and marked to be ignored until the new configuration model is live, allowing for smoother transitions and preventing test failures during the interim period.

…e to IOptions pattern Remove the obsolete `Configure` methods from various ProcessorEnrichers classes and interfaces. The configuration is now handled using the IOptions pattern, which simplifies the code and aligns with modern .NET practices. This change improves code maintainability and readability by eliminating deprecated methods and ensuring a consistent approach to configuration across the project. ♻️ (EmbededImagesRepairEnricherBase.cs): remove obsolete Configure method The obsolete `Configure` method is removed to clean up the codebase and avoid confusion. This method is no longer in use and its presence could lead to potential misuse or maintenance issues.

…etryLoggerFake for testing purposes Replace the ITelemetryLogger implementation with TelemetryLoggerFake in the service collection to facilitate unit testing. The new TelemetryLoggerFake class provides a mock implementation of the ITelemetryLogger interface, allowing tests to run without relying on the actual telemetry infrastructure. This change improves test isolation and reliability.

Update the MigrationTools.xml file to reflect the latest commit details, including the commit hash, commit date, and other related metadata. This ensures that the documentation is up-to-date with the current state of the repository. ✅ (tests): update TfsNodeStructureTests for consistency and add null check Update the TfsNodeStructureTests to use 'SourceServer' and 'TargetServer' instead of 'Source Project' and 'Target Project' for consistency. Add a null check in the GetTfsNodeStructure method to prevent potential null reference exceptions. This improves the reliability and readability of the test code.

…nfiguration Corrects the variable used in the `services.Configure` method from `options.SetDefaults()` to `o.SetDefaults()`. This ensures that the configuration is applied to the correct instance, maintaining the integrity of the test setup.

… files Add the Enrichers parameter to various processor configuration files to document the new feature that allows data processing augmentation. This change ensures that the documentation is up-to-date with the latest codebase and provides users with the necessary information to utilize the Enrichers feature effectively. 📝 (docs): add Enrichers parameter to various processor configurations Add the "Enrichers" parameter to multiple processor configuration YAML files to support data augmentation during processing. This includes: - `workitemdelete.yaml` - `workitemmigrationcontext.yaml` - `workitempostprocessingcontext.yaml` - `workitemquerymigrationcontext.yaml` - `workitemupdateareasastagscontext.yaml` Additionally, add new documentation files for processor enrichers: - `fieldmappingtool.yaml` - `gitrepomappingtool.yaml` - `tfschangesetmappingtool.yaml` These changes enhance the flexibility and functionality of the processors by allowing the use of enrichers to augment data processing. This is crucial for more complex data migration and transformation scenarios. 📝 (docs): update YAML configuration files to include 'Enrichers' parameter Add 'Enrichers' parameter to various processor configuration files to allow for the augmentation of data processing. This change improves the flexibility and extensibility of the processors by enabling the use of additional enrichers. The parameter is added to multiple YAML files to ensure consistency across different processor configurations. 📝 (docs): update configuration documentation to include "Enrichers" parameter Add the "Enrichers" parameter to various processor configuration documentation files. This parameter is a list that can augment the processing of the data. The addition ensures that the documentation is up-to-date with the latest configuration options available in the codebase, providing users with accurate and comprehensive information. 📝 (docs): update documentation to include new 'Enrichers' parameter Add the 'Enrichers' parameter to multiple configuration files to document its usage. This parameter allows users to specify a list of enrichers that can augment the processing of data. The updates ensure that the documentation is comprehensive and reflects the latest features available in the configuration options. 📝 (docs): add Enrichers parameter to processor documentation Add the Enrichers parameter to the documentation for various processors. This parameter is a list that can augment the processing of the data. Including this information ensures that users are aware of the new configuration option and understand how to utilize it effectively.

Update the XML documentation to reflect the latest git commit details, including commit hash, commit date, and other related metadata. This ensures that the documentation is accurate and up-to-date. ♻️ (ProcessorContainerOptions): remove redundant 'Enabled' property Remove the 'Enabled' property from ProcessorContainerOptions and related test cases. This property is no longer necessary and its removal simplifies the configuration. ✨ (config): add MigrationToolsConfiguration.cs for future configuration Introduce a new configuration file, MigrationToolsConfiguration.cs, to prepare for future enhancements and better configuration management. This file is currently commented out but will serve as the basis for upcoming configuration options.

♻️ (ServiceCollectionExtensions): rename migration config version enums for clarity The MigrationTools.xml file is updated to reflect the latest commit details, ensuring documentation accuracy. The migration config version enums in ServiceCollectionExtensions.cs are renamed from `before16` and `v16` to `v1` and `v2` respectively, improving clarity and consistency in the codebase. ♻️ (MigrationConfigCommand.cs): refactor to use dependency injection for IServiceProvider ✨ (MigrationConfigCommand.cs): add writable options for ProcessorContainerOptions ♻️ (MigrationToolHost.cs): update method calls to use new config schema ♻️ (VersionOptions.cs): rename MigrationConfigVersion to MigrationConfigSchema Refactor MigrationConfigCommand to use dependency injection for IServiceProvider, improving code maintainability and testability. Introduce writable options for ProcessorContainerOptions to allow dynamic updates to processor configurations. Update MigrationToolHost to use the new configuration schema, enhancing clarity and future-proofing the code. Rename MigrationConfigVersion to MigrationConfigSchema in VersionOptions for better semantic clarity and to align with the new configuration schema. ✨ (WritableOptions): add WritableOptions class to support runtime configuration updates ♻️ (config): refactor configuration schema versioning for clarity Introduce a new `WritableOptions` class to allow runtime updates to configuration settings. This enhances flexibility by enabling dynamic changes without restarting the application. Additionally, refactor the configuration schema versioning from `MigrationConfigVersion` to `MigrationConfigSchema` for improved clarity and maintainability. This change also includes updating the `ServiceCollectionExtensions` to support the new writable options and ensure backward compatibility with older configuration versions.

…lass Introduce a new property, ConfigVersion, to the VersionOptions class to store the version of the configuration. This change allows the application to track and utilize the specific version of the configuration, enhancing version control and compatibility checks.

…o v160 The migration configuration schema version is updated from v2 to v160 to reflect the new versioning scheme. This change ensures consistency across the codebase and aligns with the updated schema versioning strategy. The removal of the `Version` property from `EngineConfiguration` simplifies the configuration structure.

The deprecation warning for using an outdated configuration version is now centralized in `VersionOptions.cs`. This change improves code maintainability by ensuring the warning message is managed in a single location, reducing redundancy and potential inconsistencies.

✨ (VersionOptions): add ConfigVersionString property for better version handling ♻️ (EngineConfigurationBuilder): refactor to use VersionOptions for version comparison The MigrationTools.xml file is updated to reflect the latest commit details, ensuring documentation accuracy. The `ConfigVersionString` property is added to `VersionOptions` to store the version as a string, improving version handling. The `EngineConfigurationBuilder` is refactored to use `VersionOptions` for version comparison, enhancing code readability and maintainability.

…uple Refactor the `GetMigrationConfigVersion` method to return a tuple containing both the schema and version string. This change improves code readability and reduces redundant calls to the method. The switch statements are updated to use the tuple's schema component, ensuring consistent access to both schema and version string where needed.

…essage The warning message about using a deprecated version of the configuration is commented out to reduce console clutter. This change is likely temporary and aims to streamline the output during development or testing phases.

…or WorkItemMigration processor Add a new configuration section for the WorkItemMigration processor in `appsettings.json` to enable detailed control over work item migration settings. Introduce a constant `ConfigurationSectionName` in `WorkItemMigrationConfig.cs` for easier access to this configuration section. These changes allow for more granular control over the work item migration process, including options for updating created dates and authors, retry limits, and filtering criteria. This enhances the flexibility and robustness of the migration tool.

…rationConfigVersion Accessing the `schema` property of the `GetMigrationConfigVersion` method's return value ensures that the switch statement correctly evaluates the migration configuration schema version. This change improves code clarity and correctness by explicitly specifying the property being used for the switch case.

♻️ (FieldMappingToolOptions): add schema property to GetMigrationConfigVersion call ♻️ (EngineConfigurationBuilder): remove unused IServiceProvider dependency ✅ (tests): update EngineConfigurationTests and MigrationEngineTests to reflect changes in EngineConfigurationBuilder The MigrationTools.xml file is updated to reflect the latest commit details, ensuring documentation accuracy. The FieldMappingToolOptions class now includes the schema property in the GetMigrationConfigVersion call, improving configuration handling. The EngineConfigurationBuilder class no longer uses the IServiceProvider dependency, simplifying the constructor. Tests are updated to align with these changes, ensuring they remain functional and relevant.

Upgrade MSTest.TestAdapter and MSTest.TestFramework from 3.5.0 to 3.5.2. Upgrade Serilog from 4.0.0 to 4.0.1. Upgrade NuGet.Protocol from 6.10.1 to 6.11.0. These upgrades address minor bug fixes and performance improvements in the testing and logging frameworks, ensuring better stability and compatibility with other packages.

…ling - Update Git commit and tag information in MigrationTools.xml. - Remove `Configure` method from processors and contexts. - Delete `TeamMigrationContext` class. - Update constructors to use `IOptions` for configuration. The changes remove deprecated `Configure` methods to streamline the codebase and improve maintainability. The `TeamMigrationContext` class is removed as it is no longer in use. Constructors now use `IOptions` for configuration, enhancing dependency injection and configuration management. ♻️ (MigrationContext): remove unused Configure methods and obsolete WorkItemQueryMigrationContext 🔧 (WorkItemPostProcessingContext): use IOptions for configuration injection Remove redundant `Configure` methods from `TestVariablesMigrationContext` and `WorkItemMigrationContext` to clean up the codebase. The `WorkItemQueryMigrationContext` class is deleted as it has been marked obsolete and replaced by `TfsSharedQueryProcessor`. Additionally, update `WorkItemPostProcessingContext` to use `IOptions` for configuration injection, improving dependency management and aligning with modern practices.

…andling Remove redundant `Configure` methods from various processor classes to simplify the codebase. Update the configuration handling to use `IOptions<T>` for dependency injection, improving consistency and maintainability. The changes streamline the configuration process by leveraging dependency injection, reducing boilerplate code, and enhancing readability. This refactor also aligns with modern best practices for managing configurations in .NET applications. ♻️ (WorkItemBulkEditProcessor.cs, WorkItemDelete.cs, WorkItemUpdateAreasAsTagsContext.cs): refactor to use IOptions for configuration Refactor the constructors of `WorkItemBulkEditProcessor`, `WorkItemDelete`, and `WorkItemUpdateAreasAsTagsContext` to use `IOptions` for configuration. This change improves dependency injection and configuration management by leveraging the `IOptions` pattern, which is more aligned with modern .NET practices. The `Configure` methods are removed as they are no longer necessary.

Add an "Installation" link to the sidebar for better navigation. Create a new "installation.md" file to provide detailed installation instructions for the tools, including options for Winget, Chocolatey, and manual installation. This improves the documentation by making it easier for users to find installation instructions and ensures they have multiple methods to install the tools based on their preferences.

Add `nkdAgility_DocsBaseURL` to support dynamic base URLs for Jekyll builds. Include Ruby setup to ensure the correct environment for Jekyll. Switch from using `jekyll-build-action` to a direct Jekyll build command. These changes allow for more flexible and environment-specific documentation deployments, ensuring the base URL is correctly set based on the deployment context. The Ruby setup ensures that the necessary dependencies for Jekyll are installed and cached, improving build reliability and performance.

Fixes broken links in the getting-started.md file to ensure users can navigate to the correct documentation pages. This improves the user experience by providing accurate references and preventing confusion.

Including the _Enginev1 folder in the project file ensures that any resources or files within this folder are recognized and managed by the project. This change is necessary for organizing project resources and potentially preparing for future development or migration tasks.

…ntEnricher and related options The TfsWorkItemAttachmentEnricher and its options are removed because they are not implemented and not used anywhere in the codebase. This cleanup helps to reduce clutter and maintain a cleaner codebase.

The folder name _Enginev1 is updated to EndpointEnrichers to better reflect its purpose and improve project organization. This change enhances clarity and maintainability of the project structure.

…pace

…astructure 🔧 (configuration.json): update configuration schema to support multiple sources and targets Refactor FieldMappingTool to inherit from a new abstract Tool class, improving code modularity and maintainability. This change also introduces a new logging mechanism and removes redundant properties and methods. Update configuration.json to support multiple sources and targets, enhancing flexibility and scalability for migration configurations. This change allows for more complex migration scenarios to be defined within the configuration file.

…h latest commit details and processor renaming ♻️ (refactor): rename namespaces and classes for consistency and clarity The documentation files are updated to reflect the latest commit details, ensuring accurate reference information. The namespaces and class names are refactored to align with the new naming conventions, improving code readability and maintainability. This change also includes the addition of a new processor, `ExportUsersForMappingContext`, to enhance user mapping capabilities. ♻️ (refactor): update namespaces and imports for consistency Refactor namespaces and imports to align with the new project structure. This change improves code organization and maintainability by ensuring all classes and imports follow a consistent naming convention. This also helps in reducing confusion and potential conflicts in the future.

…tionTools.Processors Refactor the namespace to align with the new project structure and naming conventions. This change improves code organization and readability, making it easier to maintain and extend the project. The updated namespace better reflects the purpose and functionality of the classes within it.

…ferences 🔧 (config): update processor type in configuration-classic.json The solution file is cleaned up by removing redundant project entries, which simplifies the project structure and reduces potential confusion. The project references are updated to ensure consistency and correctness. The processor type in configuration-classic.json is updated from "WorkItemMigrationConfig" to "WorkItemMigrationProcessorOptions" to reflect the correct type and improve configuration accuracy. 🔧 (configuration.json): update ProcessorType value for clarity Change the ProcessorType from "WorkItemMigration" to "WorkItemMigrationProcessor" to provide a more descriptive and clear identifier. This improves readability and understanding of the configuration.

The VstsSyncMigrator.Core project reference is removed because it is no longer needed. This cleanup helps to reduce dependencies and potential build issues, ensuring that only necessary references are included in the project.

✅ (TfsNodeStructureTests.cs): fix test setup for AreaMaps dictionary initialization The Git metadata in the MigrationTools.xml file is updated to reflect the latest commit information, ensuring the documentation is accurate and up-to-date. The test setup in TfsNodeStructureTests.cs is corrected by properly initializing the AreaMaps dictionary, which ensures the test runs correctly and avoids potential null reference issues.

The Gemfile.lock is updated to include dependencies for the x86_64-linux platform. This ensures compatibility and proper functioning of the application on Linux environments, expanding the range of supported platforms.

… workflow Upgrading the Ruby version ensures compatibility with the latest features and security updates. This change helps maintain the project's dependencies and build process up-to-date with the latest Ruby version.

…markdown files Expand the spellcheck configuration to cover markdown files in the `docs` and `src` directories, as well as any markdown files in the root directory. This ensures comprehensive spellchecking across all relevant documentation files.

…ranch name Including the branch name in the docs_deploy_folder and docs_baseURL paths ensures that documentation is correctly deployed and accessible for each specific branch. This change improves the organization and accessibility of documentation for different branches, facilitating better version control and easier navigation.

…orkflow Corrects the syntax for string interpolation in the GitHub Actions workflow file. The previous syntax was incorrect, causing potential issues in resolving the `github.ref_name` variable. This change ensures that the deployment folder and base URL are correctly constructed using the `github.ref_name` variable.

Adding branch name logging helps in debugging and understanding which branch the workflow is running on. This is particularly useful for tracking and diagnosing issues in CI/CD pipelines.

Sanitizes the branch name by replacing slashes with dashes to ensure it is safe for use in file paths and URLs. This prevents potential issues with invalid characters in paths and URLs, improving the robustness of the deployment process.

…ease job Remove GitHubRelease dependency and simplify the condition for running the DocsRelease job. This change ensures that the DocsRelease job runs if the previous jobs are successful, without requiring the GitHubRelease job to complete. This streamlines the workflow and reduces unnecessary dependencies.

The dry-run configuration is commented out to ensure that the upload process is not skipped. This change is likely made to enable actual file uploads during the workflow execution, rather than just simulating them.

✨ (header): add Azure DevOps Migration Services button 💄 (css): add styles for new button class The architecture filter is removed from the content-collection-table to simplify the data display and avoid redundancy. The Azure DevOps Migration Services button is added to the header to promote this service prominently. New CSS styles are introduced to ensure the button aligns with the site's design aesthetics.

Introduce several new field mapping configuration classes to enhance the flexibility and functionality of the FieldMappingTool. These classes include: - `FieldClearMapConfig`: Allows setting an already populated field to null. - `FieldLiteralMapConfig`: Sets a field to a specific value. - `FieldMergeMapConfig`: Merges multiple fields into one. - `FieldSkipMapConfig`: Skips populating an existing field, resetting it to its original value. - `FieldValueMapConfig`: Maps field values, including default values and specific value mappings. - `FieldValuetoTagMapConfig`: Creates a tag based on a field value using regex matching. - `FieldtoFieldMapConfig`: Maps one field to another. - `FieldtoFieldMultiMapConfig`: Sets up multiple field mappings in a single configuration. - `FieldtoTagMapConfig`: Converts a field value to a tag. These additions provide more granular control over field mappings, making the tool more versatile for different migration scenarios. ✨ (FieldMappingTool): add new field mapping configuration options Introduce three new field mapping configuration classes: - `MultiValueConditionalMapConfig` - `RegexFieldMapConfig` - `TreeToTagMapConfig` These additions enhance the flexibility and functionality of the FieldMappingTool by allowing more complex and conditional field mappings. The new configurations support multi-value conditional mapping, regex-based field mapping, and converting tree structures to tags, respectively. This enables more sophisticated data transformations during migrations.

…ing configuration Introduce the IFieldMapConfig interface to standardize field mapping configuration options. This interface includes properties for WorkItemTypeName and FieldMap, and a method to set example configuration defaults. This change aims to improve code modularity and maintainability by defining a clear contract for field mapping configurations.

Change the type names in various configuration files from `*Config` to `*Options` to maintain consistency and clarity. This change ensures that the configuration files use a uniform naming convention, which improves readability and reduces potential confusion for developers working with these files. 📝 (docs): update XML documentation to reflect new configuration class names ♻️ (FieldMaps): rename configuration classes from *Config to *Options for consistency The XML documentation is updated to reflect the new class names, changing from *Config to *Options. This ensures that the documentation is accurate and consistent with the codebase. The configuration class names in the FieldMaps are also renamed to improve clarity and maintain a consistent naming convention across the project. ♻️ (FieldMaps): rename configuration classes for consistency Renames configuration classes from `Config` to `Options` to improve clarity and consistency across the codebase. This change ensures that the naming convention is uniform, making the code easier to understand and maintain. ♻️ (FieldMaps): rename configuration classes from *Config to *Options Renaming configuration classes and JSON object types from *Config to *Options to improve clarity and consistency. This change aligns the naming convention with the rest of the codebase, making it more intuitive and easier to understand. ♻️ (FieldMappingTool): rename configuration classes to options Renaming configuration classes to options for better clarity and consistency. This change aligns the naming convention with the rest of the codebase, making it more intuitive and easier to understand. This also helps in distinguishing between configuration and options, improving code readability and maintainability.

…o IFieldMapOptions 📝 (docs): update MigrationTools.xml with new commit details Refactor the configuration interface to use IFieldMapOptions instead of IFieldMapConfig for better clarity and consistency across the codebase. This change ensures that the configuration options are more accurately represented and easier to understand. Additionally, update the MigrationTools.xml documentation to reflect the latest commit details, ensuring that the documentation remains up-to-date with the current state of the code. ♻️ (FieldMaps): rename IFieldMapConfig to IFieldMapOptions for consistency Renames the interface IFieldMapConfig to IFieldMapOptions across multiple files to maintain consistency in naming conventions. This change ensures that the naming aligns with the purpose of the interface, which is to handle options/configurations for field mappings. This improves code readability and maintainability. ♻️ (FieldMappingTool): rename IFieldMapConfig to IFieldMapOptions for consistency Renaming the interface from IFieldMapConfig to IFieldMapOptions aligns with the naming conventions used throughout the codebase. This change improves code readability and consistency, making it clearer that these classes represent configuration options for field mapping tools.

…clarity Standardize the naming of member elements to ensure consistency across the documentation. This change improves readability and maintainability by aligning the naming conventions with the rest of the project. Additionally, it corrects the commit metadata to reflect the latest changes. 📝 (MigrationTools.xml): update SemVer patch number in documentation The SemVer patch number is updated from 133 to 134 to reflect the latest version. This ensures that the documentation is accurate and up-to-date with the current state of the project. ♻️ (FieldMaps): refactor import statements to use new infrastructure module Refactor import statements across multiple FieldMap classes to use the new `MigrationTools.Tools` and `MigrationTools.Tools.Infrastructure` modules. This change improves code organization and modularity by consolidating related functionalities into a dedicated infrastructure module. This also helps in maintaining a cleaner and more maintainable codebase. ♻️ (refactor): update namespace from MigrationTools.Tools.Infra to MigrationTools.Tools.Infrastructure Renaming the namespace from `MigrationTools.Tools.Infra` to `MigrationTools.Tools.Infrastructure` improves clarity and consistency across the codebase. This change ensures that the namespace accurately reflects its purpose and aligns with common naming conventions, making the code easier to understand and maintain. ♻️ (FieldMaps): refactor imports to use MigrationTools.Tools.Infrastructure Refactor import statements across multiple files to use the new `MigrationTools.Tools.Infrastructure` namespace. This change improves code organization and consistency by consolidating infrastructure-related imports into a single namespace. ♻️ (FieldMappingTool): refactor namespace and add missing using directives Refactor the namespace from `MigrationTools._EngineV1.Configuration.FieldMap` to `MigrationTools.Tools` for consistency and better organization. Add missing `using MigrationTools.Tools.Infrastructure` directives to ensure all necessary dependencies are included. This change improves code maintainability and aligns the project structure with the updated naming conventions. ♻️ (namespace): rename Infra namespace to Infrastructure for clarity Renaming the `Infra` namespace to `Infrastructure` improves readability and clarity, making it more descriptive and easier to understand. This change affects multiple files, ensuring consistency across the codebase.

♻️ (FieldMaps): refactor FieldMapOptions to inherit from base class ♻️ (FieldMappingTool): refactor to use ApplyTo instead of WorkItemTypeName ♻️ (Options): rename OptionsFor to OptionFor for consistency Add documentation for the new `Enabled` property in `FieldMapOptions`. Refactor various FieldMapOptions classes to inherit from a base class, simplifying the code and improving maintainability. Update the `FieldMappingTool` to use the `ApplyTo` property instead of `WorkItemTypeName` for better clarity and flexibility. Rename `OptionsFor` to `OptionFor` across the codebase to maintain naming consistency. ♻️ (FieldMappingTool): refactor field map options to inherit from a common base class Refactor field map option classes to inherit from a new `FieldMapOptions` base class. This change reduces code duplication and centralizes common properties and methods. The `FieldMap` property is removed as it is now redundant. This improves maintainability and consistency across different field map option classes. ♻️ (ToolOptions.cs): rename OptionsFor to OptionFor for consistency Renaming `OptionsFor` to `OptionFor` ensures consistency in naming conventions across the codebase. This change improves readability and maintains a uniform naming pattern.

Introduce new field mapping classes: `FieldClearMap`, `FieldLiteralMap`, `FieldMapBase`, `FieldMergeMap`, and `FieldSkipMap`. These classes provide various field mapping functionalities for Azure DevOps work item migration. - `FieldClearMap`: Clears the value of a specified field in the target work item. - `FieldLiteralMap`: Sets a specified field in the target work item to a literal value. - `FieldMapBase`: Serves as the base class for all field mapping operations. - `FieldMergeMap`: Merges multiple source fields into a single target field using a specified format. - `FieldSkipMap`: Skips the mapping of a specified field if certain conditions are met. These changes enhance the flexibility and functionality of the field mapping tool, allowing for more complex and customizable migration scenarios. ✨ (FieldMappingTool): add new field mapping classes for Azure DevOps Introduce new classes to support various field mapping strategies: - `FieldToFieldMap`: Maps a field from source to target. - `FieldToTagFieldMap`: Maps a field from source to target tags. - `FieldValueMap`: Maps field values with specific value mappings. - `FieldValuetoTagMap`: Maps field values to tags based on patterns. - `FieldtoFieldMultiMap`: Maps multiple fields from source to target. These changes enhance the flexibility and functionality of the field mapping tool, allowing for more complex and varied migration scenarios. ✨ (FieldMappingTool): add new field mapping tools for Azure DevOps Introduce four new field mapping tools: `MultiValueConditionalMap`, `NodePathNotAnchoredException`, `RegexFieldMap`, and `TreeToTagFieldMap`. These tools enhance the flexibility and functionality of field mapping in Azure DevOps migrations. - `MultiValueConditionalMap` allows conditional field mapping based on multiple source field values. - `NodePathNotAnchoredException` provides a custom exception for node path issues. - `RegexFieldMap` enables field value transformation using regular expressions. - `TreeToTagFieldMap` converts tree structures into tags for better organization. These additions aim to improve the robustness and versatility of the migration tools, addressing various use cases and scenarios encountered during migrations.

…clarity 📝 (MigrationTools): update generated documentation with new commit details Refactor test and configuration class names to improve clarity and consistency. The changes include renaming `SimpleFieldMapConfigMock` to `SimpleFieldMapMockOptions` and `SimpleProcessorConfigMock` to `SimpleProcessorMockOptions`. This makes the naming more intuitive and aligned with their respective options. Update the generated documentation to reflect the latest commit details, ensuring that the documentation remains accurate and up-to-date.

…ocessor ♻️ (yaml, md): update configuration and documentation for WorkItemMigrationProcessor The key "WorkItemMigration" is renamed to "WorkItemMigrationProcessor" in appsettings.json to better reflect its purpose. The YAML and Markdown files are updated to include detailed configuration options for the WorkItemMigrationProcessor, enhancing clarity and usability. Additionally, the project ID in the keepoutboundlinktargetprocessor configuration is updated to ensure accuracy.

…ueConditionalMap Adding the FieldMapDefaults configuration allows for default mappings of fields in the MultiValueConditionalMap. This enhances the flexibility and configurability of the application by providing a predefined structure for source and target field values, which can be useful for various mapping scenarios.

Refactor the field mapping configurations to include more comprehensive default mappings such as FieldSkipMap, FieldValueMap, FieldToFieldMap, FieldToFieldMultiMap, FieldToTagMap, FieldMergeMap, RegexFieldMap, FieldValueToTagMap, and TreeToTagMap. This enhances the flexibility and capabilities of the field mapping tool by providing a richer set of default options. 📝 (docs): update documentation to reflect new field mapping configurations Update the documentation files to reflect the changes in the field mapping configurations. This includes correcting the naming from FieldDefaults to FieldMapDefaults and adding detailed examples for each field map type. This ensures that the documentation is accurate and provides clear guidance on how to use the new configurations. 📝 (docs): update field map configuration samples for consistency Update the field map configuration samples to use "FieldMapDefaults" instead of "FieldDefaults" for consistency and clarity. Also, correct the casing of class names and add detailed sample configurations to improve documentation accuracy and usability. This change ensures that the documentation aligns with the actual implementation and provides clearer guidance for users configuring field maps. 📝 (docs): update field mapping documentation with detailed examples Update the field mapping documentation to provide more detailed and comprehensive examples for various field map configurations. This includes adding specific source and target fields, format expressions, and value mappings. Also, correct the naming conventions for FieldToFieldMultiMapOptions and related fields. These changes improve the clarity and usability of the documentation, making it easier for users to understand and implement the field mapping configurations correctly. 📝 (docs): update field map configuration samples and correct typos ♻️ (code): rename FieldtoFieldMultiMap to FieldToFieldMultiMap for consistency Update the documentation to reflect the correct field map configuration samples, ensuring accuracy and clarity. Correct the class name FieldtoFieldMultiMap to FieldToFieldMultiMap to maintain consistency with naming conventions. This change improves readability and reduces potential confusion for developers and users.

📝 (docs): update XML and YAML documentation for new project configuration ♻️ (ClassDataLoader): refactor and add new configuration handling logic The project GUID mapping in the solution file is updated to ensure consistency and correct project references. The XML and YAML documentation files are updated to reflect the new project configuration, including changes to project IDs and other metadata. The `ClassDataLoader` class is refactored to improve readability and maintainability, and new logic is added to handle additional configuration options, enhancing the flexibility and functionality of the data loader. ✨ (config): enhance configuration management and add OptionsManager Refactor configuration properties to improve clarity and consistency: - Rename `ConfigurationSectionName` to `ConfigurationSectionPath`. - Rename `OptionFor` to `ConfigurationOptionFor`. - Add new properties: `ConfigurationCollectionPath` and `ConfigurationCollectionObjectName`. Introduce `OptionsManager` to handle loading and saving configuration sections and lists: - Add `OptionsManager` class to manage configuration options. - Support dynamic creation of `OptionsManager` instances for different option types. - Implement methods to load and save options from configuration sections and lists. These changes improve the flexibility and maintainability of the configuration management system, making it easier to handle complex configurations and ensuring consistency across different option types. ♻️ (ProcessorContainer.cs, ProcessorOptions.cs, FieldMappingTool.cs, FieldMapOptions.cs, FieldMappingToolOptions.cs, ToolOptions.cs): rename OptionFor to ConfigurationOptionFor for clarity Renaming `OptionFor` to `ConfigurationOptionFor` across multiple files to improve clarity and consistency in the codebase. This change makes it more explicit that these options are related to configuration, enhancing code readability and maintainability.

…ucture Introduce a set of base classes and interfaces to standardize the tool infrastructure. This includes: - `EmbededImagesRepairToolBase`: Abstract class for repairing embedded images. - `IAttachmentMigrationEnricher`: Interface for attachment migration enrichers. - `ITool`: Interface for tools. - `IToolOptions`: Interface for tool options. - `Tool`: Abstract base class for tools. - `ToolOptions`: Abstract base class for tool options. These changes provide a structured foundation for developing various tools within the MigrationTools project, promoting code reuse and consistency.

…ergeMap and FieldLiteralMap ♻️ (docs): update XML documentation to reflect new processor class names ♻️ (WorkItemMigrationProcessor): rename class and options to TfsWorkItemMigrationProcessor for clarity The new field mapping configurations in `appsettings.json` provide additional flexibility for mapping fields during migration. The renaming of the `WorkItemMigrationProcessor` class and its options to `TfsWorkItemMigrationProcessor` improves clarity and consistency, making it clear that the processor is specific to TFS (Team Foundation Server). The XML documentation is updated to reflect these changes, ensuring that the documentation remains accurate and helpful. ♻️ (refactor): rename WorkItemMigrationProcessorOptions to TfsWorkItemMigrationProcessorOptions ✨ (feature): add overwrite option to InitMigrationCommand for config file handling 🔧 (config): update launchSettings.json to include new init options Renaming `WorkItemMigrationProcessorOptions` to `TfsWorkItemMigrationProcessorOptions` improves clarity and specificity, indicating that the processor options are specific to TFS. The new `overwrite` option in `InitMigrationCommand` allows users to overwrite existing configuration files, enhancing flexibility and preventing accidental overwrites. The `launchSettings.json` update includes new initialization options, providing more configuration presets for different use cases. ♻️ (MigrationConfigCommand.cs, OptionsManager.cs): refactor configuration management and add template application support Refactor the configuration management logic to improve readability and maintainability. Introduce a new method `AddOptionsToConfiguration` to handle adding or updating options in the configuration JSON. This change centralizes the logic for modifying the configuration, making it easier to manage and extend. Additionally, add support for applying templates in `MigrationConfigCommand.cs`. This feature allows users to select and apply predefined templates to their configuration, enhancing the flexibility and usability of the migration tool.

♻️ (TfsNodeStructureTool): rename NodeBasePaths to Filters for clarity ⬆️ (csproj): add DotNet.Glob package for node filtering 📝 (docs): update documentation to reflect configuration changes Refactor the configuration structure to improve clarity and maintainability. Rename `NodeBasePaths` to `Filters` to better describe its purpose. Add the `DotNet.Glob` package to support the new filtering mechanism. Update the documentation to reflect these changes and ensure consistency.

…to either areas or iterations.

- Rename `TfsTeamProjectConfig` to `TfsTeamProjectEndpointOptions` for clarity. - Change `MinimumLevel` in `configuration.json` from "Information" to "Debug". - Correct "Iteration" to "Iterations" in `appsettings.json` and `configuration.json`. - Update test files to use the new `TfsTeamProjectEndpointOptions` class. These changes improve code readability and maintainability by using more descriptive names and ensuring consistency across configuration files. The logging level change to "Debug" provides more detailed logs for troubleshooting. ♻️ (refactor): replace IMigrationClientConfig with IEndpointOptions Refactor the code to use IEndpointOptions instead of IMigrationClientConfig. This change improves the clarity and consistency of the configuration options by aligning them with the new endpoint-based architecture. The update affects multiple files, including client classes, tools, and tests, ensuring that all components now use the new configuration interface. This refactor enhances maintainability and prepares the codebase for future extensions. ♻️ (refactor): replace IMigrationClientConfig with IEndpointOptions Refactor the codebase to replace the `IMigrationClientConfig` interface with the `IEndpointOptions` interface. This change standardizes the configuration options for migration clients and endpoints, making the code more consistent and easier to maintain. The new interface provides a more descriptive and accurate representation of the configuration options used throughout the migration tools.

♻️ (TfsProcessorTests.cs): add helper methods for TfsSharedQueryProcessor ✨ (TfsTeamProjectAuthentication.cs): add TfsAuthenticationOptions class ♻️ (TfsTeamProjectEndPointOptions.cs): integrate TfsAuthenticationOptions The authentication configuration in `configuration.json` is restructured to group related fields, improving clarity and maintainability. Helper methods are added in `TfsProcessorTests.cs` to facilitate the creation and configuration of `TfsSharedQueryProcessor` instances, enhancing test setup flexibility. A new `TfsAuthenticationOptions` class is introduced to encapsulate authentication details, promoting better code organization. The `TfsTeamProjectEndPointOptions` class is updated to use `TfsAuthenticationOptions`, streamlining the authentication configuration process. ♻️ (TfsTeamProjectEndpoint): refactor authentication handling and remove redundant code Remove the redundant `NetworkCredential` and `Credentials` properties and methods. Update the code to use the new `Options.Authentication` structure for better clarity and maintainability. This change simplifies the authentication logic and ensures that all authentication-related configurations are centralized, making the code easier to understand and modify.

…asses - Delete `EngineConfigurationTests.cs`, `QueryContextTests.cs`, `TelemetryLoggerMock.cs`, and `WorkItemMigrationTests.cs` as they are no longer in use. - Mark `FakeMigrationClientConfig` and methods in `TfsProcessorTests` as `[Obsolete]` to indicate they are deprecated. - Update namespaces and remove unnecessary using directives to improve code clarity. Removing obsolete test files and marking deprecated classes help maintain a clean codebase and prevent confusion. This also ensures that only relevant and up-to-date tests are maintained, improving overall project maintainability. ✅ (tests): add unit tests for TfsNodeStructureTool Introduce comprehensive unit tests for the TfsNodeStructureTool to ensure its functionality and reliability. These tests cover various scenarios including different area paths, iteration paths, and multiple occurrences in WIQL queries. This addition aims to improve code quality and prevent future regressions by validating the expected behavior of the TfsNodeStructureTool. ✅ (tests): add unit test for FixAreaPathAndIteration method to handle multiple occurrences with mixed operators Add a new unit test to ensure the `FixAreaPathAndIterationPathForTargetQuery` method correctly handles queries with multiple occurrences of `=` and `UNDER` operators. This improves the robustness of the method by verifying its behavior in more complex scenarios. ✅ (tests): add unit tests for TfsRevisionManagerTool Introduce comprehensive unit tests for the TfsRevisionManagerTool to ensure its functionality and reliability. These tests cover various scenarios including synchronization of revisions, handling of maximum revisions, and ensuring dates are in increasing order. Adding these tests improves the robustness of the tool and helps catch potential issues early in the development process.

- Set default value for SourceToTargetFieldMappings in TfsProcessorTests. - Refactor TfsSharedQueryProcessorTests to use GetTfsSharedQueryProcessor. - Add assertion for RefName in TfsSharedQueryProcessorTests. - Remove redundant TfsSharedQueryProcessorNoEnrichersTest. Setting a default value for SourceToTargetFieldMappings ensures the tests do not fail due to null values. Refactoring to use GetTfsSharedQueryProcessor improves code readability and maintainability. Adding the assertion for RefName ensures the correct configuration is being tested. Removing the redundant test streamlines the test suite.

…ts for better DI and readability Refactor the test setup to use dependency injection (DI) more effectively. This change improves the maintainability and readability of the tests by removing obsolete methods and centralizing the creation of processor instances. It also ensures that the tests are more modular and easier to extend in the future.

…new commit details Update the MigrationTools.xml file to reflect the latest commit details, including the new commit hash, date, and number of commits. This ensures the documentation is up-to-date with the current state of the repository. ♻️ (tests): refactor TfsWorkItemEndPointTests to improve test setup Refactor the TfsWorkItemEndPointTests to streamline the creation of TfsWorkItemEndpoint instances. The new GetTfsWorkItemEndPoint method centralizes the setup of dependencies and options, making the tests more maintainable and reducing redundancy. This change improves the clarity and maintainability of the test code. ✅ (tests): add dynamic source and target names in TfsProcessorTests ♻️ (infrastructure): refactor endpoint retrieval in Processor.cs The changes introduce dynamic source and target names in `TfsProcessorTests` to improve flexibility and readability. This allows the tests to be more adaptable to different configurations. In `Processor.cs`, the endpoint retrieval logic is refactored into a new `GetEndpoint` method. This improves code readability and error handling by centralizing the logic for fetching endpoints and handling potential exceptions.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Modern Configuration Builder (v16.x) Part 1 #2241

Modern Configuration Builder (v16.x) Part 1 #2241

Commits on Jul 30, 2024

Commits on Aug 1, 2024

Commits on Aug 4, 2024

Commits on Aug 5, 2024

Commits on Aug 6, 2024

Commits on Aug 8, 2024

Commits on Aug 12, 2024

Commits on Aug 13, 2024

Commits on Aug 14, 2024

Commits on Aug 15, 2024

Commits on Aug 16, 2024

Commits on Aug 17, 2024

Commits on Aug 18, 2024

Commits on Aug 19, 2024

Commits on Aug 20, 2024

Commits on Aug 21, 2024

Commits on Aug 23, 2024

Commits on Aug 25, 2024

Commits on Aug 26, 2024

Commits on Aug 27, 2024

Commits on Aug 28, 2024

Commits on Aug 29, 2024