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"));
}