private Repl GetRepl(string[] args, out MemoryBufferConsole memoryBufferConsole)
{
SetProfile();
var arguments = ParseArguments(args);
var scriptServicesBuilder = ScriptServicesBuilderFactory.Create(arguments.CommandArguments, arguments.ScriptArguments);
IInitializationServices _initializationServices = scriptServicesBuilder.InitializationServices;
IFileSystem _fileSystem = _initializationServices.GetFileSystem();
if (_fileSystem.PackagesFile == null)
{
throw new ArgumentException("The file system provided by the initialization services provided by the script services builder has a null packages file.");
}
if (_fileSystem.PackagesFolder == null)
{
throw new ArgumentException("The file system provided by the initialization services provided by the script services builder has a null package folder.");
}
ScriptServices scriptServices = scriptServicesBuilder.Build();
memoryBufferConsole = new MemoryBufferConsole();
Repl repl = new Repl(arguments.ScriptArguments, _fileSystem, scriptServices.Engine,
scriptServices.ObjectSerializer, scriptServices.Logger, memoryBufferConsole,
scriptServices.FilePreProcessor, scriptServices.ReplCommands);
var workingDirectory = _fileSystem.CurrentDirectory;
var assemblies = scriptServices.AssemblyResolver.GetAssemblyPaths(workingDirectory);
var scriptPacks = scriptServices.ScriptPackResolver.GetPacks();
repl.Initialize(assemblies, scriptPacks, null);
return(repl);
}
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 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 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 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());
}
private void ProcessScripts(ScriptServices services)
{
IList <Type> controllers = new List <Type>();
var packs = services.ScriptPackResolver.GetPacks().Union(new List <IScriptPack>()
{
new WebApiScriptHack()
});
services.Executor.Initialize(services.AssemblyResolver.GetAssemblyPaths(_scriptsPath, _scriptsPath), packs);
var scripts = services.FileSystem.EnumerateFiles(_scriptsPath, "*.csx", SearchOption.TopDirectoryOnly);
foreach (var script in scripts)
{
var result = services.Executor.Execute(script);
var resultType = result.ReturnValue as Type;
if (resultType != null)
{
if (resultType.IsSubclassOf(typeof(ApiController)))
{
controllers.Add(resultType);
}
}
}
var controllerResolver = new AssemblyControllerTypeResolver(controllers);
_configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerResolver);
}
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 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 ShouldPromptForInput(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var config = new Config {
Repl = true
};
console.Setup(x => x.ReadLine(It.IsAny <string>())).Returns((string)null);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(config, new string[0]);
// act
sut.Execute();
// assert
console.Verify(x => x.ReadLine("> "));
}
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 Config {
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 WhenNotPassedAScript_ShouldNotCallTheEngineAutomatically(
[Frozen] Mock <IScriptEngine> scriptEngine,
[Frozen] Mock <IConsole> console,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var config = new Config {
Repl = true
};
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(config, new string[0]);
// act
sut.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 ShouldReturnErrorIfTheScriptIsIncomplete(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] TestLogProvider logProvider,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new Config {
Eval = "foo"
};
executor.Setup(i => i.ExecuteScript(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);
logProvider.Output.ShouldContain("ERROR:");
}
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 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 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 Config {
AllowPreRelease = false, PackageName = 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 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 Config { AllowPreRelease = false, PackageName = 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 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 InstallCommandShouldInstallSinglePackageIfNamePassed(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IPackageInstaller> packageInstaller,
[Frozen] Mock <IPackageAssemblyResolver> resolver,
[Frozen] Mock <IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new Config {
AllowPreRelease = false, PackageName = "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 ShouldReturnErrorIfThereIsExecutionException(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] TestLogProvider logProvider,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new Config
{
AllowPreRelease = false,
PackageName = "",
ScriptName = "test.csx"
};
executor.Setup(i => i.Execute(It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(new ScriptResult(executionException: 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);
logProvider.Output.ShouldContain("ERROR:");
}
public void ShouldPromptForInput(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IConsole> console,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var config = new Config { Repl = true };
console.Setup(x => x.ReadLine(It.IsAny<string>())).Returns((string)null);
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(config, new string[0]);
// act
sut.Execute();
// assert
console.Verify(x=>x.ReadLine("> "));
}
private void StartScriptCs()
{
var name = "WPFScript.csx";
var console = new WPFConsoleRelay();
var configurator = new LoggerConfigurator(LogLevel.Info);
configurator.Configure(console);
var logger = configurator.GetLogger();
var init = new InitializationServices(logger);
init.GetAppDomainAssemblyResolver().Initialize();
var builder = new ScriptServicesBuilder(console, logger, null, null, init)
.Cache()
.Debug(false)
.LogLevel(LogLevel.Info)
.ScriptName(name)
.Repl();
var modules = new string[0];
var extension = Path.GetExtension(name);
//OVERRIDES
builder.ScriptHostFactory <WPFScriptHostFactory>();
builder.ScriptEngine <RoslynScriptEngine>();
builder.LoadModules(extension, modules);
//BUILD SERVICE
_service = builder.Build();
_service.Executor.Initialize(Enumerable.Empty <string>(), _service.ScriptPackResolver.GetPacks(), new string[0]);
var types = new Type[] {
typeof(IConsole),
typeof(ScriptContext),
typeof(Newtonsoft.Json.Converters.BinaryConverter)
};
_service.Executor.AddReferenceAndImportNamespaces(types);
EventAggr.Instance.GetEvent <WriteLineEvent>().Subscribe((text) =>
{
string[] lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
foreach (var line in lines.Where(l => !string.IsNullOrEmpty(l)))
{
_area.Document.Text += line;
NewLine();
_area.Document.Text += ">";
}
});
EventAggr.Instance.GetEvent <WriteEvent>().Subscribe((text) =>
{
_area.Document.Text += text;
}
);
}
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 InstallCommandShouldInstallSinglePackageIfNamePassed(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IPackageInstaller> packageInstaller,
[Frozen] Mock<IPackageAssemblyResolver> resolver,
[Frozen] Mock<IInitializationServices> initializationServices,
ScriptServices services)
{
// Arrange
var args = new Config { AllowPreRelease = false, PackageName = "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 ShouldDeletePackagesFolder(string folder,
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// Arrange
var args = new Config {
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 ShouldPromptForInput(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IConsole> console,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var config = new Config { Repl = true };
var readLines = 0;
var builder = new StringBuilder();
console.Setup(x => x.ReadLine()).Callback(() => readLines++).Throws(new Exception());
console.Setup(x => x.Write(It.IsAny<string>())).Callback<string>(value => builder.Append(value));
initializationServices.Setup(i => i.GetFileSystem()).Returns(fileSystem.Object);
servicesBuilder.SetupGet(b => b.InitializationServices).Returns(initializationServices.Object);
servicesBuilder.SetupGet(b => b.ConsoleInstance).Returns(console.Object);
servicesBuilder.Setup(b => b.Build()).Returns(services);
var factory = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(config, new string[0]);
// act
sut.Execute();
// assert
builder.ToString().EndsWith("> ").ShouldBeTrue();
readLines.ShouldEqual(1);
}
public ScriptCsHost()
{
var logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
var scriptServicesBuilder =
new ScriptServicesBuilder(new ScriptConsole(), logger).LogLevel(LogLevel.Info)
.Cache(false)
.Repl(false)
.ScriptEngine <RoslynScriptEngine>();
Root = scriptServicesBuilder.Build();
}
public HtmlExecuteReplCommand(string scriptName, string[] scriptArgs, ScriptServices scriptServices)
: this(scriptName,
scriptArgs,
scriptServices.FileSystem,
scriptServices.ScriptPackResolver,
scriptServices.Repl,
scriptServices.LogProvider,
scriptServices.Console,
scriptServices.AssemblyResolver,
scriptServices.FileSystemMigrator,
scriptServices.ScriptLibraryComposer)
{
}
private ScriptResult ExecuteScript(ScriptServices services, string loader)
{
var result = services.Executor.ExecuteScript(loader);
if (result.CompileExceptionInfo != null)
{
result.CompileExceptionInfo.Throw();
}
if (result.ExecuteExceptionInfo != null)
{
result.ExecuteExceptionInfo.Throw();
}
return(result);
}
private void InitRepl()
{
var servicesBuilder = new ReplScriptServicesBuilder(new ScriptConsole(), new Common.Logging.Simple.NoOpLogger()).Repl(true);
servicesBuilder.ScriptName("F14N.REPL");
this.scriptServices = servicesBuilder.Build();
this.scriptServices.Executor.Initialize(new string[] { }, this.scriptServices.ScriptPackResolver.GetPacks());
this.scriptServices.Executor.AddReferenceAndImportNamespaces(new[] { typeof(FluentAutomation.FluentTest), typeof(FluentAutomation.SeleniumWebDriver) });
this.repl = this.scriptServices.Executor as Repl;
this.settingsManager = new SettingsManager((scriptString) =>
{
return(this.repl.Execute(scriptString));
});
}
private async void AddButton_OnClick(object sender, RoutedEventArgs e)
{
var window = new ScriptServiceWindow(_dialogService);
var result = window.ShowDialog();
if (result.HasValue && result.Value)
{
var scriptService = new ScriptService();
scriptService.Name = window.ScriptName;
scriptService.Code = window.Code;
await _engine.InsertEntity(scriptService);
ScriptServices.Add(scriptService);
IsModified = true;
}
}
private static IScriptCommand CreateScriptCommand(
ScriptCsArgs args, string[] scriptArgs, ScriptServices scriptServices)
{
return(args.Watch
? (IScriptCommand) new WatchScriptCommand(
args,
scriptArgs,
scriptServices.Console,
scriptServices.FileSystem,
scriptServices.Logger)
: new ExecuteScriptCommand(
args.ScriptName,
scriptArgs,
scriptServices.FileSystem,
scriptServices.Executor,
scriptServices.ScriptPackResolver,
scriptServices.Logger,
scriptServices.AssemblyResolver));
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock <IFileSystem> fileSystem,
[Frozen] Mock <IAssemblyUtility> assemblyUtility,
[Frozen] Mock <IScriptExecutor> executor,
[Frozen] Mock <IInitializationServices> initializationServices,
[Frozen] Mock <IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
const string NonManaged = "non-managed.dll";
var args = new Config {
AllowPreRelease = false, PackageName = "", ScriptName = "test.csx",
};
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 = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.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());
}
private static IScriptCommand CreateScriptCommand(
Config config, string[] scriptArgs, ScriptServices scriptServices)
{
return(config.Watch
? (IScriptCommand) new WatchScriptCommand(
config,
scriptArgs,
scriptServices.Console,
scriptServices.FileSystem,
scriptServices.LogProvider)
: new ExecuteScriptCommand(
config.ScriptName,
scriptArgs,
scriptServices.FileSystem,
scriptServices.Executor,
scriptServices.ScriptPackResolver,
scriptServices.LogProvider,
scriptServices.AssemblyResolver,
scriptServices.ScriptLibraryComposer));
}
internal static IEnumerable <MetadataReference> MakeMetadataReferences(this ScriptServices scriptServices, IEnumerable <string> referencesPaths)
{
var listOfReferences = new List <MetadataReference>();
foreach (var importedReference in referencesPaths.Where(x => !x.ToLowerInvariant().Contains("scriptcs.contracts")))
{
if (scriptServices.FileSystem.IsPathRooted(importedReference))
{
if (scriptServices.FileSystem.FileExists(importedReference))
{
listOfReferences.Add(MetadataReference.CreateFromFile(importedReference));
}
}
else
{
listOfReferences.Add(MetadataReference.CreateFromFile(Path.Combine(BaseAssemblyPath, importedReference.ToLower().EndsWith(".dll") ? importedReference : importedReference + ".dll")));
}
}
return(listOfReferences);
}
public void NonManagedAssembliesAreExcluded(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IAssemblyUtility> assemblyUtility,
[Frozen] Mock<IScriptExecutor> executor,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
const string NonManaged = "non-managed.dll";
var args = new Config { AllowPreRelease = false, PackageName = "", ScriptName = "test.csx", };
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 = new CommandFactory(servicesBuilder.Object);
var sut = factory.CreateCommand(args, new string[0]);
// act
sut.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 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 ScriptCsExtension(ScriptCsOptions options)
{
this.options = options;
var console = (IConsole) new ScriptConsole();
var logProvider = new ColoredConsoleLogProvider(LogLevel.Info, console);
var builder = new ScriptServicesBuilder(console, logProvider);
//var useMono = Type.GetType("Mono.Runtime") != null;
//if (useMono)
//{
// builder.ScriptEngine<MonoScriptEngine>();
//}
//else {
builder.ScriptEngine <CSharpScriptEngine>();
//}
scriptServices = builder.Build();
scriptExecutor = (ScriptExecutor)scriptServices.Executor;
scriptExecutor.Initialize(Enumerable.Empty <string>(), Enumerable.Empty <IScriptPack>());
}
public void ShouldReturnErrorIfThereIsExecutionException(
[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(executionException: 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 CommandFactory(ScriptServices scriptServices)
{
_scriptServices = scriptServices;
}
private static IScriptCommand CreateScriptCommand(
Config config, string[] scriptArgs, ScriptServices scriptServices)
{
return config.Watch
? (IScriptCommand)new WatchScriptCommand(
config,
scriptArgs,
scriptServices.Console,
scriptServices.FileSystem,
scriptServices.LogProvider,
scriptServices.FileSystemMigrator)
: new ExecuteScriptCommand(
config.ScriptName,
scriptArgs,
scriptServices.FileSystem,
scriptServices.Executor,
scriptServices.ScriptPackResolver,
scriptServices.LogProvider,
scriptServices.AssemblyResolver,
scriptServices.FileSystemMigrator,
scriptServices.ScriptLibraryComposer);
}
public void ShouldResolveScriptServices(ScriptServices scriptServices, [Frozen] Mock<IRuntimeServices> runtimeServicesMock, ScriptServicesBuilder builder)
{
runtimeServicesMock.Setup(r => r.GetScriptServices()).Returns(scriptServices);
builder.Overrides[typeof(IScriptEngine)] = null;
builder.Build().ShouldEqual(scriptServices);
}
public CommandFactory(ScriptServices scriptServices)
{
_scriptServices = scriptServices;
}
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 WhenNotPassedAScript_ShouldNotCallTheEngineAutomatically(
[Frozen] Mock<IScriptEngine> scriptEngine,
[Frozen] Mock<IConsole> console,
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var config = new Config { Repl = true };
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(config, new string[0]);
// act
sut.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 ShouldReturnErrorIfTheScriptIsIncomplete(
[Frozen] Mock<IFileSystem> fileSystem,
[Frozen] Mock<IScriptExecutor> executor,
[Frozen] TestLogProvider logProvider,
[Frozen] Mock<IInitializationServices> initializationServices,
[Frozen] Mock<IScriptServicesBuilder> servicesBuilder,
ScriptServices services)
{
// arrange
var args = new Config { 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);
logProvider.Output.ShouldContain("ERROR:");
}
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 Config { AllowPreRelease = false, PackageName = "", 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());
}
private static IScriptCommand CreateScriptCommand(
ScriptCsArgs args, string[] scriptArgs, ScriptServices scriptServices)
{
return args.Watch
? (IScriptCommand)new WatchScriptCommand(
args,
scriptArgs,
scriptServices.Console,
scriptServices.FileSystem,
scriptServices.Logger)
: (IScriptCommand)new ExecuteScriptCommand(
args.ScriptName,
scriptArgs,
scriptServices.FileSystem,
scriptServices.Executor,
scriptServices.ScriptPackResolver,
scriptServices.Logger,
scriptServices.AssemblyResolver);
}
