public void GitNotInstalledIfUpToDate()
{
using (var test = StartTest(withHttpServer: true))
{
var manifestFeed = $"http://localhost:{test.HttpServer.Port}/git/{GitInstaller.GitInstallDetails.ManifestName}";
var installDetails = new GitInstaller.GitInstallDetails(test.TestPath, test.Environment)
{
GitManifestFeed = manifestFeed
};
var gitInstaller = new GitInstaller(test.Platform, installDetails: installDetails);
var result = gitInstaller.RunSynchronously();
result.Should().NotBeNull();
var expectedInstallationPath = test.TestPath.Combine("Git");
Assert.AreEqual(expectedInstallationPath, result.GitInstallationPath);
result.GitExecutablePath.Should().Be(expectedInstallationPath.Combine("cmd", "git" + test.Environment.ExecutableExtension));
test.Environment.GitInstallationState = result;
gitInstaller = new GitInstaller(test.Platform, installDetails: installDetails);
var state = gitInstaller.VerifyGitSettings();
Assert.True(state.GitIsValid);
Assert.True(state.GitLfsIsValid);
}
}
public void GitInstallTest()
{
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, DefaultEnvironment.OnWindows)
{
GitZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipMd5Url).Filename}",
GitZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipUrl).Filename}",
GitLfsZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipMd5Url).Filename}",
GitLfsZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipUrl).Filename}",
};
TestBasePath.Combine("git").CreateDirectory();
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
var startTask = gitInstaller.SetupGitIfNeeded();
var endTask = new FuncTask <NPath, NPath>(TaskManager.Token, (s, path) => path);
startTask.OnEnd += (thisTask, path, success, exception) => thisTask.GetEndOfChain().Then(endTask);
startTask.Start();
NPath?resultPath = null;
Assert.DoesNotThrow(async() => resultPath = await endTask.Task);
resultPath.Should().NotBeNull();
}
public IntegrationTestEnvironment(ICacheContainer cacheContainer,
NPath repoPath,
NPath solutionDirectory,
CreateEnvironmentOptions options = null,
bool enableTrace = false,
bool initializeRepository = true)
{
this.enableTrace = enableTrace;
options = options ?? new CreateEnvironmentOptions(NPath.SystemTemp.Combine(ApplicationInfo.ApplicationName, "IntegrationTests"));
defaultEnvironment = new DefaultEnvironment(cacheContainer);
defaultEnvironment.FileSystem.SetCurrentDirectory(repoPath);
var environmentPath = options.UserProfilePath;
LocalAppData = environmentPath.Combine("User");
UserCachePath = LocalAppData.Combine("Cache");
CommonAppData = environmentPath.Combine("System");
SystemCachePath = CommonAppData.Combine("Cache");
var installPath = solutionDirectory.Parent.Parent.Parent.Combine("src", "com.unity.git.api", "Api");
Initialize(UnityVersion, installPath, solutionDirectory, NPath.Default, repoPath.Combine("Assets"));
InitializeRepository(initializeRepository ? (NPath?)repoPath : null);
GitDefaultInstallation = new GitInstaller.GitInstallDetails(UserCachePath, this);
if (enableTrace)
{
logger.Trace("EnvironmentPath: \"{0}\" SolutionDirectory: \"{1}\" ExtensionInstallPath: \"{2}\"",
environmentPath, solutionDirectory, ExtensionInstallPath);
}
}
public void GitLfsIsInstalledIfMissingWithCustomGitPath()
{
var tempZipExtractPath = TestBasePath.Combine("Temp", "git_zip_extract_zip_paths");
var customGitInstall = TestBasePath.Combine("CustomGitInstall").Combine(GitInstaller.GitInstallDetails.GitDirectory);
var gitZipUri = new UriString($"http://localhost:{server.Port}/unity/git/windows/git-slim.zip");
var downloader = new Downloader(Environment.FileSystem);
downloader.QueueDownload(gitZipUri, tempZipExtractPath);
downloader.RunSynchronously();
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
ZipHelper.Instance.Extract(tempZipExtractPath.Combine(gitZipUri.Filename), gitExtractPath, TaskManager.Token, null);
var source = gitExtractPath;
var target = customGitInstall;
target.DeleteIfExists();
target.EnsureParentDirectoryExists();
source.Move(target);
var gitExec = customGitInstall.Combine("cmd/git.exe");
var state = new GitInstaller.GitInstallationState();
state.GitExecutablePath = gitExec;
Environment.GitInstallationState = state;
var defaultGitInstall = TestBasePath.Combine("DefaultInstall");
var installDetails = new GitInstaller.GitInstallDetails(defaultGitInstall, DefaultEnvironment.OnWindows)
{
GitPackageFeed = "http://nope",
GitLfsPackageFeed = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitLfsPackageName}",
};
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails: installDetails);
state = gitInstaller.SetupGitIfNeeded();
state.Should().NotBeNull();
var gitLfsBasePath = defaultGitInstall.Combine(GitInstaller.GitInstallDetails.GitLfsDirectory);
var gitLfsExec = gitLfsBasePath.Combine("git-lfs.exe");
state.GitInstallationPath.Should().Be(customGitInstall);
state.GitExecutablePath.Should().Be(gitExec);
state.GitLfsInstallationPath.Should().Be(gitLfsExec.Parent);
state.GitLfsExecutablePath.Should().Be(gitLfsExec);
gitLfsExec.FileExists().Should().BeTrue();
Environment.GitInstallationState = state;
var procTask = new SimpleProcessTask(TaskManager.Token, "something")
.Configure(ProcessManager);
var pathList = procTask.Process.StartInfo.EnvironmentVariables["PATH"].ToNPathList(Environment).TakeWhile(x => x != "END");
pathList.First().Should().Be(gitLfsExec.Parent);
pathList.Skip(1).First().Should().Be(gitExec.Parent);
}
public void GitInstallWindows()
{
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, DefaultEnvironment.OnWindows)
{
GitZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipMd5Url).Filename}",
GitZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipUrl).Filename}",
GitLfsZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipMd5Url).Filename}",
GitLfsZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipUrl).Filename}",
};
TestBasePath.Combine("git").CreateDirectory();
var zipHelper = Substitute.For <IZipHelper>();
zipHelper.Extract(Arg.Any <string>(), Arg.Do <string>(x =>
{
var n = x.ToNPath();
n.EnsureDirectoryExists();
if (n.FileName == "git-lfs")
{
n.Combine("git-lfs" + Environment.ExecutableExtension).WriteAllText("");
}
}), Arg.Any <CancellationToken>(), Arg.Any <Func <long, long, bool> >()).Returns(true);
ZipHelper.Instance = zipHelper;
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
TaskCompletionSource <GitInstaller.GitInstallationState> end = new TaskCompletionSource <GitInstaller.GitInstallationState>();
var startTask = gitInstaller.SetupGitIfNeeded().Finally((_, state) => end.TrySetResult(state));
startTask.Start();
GitInstaller.GitInstallationState result = null;
Assert.DoesNotThrow(async() => result = await end.Task);
result.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath.Combine(installDetails.PackageNameWithVersion), result.GitInstallationPath);
result.GitExecutablePath.Should().Be(gitInstallationPath.Combine(installDetails.PackageNameWithVersion, "cmd", "git" + Environment.ExecutableExtension));
result.GitLfsExecutablePath.Should().Be(gitInstallationPath.Combine(installDetails.PackageNameWithVersion, "mingw32", "libexec", "git-core", "git-lfs" + Environment.ExecutableExtension));
var isCustomGitExec = result.GitExecutablePath != result.GitExecutablePath;
Environment.GitExecutablePath = result.GitExecutablePath;
Environment.GitLfsExecutablePath = result.GitLfsExecutablePath;
Environment.IsCustomGitExecutable = isCustomGitExec;
var procTask = new SimpleProcessTask(TaskManager.Token, "something")
.Configure(ProcessManager);
procTask.Process.StartInfo.EnvironmentVariables["PATH"].Should().StartWith(gitInstallationPath.ToString());
}
public void GitIsInstalledIfMissing()
{
GitInstaller.GitInstallDetails.GitPackageFeed = $"http://localhost:{server.Port}/{GitInstaller.GitInstallDetails.GitPackageName}";
var installDetails = new GitInstaller.GitInstallDetails(TestBasePath, Environment);
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails: installDetails);
var result = gitInstaller.RunSynchronously();
result.Should().NotBeNull();
var expectedInstallationPath = TestBasePath.Combine("Git");
Assert.AreEqual(expectedInstallationPath, result.GitInstallationPath);
result.GitExecutablePath.Should().Be(expectedInstallationPath.Combine("cmd", "git" + Environment.ExecutableExtension));
}
public void GitInstallWindows()
{
using (var test = StartTest(withHttpServer: true))
{
var gitInstallationPath = test.TestPath.Combine("GitInstall").CreateDirectory();
var manifestFeed = $"http://localhost:{test.HttpServer.Port}/git/{GitInstaller.GitInstallDetails.ManifestName}";
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, test.Environment)
{
GitManifestFeed = manifestFeed
};
test.TestPath.Combine("git").CreateDirectory();
var gitInstaller = new GitInstaller(test.Platform, installDetails: installDetails);
var zipHelper = Substitute.For <IZipHelper>();
zipHelper.Extract(Arg.Any <string>(), Arg.Do <string>(x =>
{
var n = x.ToSPath();
n.EnsureDirectoryExists();
if (n.FileName == "git")
{
n.Combine("git" + test.Environment.ExecutableExtension).WriteAllText("");
}
}), Arg.Any <Action <string, long> >(), Arg.Any <Func <long, long, string, bool> >(), Arg.Any <Func <string, bool> >(), Arg.Any <CancellationToken>()).Returns(true);
GitInstaller.GitInstallationState state = null;
try
{
ZipHelper.Instance = zipHelper;
state = gitInstaller.RunSynchronously();
}
finally
{
ZipHelper.Instance = null;
}
state.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath.Combine(GitInstaller.GitInstallDetails.GitDirectory), state.GitInstallationPath);
state.GitExecutablePath.Should().Be(gitInstallationPath.Combine(GitInstaller.GitInstallDetails.GitDirectory,
"cmd", "git" + test.Environment.ExecutableExtension));
test.Environment.GitInstallationState = state;
var procTask = new NativeProcessTask(test.TaskManager, test.ProcessManager, test.GitProcessEnvironment, "something", null);
procTask.Wrapper.StartInfo.EnvironmentVariables["PATH"].Should().StartWith(gitInstallationPath.ToString());
}
}
protected void SetupGit(NPath pathToSetupGitInto, string testName)
{
var autoResetEvent = new AutoResetEvent(false);
var installDetails = new GitInstaller.GitInstallDetails(pathToSetupGitInto, true);
var zipArchivesPath = pathToSetupGitInto.Combine("downloads").CreateDirectory();
Logger.Trace($"Saving git zips into {zipArchivesPath} and unzipping to {pathToSetupGitInto}");
AssemblyResources.ToFile(ResourceType.Platform, "git.zip", zipArchivesPath, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git.zip.md5", zipArchivesPath, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", zipArchivesPath, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip.md5", zipArchivesPath, Environment);
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
NPath? result = null;
Exception ex = null;
var setupTask = gitInstaller.SetupGitIfNeeded();
setupTask.OnEnd += (thisTask, _, __, ___) => {
((ITask <NPath>)thisTask.GetEndOfChain()).OnEnd += (t, path, success, exception) =>
{
result = path;
ex = exception;
autoResetEvent.Set();
};
};
setupTask.Start();
if (!autoResetEvent.WaitOne(TimeSpan.FromMinutes(5)))
{
throw new TimeoutException($"Test setup unzipping {zipArchivesPath} to {pathToSetupGitInto} timed out");
}
if (result == null)
{
if (ex != null)
{
throw ex;
}
throw new Exception("Did not install git");
}
Environment.GitExecutablePath = result.Value;
GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
}
public static void Menu_DownloadLatestDugite()
{
LogHelper.LogAdapter = new UnityLogAdapter();
var extensionInstallPath = Application.dataPath.ToSPath().Parent;
var unityEnv = TheEnvironment.instance.Environment;
var env = new ApplicationEnvironment(unityEnv);
env.Initialize(extensionInstallPath, unityEnv);
var platform = new Platform(env);
platform.Initialize();
env.InitializeRepository();
var installer = new GitInstaller.GitInstallDetails(env.RepositoryPath, env);
var manifest = DugiteReleaseManifest.Load(platform.TaskManager, installer.GitManifest, installer.GitManifestFeed, platform.Environment);
var cts = new CancellationTokenSource();
var downloader = new Downloader(platform.TaskManager, cts.Token);
var downloadPath = env.RepositoryPath.Combine("downloads");
foreach (var asset in manifest.Assets)
{
downloadPath.Combine(asset.Url.Filename).DeleteIfExists();
downloader.QueueDownload(asset.Url, downloadPath, retryCount: 3);
}
downloader.Progress(p => {
platform.TaskManager.RunInUI(() => {
if (EditorUtility.DisplayCancelableProgressBar(p.Message, p.InnerProgress?.InnerProgress?.Message ?? p.InnerProgress?.Message ?? p.Message,
p.Percentage))
{
cts.Cancel();
}
});
}).FinallyInUI((success, ex) => {
EditorUtility.ClearProgressBar();
if (success)
{
EditorUtility.DisplayDialog("Download done", downloadPath, "Ok");
}
else
{
EditorUtility.DisplayDialog("Error!", ex.GetExceptionMessageShort(), "Ok");
}
}).Start();
}
public static void Menu_DownloadLatestDugite()
{
LogHelper.LogAdapter = new UnityLogAdapter();
var unityAssetsPath = Application.dataPath;
var unityApplication = EditorApplication.applicationPath;
var unityApplicationContents = EditorApplication.applicationContentsPath;
var extensionInstallPath = Application.dataPath.ToNPath().Parent;
var unityVersion = Application.unityVersion;
var env = new DefaultEnvironment();
env.Initialize(unityVersion, extensionInstallPath, unityApplication.ToNPath(),
unityApplicationContents.ToNPath(), unityAssetsPath.ToNPath());
env.InitializeRepository();
TaskManager.Instance.Initialize(new UnityUIThreadSynchronizationContext());
var installer = new GitInstaller.GitInstallDetails(env.RepositoryPath, env);
var manifest = DugiteReleaseManifest.Load(installer.GitManifest, GitInstaller.GitInstallDetails.GitPackageFeed, env);
var downloader = new Downloader();
var downloadPath = env.RepositoryPath.Combine("downloads");
foreach (var asset in manifest.Assets)
{
downloadPath.Combine(asset.Url.Filename).DeleteIfExists();
downloader.QueueDownload(asset.Url, downloadPath, retryCount: 3);
}
downloader.Progress(p => {
TaskManager.Instance.RunInUI(() => {
if (EditorUtility.DisplayCancelableProgressBar(p.Message, p.InnerProgress?.InnerProgress?.Message ?? p.InnerProgress?.Message ?? p.Message,
p.Percentage))
{
downloader.Cancel();
}
});
}).FinallyInUI((success, ex) => {
EditorUtility.ClearProgressBar();
if (success)
{
EditorUtility.DisplayDialog("Download done", downloadPath, "Ok");
}
else
{
EditorUtility.DisplayDialog("Error!", ex.GetExceptionMessageOnly(), "Ok");
}
}).Start();
}
//[Test]
public void GitInstallMac()
{
var filesystem = Substitute.For <IFileSystem>();
DefaultEnvironment.OnMac = true;
DefaultEnvironment.OnWindows = false;
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, Environment.IsWindows)
{
GitZipMd5Url = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitZipMd5Url).AbsolutePath}",
GitZipUrl = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitZipUrl).AbsolutePath}",
GitLfsZipMd5Url = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitLfsZipMd5Url).AbsolutePath}",
GitLfsZipUrl = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitLfsZipUrl).AbsolutePath}",
};
TestBasePath.Combine("git").CreateDirectory();
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
var startTask = gitInstaller.SetupGitIfNeeded();
var endTask = new FuncTask <GitInstaller.GitInstallationState, GitInstaller.GitInstallationState>(TaskManager.Token, (s, state) => state);
startTask.OnEnd += (thisTask, path, success, exception) => thisTask.GetEndOfChain().Then(endTask);
startTask.Start();
GitInstaller.GitInstallationState result = null;
Assert.DoesNotThrow(async() => result = await endTask.Task);
result.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath.Combine(installDetails.PackageNameWithVersion), result.GitInstallationPath);
result.GitExecutablePath.Should().Be(gitInstallationPath.Combine("bin", "git" + Environment.ExecutableExtension));
result.GitLfsExecutablePath.Should().Be(gitInstallationPath.Combine(installDetails.PackageNameWithVersion, "libexec", "git-core", "git-lfs" + Environment.ExecutableExtension));
var isCustomGitExec = result.GitExecutablePath != result.GitExecutablePath;
Environment.GitExecutablePath = result.GitExecutablePath;
Environment.GitLfsExecutablePath = result.GitLfsExecutablePath;
Environment.IsCustomGitExecutable = isCustomGitExec;
var procTask = new SimpleProcessTask(TaskManager.Token, "something")
.Configure(ProcessManager);
procTask.Process.StartInfo.EnvironmentVariables["PATH"].Should().StartWith(gitInstallationPath.ToString());
}
public IntegrationTestEnvironment(SPath testPath, SPath sharedTestPath, string applicationName)
{
Guard.ArgumentNotNull(applicationName, nameof(applicationName));
ApplicationName = applicationName;
this.sharedTestEnvironmentPath = sharedTestPath.Combine("git-unity-test-environment").EnsureDirectoryExists();
this.testPath = testPath.Combine("SystemData").EnsureDirectoryExists();
LocalAppData = GetFolder(Folders.LocalApplicationData);
CommonAppData = GetFolder(Folders.CommonApplicationData);
UserCachePath = LocalAppData.Combine(applicationName).EnsureDirectoryExists();
SystemCachePath = CommonAppData.Combine(applicationName).EnsureDirectoryExists();
LogPath = GetFolder(Folders.Logs).Combine(applicationName).EnsureDirectoryExists().Combine(logFile);
GitDefaultInstallation = new GitInstaller.GitInstallDetails(sharedTestEnvironmentPath, this);
}
protected void SetupGit(NPath pathToSetupGitInto, string testName)
{
var installDetails = new GitInstaller.GitInstallDetails(pathToSetupGitInto, Environment.IsWindows);
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails);
var state = gitInstaller.SetDefaultPaths(new GitInstaller.GitInstallationState());
Environment.GitInstallationState = state;
GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
if (installDetails.GitExecutablePath.FileExists() && installDetails.GitLfsExecutablePath.FileExists())
{
return;
}
installDetails.GitInstallationPath.DeleteIfExists();
installDetails.GitZipPath.EnsureParentDirectoryExists();
installDetails.GitLfsZipPath.EnsureParentDirectoryExists();
AssemblyResources.ToFile(ResourceType.Platform, "git.zip", installDetails.GitZipPath.Parent, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git.json", installDetails.GitZipPath.Parent, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", installDetails.GitZipPath.Parent, Environment);
AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.json", installDetails.GitZipPath.Parent, Environment);
var tempZipExtractPath = TestBasePath.Combine("setup", "git_zip_extract_zip_paths").EnsureDirectoryExists();
var extractPath = tempZipExtractPath.Combine("git").CreateDirectory();
var path = new UnzipTask(TaskManager.Token, installDetails.GitZipPath, extractPath, null, Environment.FileSystem)
.Catch(e => true)
.RunSynchronously();
var source = path;
installDetails.GitInstallationPath.EnsureParentDirectoryExists();
source.Move(installDetails.GitInstallationPath);
extractPath = tempZipExtractPath.Combine("git-lfs").CreateDirectory();
path = new UnzipTask(TaskManager.Token, installDetails.GitLfsZipPath, extractPath, null, Environment.FileSystem)
.Catch(e => true)
.RunSynchronously();
installDetails.GitLfsInstallationPath.EnsureParentDirectoryExists();
path.Move(installDetails.GitLfsInstallationPath);
}
//[Test]
public void MacSkipsInstallWhenSettingsGitExists()
{
DefaultEnvironment.OnMac = true;
DefaultEnvironment.OnWindows = false;
var filesystem = Substitute.For <IFileSystem>();
filesystem.FileExists(Arg.Any <string>()).Returns(true);
filesystem.DirectoryExists(Arg.Any <string>()).Returns(true);
filesystem.DirectorySeparatorChar.Returns('/');
Environment.FileSystem = filesystem;
var gitInstallationPath = "/usr/local".ToNPath();
var gitExecutablePath = gitInstallationPath.Combine("bin/git");
var gitLfsInstallationPath = gitInstallationPath;
var gitLfsExecutablePath = gitLfsInstallationPath.Combine("bin/git-lfs");
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, Environment.IsWindows)
{
GitPackageFeed = $"http://localhost:{server.Port}/unity/git/mac/{GitInstaller.GitInstallDetails.GitPackageName}",
GitLfsPackageFeed = $"http://localhost:{server.Port}/unity/git/mac/{GitInstaller.GitInstallDetails.GitLfsPackageName}",
};
var ret = new string[] { gitLfsExecutablePath };
filesystem.GetFiles(Arg.Any <string>(), Arg.Is <string>(installDetails.GitLfsExecutablePath.FileName), Arg.Any <SearchOption>())
.Returns(ret);
var settings = Substitute.For <ISettings>();
var settingsRet = gitExecutablePath.ToString();
settings.Get(Arg.Is <string>(Constants.GitInstallPathKey), Arg.Any <string>()).Returns(settingsRet);
var installer = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails);
var result = installer.SetupGitIfNeeded();
Assert.AreEqual(gitInstallationPath, result.GitInstallationPath);
Assert.AreEqual(gitLfsInstallationPath, result.GitLfsInstallationPath);
Assert.AreEqual(gitExecutablePath, result.GitExecutablePath);
Assert.AreEqual(gitLfsExecutablePath, result.GitLfsExecutablePath);
}
public void GitInstallWindows()
{
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, DefaultEnvironment.OnWindows)
{
GitPackageFeed = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitPackageName}",
GitLfsPackageFeed = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitLfsPackageName}",
};
TestBasePath.Combine("git").CreateDirectory();
var zipHelper = Substitute.For <IZipHelper>();
zipHelper.Extract(Arg.Any <string>(), Arg.Do <string>(x =>
{
var n = x.ToNPath();
n.EnsureDirectoryExists();
if (n.FileName == "git-lfs")
{
n.Combine("git-lfs" + Environment.ExecutableExtension).WriteAllText("");
}
}), Arg.Any <CancellationToken>(), Arg.Any <Func <long, long, bool> >()).Returns(true);
ZipHelper.Instance = zipHelper;
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails: installDetails);
var state = gitInstaller.SetupGitIfNeeded();
state.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath.Combine(GitInstaller.GitInstallDetails.GitDirectory), state.GitInstallationPath);
state.GitExecutablePath.Should().Be(gitInstallationPath.Combine(GitInstaller.GitInstallDetails.GitDirectory, "cmd", "git" + Environment.ExecutableExtension));
state.GitLfsExecutablePath.Should().Be(gitInstallationPath.Combine(GitInstaller.GitInstallDetails.GitLfsDirectory, "git-lfs" + Environment.ExecutableExtension));
Environment.GitInstallationState = state;
var procTask = new SimpleProcessTask(TaskManager.Token, "something")
.Configure(ProcessManager);
procTask.Process.StartInfo.EnvironmentVariables["PATH"].Should().StartWith(gitInstallationPath.ToString());
}
protected void SetupGit(NPath pathToSetupGitInto, string testName)
{
var installDetails = new GitInstaller.GitInstallDetails(pathToSetupGitInto, Environment);
var state = installDetails.GetDefaults();
Environment.GitInstallationState = state;
GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
if (installDetails.GitExecutablePath.FileExists() && installDetails.GitLfsExecutablePath.FileExists())
{
return;
}
var key = installDetails.GitManifest.FileNameWithoutExtension + "_updatelastCheckTime";
Environment.UserSettings.Set(key, DateTimeOffset.Now);
var localCache = TestLocation.Combine("Resources");
localCache.CopyFiles(pathToSetupGitInto, true);
// skip checking for updates
state.GitPackage = DugiteReleaseManifest.Load(installDetails.GitManifest, GitInstaller.GitInstallDetails.GitPackageFeed, Environment);
var asset = state.GitPackage.DugitePackage;
state.GitZipPath = installDetails.ZipPath.Combine(asset.Name);
installDetails.GitInstallationPath.DeleteIfExists();
state.GitZipPath.EnsureParentDirectoryExists();
var gitExtractPath = TestBasePath.Combine("setup", "git_zip_extract_zip_paths").EnsureDirectoryExists();
var source = new UnzipTask(TaskManager.Token, state.GitZipPath, gitExtractPath, null, Environment.FileSystem)
.RunSynchronously();
installDetails.GitInstallationPath.EnsureParentDirectoryExists();
source.Move(installDetails.GitInstallationPath);
}
public void GitLfsIsInstalledIfMissing()
{
var tempZipExtractPath = TestBasePath.Combine("Temp", "git_zip_extract_zip_paths");
var gitInstallationPath = TestBasePath.Combine("GitInstall").Combine(GitInstaller.GitInstallDetails.GitDirectory);
var gitLfsInstallationPath = TestBasePath.Combine("GitInstall").Combine(GitInstaller.GitInstallDetails.GitLfsDirectory);
var gitZipUri = new UriString($"http://localhost:{server.Port}/unity/git/windows/git-slim.zip");
var downloader = new Downloader(Environment.FileSystem);
downloader.QueueDownload(gitZipUri, tempZipExtractPath);
downloader.RunSynchronously();
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
ZipHelper.Instance.Extract(tempZipExtractPath.Combine(gitZipUri.Filename), gitExtractPath, TaskManager.Token, null);
var source = gitExtractPath;
var target = gitInstallationPath;
target.DeleteIfExists();
target.EnsureParentDirectoryExists();
source.Move(target);
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath.Parent, DefaultEnvironment.OnWindows)
{
GitPackageFeed = "http://nope",
GitLfsPackageFeed = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitLfsPackageName}",
};
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails: installDetails);
var result = gitInstaller.SetupGitIfNeeded();
result.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath, result.GitInstallationPath);
result.GitExecutablePath.Should().Be(gitInstallationPath.Combine("cmd", "git" + Environment.ExecutableExtension));
result.GitLfsExecutablePath.Should().Be(gitLfsInstallationPath.Combine("git-lfs" + Environment.ExecutableExtension));
}
