// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <gtest/gtest.h>

#include <stout/gtest.hpp>
#include <stout/json.hpp>

#include <mesos/docker/spec.hpp>

namespace spec = docker::spec;

using std::string;

namespace mesos {
namespace internal {
namespace tests {

class DockerSpecTest : public ::testing::Test {};


TEST_F(DockerSpecTest, ParseImageReference)
{
  Try<spec::ImageReference> reference =
    spec::parseImageReference("library/busybox");

  ASSERT_SOME(reference);
  EXPECT_FALSE(reference->has_registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_FALSE(reference->has_tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("busybox");

  ASSERT_SOME(reference);
  EXPECT_FALSE(reference->has_registry());
  EXPECT_EQ("busybox", reference->repository());
  EXPECT_FALSE(reference->has_tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("library/busybox:tag");

  ASSERT_SOME(reference);
  EXPECT_FALSE(reference->has_registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_EQ("tag", reference->tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("library/busybox@sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb"); // NOLINT(whitespace/line_length)

  ASSERT_SOME(reference);
  EXPECT_FALSE(reference->has_registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_FALSE(reference->has_tag());
  EXPECT_EQ("sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb", reference->digest()); // NOLINT(whitespace/line_length)

  reference = spec::parseImageReference("registry.io/library/busybox");

  ASSERT_SOME(reference);
  EXPECT_EQ("registry.io", reference->registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_FALSE(reference->has_tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("registry.io/library/busybox:tag");

  ASSERT_SOME(reference);
  EXPECT_EQ("registry.io", reference->registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_EQ("tag", reference->tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("registry.io:80/library/busybox:tag");

  ASSERT_SOME(reference);
  EXPECT_EQ("registry.io:80", reference->registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_EQ("tag", reference->tag());
  EXPECT_FALSE(reference->has_digest());

  reference = spec::parseImageReference("registry.io:80/library/busybox@sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb"); // NOLINT(whitespace/line_length)

  ASSERT_SOME(reference);
  EXPECT_EQ("registry.io:80", reference->registry());
  EXPECT_EQ("library/busybox", reference->repository());
  EXPECT_FALSE(reference->has_tag());
  EXPECT_EQ("sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb", reference->digest()); // NOLINT(whitespace/line_length)
}


TEST_F(DockerSpecTest, GetRegistrySpec)
{
  string registry = "";
  Result<int> port = spec::getRegistryPort(registry);
  Try<string> scheme = spec::getRegistryScheme(registry);
  string host = spec::getRegistryHost(registry);

  ASSERT_NONE(port);
  EXPECT_SOME_EQ("https", scheme);
  EXPECT_TRUE(host.empty());

  registry = ":";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  ASSERT_ERROR(port);
  ASSERT_ERROR(scheme);
  EXPECT_TRUE(host.empty());

  registry = "invalid_host:x80";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  ASSERT_ERROR(port);
  ASSERT_ERROR(scheme);
  EXPECT_EQ("invalid_host", host);

  registry = "invalid_port:80:80";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  ASSERT_ERROR(port);
  ASSERT_ERROR(scheme);
  EXPECT_EQ("invalid_port", host);

  registry = "index.docker.io";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  ASSERT_NONE(port);
  EXPECT_SOME_EQ("https", scheme);
  EXPECT_EQ("index.docker.io", host);

  registry = "localhost:80";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  EXPECT_SOME_EQ(80, port);
  EXPECT_SOME_EQ("http", scheme);
  EXPECT_EQ("localhost", host);

  registry = "registry-1.docker.io:443";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  EXPECT_SOME_EQ(443, port);
  EXPECT_SOME_EQ("https", scheme);
  EXPECT_EQ("registry-1.docker.io", host);

  registry = "127.0.0.1:443";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  EXPECT_SOME_EQ(443, port);
  EXPECT_SOME_EQ("https", scheme);
  EXPECT_EQ("127.0.0.1", host);

  registry = "127.0.0.1:1234";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  EXPECT_SOME_EQ(1234, port);
  EXPECT_SOME_EQ("http", scheme);
  EXPECT_EQ("127.0.0.1", host);

  registry = "localhost:1234";
  port = spec::getRegistryPort(registry);
  scheme = spec::getRegistryScheme(registry);
  host = spec::getRegistryHost(registry);

  EXPECT_SOME_EQ(1234, port);
  EXPECT_SOME_EQ("http", scheme);
  EXPECT_EQ("localhost", host);
}


// This test verifies docker::spec::parseAuthConfig works as expected
// for new docker config file format (e.g., ~/.docker/config.json).
TEST_F(DockerSpecTest, ParseDockerConfig)
{
  string config =
    R"~(
    {
      "auths": {
        "https://index.docker.io/v1/": {
          "auth": "bWVzb3M6dGVzdA==",
          "email": "user@example.com"
        },
        "localhost:5000": {
          "auth": "dW5pZmllZDpjb250YWluZXJpemVy",
          "email": "user@example.com"
        }
      },
      "HttpHeaders": {
        "User-Agent": "Docker-Client/1.10.2 (linux)"
      }
    })~";

  Try<hashmap<string, spec::Config::Auth>> map =
    spec::parseAuthConfig(config);

  EXPECT_EQ("bWVzb3M6dGVzdA==",
            map.get()["https://index.docker.io/v1/"].auth());

  EXPECT_EQ("user@example.com",
            map.get()["https://index.docker.io/v1/"].email());

  EXPECT_EQ("dW5pZmllZDpjb250YWluZXJpemVy", map.get()["localhost:5000"].auth());
  EXPECT_EQ("user@example.com", map.get()["localhost:5000"].email());
}


// This test verifies docker::spec::parseAuthConfig works as expected
// for old docker config file format (e.g., ~/.dockercfg).
TEST_F(DockerSpecTest, ParseDockercfg)
{
  string dockercfg =
    R"~(
    {
      "quay.io": {
        "auth": "cXVheTp0ZXN0",
        "email": "user@example.com"
      },
      "https://index.docker.io/v1/": {
        "auth": "cHJpdmF0ZTpyZWdpc3RyeQ==",
        "email": "user@example.com"
      },
      "https://192.168.0.1:5050": {
        "auth": "aXA6YWRkcmVzcw==",
        "email": "user@example.com"
      }
    })~";

  Try<hashmap<string, spec::Config::Auth>> map =
    spec::parseAuthConfig(dockercfg);

  EXPECT_EQ("cXVheTp0ZXN0", map.get()["quay.io"].auth());
  EXPECT_EQ("user@example.com", map.get()["quay.io"].email());

  EXPECT_EQ("cHJpdmF0ZTpyZWdpc3RyeQ==",
            map.get()["https://index.docker.io/v1/"].auth());

  EXPECT_EQ("user@example.com",
            map.get()["https://index.docker.io/v1/"].email());

  EXPECT_EQ("aXA6YWRkcmVzcw==", map.get()["https://192.168.0.1:5050"].auth());
  EXPECT_EQ("user@example.com", map.get()["https://192.168.0.1:5050"].email());
}


TEST_F(DockerSpecTest, ParseAuthUrl)
{
  EXPECT_EQ("registry.example.com",
            spec::parseAuthUrl("https://registry.example.com/v1/"));
  EXPECT_EQ("registry.example.com",
            spec::parseAuthUrl("http://registry.example.com/v1/"));
  EXPECT_EQ("registry.example.com",
            spec::parseAuthUrl("registry.example.com"));
  EXPECT_EQ("registry.example.com",
            spec::parseAuthUrl("registry.example.com/v1/"));

  EXPECT_EQ("localhost:8000", spec::parseAuthUrl("https://localhost:8000/v1/"));
  EXPECT_EQ("localhost:8000", spec::parseAuthUrl("http://localhost:8000/v1/"));
  EXPECT_EQ("localhost:8000", spec::parseAuthUrl("localhost:8000"));
  EXPECT_EQ("localhost:8000", spec::parseAuthUrl("localhost:8000/v1/"));

  EXPECT_EQ("registry.com", spec::parseAuthUrl("https://registry.com/v1/"));
  EXPECT_EQ("registry.com", spec::parseAuthUrl("http://registry.com/v1/"));
  EXPECT_EQ("registry.com", spec::parseAuthUrl("registry.com"));
  EXPECT_EQ("registry.com", spec::parseAuthUrl("registry.com/v1/"));
}


TEST_F(DockerSpecTest, ParseV1ImageManifest)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "container": "7f652467f9e6d1b3bf51172868b9b0c2fa1c711b112f4e987029b1624dd6295f",
        "parent": "cfa753dfea5e68a24366dfba16e6edf573daa447abf65bc11619c1a98a3aff54",
        "created": "2015-09-21T20:15:47.866196515Z",
        "config": {
          "Hostname": "5f8e0e129ff1",
          "Entrypoint": null,
          "Env": null,
          "OnBuild": null,
          "OpenStdin": false,
          "MacAddress": "",
          "User": "",
          "VolumeDriver": "",
          "AttachStderr": false,
          "AttachStdout": false,
          "PublishService": "",
          "NetworkDisabled": false,
          "StdinOnce": false,
          "Cmd": [ "sh" ],
          "WorkingDir": "",
          "AttachStdin": false,
          "Volumes": null,
          "Tty": false,
          "Domainname": "",
          "Image": "cfa753dfea5e68a24366dfba16e6edf573daa447abf65bc11619c1a98a3aff54",
          "Labels": {
            "com.nvidia.cuda.version": "7.5",
            "com.nvidia.volumes.needed": "nvidia_driver"
          },
          "ExposedPorts": null
        },
        "container_config": {
          "Hostname": "5f8e0e129ff1",
          "Entrypoint": [ "./bin/start" ],
          "Env": [
            "LANG=C.UTF-8",
            "JAVA_VERSION=8u66",
            "JAVA_DEBIAN_VERSION=8u66-b01-1~bpo8+1",
            "CA_CERTIFICATES_JAVA_VERSION=20140324"
          ],
          "OnBuild": null,
          "OpenStdin": false,
          "MacAddress": "",
          "User": "",
          "VolumeDriver": "",
          "AttachStderr": false,
          "AttachStdout": false,
          "PublishService": "",
          "NetworkDisabled": false,
          "StdinOnce": false,
          "Cmd": [
            "/bin/sh",
            "-c",
            "#(nop) CMD [\"sh\"]"
          ],
          "WorkingDir": "/marathon",
          "AttachStdin": false,
          "Volumes": null,
          "Tty": false,
          "Domainname": "",
          "Image": "cfa753dfea5e68a24366dfba16e6edf573daa447abf65bc11619c1a98a3aff54",
          "Labels": {
            "com.nvidia.caffe.version": "0.14",
            "com.nvidia.digits.version": "3.0"
          },
          "ExposedPorts": null
        },
        "architecture": "amd64",
        "docker_version": "1.8.2",
        "os": "linux",
        "id": "d7057cb020844f245031d27b76cb18af05db1cc3a96a29fa7777af75f5ac91a3",
        "Size": 0
      })~");

  ASSERT_SOME(json);

  Try<spec::v1::ImageManifest> manifest = spec::v1::parse(json.get());
  ASSERT_SOME(manifest);

  EXPECT_EQ(
      "7f652467f9e6d1b3bf51172868b9b0c2fa1c711b112f4e987029b1624dd6295f",
      manifest->container());

  EXPECT_EQ(
      "cfa753dfea5e68a24366dfba16e6edf573daa447abf65bc11619c1a98a3aff54",
      manifest->parent());

  EXPECT_EQ(
      "./bin/start",
      manifest->container_config().entrypoint(0));

  EXPECT_EQ(
      "LANG=C.UTF-8",
      manifest->container_config().env(0));

  EXPECT_EQ(
      "JAVA_VERSION=8u66",
      manifest->container_config().env(1));

  EXPECT_EQ(
      "JAVA_DEBIAN_VERSION=8u66-b01-1~bpo8+1",
      manifest->container_config().env(2));

  EXPECT_EQ(
      "CA_CERTIFICATES_JAVA_VERSION=20140324",
      manifest->container_config().env(3));

  EXPECT_EQ("/bin/sh", manifest->container_config().cmd(0));
  EXPECT_EQ("-c", manifest->container_config().cmd(1));

  EXPECT_EQ(
      "#(nop) CMD [\"sh\"]",
      manifest->container_config().cmd(2));

  EXPECT_EQ(
      "0.14",
      manifest->container_config().labels().at("com.nvidia.caffe.version"));

  EXPECT_EQ(
      "3.0",
      manifest->container_config().labels().at("com.nvidia.digits.version"));

  EXPECT_EQ("sh", manifest->config().cmd(0));

  EXPECT_EQ(
      "7.5",
      manifest->config().labels().at("com.nvidia.cuda.version"));

  EXPECT_EQ(
      "nvidia_driver",
      manifest->config().labels().at("com.nvidia.volumes.needed"));

  EXPECT_EQ("1.8.2", manifest->docker_version());
  EXPECT_EQ("amd64", manifest->architecture());
  EXPECT_EQ("linux", manifest->os());
  EXPECT_EQ(0u, manifest->size());
}


TEST_F(DockerSpecTest, ParseV2ImageManifest)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "name": "dmcgowan/test-image",
        "tag": "latest",
        "architecture": "amd64",
        "fsLayers": [
          { "blobSum": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" },
          { "blobSum": "sha256:cea0d2071b01b0a79aa4a05ea56ab6fdf3fafa03369d9f4eea8d46ea33c43e5f" },
          { "blobSum": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" },
          { "blobSum": "sha256:2a7812e636235448785062100bb9103096aa6655a8f6bb9ac9b13fe8290f66df" }
        ],
        "history": [
          {
            "v1Compatibility": "{\"id\": \"2ce2e90b0bc7224de3db1f0d646fe8e2c4dd37f1793928287f6074bc451a57ea\",\"parent\": \"cf2616975b4a3cba083ca99bc3f0bf25f5f528c3c52be1596b30f60b0b1c37ff\"}"
          },
          {
            "v1Compatibility": "{\"id\": \"2ce2e90b0bc7224de3db1f0d646fe8e2c4dd37f1793928287f6074bc451a57ea\",\"parent\": \"cf2616975b4a3cba083ca99bc3f0bf25f5f528c3c52be1596b30f60b0b1c37ff\"}"
          },
          {
            "v1Compatibility": "{\"id\": \"2ce2e90b0bc7224de3db1f0d646fe8e2c4dd37f1793928287f6074bc451a57ea\",\"parent\": \"cf2616975b4a3cba083ca99bc3f0bf25f5f528c3c52be1596b30f60b0b1c37ff\"}"
          },
          {
            "v1Compatibility": "{\"id\": \"2ce2e90b0bc7224de3db1f0d646fe8e2c4dd37f1793928287f6074bc451a57ea\",\"parent\": \"cf2616975b4a3cba083ca99bc3f0bf25f5f528c3c52be1596b30f60b0b1c37ff\"}"
          }
        ],
        "schemaVersion": 1,
        "signatures": [
          {
            "header": {
              "jwk": {
                "crv": "P-256",
                "kid": "LYRA:YAG2:QQKS:376F:QQXY:3UNK:SXH7:K6ES:Y5AU:XUN5:ZLVY:KBYL",
                "kty": "EC",
                "x": "Cu_UyxwLgHzE9rvlYSmvVdqYCXY42E9eNhBb0xNv0SQ",
                "y": "zUsjWJkeKQ5tv7S-hl1Tg71cd-CqnrtiiLxSi6N_yc8"
              },
              "alg": "ES256"
            },
            "signature": "m3bgdBXZYRQ4ssAbrgj8Kjl7GNgrKQvmCSY-00yzQosKi-8UBrIRrn3Iu5alj82B6u_jNrkGCjEx3TxrfT1rig",
            "protected": "eyJmb3JtYXRMZW5ndGgiOjYwNjMsImZvcm1hdFRhaWwiOiJDbjAiLCJ0aW1lIjoiMjAxNC0wOS0xMVQxNzoxNDozMFoifQ"
          }
        ]
      })~");

  ASSERT_SOME(json);

  Try<spec::v2::ImageManifest> manifest = spec::v2::parse(json.get());
  ASSERT_SOME(manifest);

  EXPECT_EQ("dmcgowan/test-image", manifest->name());
  EXPECT_EQ("latest", manifest->tag());
  EXPECT_EQ("amd64", manifest->architecture());

  EXPECT_EQ(
      "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", // NOLINT(whitespace/line_length)
      manifest->fslayers(0).blobsum());

  EXPECT_EQ(
      "sha256:cea0d2071b01b0a79aa4a05ea56ab6fdf3fafa03369d9f4eea8d46ea33c43e5f", // NOLINT(whitespace/line_length)
      manifest->fslayers(1).blobsum());

  EXPECT_EQ(
      "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", // NOLINT(whitespace/line_length)
      manifest->fslayers(2).blobsum());

  EXPECT_EQ(
      "sha256:2a7812e636235448785062100bb9103096aa6655a8f6bb9ac9b13fe8290f66df", // NOLINT(whitespace/line_length)
      manifest->fslayers(3).blobsum());

  EXPECT_EQ(
      "2ce2e90b0bc7224de3db1f0d646fe8e2c4dd37f1793928287f6074bc451a57ea",
      manifest->history(1).v1().id());

  EXPECT_EQ(
      "cf2616975b4a3cba083ca99bc3f0bf25f5f528c3c52be1596b30f60b0b1c37ff",
      manifest->history(2).v1().parent());

  EXPECT_EQ(1u, manifest->schemaversion());

  EXPECT_EQ(
      "LYRA:YAG2:QQKS:376F:QQXY:3UNK:SXH7:K6ES:Y5AU:XUN5:ZLVY:KBYL",
      manifest->signatures(0).header().jwk().kid());

  EXPECT_EQ(
      "m3bgdBXZYRQ4ssAbrgj8Kjl7GNgrKQvmCSY-00yzQosKi-8UBrIRrn3Iu5alj82B6u_jNrkGCjEx3TxrfT1rig", // NOLINT(whitespace/line_length)
      manifest->signatures(0).signature());
}


TEST_F(DockerSpecTest, ParseInvalidV2ImageManifest)
{
  // This is an invalid manifest. The size of the repeated fields
  // 'history' and 'fsLayers' must be >= 1. The 'signatures' and
  // 'schemaVersion' fields are not set.
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "name": "dmcgowan/test-image",
        "tag": "latest",
        "architecture": "amd64"
      })~");

  ASSERT_SOME(json);

  Try<spec::v2::ImageManifest> manifest = spec::v2::parse(json.get());
  EXPECT_ERROR(manifest);
}


TEST_F(DockerSpecTest, ValidateV2ImageManifestFsLayersNonEmpty)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
    R"~(
    {
      "name": "dmcgowan/test-image",
      "tag": "latest",
      "architecture": "amd64",
      "schemaVersion": 1,
      "signatures": [
        {
          "header": {
            "jwk": {
              "crv": "P-256",
              "kid": "LYRA:YAG2:QQKS:376F:QQXY:3UNK:SXH7:K6ES:Y5AU:XUN5:ZLVY:KBYL",
              "kty": "EC",
              "x": "Cu_UyxwLgHzE9rvlYSmvVdqYCXY42E9eNhBb0xNv0SQ",
              "y": "zUsjWJkeKQ5tv7S-hl1Tg71cd-CqnrtiiLxSi6N_yc8"
            },
            "alg": "ES256"
          },
          "signature": "m3bgdBXZYRQ4ssAbrgj8Kjl7GNgrKQvmCSY-00yzQosKi-8UBrIRrn3Iu5alj82B6u_jNrkGCjEx3TxrfT1rig",
          "protected": "eyJmb3JtYXRMZW5ndGgiOjYwNjMsImZvcm1hdFRhaWwiOiJDbjAiLCJ0aW1lIjoiMjAxNC0wOS0xMVQxNzoxNDozMFoifQ"
        }
      ]
    })~");

  ASSERT_SOME(json);

  Try<spec::v2::ImageManifest> manifest = spec::v2::parse(json.get());
  EXPECT_ERROR(manifest);
}


TEST_F(DockerSpecTest, ValidateV2ImageManifestSignaturesNonEmpty)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
    R"~(
    {
      "name": "dmcgowan/test-image",
      "tag": "latest",
      "architecture": "amd64",
      "fsLayers": [
        {
          "blobSum": "sha256:2a7812e636235448785062100bb9103096aa6655a8f6bb9ac9b13fe8290f66df"
        }
      ],
      "schemaVersion": 1
    })~");

