/// <summary>
/// Load all runlogs
/// </summary>
public void LoadRunLogs()
{
var loadedLogs = new List <RunLog>();
string logBasePath = this.ProjectFolder.Trim(Path.DirectorySeparatorChar) + @"\logs\";
if (Directory.Exists(logBasePath))
{
foreach (string runLogFileDirectory in Directory.GetDirectories(logBasePath))
{
if (File.Exists(runLogFileDirectory + @"\runLog.xml") == false)
{
continue;
}
string serializedRunLog = ConfigurationFileHandler.ReadStringFromFile(runLogFileDirectory + @"\runLog.xml");
RunLog runLog = (RunLog)ConfigurationSerializer.DeserializeObject(serializedRunLog, typeof(RunLog), new Type[] { });
loadedLogs.Add(runLog);
}
}
this.RunLogs.Clear();
foreach (var log in loadedLogs.OrderBy(t => t.StartTime))
{
RunLogs.Add(log);
}
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForAzureStorageQueue_SucceedsWithIdenticalOutput()
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var azureStorageQueueMetricDefinition = GenerateBogusAzureStorageQueueMetricDefinition();
var metricDefaults = GenerateBogusMetricDefaults();
var scrapingConfiguration = new Core.Scraping.Configuration.Model.MetricsDeclaration
{
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinition>
{
azureStorageQueueMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
var deserializedAzureStorageQueueMetricDefinition = deserializedMetricDefinition as StorageQueueMetricDefinition;
AssertAzureStorageQueueMetricDefinition(deserializedAzureStorageQueueMetricDefinition, azureStorageQueueMetricDefinition, deserializedMetricDefinition);
}
public void Add(string file)
{
// Limit number of recent files to 5
if (RecentFiles.Count > 4)
{
RecentFiles.RemoveAt(0);
}
var newFile = new RecentFile()
{
FileName = Path.GetFileName(file),
FullFilePath = file
};
var recentFile = RecentFiles.FirstOrDefault(t => t.FullFilePath == newFile.FullFilePath);
if (recentFile != null)
{
RecentFiles.Remove(recentFile);
}
RecentFiles.Add(newFile);
var serializedRecentFiles = ConfigurationSerializer.SerializeObject(RecentFiles, new Type [] {});
ApplicationLocalStorageHelper.WriteToFile(RECENTFILESSTORENAME, serializedRecentFiles);
}
public static ConfigurationWindowSettings Get(DesignerItem designerItem, StepConfigurationBase configuration, ModuleLoader moduleLoader, List <IDatastore> dataStores, IEnumerable <ConnectionConfigurationBase> connections)
{
var module = Activator.CreateInstance(designerItem.ModuleDescription.ModuleType) as IModule;
ConfigurationWindowSettings configurationWindowSettings = new ConfigurationWindowSettings()
{
title = designerItem.ItemLabel,
titleImage = IntegrationTool.SDK.Diagram.IconLoader.GetFromAssembly(designerItem.ModuleDescription.ModuleType.Assembly, "Icon.xml"),
connections = connections.Where(t => t.ModuleDescription.Attributes.ConnectionType == designerItem.ModuleDescription.Attributes.ConnectionType),
moduleDescription = designerItem.ModuleDescription,
configuration = configuration,
originalConfiguration = ConfigurationSerializer.SerializeObject(configuration, moduleLoader.GetModuleTypeList()),
};
if (!dataStores.Any())
{
throw new InfoException("No incoming data available. Please connect a datasource first!");
}
if (module is IDataMerge)
{
if (dataStores.Count != 2)
{
throw new InfoException("Make sure to connect exactly two incoming datasources!");
}
configurationWindowSettings.configurationControl = ((IDataMerge)module).RenderConfigurationWindow(configuration, dataStores[0], dataStores[1]);
}
else
{
configurationWindowSettings.configurationControl = ((IModule)module).RenderConfigurationWindow(configuration, dataStores.First());
configurationWindowSettings.datastore = dataStores.First();
}
return(configurationWindowSettings);
}
void newConnection_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
NewConnection newConnection = (NewConnection)sender;
switch (newConnection.Status)
{
case Classes.WindowResult.Created:
this.Project.Connections.Add(newConnection.ConnectionConfiguration);
break;
case Classes.WindowResult.Canceled:
if (newConnection.ConnectionConfiguration == null || newConnection.OriginalConnectionConfiguration == null)
{
return;
}
object revertedConfiguration = ConfigurationSerializer.DeserializeObject(
newConnection.OriginalConnectionConfiguration,
newConnection.ConnectionConfiguration.GetType(),
moduleLoader.GetModuleTypeList()
);
((ConnectionConfigurationBase)revertedConfiguration).ModuleDescription = newConnection.ConnectionConfiguration.ModuleDescription;
int indexConfiguration = this.Project.Connections.IndexOf(newConnection.ConnectionConfiguration);
this.Project.Connections[indexConfiguration] = revertedConfiguration as ConnectionConfigurationBase;
break;
}
}
public TrayIcon()
{
Application.ApplicationExit += OnApplicationExit;
InitializeComponent();
_configuration = new Configuration();
_configurationSerializer = new Utilities.ConfigurationSerializer <Configuration>("configuration.json", _configuration);
_configuration = _configurationSerializer.Deserialize();
// Todo visibility dependent on configuration. If not, only show config form on 2nd startup
_logForm = new LogForm()
{
Visible = false
};
_mainForm = new MainForm();
_trayIcon.Visible = _configuration.ShowTrayIcon;
InitializeApplication();
//Debug.WriteLine(Reboot.GetUptime());
//Debug.WriteLine(Reboot.GetUptime2());
//Reboot.Shutdown(ShutdownType.Reboot, ForceExit.Force,ShutdownReason.MinorOther);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForAzureStorageQueue_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval, string sasTokenRawValue, string sasTokenEnvironmentVariable)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var azureStorageQueueMetricDefinition = GenerateBogusAzureStorageQueueMetricDefinition(resourceGroupName, metricScrapingInterval, sasTokenRawValue, sasTokenEnvironmentVariable);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new Promitor.Core.Scraping.Configuration.Serialization.v1.Model.MetricsDeclarationV1
{
Version = SpecVersion.v1.ToString(),
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinitionV1>
{
azureStorageQueueMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance, Mapper);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
AssertAzureStorageQueueMetricDefinition(deserializedMetricDefinition, azureStorageQueueMetricDefinition);
}
private void CopyAndStartExecutor(UpdatePreparationWorkspaceInformation workspace,
ExecutorConfiguration config)
{
var executorDirectory = Path.Combine(workspace.WorkingDirectory.FullName, "Executor");
var executorFile = new FileInfo(Path.Combine(executorDirectory, "AutoUpdate.Executor.exe"));
using (var executorStream = GetExecutorStream())
{
var archive = new ZipArchive(executorStream);
archive.ExtractToDirectory(executorDirectory);
}
executorFile.Refresh();
if (!executorFile.Exists)
{
throw new InvalidOperationException("Preparation of executor helper was not successfull");
}
var serializer = new ConfigurationSerializer();
var serializedConfig = serializer.Serialize(config);
var configFile = new FileInfo(Path.Combine(executorDirectory, ExecutorConfiguration.DEFAULT_FILENAME));
using (var configFileStream = configFile.OpenWrite())
using (var configFileWriter = new StreamWriter(configFileStream))
{
configFileWriter.Write(serializedConfig);
}
var startInfo = new ProcessStartInfo(executorFile.FullName, configFile.FullName);
startInfo.WorkingDirectory = executorDirectory;
startInfo.UseShellExecute = false;
var result = Process.Start(startInfo);
}
private void RegisterLocalServices()
{
this.localServices.Add(typeof(ISolutionRuleSetsInformationProvider), new Lazy <ILocalService>(() => new SolutionRuleSetsInformationProvider(this, Logger)));
this.localServices.Add(typeof(IRuleSetSerializer), new Lazy <ILocalService>(() => new RuleSetSerializer(this)));
this.localServices.Add(typeof(ICredentialStoreService), new Lazy <ILocalService>(() => new CredentialStore(new SecretStore(SolutionBindingSerializer.StoreNamespace))));
this.localServices.Add(typeof(IConfigurationProvider), new Lazy <ILocalService>(() =>
{
var solution = this.GetService <SVsSolution, IVsSolution>();
var store = this.GetService <ICredentialStoreService>();
var legacySerializer = new SolutionBindingSerializer(this);
var sccFileSystem = this.GetService <ISourceControlledFileSystem>();
var newConfigSerializer = new ConfigurationSerializer(solution, sccFileSystem, store, Logger);
return(new ConfigurationProvider(legacySerializer, newConfigSerializer));
}));
this.localServices.Add(typeof(IProjectSystemHelper), new Lazy <ILocalService>(() => new ProjectSystemHelper(this)));
this.localServices.Add(typeof(IRuleSetInspector), new Lazy <ILocalService>(() => new RuleSetInspector(this, Logger)));
this.localServices.Add(typeof(IRuleSetConflictsController), new Lazy <ILocalService>(() => new RuleSetConflictsController(this, new ConflictsManager(this, Logger))));
this.localServices.Add(typeof(IProjectSystemFilter), new Lazy <ILocalService>(() => new ProjectSystemFilter(this)));
this.localServices.Add(typeof(IErrorListInfoBarController), new Lazy <ILocalService>(() => new ErrorListInfoBarController(this, new SolutionBindingInformationProvider(this))));
// Use Lazy<object> to avoid creating instances needlessly, since the interfaces are serviced by the same instance
var sccFs = new Lazy <ILocalService>(() => new SourceControlledFileSystem(this, Logger));
this.localServices.Add(typeof(ISourceControlledFileSystem), sccFs);
this.localServices.Add(typeof(IFileSystem), sccFs);
Debug.Assert(SupportedLocalServices.Length == this.localServices.Count, "Unexpected number of local services");
Debug.Assert(SupportedLocalServices.All(t => this.localServices.ContainsKey(t)), "Not all the LocalServices are registered");
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForCosmosDb_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var cosmosDbMetricDefinition = GenerateBogusCosmosDbMetricDefinition(resourceGroupName, metricScrapingInterval);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new MetricsDeclarationV1
{
Version = SpecVersion.v1.ToString(),
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinitionV1>
{
cosmosDbMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance, Mapper);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, cosmosDbMetricDefinition);
AssertCosmosDbMetricDefinition(deserializedMetricDefinition, cosmosDbMetricDefinition);
}
private void SaveProject()
{
// Store current package if in design-mode
var packageOverview = this.mainWindowContent.Content as Screens.PackageOverview;
if (packageOverview != null)
{
packageOverview.SaveDiagram();
}
Type[] extraTypes = applicationInitializer.ModuleLoader.GetModuleTypeList();
// Save the connections to disk
ObservableCollection <ConnectionConfigurationBase> connections = this.CurrentProject.Connections;
string serializedConnections = ConfigurationSerializer.SerializeObject(connections, extraTypes);
ConfigurationFileHandler.SaveStringToFile(this.CurrentProject.ProjectName + "Connections.xml",
this.CurrentProject.ProjectFolder,
serializedConnections);
// Save the project to disk
this.CurrentProject.Connections = null;
string serializedProject = ConfigurationSerializer.SerializeObject(this.CurrentProject, extraTypes);
ConfigurationFileHandler.SaveStringToFile(this.CurrentProject.ProjectName + ".xml",
this.CurrentProject.ProjectFolder,
serializedProject);
this.CurrentProject.Connections = connections;
}
private void LogPlayerEvent(IPlayerEvent playerEvent)
{
try
{
var playerConfig = _scenario.Configuration.PlayerConfiguration.SingleOrDefault(pc => pc.EntityId == playerEvent.PlayerEntityId);
if (playerConfig != null)
{
var logEvent = new Engine.Logging.Database.Model.Event()
{
EventCode = playerEvent.GetType().Name,
EventId = playerEvent.Sequence,
Game = _game,
Tick = playerEvent.Tick,
Data = ConfigurationSerializer.Serialize(playerEvent),
PlayerId = playerConfig.Id,
PlayerExternalId = playerConfig.ExternalId
};
_context.InstanceEvents.Add(logEvent);
}
}
catch (Exception ex)
{
// TODO: log
}
}
public void SaveSettings()
{
var settings = ConfigurationSerializer.Load();
settings.Font = SelectedFont.Source;
ConfigurationSerializer.Save(settings);
}
public void YamlSerialization_SerializeAndDeserializeValidConfigForServiceBus_SucceedsWithIdenticalOutput(string resourceGroupName, string defaultScrapingInterval, string metricScrapingInterval)
{
// Arrange
var azureMetadata = GenerateBogusAzureMetadata();
var serviceBusMetricDefinition = GenerateBogusServiceBusMetricDefinition(resourceGroupName, metricScrapingInterval);
var metricDefaults = GenerateBogusMetricDefaults(defaultScrapingInterval);
var scrapingConfiguration = new Core.Scraping.Configuration.Model.MetricsDeclaration
{
AzureMetadata = azureMetadata,
MetricDefaults = metricDefaults,
Metrics = new List <MetricDefinition>
{
serviceBusMetricDefinition
}
};
var configurationSerializer = new ConfigurationSerializer(NullLogger.Instance);
// Act
var serializedConfiguration = configurationSerializer.Serialize(scrapingConfiguration);
var deserializedConfiguration = configurationSerializer.Deserialize(serializedConfiguration);
// Assert
Assert.NotNull(deserializedConfiguration);
AssertAzureMetadata(deserializedConfiguration, azureMetadata);
AssertMetricDefaults(deserializedConfiguration, metricDefaults);
Assert.NotNull(deserializedConfiguration.Metrics);
Assert.Single(deserializedConfiguration.Metrics);
var deserializedMetricDefinition = deserializedConfiguration.Metrics.FirstOrDefault();
AssertMetricDefinition(deserializedMetricDefinition, serviceBusMetricDefinition);
var deserializedServiceBusMetricDefinition = deserializedMetricDefinition as ServiceBusQueueMetricDefinition;
AssertServiceBusQueueMetricDefinition(deserializedServiceBusMetricDefinition, serviceBusMetricDefinition);
}
public static PartitionData <T> CreatePartition <T>(int?recordHint = null, EFileAccess access = EFileAccess.Read, EFileFlags fileFlags = EFileFlags.None)
{
var mmFactory = new CompositeFileFactory(fileFlags);
using (var dbXml = typeof(Quote).Assembly.GetManifestResourceStream(
"Apaf.NFSdb.TestShared.Resources.nfsdb.xml"))
{
var dbElement = ConfigurationSerializer.ReadConfiguration(dbXml);
var jconf = dbElement.Journals.Single(j => j.Class.EndsWith("." + typeof(T).Name));
if (recordHint.HasValue)
{
jconf.RecordHint = recordHint.Value;
}
var journalPath = Path.Combine(FindJournalsPath(), jconf.DefaultPath);
jconf.DefaultPath = journalPath;
var metadata = JournalBuilder.CreateNewJournalMetadata(jconf);
var startDate = new DateTime(2013, 10, 1);
var journalStorage = new ColumnStorage(metadata, jconf.DefaultPath,
access, 0, mmFactory);
var part = new Partition(
metadata, new CompositeFileFactory(fileFlags),
access, new PartitionDate(startDate, 0, metadata.Settings.PartitionType), 0,
Path.Combine(jconf.DefaultPath, "2013-10"), new AsyncJournalServer(TimeSpan.FromSeconds(1)));
return(new PartitionData <T>(part, metadata, journalStorage, journalPath));
}
}
public void SaveConfig(IReadTransactionContext tx = null)
{
if (_access != EFileAccess.ReadWrite)
{
throw new NFSdbIOException("Attempt to save partition {0} config in read-only state", DirectoryPath);
}
if (!Directory.Exists(DirectoryPath))
{
Directory.CreateDirectory(DirectoryPath);
}
var config = _config;
if (config == null)
{
config = new PartitionConfig();
config.Columns = _metadata.Settings.BuildColumns();
}
config.PartitionID = PartitionID;
config.RecordHint = tx != null?tx.GetPartitionTx(PartitionID).NextRowID : _metadata.Settings.RecordHint;
using (var fs = File.Open(Path.Combine(DirectoryPath, PartitionSettingsFileName), FileMode.Create, FileAccess.ReadWrite))
{
ConfigurationSerializer.WritePartitionConfiguration(fs, config);
}
_config = config;
}
public static Dictionary <string, Dictionary <string, string> > ParseLocalization(string json, string keyPrefix = null)
{
var localizationFile = ConfigurationSerializer.Deserialize <Dictionary <string, string>[]>(json);
// language code: key: value
var localization = new Dictionary <string, Dictionary <string, string> >();
foreach (var row in localizationFile)
{
if (row.TryGetValue(KeyColumn, out var key) &&
(keyPrefix == null || key.StartsWith(keyPrefix)))
{
foreach (var language in row.Keys.Where(k => k.Equals(KeyColumn) == false))
{
if (localization.TryGetValue(language, out var languageDictionary) == false)
{
languageDictionary = new Dictionary <string, string>();
localization.Add(language, languageDictionary);
}
languageDictionary.Add(key, row[language]);
}
}
}
return(localization);
}
public ReadLaterListViewModel()
{
readLaterManager = ServiceLocator.Current.GetInstance <IReadLaterManager>();
dataLoader = ServiceLocator.Current.GetInstance <IDataLoader>();
settings = ConfigurationSerializer.Load();
recommendations = new ObservableCollection <RecommendationViewModel>();
}
static ExecutorConfiguration ReadConfig(string[] args)
{
var configFilePath = ExecutorConfiguration.DEFAULT_FILENAME;
if (args.Any())
{
configFilePath = args[0];
}
_logger.LogDebug("Checking config file at '{0}'", configFilePath);
if (!File.Exists(configFilePath))
{
_logger.LogError("Could not find any config file at '{0}'", configFilePath);
return(null);
}
var serializer = new ConfigurationSerializer();
try
{
var configContent = File.ReadAllText(configFilePath);
var config = serializer.Deserialize(configContent);
return(config);
}
catch (Exception ex)
{
_logger.LogError(ex, "Deserializing of config not possible");
return(null);
}
}
private void LoadViewModels()
{
Items.Add(new HomeViewModel());
Items.Add(new ReadLaterListViewModel());
Items.Add(new ConfigurationViewModel());
ActivateItem(Items.First());
DisplayName = string.Format("NewsStand - {0}", ConfigurationSerializer.Load().Username);
}
public ConfigurationViewModel()
{
DisplayName = "CFG";
InstalledFonts = new ObservableCollection <FontFamily>(Fonts.SystemFontFamilies.OrderBy(c => c.Source));
var settings = ConfigurationSerializer.Load();
SelectedFont = string.IsNullOrEmpty(settings.Font) ? InstalledFonts.First() : InstalledFonts.Single(c => c.Source == settings.Font);
}
public virtual MetricsDeclaration Get()
{
var rawMetricsDeclaration = ReadRawDeclaration();
var config = ConfigurationSerializer.Deserialize(rawMetricsDeclaration);
return(config);
}
public void TestInitialize()
{
solutionMock = new Mock <IVsSolution>();
configurableSccFileSystem = new ConfigurableSourceControlledFileSystem();
configurableStore = new ConfigurableCredentialStore();
loggerMock = new Mock <ILogger>();
fileMock = new Mock <IFile>();
testSubject = new ConfigurationSerializer(solutionMock.Object, configurableSccFileSystem, configurableStore, loggerMock.Object, fileMock.Object);
}
internal static Configuration Load()
{
string assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string configurationPath = Path.Combine(Path.GetDirectoryName(assemblyPath), "configuration.json");
using (FileStream file = new FileStream(configurationPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
return((Configuration)ConfigurationSerializer.ReadObject(file));
}
}
public string Build()
{
var metricsDeclaration = new MetricsDeclaration
{
AzureMetadata = _azureMetadata,
Metrics = _metrics
};
return(ConfigurationSerializer.Serialize(metricsDeclaration));
}
public void LoadingConfigurationBasic()
{
WriteEmptyStandardConfiguration();
Assert.IsTrue(File.Exists(WritingEmptyConfigurationPath), "File " + WritingEmptyConfigurationPath + " is not there.");
ConfigurationExchange configuration = ConfigurationSerializer.LoadConfiguration(WritingEmptyConfigurationPath);
Assert.IsNotNull(configuration, "No Configuration: " + WritingEmptyConfigurationPath + " was loaded");
}
private void OnTick(Tick tick, uint crc)
{
var tickString = ConfigurationSerializer.Serialize(tick);
Messenger.SendAllMessage(new TickMessage
{
CRC = crc,
TickString = tickString
});
}
protected override void OnActivate()
{
base.OnActivate();
settings = ConfigurationSerializer.Load();
Username = settings.Username;
LoadRecommendations();
}
private void WriteEmptyStandardConfiguration()
{
ConfigurationGlobal global = new ConfigurationGlobal();
ConfigurationExchange output = new ConfigurationExchange(global);
bool writeConfiguration = ConfigurationSerializer.WriteConfiguration(output, WritingEmptyConfigurationPath);
Assert.IsTrue(writeConfiguration, "Configuration: " + WritingEmptyConfigurationPath + " could not be written.");
Assert.IsTrue(File.Exists(WritingEmptyConfigurationPath), "File " + WritingEmptyConfigurationPath + " was serialized but is not there.");
}
public void CalculateConfigFileName_ReturnsExpectedName()
{
// Arrange
var fullSolutionFilePath = @"c:\aaa\bbbb\C C\mysolutionName.sln";
// Act
string actual = ConfigurationSerializer.GetConnectionFilePath(fullSolutionFilePath);
// Assert
actual.Should().Be(@"c:\aaa\bbbb\C C\.sonarlint\mysolutionName.sqconfig");
}
