public void OverwriteFiles()
{
sp.SourceFile = Path.Combine(inputPath, @"testzip.zip");
Options opt = new Options()
{
DestinationFileExistsAction = FileExistAction.Overwrite,
CreateDestinationDirectory = true
};
dp.DirectoryPath = Path.Combine(dp.DirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory"));
//extract testzip.zip
Unzip.Output output = UnzipTask.ExtractArchive(sp, dp, opt, new CancellationToken());
//read first line from each file
var lines = Directory.EnumerateFiles(dp.DirectoryPath, "*", SearchOption.AllDirectories).Select(x => File.ReadLines(x).First()).ToList();
Assert.True(lines.Contains("First file") && lines.Contains("Second file") && lines.Contains("Third file"));
sp.SourceFile = Path.Combine(inputPath, @"testzip2.zip");
//Extract testzip2.zip. Should overwrite existing files from previous step
output = UnzipTask.ExtractArchive(sp, dp, opt, new CancellationToken());
var lines2 = Directory.EnumerateFiles(dp.DirectoryPath, "*", SearchOption.AllDirectories).Select(x => File.ReadLines(x).First()).ToList();
Assert.False(lines2.Contains("First file") && lines2.Contains("Second file") && lines2.Contains("Third file"));
Assert.True(lines2.Contains("Fourth file") && lines2.Contains("Fifth file") && lines2.Contains("Sixth file"));
}
public GitInstallationState ExtractGit(GitInstallationState state)
{
var tempZipExtractPath = SPath.CreateTempDirectory("git_zip_extract_zip_paths");
if (state.GitZipExists && !state.GitIsValid)
{
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
var unzipTask = new UnzipTask(Token, installDetails.GitZipPath, gitExtractPath,
sharpZipLibHelper, environment.FileSystem)
.Progress(progressReporter.UpdateProgress)
.Catch(e => {
LogHelper.Trace(e, "Failed to unzip " + installDetails.GitZipPath);
return(true);
});
unzipTask.RunSynchronously();
var target = state.GitInstallationPath;
if (unzipTask.Successful)
{
Logger.Trace("Moving Git source:{0} target:{1}", gitExtractPath.ToString(), target.ToString());
UpdateTask("Copying git", 100);
CopyHelper.Copy(gitExtractPath, target);
UpdateTask("Copying git", 100);
state.GitIsValid = true;
state.IsCustomGitPath = state.GitExecutablePath != installDetails.GitExecutablePath;
}
}
tempZipExtractPath.DeleteIfExists();
return(state);
}
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();
}
public void SourceFileDoesNotExist()
{
//throws System.IO.FileNotFoundException
sp.SourceFile = Path.Combine(inputPath, @"doesnotexist.zip");
opt.DestinationFileExistsAction = FileExistAction.Overwrite;
dp.DirectoryPath = outputPath;
Assert.That(() => UnzipTask.ExtractArchive(sp, dp, opt, new System.Threading.CancellationToken()), Throws.TypeOf <FileNotFoundException>());
}
public void PasswordError()
{
//Should throw Ionic.Zip.BadPasswordException
sp.SourceFile = Path.Combine(inputPath, @"HiQLogosWithPassword.zip");
opt.DestinationFileExistsAction = FileExistAction.Overwrite;
opt.CreateDestinationDirectory = true;
dp.DirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory");
Assert.That(() => UnzipTask.ExtractArchive(sp, dp, opt, new System.Threading.CancellationToken()), Throws.TypeOf <BadPasswordException>());
}
public void DestinatioDirectoryNotFound()
{
//throws directory not found exception
//destination directory does not exist and create destination directory == false
sp.SourceFile = Path.Combine(inputPath, @"HiQLogos.zip");
opt.DestinationFileExistsAction = FileExistAction.Error;
opt.CreateDestinationDirectory = false;
dp.DirectoryPath = Path.Combine(outputPath, @"\doesnot\exist");
Assert.That(() => UnzipTask.ExtractArchive(sp, dp, opt, new System.Threading.CancellationToken()), Throws.TypeOf <DirectoryNotFoundException>());
}
public async Task UnzipWorks()
{
var cacheContainer = Substitute.For <ICacheContainer>();
using (var test = StartTest(cacheContainer: cacheContainer))
{
var expectedContent = @"Yup this is
{
good énough
}
".Replace("\r\n", "\n");
var destinationPath = test.TestPath.Combine("unziptests").CreateDirectory();
var localCache = test.SourceDirectory.Combine("UnzipTestResources");
var archiveFilePath = localCache.Combine("testfile.zip");
var extractedPath = test.TestPath.Combine("zipextract").CreateDirectory();
var unzipTask = new UnzipTask(test.TaskManager, archiveFilePath, extractedPath, ZipHelper.Instance);
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 = test.TestPath.Combine("tgzextract").CreateDirectory();
archiveFilePath = localCache.Combine("testfile.tgz");
unzipTask = new UnzipTask(test.TaskManager, archiveFilePath, extractedPath, ZipHelper.Instance);
await unzipTask.StartAwait();
expectedFile = extractedPath.Combine("embedded-git.json");
expectedFile.Parent.DirectoryExists().Should().BeTrue();
expectedFile.FileExists().Should().BeTrue();
expectedFile.ReadAllText().Should().Be(expectedContent);
extractedPath = test.TestPath.Combine("targzextract").CreateDirectory();
archiveFilePath = localCache.Combine("testfile.tar.gz");
unzipTask = new UnzipTask(test.TaskManager, archiveFilePath, extractedPath, ZipHelper.Instance);
await unzipTask.StartAwait();
expectedFile = extractedPath.Combine("embedded-git.json");
expectedFile.Parent.DirectoryExists().Should().BeTrue();
expectedFile.FileExists().Should().BeTrue();
expectedFile.ReadAllText().Should().Be(expectedContent);
}
}
public void ExtractWithPassword()
{
//extract password protected archive
sp.SourceFile = Path.Combine(inputPath, @"HiQLogosWithPassword.zip");
sp.Password = "******";
opt.DestinationFileExistsAction = FileExistAction.Overwrite;
opt.CreateDestinationDirectory = true;
dp.DirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory");
Output output = UnzipTask.ExtractArchive(sp, dp, opt, new System.Threading.CancellationToken());
Assert.True(File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory\logo1.png")));
Assert.True(File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory\logo2.png")));
}
public void OptimizeZipThenUnzipTest()
{
ICopier copier = new Copier(Context);
IZipper zipper = new Zipper(Context);
IDirectoryFilesLister directoryFilesLister = new DirectoryFilesLister();
StandardPackageDef packageDef = new StandardPackageDef();
DirectorySource test = new DirectorySource(Context, directoryFilesLister, "test", new FullPath("tmp/test"));
DirectorySource test2 = new DirectorySource(Context, directoryFilesLister, "test2", new FullPath("tmp/test2"));
packageDef.AddFilesSource(test);
packageDef.AddFilesSource(test2);
CopyProcessor copyProcessor = new CopyProcessor(
Context,
copier,
new FullPath("tmp/output"));
copyProcessor
.AddTransformation("test", new LocalPath(@"test"))
.AddTransformation("test2", new LocalPath(@"test2"));
IPackageDef copiedPackageDef = copyProcessor.Process(packageDef);
ZipProcessor zipProcessor = new ZipProcessor(Context, zipper, new FileFullPath("tmp/test.zip"), new FullPath("tmp/output"), true, null, "test", "test2");
zipProcessor.Process(copiedPackageDef);
string zf = "tmp/test.zip";
using (ZipArchive archive = ZipFile.OpenRead(zf))
{
Assert.Equal(4, archive.Entries.Count);
var list = archive.Entries.ToList <ZipArchiveEntry>();
Assert.Contains(list, x => x.FullName == $"test2{_seperator}test.txt");
Assert.Contains(list, x => x.FullName == $"test2{_seperator}test2.txt");
Assert.Contains(list, x => x.FullName == $"test{_seperator}test2.txt");
Assert.Contains(list, x => x.FullName == "_zipmetadata.json");
}
string unzipPath = "tmp/tt/";
UnzipTask unzip = new UnzipTask(zf, unzipPath);
unzip.Execute(Context);
var newLine = System.Environment.NewLine;
CheckTestFile(Path.Combine(unzipPath, $"test2{_seperator}test.txt"), $"test.txt{newLine}");
CheckTestFile(Path.Combine(unzipPath, $"test2{_seperator}test2.txt"), $"test.txt{newLine}");
CheckTestFile(Path.Combine(unzipPath, $"test{_seperator}test.txt"), $"test.txt{newLine}");
CheckTestFile(Path.Combine(unzipPath, $"test{_seperator}test2.txt"), $"test2.txt{newLine}");
}
public void OptimizeZipThenUnzipTest()
{
ICopier copier = new Copier(Context);
IZipper zipper = new Zipper(Context);
IDirectoryFilesLister directoryFilesLister = new DirectoryFilesLister();
StandardPackageDef packageDef = new StandardPackageDef();
DirectorySource test = new DirectorySource(Context, directoryFilesLister, "test", new FullPath("tmp\\test"));
DirectorySource test2 = new DirectorySource(Context, directoryFilesLister, "test2", new FullPath("tmp\\test2"));
packageDef.AddFilesSource(test);
packageDef.AddFilesSource(test2);
CopyProcessor copyProcessor = new CopyProcessor(
Context,
copier,
new FullPath("tmp\\output"));
copyProcessor
.AddTransformation("test", new LocalPath(@"test"))
.AddTransformation("test2", new LocalPath(@"test2"));
IPackageDef copiedPackageDef = copyProcessor.Process(packageDef);
ZipProcessor zipProcessor = new ZipProcessor(Context, zipper, new FileFullPath("tmp\\test.zip"), new FullPath("tmp\\output"), true, null, "test", "test2");
zipProcessor.Process(copiedPackageDef);
string zf = "tmp\\test.zip";
using (ZipArchive archive = ZipFile.OpenRead(zf))
{
Assert.Equal(4, archive.Entries.Count);
Assert.Equal("test2\\test.txt", archive.Entries[1].FullName);
Assert.Equal("test2\\test2.txt", archive.Entries[0].FullName);
Assert.Equal("test\\test2.txt", archive.Entries[2].FullName);
Assert.Equal("_zipmetadata.json", archive.Entries[3].FullName);
}
string unzipPath = "tmp/tt/";
UnzipTask unzip = new UnzipTask(zf, unzipPath);
unzip.Execute(Context);
CheckTestFile(Path.Combine(unzipPath, "test2\\test.txt"), "test.txt\r\n");
CheckTestFile(Path.Combine(unzipPath, "test2\\test2.txt"), "test.txt\r\n");
CheckTestFile(Path.Combine(unzipPath, "test\\test.txt"), "test.txt\r\n");
CheckTestFile(Path.Combine(unzipPath, "test\\test2.txt"), "test2.txt\r\n");
}
public void CreateDirectory()
{
//create destination directory if it does not exist
sp.SourceFile = Path.Combine(inputPath, @"HiQLogos.zip");
opt.DestinationFileExistsAction = FileExistAction.Error;
opt.CreateDestinationDirectory = true;
dp.DirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory\");
outputFiles = new List <string>();
fileNames.ToList().ForEach(x => outputFiles.Add(Path.Combine(dp.DirectoryPath, x)));
Output output = UnzipTask.ExtractArchive(sp, dp, opt, new CancellationToken());
foreach (string s in outputFiles)
{
Assert.True(File.Exists(s));
}
Assert.AreEqual(output.ExtractedFiles.Count, 7);
}
public void ThrowErrorOnOverwrite()
{
sp.SourceFile = Path.Combine(inputPath, @"HiQLogos.zip");
Options opt2 = new Options()
{
DestinationFileExistsAction = FileExistAction.Overwrite,
CreateDestinationDirectory = true
};
opt.DestinationFileExistsAction = FileExistAction.Error;
opt.CreateDestinationDirectory = true;
dp.DirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\TestData\TestOut\new_directory");
//unzip files to TestOut, so that there are existing files
UnzipTask.ExtractArchive(sp, dp, opt2, new CancellationToken());
Assert.That(() => UnzipTask.ExtractArchive(sp, dp, opt, new System.Threading.CancellationToken()), Throws.TypeOf <Ionic.Zip.ZipException>());
}
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);
}
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 InstallTestGit()
{
var installDetails = Environment.GitDefaultInstallation;
var state = installDetails.GetDefaults();
Environment.GitInstallationState = state;
if (installDetails.GitExecutablePath.FileExists() && installDetails.GitLfsExecutablePath.FileExists())
{
return;
}
var key = installDetails.GitManifest.FileNameWithoutExtension + "_updatelastCheckTime";
Environment.UserSettings.Set(key, DateTimeOffset.Now);
var localCache = SourceDirectory.Combine("files/git");
localCache.CopyFiles(installDetails.ZipPath.Parent, true);
// skip checking for updates
state.GitPackage = DugiteReleaseManifest.Load(TaskManager, installDetails.GitManifest,
GitInstaller.GitInstallDetails.ManifestFeed, Environment);
var asset = state.GitPackage.DugitePackage;
state.GitZipPath = installDetails.ZipPath.Combine(asset.Name);
installDetails.GitInstallationPath.DeleteIfExists();
state.GitZipPath.EnsureParentDirectoryExists();
var gitExtractPath = TestPath.Combine("setup", "git_zip_extract_zip_paths").EnsureDirectoryExists();
var source = new UnzipTask(TaskManager, state.GitZipPath, gitExtractPath)
.RunSynchronously();
installDetails.GitInstallationPath.EnsureParentDirectoryExists();
source.Move(installDetails.GitInstallationPath);
}
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 void RenameFiles()
{
sp.SourceFile = Path.Combine(inputPath, @"HiQLogos.zip");
opt.DestinationFileExistsAction = FileExistAction.Rename;
opt.CreateDestinationDirectory = true;
dp.DirectoryPath = outputPath;
//extract files to TestOut, so that there are existing files
UnzipTask.ExtractArchive(sp, dp, opt, new CancellationToken());
Output output = UnzipTask.ExtractArchive(sp, dp, opt, new CancellationToken());
//create filenames to test against
outputFiles = new List <string>();
renamedFilenames.ToList().ForEach(x => outputFiles.Add(Path.Combine(dp.DirectoryPath, x)));
foreach (string s in outputFiles)
{
Assert.True(File.Exists(s));
}
Assert.AreEqual(output.ExtractedFiles.Count, 7);
}
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);
}
