public virtual void GenerateKeyFile(IProcessFactory processFactory, IPackageTree packageTree)
{
string strongKey = Path.Combine(packageTree.WorkingDirectory.FullName,
string.Format("{0}.snk", packageTree.Name));
string cmdLineArguments = string.Format("-k {0}", strongKey.QuotePath());
var PSI = new ProcessStartInfo("cmd.exe")
{
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false
};
var sn = GetSnExe(packageTree);
IProcess process = processFactory.GetProcess(sn.ToString().QuotePath(), cmdLineArguments, packageTree.WorkingDirectory.FullName);
while (true)
{
string line = process.GetLineOrOutput();
if (line == null)
{
break;
}
log.Info(line);
}
process.WaitForExit();
}
public virtual BuildEngine Build(IProcessFactory processFactory, IPackageTree packageTree, string mode)
{
if (builtPackages.ContainsKey(packageTree.Name))
{
return(this);
}
SetBuildMode(mode);
string pathToBuildFile = string.Format("{0}", GetBuildFilePath(packageTree).QuotePath());
if (GenerateStrongKey)
{
GenerateKeyFile(processFactory, packageTree);
}
CopyDependenciesTo(packageTree);
var cmdLineArguments = BuildTool.CommandLineArguments(pathToBuildFile, this, packageTree, Version);
var pathToBuildTool = string.Format("{0}", BuildTool.PathToBuildTool(packageTree, Version).QuotePath());
ProcessBuild(packageTree, processFactory, pathToBuildTool, cmdLineArguments);
CopyArtifactsToBuildDirectory(packageTree);
builtPackages.Add(packageTree.Name, packageTree.Name);
return(this);
}
protected override void Because()
{
rootBuildMetaData = CreateStub <IBuildMetaData>();
dependencyBuildMetaData = CreateStub <IBuildMetaData>();
var simpleDependency = new Dependency("simpleDependency", "simpleDependency.boo");
var rootDependency = new Dependency("root", "root.boo");
rootBuildMetaData.BuildEngine = new BuildEngine(new BuildToolStub(), "root.boo", Horn.Core.Utils.Framework.FrameworkVersion.FrameworkVersion35, CreateStub <IDependencyDispatcher>());
rootBuildMetaData.BuildEngine.Dependencies.Add(simpleDependency);
dependencyBuildMetaData.BuildEngine = new BuildEngine(new BuildToolStub(), "simpleDependency.boo", Utils.Framework.FrameworkVersion.FrameworkVersion35, CreateStub <IDependencyDispatcher>());
dependencyBuildMetaData.BuildEngine.Dependencies.Add(rootDependency);
packageTree = CreateStub <IPackageTree>();
packageTree.Stub(x => x.Name).Return("root");
packageTree.Stub(x => x.GetBuildMetaData("root")).Return(rootBuildMetaData);
dependentTree = CreateStub <IPackageTree>();
dependentTree.Stub(x => x.Name).Return("simpleDependency");
dependentTree.Stub(x => x.GetBuildMetaData("simpleDependency")).Return(dependencyBuildMetaData);
packageTree.Stub(x => x.RetrievePackage(simpleDependency)).Return(dependentTree);
packageTree.Stub(x => x.RetrievePackage(rootDependency)).Return(packageTree);
dependentTree.Stub(x => x.RetrievePackage(simpleDependency)).Return(dependentTree);
dependentTree.Stub(x => x.RetrievePackage(rootDependency)).Return(packageTree);
}
public IBuildMetaData GetBuildMetaData(IPackageTree packageTree, string buildFile)
{
if (factory == null)
throw new ArgumentNullException("You have not called SetDslFactory on class BooBuildConfigReader");
return CreateBuildMetaData(packageTree.CurrentDirectory, packageTree.FullName);
}
protected virtual void ProcessBuild(IPackageTree packageTree, IProcessFactory processFactory, string pathToBuildTool, string cmdLineArguments)
{
IProcess process = processFactory.GetProcess(pathToBuildTool, cmdLineArguments, packageTree.WorkingDirectory.FullName);
while (true)
{
string line = process.GetLineOrOutput();
if (line == null)
{
break;
}
log.Info(line);
}
try
{
process.WaitForExit();
}
catch (ProcessFailedException)
{
throw new BuildFailedException(string.Format("The build tool {0} failed building the {1} package", packageTree.BuildMetaData.BuildEngine.BuildTool, packageTree.Name));
}
}
public void Dispatch(IPackageTree packageTree, IList <Dependency> dependencies, string dependenciesRoot)
{
DirectoryInfo dependencyDirectory = GetDependencyDirectory(packageTree, dependenciesRoot);
if (dependencies.HasElements() && (!dependencyDirectory.Exists))
{
throw new DirectoryNotFoundException(string.Format("Package {0} cannot find folder {1} to resolve the dependencies",
packageTree.Name, dependencyDirectory.FullName));
}
foreach (Dependency dependency in dependencies)
{
IPackageTree packageForCurrentDependency = GetPackageForCurrentDependency(packageTree, dependency);
FileInfo[] sourceFiles = GetDependencyFiles(dependency, packageForCurrentDependency);
foreach (FileInfo nextFile in sourceFiles)
{
IEnumerable <string> dependencyPaths = dependentCopier.CopyDependency(nextFile, dependencyDirectory);
//we might still need this at some stage
//dependentUpdater.Execute(packageTree, dependencyPaths, dependency);
}
}
}
private BuildTree CalculateDependencies(IPackageTree packageTree, BuildTree currentTree)
{
if (currentTree == null)
{
currentTree = new BuildTree(packageTree);
}
else
{
if (HasACircularDependency(currentTree, packageTree))
{
throw new CircularDependencyException(packageTree.Name);
}
InsertDependenciesBeforeParent(currentTree, packageTree);
}
var buildMetaData = packageTree.GetBuildMetaData(packageTree.Name);
var buildEngine = buildMetaData.BuildEngine;
var dependencies = buildEngine.Dependencies;
foreach (var dependency in dependencies)
{
var package = packageTree.RetrievePackage(dependency);
if (package is NullPackageTree)
throw new UnknownInstallPackageException(string.Format("No package definition exists for dependent package {0}, which is required by {1}.", dependency.PackageName, packageTree.FullName));
CalculateDependencies(package, currentTree);
}
return currentTree;
}
public override string CheckOut(IPackageTree packageTree, FileSystemInfo destination)
{
SvnUpdateResult result = null;
using (var client = new SvnClient())
{
try
{
var svnOptions = new SvnCheckOutArgs();
if (UseRevision.HasValue)
svnOptions.Revision = new SvnRevision(UseRevision.Value);
client.CheckOut(new SvnUriTarget(new Uri(Url)), destination.FullName, svnOptions, out result);
}
catch (SvnRepositoryIOException sre)
{
HandleExceptions(sre);
}
catch (SvnObstructedUpdateException sue)
{
HandleExceptions(sue);
}
}
return result.Revision.ToString();
}
protected override void Before_each_spec()
{
textWriter = new StringWriter();
var parser = new SwitchParser(textWriter, args);
packageTree = TreeHelper.GetTempPackageTree();
var dependencyResolver = CreateStub <IDependencyResolver>();
sourceControl = new SourceControlDouble("http://someurl.com");
dependencyResolver.Stub(x => x.Resolve <IBuildConfigReader>()).Return(new BooBuildConfigReader());
dependencyResolver.Stub(x => x.Resolve <SVNSourceControl>()).Return(sourceControl);
IoC.InitializeWith(dependencyResolver);
get = MockRepository.GenerateStub <IGet>();
get.Stub(x => x.From(sourceControl)).Return(get);
get.Stub(x => x.ExportTo(packageTree)).Return(packageTree);
packageBuilder = new PackageBuilderStub(get, MockRepository.GenerateStub <IProcessFactory>(), parser.CommandArguments);
}
public virtual void OnCategoryCreated(IPackageTree packageTreeNode)
{
if (CategoryCreated != null)
{
CategoryCreated(packageTreeNode);
}
}
protected virtual void OnBuildNodeCreated(IPackageTree packageTree)
{
if (BuildNodeCreated != null)
{
BuildNodeCreated(packageTree);
}
}
public virtual void RetrieveSource(IPackageTree packageTree)
{
if (downloadedPackages.ContainsKey(packageTree.Name))
{
return;
}
if (!ShouldUpdate(packageTree))
{
downloadedPackages.Add(packageTree.Name, packageTree.Name);
return;
}
var revisionData = packageTree.GetRevisionData();
Initialise(packageTree);
SetMonitor(packageTree.WorkingDirectory.FullName);
Thread monitoringThread = StartMonitoring();
var revision = Download(packageTree, packageTree.WorkingDirectory, revisionData.Operation());
StopMonitoring(monitoringThread);
RecordCurrentRevision(packageTree, revision);
}
public override string CheckOut(IPackageTree packageTree, FileSystemInfo destination)
{
Settings.WorkingDir = destination.FullName;
try
{
if (!destination.Exists)
{
Directory.CreateDirectory(destination.FullName);
}
var result = RunGitCommand(GitCommands.GitCommands.CloneCmd(Url, destination.FullName, false).Replace("-v", ""));
if (BranchName != "master")
{
CreateAndTrackRemoteBranch(BranchName, destination);
}
}
catch (Exception ex)
{
HandleExceptions(ex);
}
return(CurrentRevisionNumber());
}
protected override void Before_each_spec()
{
textWriter = new StringWriter();
var parser = new SwitchParser(textWriter, args);
packageTree = TreeHelper.GetTempPackageTree();
var dependencyResolver = CreateStub<IDependencyResolver>();
sourceControl = new SourceControlDouble("http://someurl.com");
dependencyResolver.Stub(x => x.Resolve<IBuildConfigReader>()).Return(new BooBuildConfigReader());
dependencyResolver.Stub(x => x.Resolve<SVNSourceControl>()).Return(sourceControl);
IoC.InitializeWith(dependencyResolver);
get = MockRepository.GenerateStub<IGet>();
get.Stub(x => x.From(sourceControl)).Return(get);
get.Stub(x => x.ExportTo(packageTree)).Return(packageTree);
packageBuilder = new PackageBuilderStub(get, MockRepository.GenerateStub<IProcessFactory>(), parser.CommandArguments);
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
var path = Path.Combine(packageTree.Root.CurrentDirectory.FullName, "buildengines");
path = Path.Combine(path, "Phantom");
path = Path.Combine(path, "Phantom.exe");
return new FileInfo(path).FullName;
}
protected override void Before_each_spec()
{
sourceControlDouble = new SourceControlDouble("http://www.someurlorsomething.com/");
metaDataSynchroniser = new MetaDataSynchroniser(sourceControlDouble);
packageTreeBase = new PackageTree(metaDataSynchroniser);
}
public override string Update(IPackageTree packageTree, FileSystemInfo destination)
{
Console.WriteLine(string.Format("pulling {0} to {1}", packageTree.Name, destination.FullName));
revision = Guid.NewGuid().ToString();
return revision;
}
protected override void Before_each_spec()
{
sourceControlDouble = new SourceControlDouble("http://www.someurlorsomething.com/");
metaDataSynchroniser = new MetaDataSynchroniser(sourceControlDouble);
packageTreeBase = new PackageTree(metaDataSynchroniser);
}
public virtual void Initialise()
{
rootDirectory = fileSystemProvider.GetHornRootDirectory(HornConfig.Settings.HornRootDirectory);
metaDataSynchroniser.SynchronisePackageTree(new PackageTree(rootDirectory, null));
rootPackageTree = new PackageTree(rootDirectory, null);
}
public override string Update(IPackageTree packageTree, FileSystemInfo destination)
{
Console.WriteLine(string.Format("pulling {0} to {1}", packageTree.Name, destination.FullName));
revision = Guid.NewGuid().ToString();
return(revision);
}
public virtual FileInfo GetSnExe(IPackageTree packageTree)
{
var path = Path.Combine(packageTree.Root.CurrentDirectory.FullName, "buildengines");
path = Path.Combine(path, "Sn");
path = Path.Combine(path, "sn.exe");
return(new FileInfo(path));
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
var path = Path.Combine(packageTree.Root.CurrentDirectory.FullName, "buildengines");
path = Path.Combine(path, "Phantom");
path = Path.Combine(path, "Phantom.exe");
return(new FileInfo(path).FullName);
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree, FrameworkVersion version)
{
Console.WriteLine(pathToBuildFile);
Console.WriteLine(buildEngine);
Console.WriteLine(packageTree);
Console.WriteLine(version);
return string.Empty;
}
public IBuildMetaData GetBuildMetaData(IPackageTree packageTree, string buildFile)
{
if (factory == null)
{
throw new ArgumentNullException("You have not called SetDslFactory on class BooBuildConfigReader");
}
return(CreateBuildMetaData(packageTree.CurrentDirectory, packageTree.FullName));
}
public void Add(IPackageTree item)
{
if (BuildNodeCreated != null)
{
BuildNodeCreated(item);
}
throw new NullTreeException();
}
public override string Update(IPackageTree packageTree, FileSystemInfo destination)
{
Settings.WorkingDir = destination.FullName;
try
{
var processFactory = new DiagnosticsProcessFactory();
var git = Path.Combine(Settings.GitBinDir, "git.exe");
IProcess process = processFactory.GetProcess(git, "pull -v ", packageTree.WorkingDirectory.FullName);
while (true)
{
string line = process.GetLineOrOutput();
if (line == null)
{
break;
}
log.Info(line);
}
try
{
process.WaitForExit();
}
catch (ProcessFailedException)
{
throw new GitPullFailedException(string.Format("A git pull failed for the {0} package", packageTree.Name));
}
//Ensure we're on the right branch
if (!IsBranchCheckedOut(BranchName))
{
if (BranchExists(BranchName))
{
RunGitCommand(string.Format("checkout {0}", BranchName));
}
else
{
CreateAndTrackRemoteBranch(BranchName, destination);
}
}
//TODO: The following should work. Might be the way I set up msysgit?
//GitCommands.GitCommands.Pull("origin", "master", false);
}
catch (Exception ex)
{
HandleExceptions(ex);
}
return(CurrentRevisionNumber());
}
protected override void Because()
{
buildEngine = new BuildEngine(null, "", FrameworkVersion.FrameworkVersion35,
CreateStub <IDependencyDispatcher>());
buildEngine.BuildRootDirectory = "output";
packageTree = MockRepository.GenerateStub <IPackageTree>();
packageTree.Expect(pt => pt.WorkingDirectory).Return(new DirectoryInfo("C:\\temp"));
runner = new MSBuildBuildTool();
}
protected override void Before_each_spec()
{
base.Before_each_spec();
sourceControl = new SourceControlDouble("http://localhost/horn");
packageTree = new PackageTree(rootDirectory, null);
fileSystemProvider = CreateStub <IFileSystemProvider>();
}
public void Execute(IPackageTree packageTree, IEnumerable<string> dependencyPaths, Dependency dependency)
{
if (!HasADependencyToUpdate(dependencyPaths))
return;
InfoFormat("Dependency: Executing Dependency Updaters for {0}", packageTree.Name);
var dependentUpdaterContext = new DependentUpdaterContext(packageTree, dependencyPaths, dependency);
updaters.ForEach(updater => updater.Update(dependentUpdaterContext));
}
protected override void Because()
{
buildEngine = new BuildEngine(null, "", FrameworkVersion.FrameworkVersion35,
CreateStub<IDependencyDispatcher>());
buildEngine.BuildRootDirectory = "output";
packageTree = MockRepository.GenerateStub<IPackageTree>();
packageTree.Expect(pt => pt.WorkingDirectory).Return(new DirectoryInfo("C:\\temp"));
runner = new MSBuildBuildTool();
}
protected override void Before_each_spec()
{
base.Before_each_spec();
sourceControl = new SourceControlDouble("http://localhost/horn");
packageTree = new PackageTree(rootDirectory, null);
fileSystemProvider = CreateStub<IFileSystemProvider>();
}
public RevisionData(IPackageTree packageTree)
{
log.InfoFormat("Reading the current revision for {0}", packageTree.Name);
revisionFileInfo = GetRevisionFile(packageTree);
if (revisionFileInfo.Exists)
return;
revision = "0";
}
public virtual void BuildAndZipPackage(IPackageTree root, IFileSystemProvider fileSystemProvider, Package package, DirectoryInfo newDirectory, DirectoryInfo tempDirectory)
{
BuildPackage(package, newDirectory);
package.SetContents(root.Result);
DeleteOldZipFiles(newDirectory);
var zipFile = fileSystemProvider.ZipFolder(root.Result, newDirectory, package.FileName);
package.ZipFileName = new PackageFile(zipFile);
}
protected override void Because()
{
packageTree = CreateStub <IPackageTree>();
packageTree.Stub(x => x.WorkingDirectory).Return(new DirectoryInfo(@"C:\"));
buildToolStub = CreateStub <IBuildTool>();
buildEngine = new BuildEngine(buildToolStub, "deeper/than/this/somebuild.file", FrameworkVersion.FrameworkVersion35, CreateStub <IDependencyDispatcher>());
buildEngine.Build(new StubProcessFactory(), packageTree);
}
public static IEnumerable <IPackageTree> GetAllPackages(this IPackageTree parent)
{
foreach (var child in parent.Children)
{
yield return(child);
foreach (var descendant in child.GetAllPackages())
{
yield return(descendant);
}
}
}
public virtual void OnCategoryCreated(IPackageTree packageTreeNode)
{
if (packageTreeNode.CurrentDirectory.ContainsIllegalFiles())
{
return;
}
if (CategoryCreated != null)
{
CategoryCreated(packageTreeNode);
}
}
protected override void Because()
{
packageTree = CreateStub<IPackageTree>();
packageTree.Stub(x => x.WorkingDirectory).Return(new DirectoryInfo(@"C:\"));
buildToolStub = CreateStub<IBuildTool>();
buildEngine = new BuildEngine(buildToolStub, "deeper/than/this/somebuild.file", FrameworkVersion.FrameworkVersion35, CreateStub<IDependencyDispatcher>());
buildEngine.Build(new StubProcessFactory(), packageTree);
}
public virtual bool ShouldUpdate(IPackageTree packageTree)
{
string currentRevision = packageTree.GetRevisionData().Revision;
if (currentRevision == "0")
{
log.InfoFormat("Empty Repository");
return(true);
}
return(ShouldUpdate(currentRevision, packageTree));
}
protected override void Before_each_spec()
{
dependencyResolver = CreateStub<IDependencyResolver>();
dependencyResolver.Stub(x => x.Resolve<SVNSourceControl>()).Return(new SVNSourceControl(string.Empty));
IoC.InitializeWith(dependencyResolver);
factory = new DslFactory { BaseDirectory = DirectoryHelper.GetBaseDirectory() };
factory.Register<BooConfigReader>(new ConfigReaderEngine());
packageTree = MockRepository.GenerateStub<IPackageTree>();
}
protected override void Initialise(IPackageTree packageTree)
{
if (!packageTree.Root.Name.StartsWith(PackageTree.RootPackageTreeName))
{
throw new InvalidOperationException("The root of the package tree is not named .horn");
}
if (!packageTree.WorkingDirectory.Exists)
{
return;
}
}
public override string Update(IPackageTree packageTree, FileSystemInfo destination)
{
try
{
RunHGCommand("pull", destination.FullName);
}
catch (Exception ex)
{
HandleExceptions(ex);
}
return CurrentRevisionNumber(destination.FullName);
}
public virtual IRepositoryElement PrepareRepository(IPackageTree packageToExportTo, IGet get)
{
packageTreeToExportTo = packageToExportTo;
var root = packageToExportTo.Root;
var buildMetaData = root.GetBuildMetaData(RepositoryName);
repositoryTree = root.RetrievePackage(RepositoryName);
get.From(buildMetaData.SourceControl).ExportTo(repositoryTree);
return this;
}
public override string Update(IPackageTree packageTree, FileSystemInfo destination)
{
try
{
RunHGCommand("pull", destination.FullName);
}
catch (Exception ex)
{
HandleExceptions(ex);
}
return(CurrentRevisionNumber(destination.FullName));
}
public RevisionData(IPackageTree packageTree)
{
log.InfoFormat("Reading the current revision for {0}", packageTree.Name);
revisionFileInfo = GetRevisionFile(packageTree);
if (revisionFileInfo.Exists)
{
return;
}
revision = "0";
}
public virtual IBuildConfigReader SetDslFactory(IPackageTree packageTree)
{
PackageTree = packageTree;
factory = new DslFactory
{
BaseDirectory = packageTree.CurrentDirectory.FullName
};
factory.Register<BooConfigReader>(new ConfigReaderEngine());
return this;
}
public virtual IRepositoryElement PrepareRepository(IPackageTree packageToExportTo, IGet get)
{
packageTreeToExportTo = packageToExportTo;
var root = packageToExportTo.Root;
var buildMetaData = root.GetBuildMetaData(RepositoryName);
repositoryTree = root.RetrievePackage(RepositoryName);
get.From(buildMetaData.SourceControl).ExportTo(repositoryTree);
return(this);
}
protected override void Because()
{
packageTree = TreeHelper.GetTempPackageTree();
buildEngine = new BuildEngineStub(new BuildToolStub(), null, null);
buildEngine.BuildRootDirectory = "build";
working = packageTree.RetrievePackage("log4net").WorkingDirectory;
buildRoot = new DirectoryInfo(Path.Combine(working.FullName,
buildEngine.BuildRootDirectory));
}
public void Execute(IPackageTree packageTree, IEnumerable <string> dependencyPaths, Dependency dependency)
{
if (!HasADependencyToUpdate(dependencyPaths))
{
return;
}
InfoFormat("Dependency: Executing Dependency Updaters for {0}", packageTree.Name);
var dependentUpdaterContext = new DependentUpdaterContext(packageTree, dependencyPaths, dependency);
updaters.ForEach(updater => updater.Update(dependentUpdaterContext));
}
protected override void Before_each_spec()
{
dependencyResolver = CreateStub<IDependencyResolver>();
var environmentVariable = CreateStub<IEnvironmentVariable>();
environmentVariable.Stub(x => x.GetDirectoryFor("git.cmd")).Return(Environment.CurrentDirectory);
dependencyResolver.Stub(x => x.Resolve<GitSourceControl>()).Return(new GitSourceControl(environmentVariable));
IoC.InitializeWith(dependencyResolver);
factory = new DslFactory { BaseDirectory = DirectoryHelper.GetBaseDirectory() };
factory.Register<BooConfigReader>(new ConfigReaderEngine());
packageTree = MockRepository.GenerateStub<IPackageTree>();
}
protected virtual void BuildDependencyTree(IPackageTree packageTree, IDependencyTree dependencyTree)
{
foreach (var nextTree in dependencyTree)
{
IBuildMetaData nextMetaData = GetBuildMetaData(nextTree);
if (!commandArgs.RebuildOnly)
RetrieveSourceCode(nextMetaData, nextTree);
ExecutePrebuildCommands(nextMetaData, nextTree);
BuildSource(nextTree, nextMetaData);
}
}
public override string CheckOut(IPackageTree packageTree, FileSystemInfo destination)
{
try
{
if (!destination.Exists)
Directory.CreateDirectory(destination.FullName);
RunHGCommand(string.Format("{0} {1} {2}", "clone", Url, destination.FullName), destination.FullName);
}
catch (Exception ex)
{
HandleExceptions(ex);
}
return CurrentRevisionNumber(destination.FullName);
}
public Category(Category parent, IPackageTree packageTreeNode)
{
Categories = new List<Category>();
Packages = new List<Package>();
Name = packageTreeNode.Name;
Parent = parent;
foreach (var buildMetaData in packageTreeNode.GetAllPackageMetaData())
{
Packages.Add(new Package(this, buildMetaData));
}
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree,
FrameworkVersion version)
{
var cmdLine = new StringBuilder();
cmdLine.AppendFormat(
"{0} /p:OutputPath=\"{1}\" /p:TargetFrameworkVersion={2} /p:NoWarn=1591 /consoleloggerparameters:Summary",
pathToBuildFile.QuotePath(), Path.Combine(packageTree.WorkingDirectory.FullName, buildEngine.BuildRootDirectory),
GetFrameworkVersionForBuildTool(version));
AppendTasks(buildEngine, cmdLine);
AppendParameters(buildEngine, cmdLine);
return cmdLine.ToString();
}
public override void before_each_spec()
{
var dependencyResolver = MockRepository.GenerateStub<IDependencyResolver>();
fileSystemProvider = MockRepository.GenerateStub<IFileSystemProvider>();
packageBuilder = MockRepository.GenerateStub<IPackageCommand>();
rootPackageTree = MockRepository.GenerateStub<IPackageTree>();
buildMetaData = MockRepository.GenerateStub<IBuildMetaData>();
commandArgs = new CommandArgs("horn", false, null, false, null);
dependencyResolver.Stub(x => x.HasComponent<ICommandArgs>()).Return(true);
dependencyResolver.Stub(x => x.Resolve<ICommandArgs>()).Return(commandArgs);
dependencyResolver.Stub(x => x.Resolve<IPackageCommand>("install")
).Return(packageBuilder);
IoC.InitializeWith(dependencyResolver);
rootPackageTree.Stub(x => x.Result).Return(new DirectoryInfo(@"z:\horn"));
buildMetaData.ProjectInfo= new Dictionary<string, object>();
rootPackageTree.Stub(x => x.GetAllPackageMetaData()).Return(new List<IBuildMetaData> {buildMetaData});
rootPackageTree.Stub(x => x.Name).Return("horn");
var category = new Category(null, rootPackageTree);
fileSystemProvider.Stub(x => x.GetFiles(Arg<DirectoryInfo>.Is.TypeOf, Arg<string>.Is.TypeOf)).Return(
new List<FileInfo>
{
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 30).ToString(FileSystemProvider.FileDateFormat))),
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 29).ToString(FileSystemProvider.FileDateFormat))),
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 31).ToString(FileSystemProvider.FileDateFormat)))
}.ToArray());
package = new PackageDouble(category, buildMetaData);
string zipFileName = string.Format("{0}-{1}.zip", package.Name, DateTime.Now.ToString(FileSystemProvider.FileDateFormat));
fileSystemProvider.Stub(
x => x.ZipFolder(Arg<DirectoryInfo>.Is.TypeOf, Arg<DirectoryInfo>.Is.TypeOf, Arg<string>.Is.TypeOf)).
Return(new FileInfo(zipFileName));
}
protected string GetRootPath()
{
outputPath = CreateDirectory("Output");
workingPath = CreateDirectory("Working");
packageTree = MockRepository.GenerateStub<IPackageTree>();
packageTree.Stub(x => x.OutputDirectory).Return(new DirectoryInfo(outputPath));
packageTree.Stub(x => x.Result).Return(new DirectoryInfo(outputPath));
var executionBase = AppDomain.CurrentDomain.BaseDirectory;
return ResolveRootPath(executionBase);
}
protected virtual void ExecuteExportList(IBuildMetaData buildMetaData, IPackageTree componentTree)
{
if (!buildMetaData.ExportList.HasElements())
return;
var initialise = true;
foreach (var sourceControl in buildMetaData.ExportList)
{
log.InfoFormat("\nHorn is fetching {0}.\n\n".ToUpper(), sourceControl.Url);
get.From(sourceControl).ExportTo(componentTree, sourceControl.ExportPath, initialise);
initialise = false;
}
}
protected override void Because()
{
rootBuildMetaData = CreateStub<IBuildMetaData>();
dependencyBuildMetaData = CreateStub<IBuildMetaData>();
rootBuildMetaData.BuildEngine = new BuildEngine(new BuildToolStub(), "root.boo", Utils.Framework.FrameworkVersion.FrameworkVersion35, CreateStub<IDependencyDispatcher>());
rootBuildMetaData.BuildEngine.Dependencies.Add(new Dependency("simpleDependency", "simpleDependency"));
dependencyBuildMetaData.BuildEngine = new BuildEngine(new BuildToolStub(), "simpleDependency", Utils.Framework.FrameworkVersion.FrameworkVersion35, CreateStub<IDependencyDispatcher>());
packageTree = CreateStub<IPackageTree>();
packageTree.Stub(x => x.Name).Return("root");
packageTree.Stub(x => x.GetBuildMetaData("root")).Return(rootBuildMetaData);
dependentTree = new NullPackageTree();
packageTree.Stub(x => x.RetrievePackage(new Dependency("dependency", "dependency"))).IgnoreArguments().Return(dependentTree);
}
public virtual void Execute(IPackageTree packageTree)
{
Initialise();
LogPackageDetails();
if (!packageTree.BuildNodes().Select(x => x.Name).ToList().Contains(commandArgs.PackageName))
throw new UnknownInstallPackageException(string.Format("No package definition exists for {0}.", commandArgs.PackageName));
IPackageTree componentTree = packageTree.RetrievePackage(commandArgs);
IDependencyTree dependencyTree = GetDependencyTree(componentTree);
BuildDependencyTree(packageTree, dependencyTree);
log.InfoFormat("\nHorn has finished installing {0}.\n\n".ToUpper(), commandArgs.PackageName);
}
public override void BuildAndZipPackage(IPackageTree root, IFileSystemProvider fileSystemProvider, Package package, DirectoryInfo newDirectory, DirectoryInfo tempDirectory)
{
var tempFileName = Path.Combine(newDirectory.FullName, string.Format("{0}.txt", package.FileName));
fileSystemProvider.WriteTextFile(tempFileName, "some text");
var zip = fileSystemProvider.ZipFolder(newDirectory, newDirectory, package.FileName);
//fileSystemProvider.CopyFile(zip.FullName, zip.FullName, true);
try
{
fileSystemProvider.DeleteFile(tempFileName);
}
catch
{
}
}
private FileInfo[] GetDependencyFiles(Dependency dependency, IPackageTree packageForCurrentDependency)
{
DirectoryInfo dependencyDirectory = packageForCurrentDependency.Result;
var files = dependencyDirectory.GetFiles(string.Format("{0}.*", dependency.Library));
var ret = new List<FileInfo>();
files.ForEach(file =>
{
var extension =
Path.GetFileName(file.FullName).Substring(dependency.Library.Length);
if (AllowedExtensions.Contains(extension))
ret.Add(file);
});
return ret.ToArray();
}
