internal IExecutorConfiguration Dump()
        {
            Factory.Instance.Create(out IWorkerClientConfiguration workerClientConfig);
            workerClientConfig.AutoShutdown           = Worker.AutoShutdown;
            workerClientConfig.TestAssembly           = null;
            workerClientConfig.TestMethodModeOverride = Execution.TestMethodModeOverride;
            workerClientConfig.WriteReport            = Worker.WriteReport;

            Factory.Instance.Create(out IWorkerRemoteConfiguration workerRemoteConfig);
            workerRemoteConfig.ClientConfiguration = workerClientConfig;
            workerRemoteConfig.Executable          = null;
            workerRemoteConfig.StartClientVisible  = Worker.StartClientVisible;

            Factory.Instance.Create(out IProxyClientConfiguration proxyClientConfiguration);
            proxyClientConfiguration.WorkerRemoteConfiguration = workerRemoteConfig;
            proxyClientConfiguration.AssemblyModeOverride      = Execution.AssemblyModeOverride;

            RuntimesHelper.TryGetMatchingRuntimes(new RuntimeInfo(FrameworkIdentifiers.NETStandard, new Version(2, 0)), out IEnumerable <RuntimeInfo> runtimes);
            IEnumerable <RuntimeInfo> filterRuntimes = Execution.RuntimesFilter.Values.SelectMany(ri => ri.Convert());

            proxyClientConfiguration.AvailableRuntimes = runtimes
                                                         .Where(r => Execution.RuntimesFilter.Mode switch {
                FilterModes.Blacklist => !filterRuntimes.Contains(r),
                FilterModes.WhiteList => filterRuntimes.Contains(r),
                _ => false,
            });
Esempio n. 2
0
        private IEnumerable <IWorkerRemoteInfo> CreateRemoteInfos()
        {
            _log.Debug(nameof(CreateRemoteInfos));

            IList <IWorkerRemoteInfo> infos = new List <IWorkerRemoteInfo>();

            if (RuntimesHelper.TryGetMatchingRuntimes(TestAssemblyRuntime, out IEnumerable <RuntimeInfo> matchingRuntimes))
            {
                Func <IEnumerable <Version>, Version>       filter        = Configuration.SelectedRuntimes == SelectedExecutionRuntimes.Highest ? Enumerable.Max : Enumerable.Min;
                IDictionary <FrameworkIdentifiers, Version> versionfilter = matchingRuntimes
                                                                            .Where(r => Configuration.AvailableRuntimes.Contains(r))
                                                                            .GroupBy(r => r.Framework)
                                                                            .ToDictionary(g => g.Key, g => filter(g.Select(r => r.Version)));

                _log.Debug($"Selected versions are {versionfilter.Format()}.");

                foreach (RuntimeInfo runtime in matchingRuntimes)
                {
                    Factory.Instance.Create(out IWorkerRemoteInfo info, Configuration, runtime);
                    info.IsSelected = info.Configuration.HasExecutable &&
                                      (Configuration.SelectedRuntimes == SelectedExecutionRuntimes.All ||
                                       (versionfilter.ContainsKey(info.Runtime.Framework) && info.Runtime.Version == versionfilter[info.Runtime.Framework]));

                    _log.Debug($"Created worker remote: {info.Format()}");

                    infos.Add(info);
                }
            }

            if (infos.Count > 0)
            {
                _log.Info($"Defined {infos.Count.Format()} worker remotes.");
            }
            else
            {
                _log.Info("No remotes defined.");
            }

            return(infos);
        }