  ASSERT_SOME(json);

  Try<spec::v2::ImageManifest> manifest = spec::v2::parse(json.get());
  EXPECT_ERROR(manifest);
}


TEST_F(DockerSpecTest, ParseV2_2ImageManifest)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "schemaVersion": 2,
        "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
        "config": {
            "mediaType": "application/vnd.docker.container.image.v1+json",
            "size": 7023,
            "digest": "sha256:b5b2b2c507a0944348e0303114d8d93aaaa081732b86451d9bce1f432a537bc7"
        },
        "layers": [
            {
                "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
                "size": 32654,
                "digest": "sha256:e692418e4cbaf90ca69d05a66403747baa33ee08806650b51fab815ad7fc331f"
            },
            {
                "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
                "size": 16724,
                "digest": "sha256:3c3a4604a545cdc127456d94e421cd355bca5b528f4a9c1905b15da2eb4a4c6b"
            },
            {
                "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
                "size": 73109,
                "digest": "sha256:ec4b8955958665577945c89419d1af06b5f7636b4ac3da7f12184802ad867736"
            }
        ]
      })~");

  ASSERT_SOME(json);

  Try<spec::v2_2::ImageManifest> manifest = spec::v2_2::parse(json.get());
  ASSERT_SOME(manifest);

  EXPECT_EQ(2u, manifest->schemaversion());
  EXPECT_EQ(
      "application/vnd.docker.distribution.manifest.v2+json",
      manifest->mediatype());

  EXPECT_EQ(
      "application/vnd.docker.container.image.v1+json",
      manifest->config().mediatype());
  EXPECT_EQ(7023u, manifest->config().size());
  EXPECT_EQ(
      "sha256:b5b2b2c507a0944348e0303114d8d93aaaa081732b86451d9bce1f432a537bc7",
      manifest->config().digest());

  EXPECT_EQ(3, manifest->layers_size());

  EXPECT_EQ(
      "application/vnd.docker.image.rootfs.diff.tar.gzip",
      manifest->layers(0).mediatype());
  EXPECT_EQ(32654u, manifest->layers(0).size());
  EXPECT_EQ(
      "sha256:e692418e4cbaf90ca69d05a66403747baa33ee08806650b51fab815ad7fc331f",
      manifest->layers(0).digest());

  EXPECT_EQ(
      "application/vnd.docker.image.rootfs.diff.tar.gzip",
      manifest->layers(1).mediatype());
  EXPECT_EQ(16724u, manifest->layers(1).size());
  EXPECT_EQ(
      "sha256:3c3a4604a545cdc127456d94e421cd355bca5b528f4a9c1905b15da2eb4a4c6b",
      manifest->layers(1).digest());

  EXPECT_EQ(
      "application/vnd.docker.image.rootfs.diff.tar.gzip",
      manifest->layers(2).mediatype());
  EXPECT_EQ(73109u, manifest->layers(2).size());
  EXPECT_EQ(
      "sha256:ec4b8955958665577945c89419d1af06b5f7636b4ac3da7f12184802ad867736",
      manifest->layers(2).digest());
}


