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