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);
            }
        }
Beispiel #2
0
        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();
        }
Beispiel #3
0
        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);
        }