TEST_F(DockerSpecTest, ParseInvalidV2_2ImageManifest)
{
  // This is an invalid manifest. The size of the repeated fields
  // 'layers' must be >= 1. The 'signatures' and
  // 'schemaVersion' fields are not set.
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
        "config": {
            "mediaType": "application/vnd.docker.container.image.v1+json",
            "size": 7023,
            "digest": "sha256:b5b2b2c507a0944348e0303114d8d93aaaa081732b86451d9bce1f432a537bc7"
        }
      })~");

  ASSERT_SOME(json);

  Try<spec::v2_2::ImageManifest> manifest = spec::v2_2::parse(json.get());
  EXPECT_ERROR(manifest);
}


TEST_F(DockerSpecTest, ValidateV2_2ImageManifestLayersNonEmpty)
{
  Try<JSON::Object> json = JSON::parse<JSON::Object>(
      R"~(
      {
        "schemaVersion": 2,
        "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
        "config": {
            "mediaType": "application/vnd.docker.container.image.v1+json",
            "size": 7023,
            "digest": "sha256:b5b2b2c507a0944348e0303114d8d93aaaa081732b86451d9bce1f432a537bc7"
        }
      })~");

  ASSERT_SOME(json);

  Try<spec::v2_2::ImageManifest> manifest = spec::v2_2::parse(json.get());
  EXPECT_ERROR(manifest);
}

} // namespace tests {
} // namespace internal {
} // namespace mesos {