private void LoadFileSettingsAndCommands()
{
instancesToDispose.Add(settings = new FileSettings());
RegisterInstance(settings);
if (!settings.CustomSettingsExists)
ContentIsReady += settings.LoadDefaultSettings;
ContentIsReady += () => ContentLoader.Load<InputCommands>("DefaultCommands");
ContentIsReady += () => Window.ViewportPixelSize = settings.Resolution;
}
public async Task ShouldPopulateGithubSettings()
{
var fileSettings = FileSettings.Empty();
var settings = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.GithubAuthSettings, Is.Not.Null);
Assert.That(settings.GithubAuthSettings.Token, Is.EqualTo("testToken"));
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Scope, Is.EqualTo(ServerScope.Repository));
Assert.That(settings.SourceControlServerSettings.Repository, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Repository.GithubUri, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Repository.GithubUri, Is.EqualTo(new Uri("http://github.com/test/test")));
Assert.That(settings.SourceControlServerSettings.OrganisationName, Is.Null);
}
public async Task LabelsOnCommandLineWillReplaceFileLabels()
{
var fileSettings = new FileSettings
{
Label = new[] { "testLabel" }
};
var settings = await CaptureSettings(fileSettings, true);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Labels, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Labels, Has.Count.EqualTo(2));
Assert.That(settings.SourceControlServerSettings.Labels, Does.Contain("runLabel1"));
Assert.That(settings.SourceControlServerSettings.Labels, Does.Contain("runLabel2"));
Assert.That(settings.SourceControlServerSettings.Labels, Does.Not.Contain("testLabel"));
}
private void ConfigureInternalDependencies(StartupParameters parameters)
{
For <ISnsTopicCreator>().Use <SnsTopicCreator>();
For <ISnsSubscriptionCreator>().Use <SnsSubscriptionCreator>();
For <ITableAlarmCreator>().Use <TableAlarmCreator>();
For <IIndexAlarmCreator>().Use <IndexAlarmCreator>();
For <IAlarmFinder>().Use <AlarmFinder>().Singleton();
For <IQueueAlarmCreator>().Use <QueueAlarmCreator>();
For <IDynamoAlarmGenerator>().Use <DynamoAlarmGenerator>();
For <IOrphanTablesReporter>().Use <OrphanTablesReporter>();
For <IOrphanQueuesReporter>().Use <OrphanQueuesReporter>();
For <ISqsAlarmGenerator>().Use <SqsAlarmGenerator>();
if (!string.IsNullOrWhiteSpace(parameters.WriteCloudFormationTemplatesToDirectory))
{
For <ICloudformationStackDeployer>()
.Use(
ctx => new DummyCloudFormationStackDeployer(
parameters.WriteCloudFormationTemplatesToDirectory,
ctx.GetInstance <IAlarmLogger>()));
}
else
{
var s3Location = GetS3Location(parameters);
For <ICloudformationStackDeployer>()
.Use(ctx => new CloudFormationStackDeployer(
ctx.GetInstance <IAlarmLogger>(),
ctx.GetInstance <IAmazonCloudFormation>(),
ctx.GetInstance <IAmazonS3>(),
s3Location
));
}
For <IAlarmCreator>().Use <CloudFormationAlarmCreator>();
var fileSettings = new FileSettings(parameters.ConfigFolderLocation);
For <FileSettings>().Use(fileSettings);
For <ILegacyAlarmTracker>().Use <LegacyAlarmTracker>().Singleton();
For <IOrphanedAlarmReporter>().Use <OrphanedAlarmReporter>();
}
public void Save(ISettingsStore settings)
{
var model = new FileSettings();
IncludeFolders.Populate(ref model);
IncludeExtensions.Populate(ref model);
ExcludeFolders.Populate(ref model);
ExcludePatterns.Populate(ref model);
model.Save(settings);
if (!_hasChanges)
{
_hasChanges = IncludeFolders.IsDirty || IncludeExtensions.IsDirty ||
ExcludeFolders.IsDirty || ExcludePatterns.IsDirty;
}
}
public async Task ShouldPopulateGithubSettings()
{
var fileSettings = FileSettings.Empty();
var settings = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.GithubAuthSettings, Is.Not.Null);
Assert.That(settings.GithubAuthSettings.Token, Is.EqualTo("testToken"));
Assert.That(settings.GithubAuthSettings.ApiBase, Is.Not.Null);
Assert.That(settings.GithubAuthSettings.ApiBase.ToString(), Is.EqualTo("http://github.contoso.com/api/"));
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Repository, Is.Null);
Assert.That(settings.SourceControlServerSettings.OrganisationName, Is.Null);
}
/// <summary>
/// Открыть пользовательские настройки
/// </summary>
public static bool OpenUserSettings()
{
if (_login == string.Empty)
{
return(false);
}
FileSettings fileSettings = new FileSettings(_login, _md5);
try
{
fileSettings.Read();
//Проверка существования базы данных в виде файла
if (fileSettings.FindDatabaseFile())
{
IsDatabaseContextCreated = true;
}
User = fileSettings.User;
User.Change();
}
catch (NirsException exception)
{
fileSettings.Delete();
ErrorManager.ExecuteException(exception);
User = new User
{
Changer = true
};
User.Change();
return(false);
}
if (User == null)
{
User = new User();
}
User.Change();
if (User.DateLastEditDatabase != DateTime.MinValue)
{
IsDatabaseContextCreated = true;
}
return(true);
}
public static bool Contains(this FileSettings settings, FileSetting comparer)
{
if (settings == null)
{
return(false);
}
foreach (var setting in settings.Settings)
{
if (setting.RoleId == comparer.RoleId)
{
return(true);
}
}
return(false);
}
public async Task ShouldCallEngineAndNotSucceedWithoutParams()
{
var engine = Substitute.For <IGitHubEngine>();
var logger = Substitute.For <IConfigureLogLevel>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.Get().Returns(FileSettings.Empty());
var command = new OrganisationCommand(engine, logger, fileSettings);
var status = await command.OnExecute();
Assert.That(status, Is.EqualTo(-1));
await engine
.DidNotReceive()
.Run(Arg.Any <SettingsContainer>());
}
public async Task WillReadLabelFromFile()
{
var fileSettings = new FileSettings
{
Label = new List <string> {
"testLabel"
}
};
var(settings, _) = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Labels, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Labels, Has.Count.EqualTo(1));
Assert.That(settings.SourceControlServerSettings.Labels, Does.Contain("testLabel"));
}
public async Task WillReadRepoFiltersFromFile()
{
var fileSettings = new FileSettings
{
IncludeRepos = "foo",
ExcludeRepos = "bar"
};
var settings = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.IncludeRepos, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.ExcludeRepos, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.IncludeRepos.ToString(), Is.EqualTo("foo"));
Assert.That(settings.SourceControlServerSettings.ExcludeRepos.ToString(), Is.EqualTo("bar"));
}
public async Task ShouldCallEngineAndSucceed()
{
var engine = Substitute.For <ILocalEngine>();
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.GetSettings().Returns(FileSettings.Empty());
var command = new UpdateCommand(engine, logger, fileSettings);
var status = await command.OnExecute();
Assert.That(status, Is.EqualTo(0));
await engine
.Received(1)
.Run(Arg.Any <SettingsContainer>(), true);
}
public async Task CommandLineWillOverrideIncludeRepo()
{
var fileSettings = new FileSettings
{
IncludeRepos = "foo",
ExcludeRepos = "bar"
};
var settings = await CaptureSettings(fileSettings, true, false);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.IncludeRepos, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.ExcludeRepos, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.IncludeRepos.ToString(), Is.EqualTo("IncludeFromCommand"));
Assert.That(settings.SourceControlServerSettings.ExcludeRepos.ToString(), Is.EqualTo("bar"));
}
static FileSettings[] ParseFiles(Parser parser)
{
fileSettings = new FileSettings();
fileSettings.Fill = buildSettings.Fill;
fileSettings.Hirom = buildSettings.Hirom;
fileSettings.Lorom = buildSettings.Lorom;
List <FileSettings> result = new List <FileSettings>();
string sectionName = parser.GetString();
Debug.Assert(sectionName.Length <= 0 || !sectionNames.Contains(sectionName), "Duplicate section");
parser.AssertOpen();
while (!(parser.CurrentLine == "}"))
{
Debug.Assert(parser.CurrentLine != "{", "Unexpected {");
Debug.Assert(!parser.EOF, "Unexpected EOF");
string targetMode = parser.GetString();
parser.AssertColon();
string targetfile;
FileSettings fs;
switch (targetMode.ToLowerInvariant())
{
case "file":
targetfile = parser.GetCompoundString();
parser.AssertEquals();
fs = ParseFileInfo(parser);
fs.Target = targetfile;
fs.Section = sectionName;
result.Add(fs);
break;
case "option":
fileSettings = ParseFileInfoSettings(parser);
break;
}
parser.AssertEnd();
}
parser.AssertClose();
return(result.ToArray());
}
public async Task <SettingsContainer> CaptureSettings(FileSettings settingsIn)
{
var logger = Substitute.For <IConfigureLogLevel>();
var fileSettings = Substitute.For <IFileSettingsCache>();
SettingsContainer settingsOut = null;
var engine = Substitute.For <ILocalEngine>();
await engine.Run(Arg.Do <SettingsContainer>(x => settingsOut = x), false);
fileSettings.Get().Returns(settingsIn);
var command = new InspectCommand(engine, logger, fileSettings);
await command.OnExecute();
return(settingsOut);
}
public async Task ShouldPopulateSettings()
{
var fileSettings = FileSettings.Empty();
var(settings, platformSettings) = await CaptureSettings(fileSettings);
Assert.That(platformSettings, Is.Not.Null);
Assert.That(platformSettings.Token, Is.Not.Null);
Assert.That(platformSettings.Token, Is.EqualTo("testToken"));
Assert.That(platformSettings.BaseApiUrl, Is.Not.Null);
Assert.That(platformSettings.BaseApiUrl.ToString(), Is.EqualTo("http://github.contoso.com/"));
Assert.That(settings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings, Is.Not.Null);
Assert.That(settings.SourceControlServerSettings.Repository, Is.Null);
Assert.That(settings.SourceControlServerSettings.OrganisationName, Is.Null);
}
public async Task ShouldSetLogLevelFromCommand()
{
var engine = Substitute.For <ILocalEngine>();
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.GetSettings().Returns(FileSettings.Empty());
var command = new InspectCommand(engine, logger, fileSettings);
command.Verbosity = LogLevel.Minimal;
await command.OnExecute();
logger
.Received(1)
.Initialise(LogLevel.Minimal, LogDestination.Console, Arg.Any <string>());
}
private void btnViewPdf_Click(object sender, EventArgs e)
{
if (gridFiles.Rows.Count > 0)
{
//Find the selected id
int selectedId = int.Parse(gridFiles.SelectedRows[0].Cells[0].Value.ToString());
//Find the selected row
var selectedFile = list.First(x => x.Id == selectedId);
if (selectedFile.FileName != null)
{
//View the file
FileSettings fileSettings = new FileSettings();
fileSettings.FileName = selectedFile.FileName;
frmUpdatePdf updatePdf = new frmUpdatePdf(fileSettings, true);
updatePdf.ShowDialog();
}
}
}
public static async Task <(SettingsContainer fileSettings, CollaborationPlatformSettings platformSettings)> CaptureSettings(
FileSettings settingsIn,
bool addCommandRepoInclude = false,
bool addCommandRepoExclude = false,
int?maxRepo = null,
ForkMode?forkMode = null)
{
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
SettingsContainer settingsOut = null;
var engine = Substitute.For <ICollaborationEngine>();
await engine.Run(Arg.Do <SettingsContainer>(x => settingsOut = x));
fileSettings.GetSettings().Returns(settingsIn);
var collaborationFactory = GetCollaborationFactory();
var command = new OrganisationCommand(engine, logger, fileSettings, collaborationFactory);
command.PersonalAccessToken = "testToken";
command.GithubOrganisationName = "testOrg";
if (addCommandRepoInclude)
{
command.IncludeRepos = "IncludeFromCommand";
}
if (addCommandRepoExclude)
{
command.ExcludeRepos = "ExcludeFromCommand";
}
if (forkMode != null)
{
command.ForkMode = forkMode;
}
command.MaxRepositoriesChanged = maxRepo;
await command.OnExecute();
return(settingsOut, collaborationFactory.Settings);
}
public async Task EmptyFileResultsInDefaultSettings()
{
var fileSettings = FileSettings.Empty();
var settings = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.PackageFilters, Is.Not.Null);
Assert.That(settings.UserSettings, Is.Not.Null);
Assert.That(settings.PackageFilters.MinimumAge, Is.EqualTo(TimeSpan.FromDays(7)));
Assert.That(settings.PackageFilters.Excludes, Is.Null);
Assert.That(settings.PackageFilters.Includes, Is.Null);
Assert.That(settings.PackageFilters.MaxPackageUpdates, Is.EqualTo(1));
Assert.That(settings.UserSettings.AllowedChange, Is.EqualTo(VersionChange.Major));
Assert.That(settings.UserSettings.NuGetSources, Is.Null);
Assert.That(settings.UserSettings.ReportMode, Is.EqualTo(ReportMode.Off));
}
public void SetData(FileSettings fileSettings)
{
RemoveEventHandlers();
fileName_choiceTextControl.onOff_CheckBox.Checked = fileSettings.FileName.Value;
fileName_choiceTextControl.text_Box.Text = fileSettings.FileName.Key;
prefix_choiceComboControl.onOff_CheckBox.Checked = fileSettings.FileNamePrefix.Value;
prefix_choiceComboControl.choice_Combo.SelectedItem = fileSettings.FileNamePrefix.Key;
suffix_choiceComboControl.onOff_CheckBox.Checked = fileSettings.FileNameSuffix.Value;
suffix_choiceComboControl.choice_Combo.SelectedItem = fileSettings.FileNameSuffix.Key;
SetComboBoxData(fileSettings.FileType, fileType_choiceComboControl, ListValues.FileType);
SetComboBoxData(fileSettings.FileNumbering, fileNumbering_choiceComboControl, ListValues.FileNumbering);
SetComboBoxData(fileSettings.Resolution, resolution_choiceComboControl, ListValues.Resolution);
SetComboBoxData(fileSettings.FileSize, fileSize_choiceComboControl, ListValues.FileSizeList);
SetComboBoxData(fileSettings.FileColor, color_choiceComboControl, ListValues.ChromaticModes);
AddEventHandlers();
}
private void grdFiles_DoubleClick(object sender, EventArgs e)
{
// Process row
DataGridViewSelectedRowCollection rows = grdFiles.SelectedRows;
if ((rows == null) || (rows.Count != 1))
{
return; // Not sure what happened here
}
BindingAssembly.File file = rows[0].DataBoundItem as BindingAssembly.File;
if (file != null)
{
FileSettings fs = new FileSettings();
fs.FiletoScreen(file);
fs.ShowDialog();
}
grdFiles.Refresh();
}
public async Task ShouldCallEngineAndNotSucceedWithoutParams()
{
var engine = Substitute.For <ICollaborationEngine>();
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.GetSettings().Returns(FileSettings.Empty());
var collaborationFactory = GetCollaborationFactory();
var command = new GlobalCommand(engine, logger, fileSettings, collaborationFactory);
var status = await command.OnExecute();
Assert.That(status, Is.EqualTo(-1));
await engine
.DidNotReceive()
.Run(Arg.Any <SettingsContainer>());
}
public async Task <bool> TryWriteDrawing(string fileName, Drawing drawing, ViewPort viewPort, Stream stream, bool preserveSettings = true)
{
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
var extension = Path.GetExtension(fileName);
var writer = WriterFromExtension(extension);
if (writer == null)
{
throw new Exception("Unknown file extension " + extension);
}
object fileSettings = null;
if (!preserveSettings)
{
fileSettings = writer.GetFileSettingsFromDrawing(drawing);
}
if (fileSettings != null)
{
var parameter = new FileSettings(extension.ToLower(), fileSettings);
fileSettings = await _workspace.DialogService.ShowDialog("FileSettings", parameter);
if (fileSettings is null)
{
return(false);
}
}
_drawingSettingsCache.TryGetValue(drawing, out var previousDrawingSettings);
await writer.WriteDrawing(fileName, stream, drawing, viewPort, fileSettings ?? previousDrawingSettings);
if (fileSettings != null)
{
_drawingSettingsCache[drawing] = fileSettings;
}
return(true);
}
public static async Task <(SettingsContainer settingsContainer, CollaborationPlatformSettings platformSettings)> CaptureSettings(
FileSettings settingsIn,
bool addLabels = false,
int?maxPackageUpdates = null,
int?maxOpenPullRequests = null
)
{
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
var environmentVariablesProvider = Substitute.For <IEnvironmentVariablesProvider>();
fileSettings.GetSettings().Returns(settingsIn);
var settingReader = new GitHubSettingsReader(new MockedGitDiscoveryDriver(), environmentVariablesProvider);
var settingsReaders = new List <ISettingsReader> {
settingReader
};
var collaborationFactory = GetCollaborationFactory(environmentVariablesProvider, settingsReaders);
SettingsContainer settingsOut = null;
var engine = Substitute.For <ICollaborationEngine>();
await engine.Run(Arg.Do <SettingsContainer>(x => settingsOut = x));
var command = new RepositoryCommand(engine, logger, fileSettings, collaborationFactory, settingsReaders);
command.PersonalAccessToken = "testToken";
command.RepositoryUri = "http://github.com/test/test";
if (addLabels)
{
command.Label = new List <string> {
"runLabel1", "runLabel2"
};
}
command.MaxPackageUpdates = maxPackageUpdates;
command.MaxOpenPullRequests = maxOpenPullRequests;
await command.OnExecute();
return(settingsOut, collaborationFactory.Settings);
}
public async Task EmptyFileResultsInDefaultSettings()
{
var fileSettings = FileSettings.Empty();
var settings = await CaptureSettings(fileSettings);
Assert.That(settings, Is.Not.Null);
Assert.That(settings.PackageFilters, Is.Not.Null);
Assert.That(settings.UserSettings, Is.Not.Null);
Assert.That(settings.PackageFilters.MinimumAge, Is.EqualTo(TimeSpan.FromDays(7)));
Assert.That(settings.PackageFilters.Excludes, Is.Null);
Assert.That(settings.PackageFilters.Includes, Is.Null);
Assert.That(settings.PackageFilters.MaxPackageUpdates, Is.EqualTo(1));
Assert.That(settings.UserSettings.AllowedChange, Is.EqualTo(VersionChange.Major));
Assert.That(settings.UserSettings.NuGetSources, Is.Null);
Assert.That(settings.UserSettings.OutputDestination, Is.EqualTo(OutputDestination.Console));
Assert.That(settings.UserSettings.OutputFormat, Is.EqualTo(OutputFormat.Text));
}
public async Task LogToFileBySettingLogDestination()
{
var engine = Substitute.For <ILocalEngine>();
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
var settings = FileSettings.Empty();
fileSettings.GetSettings().Returns(settings);
var command = new InspectCommand(engine, logger, fileSettings);
command.LogDestination = LogDestination.File;
await command.OnExecute();
logger
.Received(1)
.Initialise(LogLevel.Normal, LogDestination.File, "nukeeper.log");
}
public PolicyBillingController(JbsDbContext context, Life21DbContext Life21, IFlashMessage flash)
{
filesettings = new FileSettings();
_context = context;
_contextLife21 = Life21;
this.flashMessage = flash;
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var Configuration = builder.Build();
EmailCAF = Configuration.GetValue <string>("Email:EmailCAF");
EmailPHS = Configuration.GetValue <string>("Email:EmailPHS");
EmailFA = Configuration.GetValue <string>("Email:EmailFA");
EmailCS = Configuration.GetValue <string>("Email:EmailCS");
EmailBilling = Configuration.GetValue <string>("Email:EmailBilling");
DirCommand = filesettings.DirCommand;
ConsoleExecResult = filesettings.FileExecresult;
}
public async Task ShouldCallEngineAndSucceedWithRequiredGithubParams()
{
var engine = Substitute.For <IGitHubEngine>();
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.GetSettings().Returns(FileSettings.Empty());
var command = new OrganisationCommand(engine, logger, fileSettings);
command.GitHubToken = "abc";
command.GithubOrganisationName = "testOrg";
var status = await command.OnExecute();
Assert.That(status, Is.EqualTo(0));
await engine
.Received(1)
.Run(Arg.Any <SettingsContainer>());
}
public async Task ShouldCallEngineAndSucceedWithRequiredGithubParams()
{
var engine = Substitute.For <IGitHubEngine>();
var logger = Substitute.For <IConfigureLogLevel>();
var fileSettings = Substitute.For <IFileSettingsCache>();
fileSettings.Get().Returns(FileSettings.Empty());
var command = new RepositoryCommand(engine, logger, fileSettings);
command.GitHubToken = "abc";
command.GitHubRepositoryUri = "http://github.com/abc/abc";
var status = await command.OnExecute();
Assert.That(status, Is.EqualTo(0));
await engine
.Received(1)
.Run(Arg.Any <SettingsContainer>());
}
public async Task <SettingsContainer> CaptureSettings(FileSettings settingsIn,
VersionChange?change = null)
{
var logger = Substitute.For <IConfigureLogger>();
var fileSettings = Substitute.For <IFileSettingsCache>();
SettingsContainer settingsOut = null;
var engine = Substitute.For <ILocalEngine>();
await engine.Run(Arg.Do <SettingsContainer>(x => settingsOut = x), true);
fileSettings.Get().Returns(settingsIn);
var command = new UpdateCommand(engine, logger, fileSettings);
command.AllowedChange = change;
await command.OnExecute();
return(settingsOut);
}
public void SolutionFilePathCanBeLoadedFromSettings()
{
var settings = new FileSettings();
var service = new OnlineService();
var connection = new OnlineServiceConnection(settings,
() => { throw new ConnectionTimedOut(); });
service.Connect("CurrentUser", connection);
service.ChangeProject("DeltaEngine.Tutorials");
Thread.Sleep(1000);
Assert.AreEqual(TutorialsSolutionFilePath, service.CurrentContentProjectSolutionFilePath);
}
public void InitialFileSettings(FileSettings fileSettings)
{
enableFilterToolStripMenuItem.Checked = fileSettings.EnableFilter;
enableTrimToolStripMenuItem.Checked = fileSettings.EnableTrim;
enableHighlightingToolStripMenuItem.Checked = fileSettings.EnableHighlight;
LoadLastNLines = fileSettings.LoadLastLines;
autoScrollToolStripMenuItem.Checked = fileSettings.AutoScroll;
showLineNumbersToolStripMenuItem.Checked = fileSettings.ShowLineNumbers;
}
public void SolutionFilePathIsStoredInSettingsFileWithProjectName()
{
var settings = new FileSettings();
var service = new OnlineService();
var connection = new OnlineServiceConnection(settings,
() => { throw new ConnectionTimedOut(); });
service.Connect("CurrentUser", connection);
service.ChangeProject("DeltaEngine.Tutorials");
Thread.Sleep(1000);
service.CurrentContentProjectSolutionFilePath = TutorialsSolutionFilePath;
var projects = Settings.Current.GetValue("ContentProjects", new Dictionary<string, string>());
Assert.GreaterOrEqual(projects.Count, 1);
settings.Save();
}
public void Init()
{
StackTraceExtensions.SetUnitTestName(TestContext.CurrentContext.Test.FullName);
fileSettings = new FileSettings();
}
protected virtual FileSettings GetSettings(Pop3Box box)
{
FileSettings settings = new FileSettings();
if (box.Parameters.Contains("ContainerKey")) {
settings.ContainerKey = box.Parameters["ContainerKey"];
}
if (box.Parameters.Contains("FolderId"))
{
settings.FolderId = int.Parse(box.Parameters["FolderId"]);
}
if (box.Parameters.Contains("FolderPattern"))
{
settings.FolderPattern = box.Parameters["FolderPattern"].Trim();
}
if (box.Parameters.Contains("OnlyExternalSenders"))
{
settings.OnlyExternalSenders = str2bool(box.Parameters["OnlyExternalSenders"]);
}
if (box.Parameters.Contains("AutoKillForUnknown"))
{
settings.AutoKillForUnknown = str2bool(box.Parameters["AutoKillForUnknown"]);
}
if (box.Parameters.Contains("SaveMessageBodyAsEml"))
{
settings.SaveMessageBodyAsEml = str2bool(box.Parameters["SaveMessageBodyAsEml"]);
}
if (box.Parameters.Contains("SaveMessageBodyAsMht"))
{
settings.SaveMessageBodyAsMht = str2bool(box.Parameters["SaveMessageBodyAsMht"]);
}
if (box.Parameters.Contains("SaveMessageBodyAsMsg"))
{
settings.SaveMessageBodyAsMsg = str2bool(box.Parameters["SaveMessageBodyAsMsg"]);
}
return settings;
}
