test/archive_test.dart

// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

@TestOn('vm')

import 'dart:convert';
import 'dart:io';

import 'package:archive/archive.dart';
import 'package:async/async.dart';
import 'package:path/path.dart' as p;
import 'package:test/test.dart';
import 'package:test_descriptor/test_descriptor.dart' as d;

import 'utils.dart';

void main() {
  group("create()", () {
    test("creates an empty archive", () async {
      await d.archive("test.tar").create();

      var archive =
          TarDecoder().decodeBytes(File(d.path("test.tar")).readAsBytesSync());
      expect(archive.files, isEmpty);
    });

    test("creates an archive with files", () async {
      await d.archive("test.tar", [
        d.file("file1.txt", "contents 1"),
        d.file("file2.txt", "contents 2")
      ]).create();

      var files = TarDecoder()
          .decodeBytes(File(d.path("test.tar")).readAsBytesSync())
          .files;
      expect(files.length, equals(2));
      _expectFile(files[0], "file1.txt", "contents 1");
      _expectFile(files[1], "file2.txt", "contents 2");
    });

    test("creates an archive with files in a directory", () async {
      await d.archive("test.tar", [
        d.dir("dir", [
          d.file("file1.txt", "contents 1"),
          d.file("file2.txt", "contents 2")
        ])
      ]).create();

      var files = TarDecoder()
          .decodeBytes(File(d.path("test.tar")).readAsBytesSync())
          .files;
      expect(files.length, equals(2));
      _expectFile(files[0], "dir/file1.txt", "contents 1");
      _expectFile(files[1], "dir/file2.txt", "contents 2");
    });

    test("creates an archive with files in a nested directory", () async {
      await d.archive("test.tar", [
        d.dir("dir", [
          d.dir("subdir", [
            d.file("file1.txt", "contents 1"),
            d.file("file2.txt", "contents 2")
          ])
        ])
      ]).create();

      var files = TarDecoder()
          .decodeBytes(File(d.path("test.tar")).readAsBytesSync())
          .files;
      expect(files.length, equals(2));
      _expectFile(files[0], "dir/subdir/file1.txt", "contents 1");
      _expectFile(files[1], "dir/subdir/file2.txt", "contents 2");
    });

    group("creates a file in", () {
      test("zip format", () async {
        await d.archive("test.zip", [d.file("file.txt", "contents")]).create();

        var archive = ZipDecoder()
            .decodeBytes(File(d.path("test.zip")).readAsBytesSync());
        _expectFile(archive.files.single, "file.txt", "contents");
      });

      group("gzip tar format", () {
        for (var extension in [".tar.gz", ".tar.gzip", ".tgz"]) {
          test("with $extension", () async {
            await d.archive(
                "test$extension", [d.file("file.txt", "contents")]).create();

            var archive = TarDecoder().decodeBytes(GZipDecoder()
                .decodeBytes(File(d.path("test$extension")).readAsBytesSync()));
            _expectFile(archive.files.single, "file.txt", "contents");
          });
        }
      });

      group("bzip2 tar format", () {
        for (var extension in [".tar.bz2", ".tar.bzip2"]) {
          test("with $extension", () async {
            await d.archive(
                "test$extension", [d.file("file.txt", "contents")]).create();

            var archive = TarDecoder().decodeBytes(BZip2Decoder()
                .decodeBytes(File(d.path("test$extension")).readAsBytesSync()));
            _expectFile(archive.files.single, "file.txt", "contents");
          });
        }
      });
    });

    group("gracefully rejects", () {
      test("an uncreatable descriptor", () async {
        await expectLater(
            d.archive("test.tar", [d.filePattern(RegExp(r"^foo-"))]).create(),
            throwsUnsupportedError);
        await d.nothing("test.tar").validate();
      });

      test("a non-file non-directory descriptor", () async {
        await expectLater(
            d.archive("test.tar", [d.nothing("file.txt")]).create(),
            throwsUnsupportedError);
        await d.nothing("test.tar").validate();
      });

      test("an unknown file extension", () async {
        await expectLater(
            d.archive("test.asdf", [d.nothing("file.txt")]).create(),
            throwsUnsupportedError);
      });
    });
  });

  group("validate()", () {
    group("with an empty archive", () {
      test("succeeds if an empty archive exists", () async {
        File(d.path("test.tar"))
            .writeAsBytesSync(TarEncoder().encode(Archive()));
        await d.archive("test.tar").validate();
      });

      test("succeeds if a non-empty archive exists", () async {
        File(d.path("test.tar")).writeAsBytesSync(
            TarEncoder().encode(Archive()..addFile(_file("file.txt"))));
        await d.archive("test.tar").validate();
      });

      test("fails if no archive exists", () {
        expect(d.archive("test.tar").validate(),
            throwsA(toString(startsWith('File not found: "test.tar".'))));
      });

      test("fails if an invalid archive exists", () {
        d.file("test.tar", "not a valid tar file").create();
        expect(
            d.archive("test.tar").validate(),
            throwsA(toString(
                startsWith('File "test.tar" is not a valid archive.'))));
      });
    });

    test("succeeds if an archive contains a matching file", () async {
      File(d.path("test.tar")).writeAsBytesSync(TarEncoder()
          .encode(Archive()..addFile(_file("file.txt", "contents"))));
      await d.archive("test.tar", [d.file("file.txt", "contents")]).validate();
    });

    test("fails if an archive doesn't contain a file", () async {
      File(d.path("test.tar")).writeAsBytesSync(TarEncoder().encode(Archive()));
      expect(
          d.archive("test.tar", [d.file("file.txt", "contents")]).validate(),
          throwsA(
              toString(startsWith('File not found: "test.tar/file.txt".'))));
    });

    test("fails if an archive contains a non-matching file", () async {
      File(d.path("test.tar")).writeAsBytesSync(TarEncoder()
          .encode(Archive()..addFile(_file("file.txt", "wrong contents"))));
      expect(
          d.archive("test.tar", [d.file("file.txt", "contents")]).validate(),
          throwsA(toString(
              startsWith('File "test.tar/file.txt" should contain:'))));
    });

    test("succeeds if an archive contains a file matching a pattern", () async {
      File(d.path("test.tar")).writeAsBytesSync(TarEncoder()
          .encode(Archive()..addFile(_file("file.txt", "contents"))));
      await d.archive("test.tar",
          [d.filePattern(RegExp(r"f..e\.txt"), "contents")]).validate();
    });

    group("validates a file in", () {
      test("zip format", () async {
        File(d.path("test.zip")).writeAsBytesSync(ZipEncoder()
            .encode(Archive()..addFile(_file("file.txt", "contents"))));

        await d
            .archive("test.zip", [d.file("file.txt", "contents")]).validate();
      });

      group("gzip tar format", () {
        for (var extension in [".tar.gz", ".tar.gzip", ".tgz"]) {
          test("with $extension", () async {
            File(d.path("test$extension")).writeAsBytesSync(GZipEncoder()
                .encode(TarEncoder().encode(
                    Archive()..addFile(_file("file.txt", "contents")))));

            await d.archive(
                "test$extension", [d.file("file.txt", "contents")]).validate();
          });
        }
      });

      group("bzip2 tar format", () {
        for (var extension in [".tar.bz2", ".tar.bzip2"]) {
          test("with $extension", () async {
            File(d.path("test$extension")).writeAsBytesSync(BZip2Encoder()
                .encode(TarEncoder().encode(
                    Archive()..addFile(_file("file.txt", "contents")))));

            await d.archive(
                "test$extension", [d.file("file.txt", "contents")]).validate();
          });
        }
      });
    });

    test("gracefully rejects an unknown file format", () {
      expect(d.archive("test.asdf").validate(), throwsUnsupportedError);
    });
  });

  test("read() is unsupported", () {
    expect(d.archive("test.tar").read(), throwsUnsupportedError);
  });

  test("readAsBytes() returns the contents of the archive", () async {
    var descriptor = d.archive("test.tar",
        [d.file("file1.txt", "contents 1"), d.file("file2.txt", "contents 2")]);

    var files = TarDecoder()
        .decodeBytes(await collectBytes(descriptor.readAsBytes()))
        .files;
    expect(files.length, equals(2));
    _expectFile(files[0], "file1.txt", "contents 1");
    _expectFile(files[1], "file2.txt", "contents 2");
  });

  test("archive returns the in-memory contents", () async {
    var archive = await d.archive("test.tar", [
      d.file("file1.txt", "contents 1"),
      d.file("file2.txt", "contents 2")
    ]).archive;

    var files = archive.files;
    expect(files.length, equals(2));
    _expectFile(files[0], "file1.txt", "contents 1");
    _expectFile(files[1], "file2.txt", "contents 2");
  });

  test("io refers to the file within the sandbox", () {
    expect(d.file('test.tar').io.path, equals(p.join(d.sandbox, 'test.tar')));
  });
}

/// Asserts that [file] has the given [name] and [contents].
void _expectFile(ArchiveFile file, String name, String contents) {
  expect(file.name, equals(name));
  expect(utf8.decode(file.content as List<int>), equals(contents));
}

/// Creates an [ArchiveFile] with the given [name] and [contents].
ArchiveFile _file(String name, [String contents]) {
  var bytes = utf8.encode(contents ?? "");
  return ArchiveFile(name, bytes.length, bytes)
    // Setting the mode and mod time are necessary to work around
    // brendan-duncan/archive#76.
    ..mode = 428
    ..lastModTime = DateTime.now().millisecondsSinceEpoch ~/ 1000;
}