public void SignCommandArgParsing_MultipleCertificateOptions(
string certificatePath,
string certificateSubjectName,
string certificateFingerprint)
{
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var mockSignCommandRunner = new Mock <ISignCommandRunner>();
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificatePath = certificatePath,
CertificateSubjectName = certificateSubjectName,
CertificateFingerprint = certificateFingerprint
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
var ex = Assert.Throws <ArgumentException>(() => signCommand.GetSignArgs());
Assert.Equal(_multipleCertificateException, ex.Message);
}
public void SignCommandArgParsing_ValidCertificateStoreName(string storeName)
{
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var certificateFingerprint = new Guid().ToString();
var parsable = Enum.TryParse(storeName, ignoreCase: true, result: out StoreName parsedStoreName);
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificateFingerprint = certificateFingerprint,
CertificateStoreName = storeName
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
Assert.True(parsable);
var signArgs = signCommand.GetSignArgs();
Assert.Equal(parsedStoreName, signArgs.CertificateStoreName);
Assert.Equal(StoreLocation.CurrentUser, signArgs.CertificateStoreLocation);
}
public void SignCommandArgParsing_ValidTimestampHashAlgorithm(string timestampHashAlgorithm)
{
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var certificatePath = @"\\path\file.pfx";
var parsable = Enum.TryParse(timestampHashAlgorithm, ignoreCase: true, result: out HashAlgorithmName parsedTimestampHashAlgorithm);
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificatePath = certificatePath,
TimestampHashAlgorithm = timestampHashAlgorithm
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
Assert.True(parsable);
var signArgs = signCommand.GetSignArgs();
Assert.Equal(HashAlgorithmName.SHA256, signArgs.SignatureHashAlgorithm);
Assert.Equal(parsedTimestampHashAlgorithm, signArgs.TimestampHashAlgorithm);
}
public void TestColor()
{
Action action = VP.Create().Sign(color: Color.Red);
SignCommand sign = action.Create.GetCommandOfType <SignCommand>();
Assert.IsNotNull(sign);
Assert.IsTrue(sign.ForeColor.Equals(System.Drawing.Color.Red));
}
private void RaiseCommandsCanExecute()
{
SignCommand.RaiseCanExecuteChanged();
BuildCommand.RaiseCanExecuteChanged();
ChooseFileCommand.RaiseCanExecuteChanged();
ChooseFolderCommand.RaiseCanExecuteChanged();
InstallFrameworkCommand.RaiseCanExecuteChanged();
ShowSearchWindowCommand.RaiseCanExecuteChanged();
}
public void SignCommandArgParsing_ValidArgs_CertSubjectNameAsync()
{
//Debugger.Launch();
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var certificateSubjectName = new Guid().ToString();
var hashAlgorithm = "sha256";
Enum.TryParse(hashAlgorithm, ignoreCase: true, result: out HashAlgorithmName parsedHashAlgorithm);
var timestampHashAlgorithm = "sha512";
Enum.TryParse(timestampHashAlgorithm, ignoreCase: true, result: out HashAlgorithmName parsedTimestampHashAlgorithm);
var storeName = "CertificateAuthority";
Enum.TryParse(storeName, ignoreCase: true, result: out StoreName parsedStoreName);
var storeLocation = "LocalMachine";
Enum.TryParse(storeLocation, ignoreCase: true, result: out StoreLocation parsedStoreLocation);
var nonInteractive = true;
var overwrite = true;
var outputDir = @".\test\output\path";
var mockConsole = new Mock <IConsole>();
mockConsole.Setup(c => c.Verbosity).Returns(Verbosity.Detailed);
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificateSubjectName = certificateSubjectName,
CertificateStoreName = storeName,
CertificateStoreLocation = storeLocation,
HashAlgorithm = hashAlgorithm,
TimestampHashAlgorithm = timestampHashAlgorithm,
OutputDirectory = outputDir,
NonInteractive = nonInteractive,
Overwrite = overwrite,
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
var signArgs = signCommand.GetSignArgs();
Assert.Null(signArgs.CertificatePath);
Assert.Null(signArgs.CertificateFingerprint);
Assert.Equal(certificateSubjectName, signArgs.CertificateSubjectName, StringComparer.Ordinal);
Assert.Equal(parsedStoreLocation, signArgs.CertificateStoreLocation);
Assert.Equal(parsedStoreName, signArgs.CertificateStoreName);
Assert.Equal(mockConsole.Object, signArgs.Logger);
Assert.Equal(nonInteractive, signArgs.NonInteractive);
Assert.Equal(overwrite, signArgs.Overwrite);
Assert.Equal(packagePath, signArgs.PackagePath, StringComparer.Ordinal);
Assert.Equal(timestamper, signArgs.Timestamper, StringComparer.Ordinal);
Assert.Equal(outputDir, signArgs.OutputDirectory, StringComparer.Ordinal);
}
public NuGetSignService(IKeyVaultService keyVaultService,
ILogger <NuGetSignService> logger,
ITelemetryLogger telemetryLogger)
{
this.keyVaultService = keyVaultService;
this.logger = logger;
this.telemetryLogger = telemetryLogger;
signToolName = nameof(NuGetSignService);
signCommand = new SignCommand(logger);
}
public void SignCommandArgParsing_NoPackagePath()
{
// Arrange
var mockSignCommandRunner = new Mock <ISignCommandRunner>();
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
};
// Act & Assert
var ex = Assert.Throws <ArgumentException>(() => signCommand.GetSignArgs());
Assert.Equal(_noPackageException, ex.Message);
}
public void TestSignWithDefaultValues()
{
Action action = Action.Parse("create sign");
SignCommand sign = action.Create.GetCommandOfType <SignCommand>();
Assert.IsNotNull(sign);
Assert.AreEqual("sign", sign.CommandName, true);
Assert.AreEqual(String.Empty, sign.Text);
Assert.AreEqual(Color.DefaultSignBackColor, sign.BackColor);
Assert.AreEqual(Color.White, sign.ForeColor);
Assert.AreEqual(String.Empty, sign.TargetName);
Assert.AreEqual(TextAlignment.Center, sign.Alignment);
Assert.IsFalse(sign.Shadow);
Assert.IsFalse(sign.IsGlobal);
Assert.IsFalse(sign.IsLocked);
}
public void TestSignWithCustomValues()
{
Action action =
Action.Parse(
"create sign color=red \"Hello World\" bcolor=white align=left shadow name=foo global lock");
SignCommand sign = action.Create.GetCommandOfType <SignCommand>();
Assert.IsNotNull(sign);
Assert.AreEqual("sign", sign.CommandName, true);
Assert.AreEqual("Hello World", sign.Text);
Assert.AreEqual(Color.White, sign.BackColor);
Assert.AreEqual(Color.Red, sign.ForeColor);
Assert.AreEqual("foo", sign.TargetName);
Assert.AreEqual(TextAlignment.Left, sign.Alignment);
Assert.IsTrue(sign.Shadow);
Assert.IsTrue(sign.IsGlobal);
Assert.IsTrue(sign.IsLocked);
}
public void SignCommandArgParsing_InvalidTimestampHashAlgorithm()
{
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var certificatePath = @"\\path\file.pfx";
var timestampHashAlgorithm = "MD5";
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificatePath = certificatePath,
TimestampHashAlgorithm = timestampHashAlgorithm
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
var ex = Assert.Throws <ArgumentException>(() => signCommand.GetSignArgs());
Assert.Equal(string.Format(_invalidArgException, nameof(signCommand.TimestampHashAlgorithm)), ex.Message);
}
public void SignCommandArgParsing_InvalidCertificateStoreLocation()
{
// Arrange
var packagePath = @"\\path\package.nupkg";
var timestamper = "https://timestamper.test";
var certificateFingerprint = new Guid().ToString();
var storeLocation = "random_location";
var mockConsole = new Mock <IConsole>();
var signCommand = new SignCommand
{
Console = mockConsole.Object,
Timestamper = timestamper,
CertificateFingerprint = certificateFingerprint,
CertificateStoreLocation = storeLocation
};
signCommand.Arguments.Add(packagePath);
// Act & Assert
var ex = Assert.Throws <ArgumentException>(() => signCommand.GetSignArgs());
Assert.Equal(string.Format(_invalidArgException, nameof(signCommand.CertificateStoreLocation)), ex.Message);
}
private void SignCommandArgs(Action <Mock <ISignCommandRunner>, CommandLineApplication, Func <LogLevel>, Func <SignArgs> > verify)
{
// Arrange
var logLevel = LogLevel.Information;
var logger = new TestCommandOutputLogger();
var testApp = new CommandLineApplication();
var mockCommandRunner = new Mock <ISignCommandRunner>();
SignArgs parsedArgs = null;
mockCommandRunner
.Setup(m => m.ExecuteCommandAsync(It.IsAny <SignArgs>()))
.Callback <SignArgs>(x => parsedArgs = x)
.Returns(Task.FromResult(0));
testApp.Name = "dotnet nuget_test";
SignCommand.Register(testApp,
() => logger,
ll => logLevel = ll,
() => mockCommandRunner.Object);
// Act & Assert
verify(mockCommandRunner, testApp, () => logLevel, () => parsedArgs);
}
public virtual void ExecuteSign(SignCommand command) {
command.Sender = NoticeScreen;
NoticeScreen.Sign.OnNext(command);
}
public virtual void SignHandler(SignCommand command) {
this.Sign(command.Sender as NoticeScreenViewModel);
}
