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); }
public async Task CannotGetEncryptedSecretAfterSettingIfDisguiserFails() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var secret = new EncryptedSecretCrewMember(); sut.Reset(secret, true); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName, SurName = SomeSurName, Rank = SomeRank }; var errorsAndInfos = new ErrorsAndInfos(); await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); sut = ContainerWithMockedDisguiser.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); Assert.IsNull(GetSecretCrewMember(sut, secret)); await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.IsNull(GetSecretCrewMember(sut, secret)); CleanUpSecretRepository(false); }
public async Task CanSetAndGetSecretListOfElements() { var sut = ContainerWithMockedDisguiser.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var secret = new SecretListOfElements(); sut.Reset(secret, false); var listOfElements = new ListOfElements { new() { Value = "One" }, new() { Value = "Two" } }; sut.Values[secret.Guid] = listOfElements; var errorsAndInfos = new ErrorsAndInfos(); await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); CsArgumentPrompterMock.Setup(p => p.PromptForArgument(It.IsAny <string>(), It.IsAny <string>())).Returns(Passphrase + Passphrase); await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); listOfElements = GetSecretListOfElements(sut, secret); Assert.AreEqual(2, listOfElements.Count); Assert.AreEqual("Two", listOfElements[1].Value); CleanUpSecretRepository(false); }
public async Task CanGetDefaultForEncryptedSecretWithEmptyPassphraseButItIsNotSaved() { var sut = ContainerWithMockedDisguiser.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var errorsAndInfos = new ErrorsAndInfos(); await SetShouldDefaultSecretsBeStored(sut, true, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); var secret = new EncryptedSecretCrewMember(); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName }; sut.Reset(secret, true); Assert.IsNull(GetSecretCrewMember(sut, secret)); Assert.IsFalse(sut.Exists(secret, true)); var crewMember = await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.IsFalse(sut.Exists(secret, true)); Assert.AreEqual(EncryptedSecretCrewMember.DefaultFirstName, crewMember.FirstName); CleanUpSecretRepository(false); }
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 CannotGetEncryptedSecretAfterSettingIfPassphraseIsWrong() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var secret = new EncryptedSecretCrewMember(); sut.Reset(secret, true); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName, SurName = SomeSurName, Rank = SomeRank }; var errorsAndInfos = new ErrorsAndInfos(); await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); CsArgumentPrompterMock.Setup(p => p.PromptForArgument(It.IsAny <string>(), It.IsAny <string>())).Returns(() => "Wrong-Password"); Assert.IsNull(GetSecretCrewMember(sut, secret)); try { await sut.GetAsync(secret, errorsAndInfos); throw new Exception("ZipException expected"); } catch (ZipException e) { Assert.IsTrue(e.Message.Contains("Invalid password", StringComparison.InvariantCultureIgnoreCase)); } Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.IsNull(GetSecretCrewMember(sut, secret)); CleanUpSecretRepository(false); }
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; } }
public async Task CanGetAfterSetting() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var secret = new SecretCrewMember(); sut.Reset(secret, false); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName, SurName = SomeSurName, Rank = SomeRank }; var errorsAndInfos = new ErrorsAndInfos(); await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); sut.Values.Remove(secret.Guid); Assert.IsNull(GetSecretCrewMember(sut, secret)); await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(SomeFirstName, GetSecretCrewMember(sut, secret).FirstName); Assert.AreEqual(SomeSurName, GetSecretCrewMember(sut, secret).SurName); Assert.AreEqual(SomeRank, GetSecretCrewMember(sut, secret).Rank); CleanUpSecretRepository(false); }
public async Task SavedScriptSecretIsUsedDuringExecution() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var errorsAndInfos = new ErrorsAndInfos(); await SetShouldDefaultSecretsBeStored(sut, true, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); var secret = new SecretStringFunction(); sut.Reset(secret, false); var script = await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); const string addedString = "/* This script has been altered */"; Assert.IsFalse(script.LambdaExpression.Contains(addedString)); script.LambdaExpression = addedString + "\r\n" + script.LambdaExpression; await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); sut.Values.Clear(); await sut.ValueOrDefaultAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); script = (CsLambda)sut.Values[secret.Guid]; Assert.IsTrue(script.LambdaExpression.StartsWith(addedString)); CleanUpSecretRepository(false); }
public async Task CanGetDefault() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var errorsAndInfos = new ErrorsAndInfos(); await SetShouldDefaultSecretsBeStored(sut, true, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); var secret = new SecretCrewMember(); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName }; sut.Reset(secret, false); Assert.IsNull(GetSecretCrewMember(sut, secret)); var crewMember = await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(SecretCrewMember.DefaultFirstName, crewMember.FirstName); CleanUpSecretRepository(false); }
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 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 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 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 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 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()); }
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 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); }
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 async Task CanWorkWithAlternativePeghEnvironment() { var sut = Container.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(sut); var alternativeSut = AlternativeContainer.Resolve <ISecretRepository>() as SecretRepository; Assert.IsNotNull(alternativeSut); var secret = new SecretCrewMember(); sut.Reset(secret, false); sut.Values[secret.Guid] = new CrewMember { FirstName = SomeFirstName, SurName = SomeSurName, Rank = SomeRank }; var errorsAndInfos = new ErrorsAndInfos(); await sut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); secret = new SecretCrewMember(); alternativeSut.Reset(secret, false); alternativeSut.Values[secret.Guid] = new CrewMember { FirstName = "ALT " + SomeFirstName, SurName = "ALT" + SomeSurName, Rank = "ALT" + SomeRank }; errorsAndInfos = new ErrorsAndInfos(); await alternativeSut.SetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); sut.Values.Remove(secret.Guid); alternativeSut.Values.Remove(secret.Guid); await alternativeSut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.AreEqual("ALT " + SomeFirstName, GetSecretCrewMember(alternativeSut, secret).FirstName); await sut.GetAsync(secret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.Errors.Any(), errorsAndInfos.ErrorsToString()); Assert.AreEqual(SomeFirstName, GetSecretCrewMember(sut, secret).FirstName); CleanUpSecretRepository(false); CleanUpSecretRepository(true); }
public async Task CanGetTashApp() { var errorsAndInfos = new ErrorsAndInfos(); var tashApp = await _Sut.GetTashAppAsync(errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsNotNull(tashApp); }
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 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")); }
public async Task CanGetSecretDvinApps() { var repository = vContainer.Resolve <ISecretRepository>(); var dvinAppsSecret = new SecretDvinApps(); var errorsAndInfos = new ErrorsAndInfos(); var dvinApps = await repository.GetAsync(dvinAppsSecret, errorsAndInfos); Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsToString()); Assert.IsTrue(dvinApps.Any(c => c.Id == "GraspNetCore")); }