public async Task CanEncryptAndDecryptStringsUsingRealEncrypter() { var secretRepository = Container.Resolve <ISecretRepository>(); var encrypterSecret = new SecretStringEncrypterFunction(); Assert.IsFalse(string.IsNullOrEmpty(encrypterSecret.Guid)); var errorsAndInfos = new ErrorsAndInfos(); var csLambda = await secretRepository.GetAsync(encrypterSecret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); var secretEncrypterFunction = await secretRepository.CompileCsLambdaAsync <string, string>(csLambda); var decrypterSecret = new SecretStringDecrypterFunction(); Assert.IsFalse(string.IsNullOrEmpty(decrypterSecret.Guid)); csLambda = await secretRepository.GetAsync(decrypterSecret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); var secretDecrypterFunction = await secretRepository.CompileCsLambdaAsync <string, string>(csLambda); const string originalString = "Whatever you do not want to reveal, keep it secret (\\, € ✂ and ❤)!"; var encryptedString = secretEncrypterFunction(originalString); Assert.AreNotEqual(originalString, encryptedString); var decryptedString = secretDecrypterFunction(encryptedString); Assert.AreEqual(originalString, decryptedString); }
private async void DualityWindow_OnLoaded(object sender, RoutedEventArgs e) { var container = new ContainerBuilder().UsePegh(new DummyCsArgumentPrompter()).Build(); if (Environment.MachineName.ToUpper() != "DELTAFLYER") { InfoText.Text = "Sorry, you should not run this program on this machine"; return; } var secret = new DualityFoldersSecret(); var errorsAndInfos = new ErrorsAndInfos(); var secretDualityFolders = await container.Resolve <ISecretRepository>().GetAsync(secret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } var persistenceFolder = await container.Resolve <IFolderResolver>().ResolveAsync(@"$(GitHub)\DualityBin\Release\Persistence", errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } persistenceFolder.CreateIfNecessary(); var workFile = persistenceFolder.FullName + @"\DualityWork.xml"; var work = File.Exists(workFile) ? new DualityWork(workFile, Environment.MachineName) : new DualityWork(); work.UpdateFolders(secretDualityFolders); File.Delete(workFile); work.Save(workFile); CreateWorker(work, workFile); }
public async Task CanPublishApps() { var repository = vContainer.Resolve <IDvinRepository>(); var fileSystemService = new FileSystemService(); var errorsAndInfos = new ErrorsAndInfos(); var apps = await repository.LoadAsync(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); // ReSharper disable once LoopCanBePartlyConvertedToQuery foreach (var app in apps) { if (!app.HasAppBeenBuiltAfterLatestSourceChanges(fileSystemService)) { continue; } app.Publish(fileSystemService, errorsAndInfos); if (errorsAndInfos.Errors.Any(e => e.StartsWith("No folders specified"))) { continue; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); break; } }
private async Task FindReplacementsIfNecessaryAsync() { if (Replacements.Any()) { return; } var errorsAndInfos = new ErrorsAndInfos(); var machineDrivesSecret = new MachineDrivesSecret(); var machineDrives = await SecretRepository.GetAsync(machineDrivesSecret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } machineDrives.DrivesOnThisMachine().ToList().ForEach(AddReplacement); var logicalFoldersSecret = new LogicalFoldersSecret(); var logicalFolders = await SecretRepository.GetAsync(logicalFoldersSecret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } logicalFolders.ForEach(AddReplacement); var keys = Replacements.Keys.ToList(); foreach (var key in keys) { Replacements[key] = ResolveIterative(Replacements[key]).FullName; } }
public async Task CanGetSecretSecuredHttpGateSettings() { var repository = _Container.Resolve <ISecretRepository>(); var securedHttpGateSettingsSecret = new SecretSecuredHttpGateSettings(); var errorsAndInfos = new ErrorsAndInfos(); var securedHttpGateSettings = await repository.GetAsync(securedHttpGateSettingsSecret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), string.Join("\r\n", errorsAndInfos.Errors)); var folder = await _Container.Resolve <IFolderResolver>().ResolveAsync(securedHttpGateSettings.LocalhostTempPath, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), string.Join("\r\n", errorsAndInfos.Errors)); var file = Directory.GetFiles(folder.FullName, "*.txt").FirstOrDefault(); if (string.IsNullOrEmpty(file)) { return; } var contents = await File.ReadAllTextAsync(file); var shortFileName = file.Substring(file.LastIndexOf('\\') + 1); var httpGate = _Container.Resolve <IHttpGate>(); var httpResponseMessage = await httpGate.GetAsync(new Uri(securedHttpGateSettings.LocalhostTempPathUrl + shortFileName)); var httpContents = await httpResponseMessage.Content.ReadAsStringAsync(); Assert.AreEqual(contents, httpContents); }
public async Task DriveResolvesToActualDrive() { IErrorsAndInfos errorsAndInfos = new ErrorsAndInfos(); Assert.AreEqual(@"E:", (await _Sut.ResolveAsync(@"$(SomeDrive)", errorsAndInfos)).FullName); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(@"E:", (await _Sut.ResolveAsync(@"$(SomeDrive)\", errorsAndInfos)).FullName); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); }
public async Task CanResolveLogicalFolder() { var errorsAndInfos = new ErrorsAndInfos(); Assert.AreEqual(@"E:\Logical\Folder", (await _Sut.ResolveAsync(@"$(SomeLogicalFolder)", errorsAndInfos)).FullName); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(@"E:\Logical\Folder\Other", (await _Sut.ResolveAsync(@"$(SomeOtherLogicalFolder)", errorsAndInfos)).FullName); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); }
public async Task <IErrorsAndInfos> EnsureTashAppIsRunningAsync() { using (_SimpleLogger.BeginScope(SimpleLoggingScopeId.Create(nameof(EnsureTashAppIsRunningAsync)))) { var methodNamesFromStack = _MethodNamesFromStackFramesExtractor.ExtractMethodNamesFromStackFrames(); _SimpleLogger.LogInformationWithCallStack("Ensuring tash app is running", methodNamesFromStack); var errorsAndInfos = new ErrorsAndInfos(); try { var processes = await GetControllableProcessesAsync(); if (processes != null) { _SimpleLogger.LogInformationWithCallStack("Tash app is running", methodNamesFromStack); return(errorsAndInfos); } } catch { _SimpleLogger.LogInformationWithCallStack("Exception was thrown, tash app probably is not running", methodNamesFromStack); } var tashApp = await GetTashAppAsync(errorsAndInfos); if (errorsAndInfos.AnyErrors()) { _SimpleLogger.LogInformationWithCallStack("Could not get tash app", methodNamesFromStack); return(errorsAndInfos); } var fileSystemService = new FileSystemService(); tashApp.Start(fileSystemService, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { _SimpleLogger.LogInformationWithCallStack("Could not start tash app", methodNamesFromStack); errorsAndInfos.Errors.ToList().ForEach(e => _SimpleLogger.LogErrorWithCallStack(e, methodNamesFromStack)); return(errorsAndInfos); } await Task.Delay(TimeSpan.FromSeconds(10)); try { var processes = await GetControllableProcessesAsync(); if (processes != null) { _SimpleLogger.LogInformationWithCallStack("Tash app is running", methodNamesFromStack); return(errorsAndInfos); } } catch { const string errorMessage = "Tash started but not answering"; errorsAndInfos.Errors.Add(errorMessage); // Should this occur regularly, maybe the Tash process can be killed _SimpleLogger.LogErrorWithCallStack(errorMessage, methodNamesFromStack); } return(errorsAndInfos); } }
public async Task CanCheckIfPullRequestsExist() { var sut = vContainer.Resolve <IGitHubUtilities>(); var errorsAndInfos = new ErrorsAndInfos(); var hasOpenPullRequest = await HasOpenPullRequestAsync(sut, "", errorsAndInfos); if (hasOpenPullRequest.Inconclusive) { return; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsTrue(hasOpenPullRequest.YesNo); hasOpenPullRequest = await HasOpenPullRequestAsync(sut, "1", errorsAndInfos); if (hasOpenPullRequest.Inconclusive) { return; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsFalse(hasOpenPullRequest.YesNo); hasOpenPullRequest = await HasOpenPullRequestForThisBranchAsync(sut, true, errorsAndInfos); if (hasOpenPullRequest.Inconclusive) { return; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsFalse(hasOpenPullRequest.YesNo); hasOpenPullRequest = await HasOpenPullRequestForThisBranchAsync(sut, false, errorsAndInfos); if (hasOpenPullRequest.Inconclusive) { return; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsTrue(hasOpenPullRequest.YesNo); var hasPullRequest = await HasPullRequestForThisBranchAndItsHeadTipAsync(sut, errorsAndInfos); if (hasOpenPullRequest.Inconclusive) { return; } Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsTrue(hasPullRequest.YesNo); }
public async Task CanUseRealResolver() { var sut = ProductionContainer.Resolve <IFolderResolver>(); var errorsAndInfos = new ErrorsAndInfos(); var folder = await sut.ResolveAsync("$(MainUserFolder)", errorsAndInfos); Assert.IsTrue(folder.SubFolder("CSharp").Exists()); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(folder.SubFolder("GitHub").Exists()); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); }
public void CanCheckIfIsBranchAheadOfMaster() { var errorsAndInfos = new ErrorsAndInfos(); CloneRepository(DoNotPullFolder.Folder(), "do-not-pull-from-me", errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsFalse(vSut.IsBranchAheadOfMaster(MasterFolder)); vContainer.Resolve <IEmbeddedCakeScriptCopier>().CopyCakeScriptEmbeddedInAssembly(Assembly.GetExecutingAssembly(), BuildCake.Standard, DoNotPullFolder, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); TargetRunner.RunBuildCakeScript(BuildCake.Standard, DoNotPullFolder, "CleanRestorePull", errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.IsTrue(vSut.IsBranchAheadOfMaster(DoNotPullFolder.Folder())); }
public async Task CanGetDvinApp() { var sut = vContainer.Resolve <IDvinRepository>(); var errorsAndInfos = new ErrorsAndInfos(); var apps = await sut.LoadAsync(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(apps.Any()); var app = await sut.LoadAsync(apps[0].Id, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(app.Id, apps[0].Id); }
public async Task CanStartSampleApp() { var repository = vContainer.Resolve <IDvinRepository>(); var errorsAndInfos = new ErrorsAndInfos(); var dvinApp = await repository.LoadAsync(Constants.DvinSampleAppId, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(dvinApp); var fileSystemService = new FileSystemService(); dvinApp.ValidatePubXml(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); #if DEBUG if (!dvinApp.HasAppBeenBuiltAfterLatestSourceChanges(fileSystemService)) { return; } #endif if (!dvinApp.HasAppBeenPublishedAfterLatestSourceChanges(fileSystemService)) { dvinApp.Publish(fileSystemService, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); } Assert.IsTrue(dvinApp.HasAppBeenPublishedAfterLatestSourceChanges(fileSystemService)); using var process = dvinApp.Start(fileSystemService, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(process); var url = $"http://localhost:{dvinApp.Port}/Home"; Wait.Until(() => dvinApp.IsPortListenedTo(), TimeSpan.FromSeconds(5)); Assert.IsTrue(dvinApp.IsPortListenedTo(), errorsAndInfos.ErrorsToString()); try { using var client = new HttpClient(); var response = await client.GetAsync(url); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); var content = await response.Content.ReadAsStringAsync(); Assert.IsTrue(content.Contains("Hello World says your dvin app")); } catch { KillProcess(process); throw; } KillProcess(process); }
public async Task SampleAppCanPublishItselfWhileRunning() { var repository = vContainer.Resolve <IDvinRepository>(); var errorsAndInfos = new ErrorsAndInfos(); var dvinApp = await repository.LoadAsync(Constants.DvinSampleAppId, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(dvinApp); var fileSystemService = new FileSystemService(); dvinApp.ValidatePubXml(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); var timeBeforePublishing = DateTime.Now; dvinApp.Publish(fileSystemService, true, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); var lastPublishedAt = dvinApp.LastPublishedAt(fileSystemService); Assert.IsTrue(lastPublishedAt > timeBeforePublishing); using var process = dvinApp.Start(fileSystemService, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(process); var url = $"http://localhost:{dvinApp.Port}/Publish"; Wait.Until(() => dvinApp.IsPortListenedTo(), TimeSpan.FromSeconds(5)); Assert.IsTrue(dvinApp.IsPortListenedTo(), errorsAndInfos.ErrorsToString()); try { using var client = new HttpClient(); timeBeforePublishing = DateTime.Now; var response = await client.GetAsync(url); var content = await response.Content.ReadAsStringAsync(); Assert.AreNotEqual(HttpStatusCode.InternalServerError, response.StatusCode, content); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.IsTrue(content.Contains("Your dvin app just published itself"), content); lastPublishedAt = dvinApp.LastPublishedAt(fileSystemService); Assert.IsTrue(lastPublishedAt > timeBeforePublishing); } catch { KillProcess(process); throw; } KillProcess(process); }
public async Task CanGetCacheckConfiguration() { var container = (await new ContainerBuilder().UseCacheckVishizhukelNetAndPeghAsync(null)).Build(); var secretRepository = container.Resolve <ISecretRepository>(); var errorsAndInfos = new ErrorsAndInfos(); var secret = await secretRepository.GetAsync(new CacheckConfigurationSecret(), errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsFalse(string.IsNullOrEmpty(secret.SourceFolder), "Source folder is empty"); var resolver = container.Resolve <IFolderResolver>(); var sourceFolder = await resolver.ResolveAsync(secret.SourceFolder, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(sourceFolder.Exists(), $"Source folder \"{secret.SourceFolder}\" does not exist"); }
public void NextCheckIsWithinCheckInterval() { var errorsAndInfos = new ErrorsAndInfos(); var testRootFolder = TempFolder(true).SubFolder("NextCheckIsWithinCheckInterval"); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); CopyTemplateTestFileSystemTo(testRootFolder); const long ticks = 1000000000000; var folders = CreateTestFoldersOnTwoMachines(testRootFolder, new DateTime(ticks)); var work = new DualityWork { ForMachine = folders[0].MachineId }; work.UpdateFolders(folders); var folder = work.DualityFolders[2]; Assert.IsTrue(folder.NeedsProcessing()); Assert.AreEqual("", folder.Process()); Assert.IsFalse(folder.NeedsProcessing()); var minimum = DateTime.Now.AddTicks(ticks / 2); var maximum = DateTime.Now.AddTicks(ticks); Assert.IsTrue(folder.NextCheckAt >= minimum); Assert.IsTrue(folder.NextCheckAt <= maximum); }
private async void BackbendWindow_OnLoaded(object sender, RoutedEventArgs e) { await NavigateToMessage($"Starting {Constants.BackbendAppId}…"); var errorsAndInfos = new ErrorsAndInfos(); var dvinApp = await vContainer.Resolve <IDvinRepository>().LoadAsync(Constants.BackbendAppId, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { await NavigateToMessage(errorsAndInfos.ErrorsToString()); return; } if (dvinApp == null) { await NavigateToMessage($"{Constants.BackbendAppId} app not found"); return; } Wait.Until(() => dvinApp.IsPortListenedTo(), TimeSpan.FromSeconds(5)); if (!dvinApp.IsPortListenedTo() && !await StartAppAndReturnSuccess(dvinApp)) { return; } Cursor = Cursors.Wait; Width = 660; Height = 660; vNavigated = false; HtmlOutput.Navigate("http://localhost:" + dvinApp.Port); }
public async Task CollectAndShowAsync(IContainer container, bool isIntegrationTest) { var errorsAndInfos = new ErrorsAndInfos(); var secretRepository = container.Resolve <ISecretRepository>(); CalculationLogger.ClearLogs(); var allPostings = await PostingCollector.CollectPostingsAsync(container, isIntegrationTest); var postingClassificationsSecret = await secretRepository.GetAsync(new PostingClassificationsSecret(), errorsAndInfos); if (errorsAndInfos.AnyErrors()) { await DataPresenter.WriteErrorsAsync(errorsAndInfos); return; } var postingClassifications = postingClassificationsSecret.Cast <IPostingClassification>().ToList(); await SummaryCalculator.CalculateAndShowSummaryAsync(allPostings, postingClassifications); await AverageCalculator.CalculateAndShowAverageAsync(allPostings, postingClassifications); await MonthlyDeltaCalculator.CalculateAndShowMonthlyDeltaAsync(allPostings, postingClassifications); await ClassifiedPostingsCalculator.CalculateAndShowClassifiedPostingsAsync(allPostings, postingClassifications, DateTime.Now.AddYears(-1), 70); CalculationLogger.Flush(); }
public void CanInstallGlobalDotNetCakeIfNecessary() { var errorsAndInfos = new ErrorsAndInfos(); Sut.InstallGlobalDotNetCakeIfNecessary(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); }
protected async Task LoadSecretsIfNecessaryAsync() { if (SecretEncrypterFunction != null) { return; } var encrypterSecret = new SecretStringEncrypterFunction(); var errorsAndInfos = new ErrorsAndInfos(); var csLambda = await SecretRepository.GetAsync(encrypterSecret, errorsAndInfos); SecretEncrypterFunction = await SecretRepository.CompileCsLambdaAsync <string, string>(csLambda); var decrypterSecret = new SecretStringDecrypterFunction(); csLambda = await SecretRepository.GetAsync(decrypterSecret, errorsAndInfos); SecretDecrypterFunction = await SecretRepository.CompileCsLambdaAsync <string, string>(csLambda); if (!errorsAndInfos.AnyErrors()) { return; } throw new Exception(errorsAndInfos.ErrorsToString()); }
public async Task CalculateAndShowAverageAsync(IList <IPosting> allPostings, IList <IPostingClassification> postingClassifications) { var errorsAndInfos = new ErrorsAndInfos(); var detailedAggregation = PostingAggregator.AggregatePostings(allPostings, postingClassifications, errorsAndInfos).OrderBy(result => result.Key.CombinedClassification).ToList(); if (errorsAndInfos.AnyErrors()) { await DataPresenter.WriteErrorsAsync(errorsAndInfos); return; } var thisYear = allPostings.Max(p => p.Date.Year); var lastYearsPostings = allPostings.Where(p => p.Date.Year < thisYear).ToList(); var lastYearsDetailedAggregation = PostingAggregator.AggregatePostings(lastYearsPostings, postingClassifications, errorsAndInfos).ToList(); if (errorsAndInfos.AnyErrors()) { await DataPresenter.WriteErrorsAsync(errorsAndInfos); return; } var thisYearsPostings = allPostings.Where(p => p.Date.Year == thisYear).ToList(); var thisYearsDetailedAggregation = PostingAggregator.AggregatePostings(thisYearsPostings, postingClassifications, errorsAndInfos).ToList(); if (errorsAndInfos.AnyErrors()) { await DataPresenter.WriteErrorsAsync(errorsAndInfos); return; } var numberOfDistinctMonths = allPostings.Select(p => p.Date.Month * 100 + p.Date.Year).Distinct().Count(); var numberOfDistinctMonthsLastYear = lastYearsPostings.Any() ? lastYearsPostings.Select(p => p.Date.Month * 100 + p.Date.Year).Distinct().Count() : 1; var numberOfDistinctMonthsThisYear = thisYearsPostings.Any() ? thisYearsPostings.Select(p => p.Date.Month * 100 + p.Date.Year).Distinct().Count() : 1; var classificationAverageList = detailedAggregation.Select( result => new TypeItemSum { Type = result.Key.Sign, Item = result.Key.Classification, Sum = result.Value / numberOfDistinctMonths, SumThisYear = GetOtherSum(result.Key, thisYearsDetailedAggregation) / numberOfDistinctMonthsThisYear, SumLastYear = GetOtherSum(result.Key, lastYearsDetailedAggregation) / numberOfDistinctMonthsLastYear } ).Cast <ICollectionViewSourceEntity>().ToList(); await DataPresenter.Handlers.ClassificationAveragesHandler.CollectionChangedAsync(classificationAverageList); }
public async Task CanGetTashApp() { var errorsAndInfos = new ErrorsAndInfos(); var tashApp = await _Sut.GetTashAppAsync(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(tashApp); }
public SearchCommandTest() { var container = new ContainerBuilder().UsePegh("PureSearch", new DummyCsArgumentPrompter()).Build(); var errorsAndInfos = new ErrorsAndInfos(); GitHubFolder = container.Resolve <IFolderResolver>().ResolveAsync(@"$(GitHub)", errorsAndInfos).Result; Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); }
public void GlobalDotNetCakeIsInstalled() { var errorsAndInfos = new ErrorsAndInfos(); var isInstalled = Sut.IsGlobalDotNetCakeInstalled(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(isInstalled); }
public void Initialize() { vContainer = new ContainerBuilder().UseGittyAndPegh(new DummyCsArgumentPrompter()).UseGittyTestUtilities().Build(); vGitUtilities = vContainer.Resolve <IGitUtilities>(); var checkOutFolder = new Folder(Path.GetTempPath()).SubFolder("AspenlaubTemp").SubFolder(nameof(GitHubUtilitiesTest)); MasterFolder = checkOutFolder.SubFolder("PakledCore-Master"); DevelopmentFolder = checkOutFolder.SubFolder("PakledCore-Development"); CleanUp(); var errorsAndInfos = new ErrorsAndInfos(); CloneRepository(MasterFolder, "master", errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); CloneRepository(DevelopmentFolder, "do-not-pull-from-me", errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); }
public void CanIdentifyUrlOwnerAndName() { var errorsAndInfos = new ErrorsAndInfos(); vSut.IdentifyOwnerAndName(MasterFolder, out var owner, out var name, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos()); Assert.AreEqual("aspenlaub", owner); Assert.AreEqual("PakledCore", name); }
public async Task CanGetSecretBackbendApp() { var repository = vContainer.Resolve <IDvinRepository>(); var errorsAndInfos = new ErrorsAndInfos(); var dvinApp = await repository.LoadAsync(Constants.BackbendAppId, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(dvinApp); }
public async Task CanGetSecretDualityFolders() { var secret = new DualityFoldersSecret(); var errorsAndInfos = new ErrorsAndInfos(); var secretDualityFolders = await vContainer.Resolve <ISecretRepository>().GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(secretDualityFolders.Count >= 10); }
public async Task HaveBenchmarkDefinitionsSecret() { var secret = new SecretBenchmarkDefinitions(); var container = new ContainerBuilder().UsePegh(new DummyCsArgumentPrompter()).Build(); var errorsAndInfos = new ErrorsAndInfos(); await container.Resolve <ISecretRepository>().GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), string.Join("\r\n", errorsAndInfos.Errors)); }
public async Task CanGetLogicalFolders() { var secretRepository = Container.Resolve <ISecretRepository>(); var logicalFoldersSecret = new LogicalFoldersSecret(); var errorsAndInfos = new ErrorsAndInfos(); var logicalFolders = await secretRepository.GetAsync(logicalFoldersSecret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(logicalFolders.Any(m => m.Name == "MainUserFolder")); }