protected void InitializeEnvironment(NPath repoPath,
bool enableEnvironmentTrace = false,
bool initializeRepository = true
)
{
var cacheContainer = new CacheContainer();
cacheContainer.SetCacheInitializer(CacheType.Branches, () => BranchesCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitAheadBehind, () => GitAheadBehindCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitLocks, () => GitLocksCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitLog, () => GitLogCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitStatus, () => GitStatusCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitUser, () => GitUserCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.RepositoryInfo, () => RepositoryInfoCache.Instance);
var environment = new IntegrationTestEnvironment(cacheContainer,
repoPath,
SolutionDirectory,
enableTrace: enableEnvironmentTrace,
initializeRepository: initializeRepository);
environment.NodeJsExecutablePath = TestApp;
environment.OctorunScriptPath = TestApp;
Environment = environment;
}
public void TaskFailsWhenMD5Incorect()
{
InitializeTaskManager();
var cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory);
var destinationPath = TestBasePath.Combine("git_zip").CreateDirectory();
var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", destinationPath, Environment);
var extractedPath = TestBasePath.Combine("git_zip_extracted").CreateDirectory();
var failed = false;
Exception exception = null;
var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, Environment.FileSystem, "AABBCCDD")
.Finally((b, ex) => {
failed = true;
exception = ex;
});
unzipTask.Start().Wait();
extractedPath.DirectoryExists().Should().BeFalse();
failed.Should().BeTrue();
exception.Should().NotBeNull();
exception.Should().BeOfType <UnzipTaskException>();
}
public void TaskSucceeds()
{
InitializeTaskManager();
var cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory);
var destinationPath = TestBasePath.Combine("git_zip").CreateDirectory();
var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", destinationPath, Environment);
var extractedPath = TestBasePath.Combine("git_zip_extracted").CreateDirectory();
var zipProgress = 0;
Logger.Trace("Pct Complete {0}%", zipProgress);
var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, Environment.FileSystem, GitInstallDetails.GitExtractedMD5,
new Progress <float>(zipFileProgress => {
var zipFileProgressInteger = (int)(zipFileProgress * 100);
if (zipProgress != zipFileProgressInteger)
{
zipProgress = zipFileProgressInteger;
Logger.Trace("Pct Complete {0}%", zipProgress);
}
}));
unzipTask.Start().Wait();
extractedPath.DirectoryExists().Should().BeTrue();
}
protected async Task <IEnvironment> Initialize(NPath repoPath, NPath environmentPath = null,
bool enableEnvironmentTrace = false, bool initializeRepository = true, Action <RepositoryManager> onRepositoryManagerCreated = null)
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
//TODO: Mock CacheContainer
ICacheContainer cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, repoPath, SolutionDirectory, environmentPath, enableEnvironmentTrace);
var gitSetup = new GitInstaller(Environment, TaskManager.Token);
await gitSetup.SetupIfNeeded();
Environment.GitExecutablePath = gitSetup.GitExecutablePath;
Platform = new Platform(Environment);
GitEnvironment = Platform.GitEnvironment;
ProcessManager = new ProcessManager(Environment, GitEnvironment, TaskManager.Token);
Platform.Initialize(ProcessManager, TaskManager);
GitClient = new GitClient(Environment, ProcessManager, TaskManager);
var repositoryManager = GitHub.Unity.RepositoryManager.CreateInstance(Platform, TaskManager, GitClient, repoPath);
onRepositoryManagerCreated?.Invoke(repositoryManager);
RepositoryManager = repositoryManager;
RepositoryManager.Initialize();
if (initializeRepository)
{
Environment.Repository = new Repository(repoPath, cacheContainer);
Environment.Repository.Initialize(RepositoryManager);
}
RepositoryManager.Start();
DotGitPath = repoPath.Combine(".git");
if (DotGitPath.FileExists())
{
DotGitPath =
DotGitPath.ReadAllLines()
.Where(x => x.StartsWith("gitdir:"))
.Select(x => x.Substring(7).Trim().ToNPath())
.First();
}
BranchesPath = DotGitPath.Combine("refs", "heads");
RemotesPath = DotGitPath.Combine("refs", "remotes");
DotGitIndex = DotGitPath.Combine("index");
DotGitHead = DotGitPath.Combine("HEAD");
DotGitConfig = DotGitPath.Combine("config");
return(Environment);
}
protected async Task <IEnvironment> Initialize(NPath repoPath, NPath environmentPath = null,
bool enableEnvironmentTrace = false)
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
Environment = new IntegrationTestEnvironment(repoPath, SolutionDirectory, environmentPath, enableEnvironmentTrace);
var gitSetup = new GitInstaller(Environment, TaskManager.Token);
await gitSetup.SetupIfNeeded();
Environment.GitExecutablePath = gitSetup.GitExecutablePath;
Platform = new Platform(Environment);
GitEnvironment = Platform.GitEnvironment;
ProcessManager = new ProcessManager(Environment, GitEnvironment, TaskManager.Token);
Platform.Initialize(ProcessManager, TaskManager);
GitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
var usageTracker = new NullUsageTracker();
var repositoryManagerFactory = new RepositoryManagerFactory();
RepositoryManager = repositoryManagerFactory.CreateRepositoryManager(Platform, TaskManager, usageTracker, GitClient, repoPath);
await RepositoryManager.Initialize();
RepositoryManager.Start();
Environment.Repository = RepositoryManager.Repository;
DotGitPath = repoPath.Combine(".git");
if (DotGitPath.FileExists())
{
DotGitPath =
DotGitPath.ReadAllLines()
.Where(x => x.StartsWith("gitdir:"))
.Select(x => x.Substring(7).Trim().ToNPath())
.First();
}
BranchesPath = DotGitPath.Combine("refs", "heads");
RemotesPath = DotGitPath.Combine("refs", "remotes");
DotGitIndex = DotGitPath.Combine("index");
DotGitHead = DotGitPath.Combine("HEAD");
DotGitConfig = DotGitPath.Combine("config");
return(Environment);
}
protected void InitializeEnvironment(NPath repoPath,
NPath environmentPath = null,
bool enableEnvironmentTrace = false,
bool initializeRepository = true
)
{
CacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(CacheContainer,
repoPath,
SolutionDirectory,
environmentPath,
enableEnvironmentTrace,
initializeRepository);
}
protected async Task InitializePlatform(NPath repoPath, NPath environmentPath, bool enableEnvironmentTrace)
{
InitializeTaskManager();
CacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(CacheContainer, repoPath, SolutionDirectory, environmentPath,
enableEnvironmentTrace);
var gitSetup = new GitInstaller(Environment, TaskManager.Token);
await gitSetup.SetupIfNeeded();
Environment.GitExecutablePath = gitSetup.GitExecutablePath;
Platform = new Platform(Environment);
GitEnvironment = Platform.GitEnvironment;
ProcessManager = new ProcessManager(Environment, GitEnvironment, TaskManager.Token);
Platform.Initialize(ProcessManager, TaskManager);
GitClient = new GitClient(Environment, ProcessManager, TaskManager);
}
protected void InitializeEnvironment(NPath repoPath,
NPath?environmentPath = null,
bool enableEnvironmentTrace = false,
bool initializeRepository = true
)
{
var cacheContainer = new CacheContainer();
cacheContainer.SetCacheInitializer(CacheType.Branches, () => BranchesCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitAheadBehind, () => GitAheadBehindCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitLocks, () => GitLocksCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitLog, () => GitLogCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitStatus, () => GitStatusCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.GitUser, () => GitUserCache.Instance);
cacheContainer.SetCacheInitializer(CacheType.RepositoryInfo, () => RepositoryInfoCache.Instance);
Environment = new IntegrationTestEnvironment(cacheContainer,
repoPath,
SolutionDirectory,
environmentPath,
enableEnvironmentTrace,
initializeRepository);
}
public async Task UnzipWorks()
{
var cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory);
InitializeTaskManager();
var destinationPath = TestBasePath.Combine("gitlfs_zip").CreateDirectory();
var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", destinationPath, Environment);
var extractedPath = TestBasePath.Combine("gitlfs_zip_extracted").CreateDirectory();
var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath,
ZipHelper.Instance,
Environment.FileSystem)
.Progress(p =>
{
});
await unzipTask.StartAwait();
extractedPath.DirectoryExists().Should().BeTrue();
}
public async Task UnzipWorks()
{
var cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory, new CreateEnvironmentOptions(TestBasePath));
InitializeTaskManager();
var expectedContent = @"Yup this is
{
good énough
}
".Replace("\r\n", "\n");
var destinationPath = TestBasePath.Combine("unziptests").CreateDirectory();
var localCache = TestLocation.Combine("UnzipTestResources");
var archiveFilePath = localCache.Combine("testfile.zip");
var extractedPath = TestBasePath.Combine("zipextract").CreateDirectory();
var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath,
ZipHelper.Instance,
Environment.FileSystem);
await unzipTask.StartAwait();
var expectedFile = extractedPath.Combine("embedded-git.json");
expectedFile.Parent.DirectoryExists().Should().BeTrue();
expectedFile.FileExists().Should().BeTrue();
var actualContent = expectedFile.ReadAllText();
actualContent.Should().Be(expectedContent);
extractedPath = TestBasePath.Combine("tgzextract").CreateDirectory();
archiveFilePath = localCache.Combine("testfile.tgz");
unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath,
ZipHelper.Instance,
Environment.FileSystem);
await unzipTask.StartAwait();
expectedFile = extractedPath.Combine("embedded-git.json");
expectedFile.Parent.DirectoryExists().Should().BeTrue();
expectedFile.FileExists().Should().BeTrue();
expectedFile.ReadAllText().Should().Be(expectedContent);
extractedPath = TestBasePath.Combine("targzextract").CreateDirectory();
archiveFilePath = localCache.Combine("testfile.tar.gz");
unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath,
ZipHelper.Instance,
Environment.FileSystem);
await unzipTask.StartAwait();
expectedFile = extractedPath.Combine("embedded-git.json");
expectedFile.Parent.DirectoryExists().Should().BeTrue();
expectedFile.FileExists().Should().BeTrue();
expectedFile.ReadAllText().Should().Be(expectedContent);
}
