public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed()
{
var args = new ScriptCsArgs
{
AllowPreReleaseFlag = false,
Install = "",
ScriptName = null
};
var fs = new Mock<IFileSystem>();
fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(@"C:\");
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, scriptpackResolver.Object, packageInstaller.Object);
resolver.Setup(i => i.GetPackages(It.IsAny<string>())).Returns(new List<IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
packageInstaller.Verify(i => i.InstallPackages(It.Is<IEnumerable<IPackageReference>>(x => x.Count() == 2), It.IsAny<bool>(), It.IsAny<Action<string>>()), Times.Once());
}
private static ScriptCsArgs ReconcileArguments(ScriptCsArgs configArgs, ScriptCsArgs commandArgs, SplitResult splitResult)
{
if (configArgs == null)
return commandArgs;
if (commandArgs == null)
return configArgs;
foreach (var property in typeof(ScriptCsArgs).GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
var configValue = property.GetValue(configArgs);
var commandValue = property.GetValue(commandArgs);
var defaultValue = GetPropertyDefaultValue(property);
if (!object.Equals(configValue, commandValue))
{
if (!object.Equals(commandValue, defaultValue))
{
property.SetValue(configArgs, commandValue);
}
else
{
if (IsCommandLinePresent(splitResult.CommandArguments, property))
property.SetValue(configArgs, commandValue);
}
}
}
return configArgs;
}
public void VersionCommandShouldOutputVersion(
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IFileSystem> fileSystem)
{
// Arrange
var args = new ScriptCsArgs {
Version = true
};
var assembly = typeof(ScriptCsArgs).Assembly;
var currentVersion = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
console.Verify(x => x.Write(It.Is <string>(y => y.Contains(currentVersion.ToString()))));
}
public void ShouldReturnErrorIfThereIsCompileException(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <ILog> logger,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx"
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
executor.Setup(i => i.Execute(It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(new ScriptResult(compilationException: new Exception("test")));
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = fixture.Create <CommandFactory>();
// Act
var result = factory.CreateCommand(args, new string[0]).Execute();
// Assert
result.ShouldEqual(CommandResult.Error);
logger.Verify(i => i.Error(It.IsAny <object>()), Times.Once());
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs()
{
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx"
};
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
executor.Verify(i => i.Execute(It.Is<string>(x => x == "test.csx"), It.IsAny<IEnumerable<string>>(), It.IsAny<IEnumerable<IScriptPack>>()), Times.Once());
}
public void ShouldCreateBinFolderIfItDoesNotExist()
{
var args = new ScriptCsArgs {
Restore = true, ScriptName = ""
};
var fs = new Mock <IFileSystem>();
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
const string CurrentDirectory = @"C:\";
const string BinFolder = @"C:\bin";
fs.Setup(x => x.GetWorkingDirectory(It.IsAny <string>())).Returns(CurrentDirectory);
var binFolderCreated = false;
fs.Setup(x => x.DirectoryExists(BinFolder)).Returns(() => binFolderCreated).Verifiable();
fs.Setup(x => x.CreateDirectory(BinFolder)).Callback(() => binFolderCreated = true).Verifiable();
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(x => x.DirectoryExists(BinFolder), Times.AtLeastOnce());
fs.Verify(x => x.CreateDirectory(BinFolder), Times.Once());
}
public WatchScriptCommand(
ScriptCsArgs commandArgs,
string[] scriptArgs,
IConsole console,
IFileSystem fileSystem,
ILog logger,
IFileSystemMigrator fileSystemMigrator)
{
Guard.AgainstNullArgument("commandArgs", commandArgs);
Guard.AgainstNullArgument("scriptArgs", scriptArgs);
Guard.AgainstNullArgument("console", console);
Guard.AgainstNullArgument("fileSystem", fileSystem);
Guard.AgainstNullArgument("logger", logger);
Guard.AgainstNullArgument("fileSystemMigrator", fileSystemMigrator);
_commandArgs = commandArgs;
_scriptArgs = scriptArgs;
_console = console;
_fileSystem = fileSystem;
_logger = logger;
_fileSystemMigrator = fileSystemMigrator;
_executeScriptCommand = new CrossAppDomainExecuteScriptCommand
{
CommandArgs = _commandArgs,
ScriptArgs = _scriptArgs,
};
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IScriptExecutor> executor,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "", ScriptName = "test.csx" };
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze<Mock<IScriptServicesBuilder>>();
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = fixture.Create<CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.IsAny<IEnumerable<string>>(), It.IsAny<IEnumerable<IScriptPack>>()), Times.Once());
executor.Verify(i => i.Execute(It.Is<string>(x => x == "test.csx"), It.IsAny<string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void ShouldCreateMissingBinFolder()
{
const string WorkingDirectory = @"C:\";
var binFolder = Path.Combine(WorkingDirectory, "bin");
var args = new ScriptCsArgs {
ScriptName = "test.csx"
};
var fs = new Mock <IFileSystem>();
fs.Setup(x => x.GetWorkingDirectory(It.IsAny <string>())).Returns(WorkingDirectory);
fs.Setup(x => x.DirectoryExists(binFolder)).Returns(false);
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(x => x.CreateDirectory(binFolder), Times.Once());
}
public WatchScriptCommand(
ScriptCsArgs commandArgs,
string[] scriptArgs,
IConsole console,
IFileSystem fileSystem,
ILog logger,
IFileSystemMigrator fileSystemMigrator)
{
Guard.AgainstNullArgument("commandArgs", commandArgs);
Guard.AgainstNullArgument("scriptArgs", scriptArgs);
Guard.AgainstNullArgument("console", console);
Guard.AgainstNullArgument("fileSystem", fileSystem);
Guard.AgainstNullArgument("logger", logger);
Guard.AgainstNullArgument("fileSystemMigrator", fileSystemMigrator);
_commandArgs = commandArgs;
_scriptArgs = scriptArgs;
_console = console;
_fileSystem = fileSystem;
_logger = logger;
_fileSystemMigrator = fileSystemMigrator;
_executeScriptCommand = new CrossAppDomainExecuteScriptCommand
{
CommandArgs = _commandArgs,
ScriptArgs = _scriptArgs,
};
}
public void ShouldPromptForInput(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var readLines = 0;
var builder = new StringBuilder();
var args = new ScriptCsArgs {
Repl = true
};
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
console.Setup(x => x.ReadLine()).Callback(() => readLines++).Throws(new Exception());
console.Setup(x => x.Write(It.IsAny <string>())).Callback <string>(value => builder.Append(value));
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
builder.ToString().EndsWith("> ").ShouldBeTrue();
readLines.ShouldEqual(1);
}
public void InstallCommandShouldInstallSinglePackageIfNamePassed(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IPackageInstaller> packageInstaller,
[Frozen] Mock <IPackageAssemblyResolver> resolver,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "mypackage",
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initializationServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initializationServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
var factory = fixture.Create <CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
packageInstaller.Verify(
i => i.InstallPackages(
It.Is <IEnumerable <IPackageReference> >(x => x.Count() == 1 && x.First().PackageId == "mypackage"),
It.IsAny <bool>()),
Times.Once());
}
public void WhenPassedAScript_ShouldPressedReplWithScript(
[Frozen] Mock <IScriptEngine> scriptEngine,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new ScriptCsArgs {
Repl = true, ScriptName = "test.csx",
};
scriptEngine.Setup(x => x.Execute(
"#load test.csx",
It.IsAny <string[]>(),
It.IsAny <AssemblyReferences>(),
It.IsAny <IEnumerable <string> >(),
It.IsAny <ScriptPackSession>()));
console.Setup(x => x.ReadLine()).Throws(new Exception());
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.Execute();
// assert
scriptEngine.Verify();
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IAssemblyUtility> assemblyUtility,
[Frozen] Mock <IScriptExecutor> executor,
CommandFactory factory)
{
// Arrange
const string NonManaged = "non-managed.dll";
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = "test.csx"
};
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
fileSystem.Setup(x => x.EnumerateFiles(It.IsAny <string>(), It.IsAny <string>(), SearchOption.AllDirectories))
.Returns(new[] { "managed.dll", NonManaged });
assemblyUtility.Setup(x => x.IsManagedAssembly(It.Is <string>(y => y == NonManaged))).Returns(false);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.Is <IEnumerable <string> >(x => !x.Contains(NonManaged)), It.IsAny <IEnumerable <IScriptPack> >()), Times.Once());
executor.Verify(i => i.Execute(It.Is <string>(x => x == "test.csx"), It.IsAny <string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void ShouldReturnErrorIfThereIsCompileException(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <ILog> logger,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx",
};
executor.Setup(i => i.Execute(It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(new ScriptResult(compilationException: new Exception("test")));
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
var result = sut.Execute();
// assert
result.ShouldEqual(CommandResult.Error);
logger.Verify(
i => i.ErrorFormat(It.IsAny <string>(), It.IsAny <Exception>(), It.IsAny <string>()), Times.Once());
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IAssemblyUtility> assemblyUtility,
[Frozen] Mock<IScriptExecutor> executor,
CommandFactory factory)
{
// Arrange
const string NonManaged = "non-managed.dll";
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "", ScriptName = "test.csx" };
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
fileSystem.Setup(x => x.EnumerateFiles(It.IsAny<string>(), It.IsAny<string>(), SearchOption.AllDirectories))
.Returns(new[] { "managed.dll", NonManaged });
assemblyUtility.Setup(x => x.IsManagedAssembly(It.Is<string>(y => y == NonManaged))).Returns(false);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.Is<IEnumerable<string>>(x => !x.Contains(NonManaged)), It.IsAny<IEnumerable<IScriptPack>>()), Times.Once());
executor.Verify(i => i.Execute(It.Is<string>(x => x == "test.csx"), It.IsAny<string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void InstallCommandShouldInstallSinglePackageIfNamePassed(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IPackageInstaller> packageInstaller,
[Frozen] Mock<IPackageAssemblyResolver> resolver,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "mypackage", };
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze<Mock<IScriptServicesBuilder>>();
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initializationServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initializationServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
var factory = fixture.Create<CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
packageInstaller.Verify(
i => i.InstallPackages(
It.Is<IEnumerable<IPackageReference>>(x => x.Count() == 1 && x.First().PackageId == "mypackage"),
It.IsAny<bool>()),
Times.Once());
}
public void ShouldPromptForInput(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IConsole> console,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var readLines = 0;
var builder = new StringBuilder();
var args = new ScriptCsArgs { Repl = true };
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
console.Setup(x => x.ReadLine()).Callback(() => readLines++).Throws(new Exception());
console.Setup(x => x.Write(It.IsAny<string>())).Callback<string>(value => builder.Append(value));
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
builder.ToString().EndsWith("> ").ShouldBeTrue();
readLines.ShouldEqual(1);
}
public void ShouldCopyFilesInPathIfLastWriteTimeDiffersFromLastWriteTimeOfFileInBin()
{
var args = new ScriptCsArgs { Restore = true, ScriptName = "" };
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, scriptpackResolver.Object, packageInstaller.Object);
const string CurrentDirectory = @"C:\";
var sourceFilePath = Path.Combine(CurrentDirectory, "fileName.cs");
var sourceWriteTime = new DateTime(2013, 3, 7);
var destFilePath = Path.Combine(CurrentDirectory, "bin", "fileName.cs");
var destWriteTime = new DateTime(2013, 2, 7);
fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory);
fs.Setup(x => x.GetLastWriteTime(sourceFilePath)).Returns(sourceWriteTime).Verifiable();
fs.Setup(x => x.GetLastWriteTime(destFilePath)).Returns(destWriteTime).Verifiable();
resolver.Setup(i => i.GetAssemblyNames(CurrentDirectory, It.IsAny<Action<string>>())).Returns(new[] { sourceFilePath });
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(x => x.Copy(sourceFilePath, destFilePath, true), Times.Once());
fs.Verify(x => x.GetLastWriteTime(sourceFilePath), Times.Once());
fs.Verify(x => x.GetLastWriteTime(destFilePath), Times.Once());
}
public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed(
[Frozen] Mock<IPackageInstaller> packageInstaller,
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IPackageAssemblyResolver> resolver,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs { AllowPreRelease = false, Install = string.Empty, };
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initializationServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initializationServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
resolver.Setup(i => i.GetPackages(It.IsAny<string>())).Returns(new List<IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.Execute();
// Assert
packageInstaller.Verify(i => i.InstallPackages(It.Is<IEnumerable<IPackageReference>>(x => x.Count() == 2), It.IsAny<bool>()), Times.Once());
}
public void WhenNotPassedAScript_ShouldNotCallTheEngineAutomatically(
[Frozen] Mock <IScriptEngine> scriptEngine,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs {
Repl = true
};
console.Setup(x => x.ReadLine()).Returns(() =>
{
console.Setup(x => x.ReadLine()).Throws(new Exception());
return(string.Empty);
});
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
scriptEngine.Verify(
x => x.Execute(It.IsAny <string>(), It.IsAny <string[]>(), It.IsAny <AssemblyReferences>(), It.IsAny <IEnumerable <string> >(), It.IsAny <ScriptPackSession>()), Times.Never());
}
public void ShouldDeletePackagesFolder(string folder,
Mock <IFileSystem> fileSystem,
Mock <IInitializationServices> initializationServices)
{
// Arrange
var args = new ScriptCsArgs {
Clean = true
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
fileSystem.Setup(i => i.DirectoryExists(It.Is <string>(x => x.Contains(folder)))).Returns(true);
fileSystem.Setup(i => i.GetWorkingDirectory(It.IsAny <string>())).Returns("c:\\");
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
var factory = fixture.Create <CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
fileSystem.Verify(i => i.DirectoryExists(It.Is <string>(x => x.Contains(folder))), Times.Once());
fileSystem.Verify(i => i.DeleteDirectory(It.Is <string>(x => x.Contains(folder))), Times.Once());
}
public void ShouldCreateBinFolderIfItDoesNotExist()
{
var args = new ScriptCsArgs { Restore = true, ScriptName = "" };
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, scriptpackResolver.Object, packageInstaller.Object);
const string CurrentDirectory = @"C:\";
const string BinFolder = @"C:\bin";
fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory);
var binFolderCreated = false;
fs.Setup(x => x.DirectoryExists(BinFolder)).Returns(() => binFolderCreated).Verifiable();
fs.Setup(x => x.CreateDirectory(BinFolder)).Callback(() => binFolderCreated = true).Verifiable();
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(x => x.DirectoryExists(BinFolder), Times.AtLeastOnce());
fs.Verify(x => x.CreateDirectory(BinFolder), Times.Once());
}
public void VersionCommandShouldOutputVersion()
{
var args = new ScriptCsArgs
{
Version = true
};
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
// clear the fake console output
_outputText.Clear();
result.Execute();
Assert.Contains("scriptcs version " + _currentVersion.ToString(), _outputText.ToString());
}
public void WhenPassedAScript_ShouldPressedReplWithScript(
[Frozen] Mock<IScriptEngine> scriptEngine,
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IConsole> console,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs { Repl = true, ScriptName = "test.csx" };
console.Setup(x => x.ReadLine()).Returns(() =>
{
console.Setup(x => x.ReadLine()).Throws(new Exception());
return string.Empty;
});
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
servicesBuilder.Setup(b => b.Build()).Returns(services);
//initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
scriptEngine.Setup(
x => x.Execute("#load test.csx", It.IsAny<string[]>(), It.IsAny<AssemblyReferences>(), It.IsAny<IEnumerable<string>>(), It.IsAny<ScriptPackSession>()));
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
scriptEngine.Verify();
}
public void ShouldReturnErrorIfTheScriptIsIncomplete(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <ILog> logger,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new ScriptCsArgs {
ScriptName = "test.csx"
};
executor.Setup(i => i.Execute(It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(ScriptResult.Incomplete);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
var result = sut.Execute();
// assert
result.ShouldEqual(CommandResult.Error);
logger.Verify(i => i.Error(It.IsAny <object>()), Times.Once());
}
public void ShouldDeletePackagesFolder(string folder,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs {
Clean = true
};
fileSystem.Setup(i => i.DirectoryExists(It.Is <string>(x => x.Contains(folder)))).Returns(true);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
fileSystem.Verify(i => i.DirectoryExists(It.Is <string>(x => x.Contains(folder))), Times.Once());
fileSystem.Verify(i => i.DeleteDirectory(It.Is <string>(x => x.Contains(folder))), Times.Once());
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IAssemblyUtility> assemblyUtility,
[Frozen] Mock<IScriptExecutor> executor,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
const string NonManaged = "non-managed.dll";
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "", ScriptName = "test.csx" };
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze<Mock<IScriptServicesBuilder>>();
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
fileSystem.Setup(x => x.EnumerateFiles(It.IsAny<string>(), It.IsAny<string>(), SearchOption.AllDirectories))
.Returns(new[] { "managed.dll", NonManaged });
assemblyUtility.Setup(x => x.IsManagedAssembly(It.Is<string>(y => y == NonManaged))).Returns(false);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = fixture.Create<CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.Is<IEnumerable<string>>(x => !x.Contains(NonManaged)), It.IsAny<IEnumerable<IScriptPack>>()), Times.Once());
executor.Verify(i => i.Execute(It.Is<string>(x => x == "test.csx"), It.IsAny<string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void ShouldNotDeleteBinFolderIfDllsAreLeft()
{
var args = new ScriptCsArgs {
Clean = true
};
var fs = new Mock <IFileSystem>();
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
fs.Setup(i => i.DirectoryExists(It.Is <string>(x => x.Contains(Constants.BinFolder)))).Returns(true);
fs.Setup(i => i.GetWorkingDirectory(It.IsAny <string>())).Returns("c:/");
fs.Setup(i => i.EnumerateFiles(It.IsAny <string>(), It.IsAny <string>())).Returns(new[] { "c:/file.dll", "c:/file2.dll" });
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(i => i.DeleteDirectory(It.Is <string>(x => x.Contains(Constants.BinFolder))), Times.Never());
}
public void ShouldDeletePackagesFolder()
{
var args = new ScriptCsArgs { Clean = true };
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var assemblyName = new Mock<IAssemblyName>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object, assemblyName.Object);
fs.Setup(i => i.DirectoryExists(It.Is<string>(x => x.Contains(Constants.PackagesFolder)))).Returns(true);
fs.Setup(i => i.GetWorkingDirectory(It.IsAny<string>())).Returns("c:\\");
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args, new string[0]);
result.Execute();
fs.Verify(i => i.DirectoryExists(It.Is<string>(x => x.Contains(Constants.PackagesFolder))), Times.Once());
fs.Verify(i => i.DeleteDirectory(It.Is<string>(x => x.Contains(Constants.PackagesFolder))), Times.Once());
}
public void InstallCommandShouldInstallSinglePackageIfNamePassed()
{
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "mypackage",
ScriptName = null
};
const string CurrentDirectory = @"C:\";
var fs = new Mock<IFileSystem>();
fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory);
fs.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
packageInstaller.Verify(i => i.InstallPackages(It.Is<IEnumerable<IPackageReference>>(x => x.Count() == 1 && x.First().PackageId == "mypackage"), It.IsAny<bool>(), It.IsAny<Action<string>>()), Times.Once());
}
public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed(
[Frozen] Mock <IPackageInstaller> packageInstaller,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IPackageAssemblyResolver> resolver,
[Frozen] Mock <IInitializationServices> initServices)
{
// Arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = null
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
fileSystem.Setup(x => x.GetWorkingDirectory(It.IsAny <string>())).Returns(CurrentDirectory);
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
initServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initServices.Object);
resolver.Setup(i => i.GetPackages(It.IsAny <string>())).Returns(new List <IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
var factory = fixture.Create <CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
packageInstaller.Verify(i => i.InstallPackages(It.Is <IEnumerable <IPackageReference> >(x => x.Count() == 2), It.IsAny <bool>()), Times.Once());
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = "test.csx"
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = fixture.Create <CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.IsAny <IEnumerable <string> >(), It.IsAny <IEnumerable <IScriptPack> >()), Times.Once());
executor.Verify(i => i.Execute(It.Is <string>(x => x == "test.csx"), It.IsAny <string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IPackageAssemblyResolver> resolver,
[Frozen] Mock <IPackageInstaller> packageInstaller,
CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = null
};
fileSystem.Setup(x => x.GetWorkingDirectory(It.IsAny <string>())).Returns(CurrentDirectory);
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
resolver.Setup(i => i.GetPackages(It.IsAny <string>())).Returns(new List <IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
packageInstaller.Verify(i => i.InstallPackages(It.Is <IEnumerable <IPackageReference> >(x => x.Count() == 2), It.IsAny <bool>(), It.IsAny <Action <string> >()), Times.Once());
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IAssemblyUtility> assemblyUtility,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
const string NonManaged = "non-managed.dll";
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = "test.csx"
};
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze <Mock <IScriptServicesBuilder> >();
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
fileSystem.Setup(x => x.EnumerateFiles(It.IsAny <string>(), It.IsAny <string>(), SearchOption.AllDirectories))
.Returns(new[] { "managed.dll", NonManaged });
assemblyUtility.Setup(x => x.IsManagedAssembly(It.Is <string>(y => y == NonManaged))).Returns(false);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = fixture.Create <CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.Is <IEnumerable <string> >(x => !x.Contains(NonManaged)), It.IsAny <IEnumerable <IScriptPack> >()), Times.Once());
executor.Verify(i => i.Execute(It.Is <string>(x => x == "test.csx"), It.IsAny <string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void InstallCommandShouldInstallSinglePackageIfNamePassed()
{
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "mypackage",
ScriptName = null
};
const string CurrentDirectory = @"C:\";
var fs = new Mock <IFileSystem>();
fs.Setup(x => x.GetWorkingDirectory(It.IsAny <string>())).Returns(CurrentDirectory);
fs.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
packageInstaller.Verify(i => i.InstallPackages(It.Is <IEnumerable <IPackageReference> >(x => x.Count() == 1 && x.First().PackageId == "mypackage"), It.IsAny <bool>(), It.IsAny <Action <string> >()), Times.Once());
}
public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed(
[Frozen] Mock<IPackageInstaller> packageInstaller,
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IPackageAssemblyResolver> resolver,
[Frozen] Mock<IInitializationServices> initServices)
{
// Arrange
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "", ScriptName = null };
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var servicesBuilder = fixture.Freeze<Mock<IScriptServicesBuilder>>();
fileSystem.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory);
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
initServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initServices.Object);
resolver.Setup(i => i.GetPackages(It.IsAny<string>())).Returns(new List<IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
var factory = fixture.Create<CommandFactory>();
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
packageInstaller.Verify(i => i.InstallPackages(It.Is<IEnumerable<IPackageReference>>(x => x.Count() == 2), It.IsAny<bool>()), Times.Once());
}
public void InstallCommandShouldInstallFromPackagesConfigIfNoNamePassed(
[Frozen] Mock <IPackageInstaller> packageInstaller,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IPackageAssemblyResolver> resolver,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// Arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = string.Empty,
};
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
initializationServices.Setup(i => i.GetPackageInstaller()).Returns(packageInstaller.Object);
initializationServices.Setup(i => i.GetPackageAssemblyResolver()).Returns(resolver.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
resolver.Setup(i => i.GetPackages(It.IsAny <string>())).Returns(new List <IPackageReference>
{
new PackageReference("a", new FrameworkName(".NETFramework,Version=v4.0"), new Version()),
new PackageReference("b", new FrameworkName(".NETFramework,Version=v4.0"), new Version())
});
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.Execute();
// Assert
packageInstaller.Verify(i => i.InstallPackages(It.Is <IEnumerable <IPackageReference> >(x => x.Count() == 2), It.IsAny <bool>()), Times.Once());
}
public void ShouldReturnErrorIfThereIsCompileException(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <ILog> logger,
CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx"
};
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
executor.Setup(i => i.Execute(It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(new ScriptResult {
CompileExceptionInfo = ExceptionDispatchInfo.Capture(new Exception("test"))
});
// Act
var result = factory.CreateCommand(args, new string[0]).Execute();
// Assert
result.ShouldEqual(CommandResult.Error);
logger.Verify(i => i.Error(It.IsAny <object>()), Times.Once());
}
public void ShouldDeleteAllFilesResolvedFromPackages()
{
var args = new ScriptCsArgs { Clean = true };
var fs = new Mock<IFileSystem>();
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
fs.Setup(i => i.DirectoryExists(It.Is<string>(x => x.Contains(Constants.BinFolder)))).Returns(true);
fs.Setup(i => i.GetWorkingDirectory(It.IsAny<string>())).Returns("c:\\");
fs.Setup(i => i.FileExists(It.IsAny<string>())).Returns(true);
resolver.Setup(i => i.GetAssemblyNames(It.IsAny<string>(), It.IsAny<Action<string>>())).Returns(new[] { "c:\\file.dll", "c:\\file2.dll" });
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(i => i.FileDelete(It.IsAny<string>()), Times.Exactly(2));
}
private static ScriptCsArgs ReconcileArguments(ScriptCsArgs globalConfigArgs, ScriptCsArgs localConfigArgs, ScriptCsArgs commandArgs, SplitResult splitResult)
{
if (globalConfigArgs == null && localConfigArgs == null)
{
return(commandArgs);
}
if (globalConfigArgs == null && commandArgs == null)
{
return(localConfigArgs);
}
if (localConfigArgs == null && commandArgs == null)
{
return(globalConfigArgs);
}
var reconciledArgs = new ScriptCsArgs();
foreach (var property in typeof(ScriptCsArgs).GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
var defaultValue = GetPropertyDefaultValue(property);
if (commandArgs != null)
{
var commandValue = property.GetValue(commandArgs);
if (!Equals(commandValue, defaultValue))
{
property.SetValue(reconciledArgs, commandValue);
continue;
}
if (IsCommandLinePresent(splitResult.CommandArguments, property))
{
property.SetValue(reconciledArgs, commandValue);
continue;
}
}
if (localConfigArgs != null)
{
var localConfigValue = property.GetValue(localConfigArgs);
if (!Equals(localConfigValue, defaultValue))
{
property.SetValue(reconciledArgs, localConfigValue);
continue;
}
}
if (globalConfigArgs != null)
{
var globalConfigValue = property.GetValue(globalConfigArgs);
if (!Equals(globalConfigValue, defaultValue))
{
property.SetValue(reconciledArgs, globalConfigValue);
}
}
}
return(reconciledArgs);
}
public void ShouldCreateMissingBinFolder()
{
const string WorkingDirectory = @"C:\";
var binFolder = Path.Combine(WorkingDirectory, "bin");
var args = new ScriptCsArgs { ScriptName = "test.csx" };
var fs = new Mock<IFileSystem>();
fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(WorkingDirectory);
fs.Setup(x => x.DirectoryExists(binFolder)).Returns(false);
var resolver = new Mock<IPackageAssemblyResolver>();
var executor = new Mock<IScriptExecutor>();
var engine = new Mock<IScriptEngine>();
var scriptpackResolver = new Mock<IScriptPackResolver>();
var packageInstaller = new Mock<IPackageInstaller>();
var logger = new Mock<ILog>();
var filePreProcessor = new Mock<IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
fs.Verify(x => x.CreateDirectory(binFolder), Times.Once());
}
public void VersionCommandShouldOutputVersion()
{
var args = new ScriptCsArgs
{
Version = true
};
var fs = new Mock <IFileSystem>();
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
// clear the fake console output
_outputText.Clear();
result.Execute();
Assert.Contains("scriptcs version " + _currentVersion.ToString(), _outputText.ToString());
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new ScriptCsArgs {
AllowPreRelease = false, Install = "", ScriptName = "test.csx",
};
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.Execute();
// assert
executor.Verify(
i => i.Initialize(
It.IsAny <IEnumerable <string> >(), It.IsAny <IEnumerable <IScriptPack> >()), Times.Once());
executor.Verify(
i => i.Execute(It.Is <string>(x => x == "test.csx"), It.IsAny <string[]>()), Times.Once());
executor.Verify(
i => i.Terminate(), Times.Once());
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs()
{
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx"
};
var fs = new Mock <IFileSystem>();
var resolver = new Mock <IPackageAssemblyResolver>();
var executor = new Mock <IScriptExecutor>();
var engine = new Mock <IScriptEngine>();
var scriptpackResolver = new Mock <IScriptPackResolver>();
var packageInstaller = new Mock <IPackageInstaller>();
var logger = new Mock <ILog>();
var filePreProcessor = new Mock <IFilePreProcessor>();
var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, engine.Object, filePreProcessor.Object, scriptpackResolver.Object, packageInstaller.Object, logger.Object);
var factory = new CommandFactory(root);
var result = factory.CreateCommand(args);
result.Execute();
executor.Verify(i => i.Execute(It.Is <string>(x => x == "test.csx"), It.IsAny <IEnumerable <string> >(), It.IsAny <IEnumerable <IScriptPack> >()), Times.Once());
}
public ScriptCsArgs Parse(string content)
{
if (!string.IsNullOrWhiteSpace(content))
{
var fromJson = ParseJson(content);
if (fromJson != null)
{
var arguments = new ScriptCsArgs();
var configFileValues = new Dictionary <string, string>(fromJson, StringComparer.InvariantCultureIgnoreCase);
foreach (var property in typeof(ScriptCsArgs).GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
string key = "";
if (configFileValues.ContainsKey(property.Name))
{
key = property.Name;
}
else
{
var attributes = property.GetCustomAttributes(false)
.ToDictionary(a => a.GetType().Name, a => a);
if (attributes.ContainsKey(typeof(ArgIgnoreAttribute).Name))
{
continue;
}
if (attributes.ContainsKey(typeof(ArgShortcut).Name))
{
var attribute = (attributes[typeof(ArgShortcut).Name] as ArgShortcut);
if (attribute != null)
{
if (string.IsNullOrEmpty(key) && configFileValues.ContainsKey(attribute.Shortcut))
{
key = attribute.Shortcut;
}
}
}
}
if (!string.IsNullOrEmpty(key))
{
string value = configFileValues[key];
var converter = TypeDescriptor.GetConverter(property.PropertyType);
var result = converter.ConvertFrom(value);
property.SetValue(arguments, result);
}
}
return(arguments);
}
}
return(null);
}
public ScriptCsArgs Parse(string[] args)
{
//no args initialized REPL
if (args == null || args.Length <= 0)
{
return new ScriptCsArgs {
Repl = true
}
}
;
ScriptCsArgs commandArgs = null;
const string unexpectedArgumentMessage = "unexpected named argument: ";
try
{
var installArgPosition = Array.FindIndex(args, x => x.ToLowerInvariant() == "-install");
string packageVersion = null;
if (installArgPosition == 0 && args.Length > 2 && !args[installArgPosition + 2].StartsWith("-"))
{
packageVersion = args[installArgPosition + 2];
var argsList = args.ToList();
argsList.RemoveAt(installArgPosition + 2);
args = argsList.ToArray();
}
commandArgs = Args.Parse <ScriptCsArgs>(args);
//if there is only 1 arg and it is a loglevel, it's also REPL
if (args.Length == 2 && args.Any(x => x.ToLowerInvariant() == "-loglevel" || x.ToLowerInvariant() == "-log"))
{
commandArgs.Repl = true;
}
if (!string.IsNullOrWhiteSpace(packageVersion))
{
commandArgs.PackageVersion = packageVersion;
}
}
catch (ArgException ex)
{
if (ex.Message.ToLower().StartsWith(unexpectedArgumentMessage))
{
var token = ex.Message.Substring(unexpectedArgumentMessage.Length);
_console.WriteLine(string.Format("Parameter \"{0}\" is not supported!", token));
}
else
{
_console.WriteLine(ex.Message);
}
}
return(commandArgs);
}
}
public void ShouldCleanWhenCleanFlagIsPassed()
{
var args = new ScriptCsArgs { Clean = true, ScriptName = null };
var factory = new CommandFactory(CreateRoot());
var result = factory.CreateCommand(args);
result.ShouldNotBeNull();
result.ShouldImplement<ICleanCommand>();
}
public void ShouldSetVersionIfPackageVersionNumberSpecifiedExplicitly()
{
string[] args = { "-install", "glimpse.scriptcs", "-packageversion", "1.0.1", "-pre" };
var result = ScriptCsArgs.Parse(args);
result.Install.ShouldEqual("glimpse.scriptcs");
result.PackageVersion.ShouldEqual("1.0.1");
result.AllowPreRelease.ShouldBeTrue();
}
public ScriptCsArgs Parse(string content)
{
if (!string.IsNullOrWhiteSpace(content))
{
var fromJson = ParseJson(content);
if (fromJson != null)
{
var arguments = new ScriptCsArgs();
var configFileValues = new Dictionary<string, string>(fromJson, StringComparer.InvariantCultureIgnoreCase);
foreach (var property in typeof(ScriptCsArgs).GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
string key = "";
var attributes = property.GetCustomAttributes(false)
.ToDictionary(a => a.GetType().Name, a => a);
if (attributes.ContainsKey(typeof(ArgIgnoreAttribute).Name))
continue;
if (attributes.ContainsKey(typeof(ArgShortcut).Name))
{
var attribute = (attributes[typeof(ArgShortcut).Name] as ArgShortcut);
if (attribute != null)
{
if (configFileValues.ContainsKey(property.Name))
{
key = property.Name;
}
if (string.IsNullOrEmpty(key) && configFileValues.ContainsKey(attribute.Shortcut))
{
key = attribute.Shortcut;
}
}
}
if (!string.IsNullOrEmpty(key))
{
string value = configFileValues[key];
var converter = TypeDescriptor.GetConverter(property.PropertyType);
var result = converter.ConvertFrom(value);
property.SetValue(arguments, result);
}
}
return arguments;
}
}
return null;
}
public void ShouldReturnHelpCommandWhenHelpIsPassed()
{
var args = new ScriptCsArgs
{
Help = true
};
var factory = new CommandFactory(CreateRoot());
var result = factory.CreateCommand(args);
result.ShouldImplement <IHelpCommand>();
}
public void ShouldExecuteWhenScriptNameIsPassed()
{
var args = new ScriptCsArgs
{
AllowPreReleaseFlag = false,
Install = null,
ScriptName = "test.csx"
};
var factory = new CommandFactory(CreateRoot());
var result = factory.CreateCommand(args);
result.ShouldImplement<IScriptCommand>();
}
public void VersionCommandShouldOutputVersion([Frozen] Mock<IConsole> console, CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs { Version = true };
var assembly = typeof(ScriptCsArgs).Assembly;
var currentVersion = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
console.Verify(x => x.WriteLine(It.Is<string>(y => y.Contains(currentVersion.ToString()))));
}
public void ShouldExecuteWhenBothNameAndInstallArePassed()
{
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = "",
ScriptName = "test.csx"
};
var factory = new CommandFactory(CreateRoot());
var result = factory.CreateCommand(args, new string[0]);
result.ShouldImplement<IScriptCommand>();
}
public void ShouldDeletePackagesFolder([Frozen] Mock<IFileSystem> fileSystem, CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs { Clean = true };
fileSystem.Setup(i => i.DirectoryExists(It.Is<string>(x => x.Contains(Constants.PackagesFolder)))).Returns(true);
fileSystem.Setup(i => i.GetWorkingDirectory(It.IsAny<string>())).Returns("c:\\");
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
fileSystem.Verify(i => i.DirectoryExists(It.Is<string>(x => x.Contains(Constants.PackagesFolder))), Times.Once());
fileSystem.Verify(i => i.DeleteDirectory(It.Is<string>(x => x.Contains(Constants.PackagesFolder))), Times.Once());
}
public void ShouldExecuteWhenScriptNameIsPassed()
{
// Arrange
var args = new ScriptCsArgs
{
AllowPreRelease = false,
Install = null,
ScriptName = "test.csx"
};
// Act
var factory = new CommandFactory(CreateBuilder());
var result = factory.CreateCommand(args, new string[0]);
// Assert
result.ShouldImplement<IScriptCommand>();
}
public void WhenNotPassedAScript_ShouldNotCallTheEngineAutomatically(
[Frozen] Mock<IScriptEngine> scriptEngine, [Frozen] Mock<IFileSystem> fileSystem, [Frozen] Mock<IConsole> console,
CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs { Repl = true };
console.Setup(x => x.ReadLine()).Returns(() => string.Empty);
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
scriptEngine.Verify(
x => x.Execute(It.IsAny<string>(), It.IsAny<string[]>(), It.IsAny<IEnumerable<string>>(), It.IsAny<IEnumerable<string>>(), It.IsAny<ScriptPackSession>()), Times.Never());
}
public void ScriptExecCommandShouldInvokeWithScriptPassedFromArgs(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IScriptExecutor> executor,
CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs { AllowPreRelease = false, Install = "", ScriptName = "test.csx" };
fileSystem.SetupGet(x => x.CurrentDirectory).Returns(CurrentDirectory);
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
executor.Verify(i => i.Initialize(It.IsAny<IEnumerable<string>>(), It.IsAny<IEnumerable<IScriptPack>>()), Times.Once());
executor.Verify(i => i.Execute(It.Is<string>(x => x == "test.csx"), It.IsAny<string[]>()), Times.Once());
executor.Verify(i => i.Terminate(), Times.Once());
}
public void ShouldInstallWhenInstallFlagIsOn()
{
var args = new ScriptCsArgs
{
AllowPreReleaseFlag = false,
Install = "",
ScriptName = null
};
var factory = new CommandFactory(CreateRoot());
var result = factory.CreateCommand(args);
var compositeCommand = result as ICompositeCommand;
compositeCommand.ShouldNotBeNull();
(compositeCommand.Commands[0] is IInstallCommand).ShouldBeTrue();
(compositeCommand.Commands[1] is IRestoreCommand).ShouldBeTrue();
}
public void WhenPassedAScript_ShouldPressedReplWithScript(
[Frozen] Mock<IScriptEngine> scriptEngine, [Frozen] Mock<IFileSystem> fileSystem,[Frozen] Mock<IConsole> console,
CommandFactory factory)
{
// Arrange
var args = new ScriptCsArgs { Repl = true, ScriptName = "test.csx"};
console.Setup(x => x.ReadLine()).Returns(() => string.Empty);
fileSystem.SetupGet(x => x.CurrentDirectory).Returns("C:\\");
scriptEngine.Setup(
x => x.Execute("#load test.csx", It.IsAny<string[]>(), It.IsAny<IEnumerable<string>>(), It.IsAny<IEnumerable<string>>(), It.IsAny<ScriptPackSession>()));
// Act
factory.CreateCommand(args, new string[0]).Execute();
// Assert
scriptEngine.Verify();
}
