// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "extensions/common/extension_builder.h"

#include "base/values.h"
#include "base/version.h"
#include "components/version_info/channel.h"
#include "extensions/common/extension.h"
#include "extensions/common/features/feature_channel.h"
#include "extensions/common/file_util.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/manifest_handlers/background_info.h"
#include "extensions/common/manifest_handlers/content_scripts_handler.h"
#include "extensions/common/manifest_handlers/externally_connectable.h"
#include "extensions/common/manifest_handlers/permissions_parser.h"
#include "extensions/common/permissions/permissions_data.h"
#include "extensions/common/user_script.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace extensions {

TEST(ExtensionBuilderTest, Basic) {
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("some name").Build();
    ASSERT_TRUE(extension);
    EXPECT_EQ("some name", extension->name());
    EXPECT_TRUE(extension->is_extension());
    EXPECT_EQ(3, extension->manifest_version());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("some app", ExtensionBuilder::Type::PLATFORM_APP)
            .Build();
    ASSERT_TRUE(extension);
    EXPECT_EQ("some app", extension->name());
    EXPECT_TRUE(extension->is_platform_app());
    EXPECT_EQ(2, extension->manifest_version());
  }
}

TEST(ExtensionBuilderTest, AddAPIPermission) {
  // MV2 API permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").SetManifestVersion(2).Build();
    EXPECT_TRUE(extension->permissions_data()->active_permissions().IsEmpty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .SetManifestVersion(2)
            .AddAPIPermission("storage")
            .AddAPIPermissions({"alarms", "idle"})
            .Build();
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("storage"));
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("alarms"));
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("idle"));
  }

  // Required API permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").Build();
    EXPECT_TRUE(extension->permissions_data()->active_permissions().IsEmpty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .AddAPIPermission("storage")
            .AddAPIPermissions({"alarms", "idle"})
            .Build();
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("storage"));
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("alarms"));
    EXPECT_TRUE(extension->permissions_data()->HasAPIPermission("idle"));
  }
}

TEST(ExtensionBuilderTest, AddOptionalAPIPermission) {
  // MV2 optional API permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").SetManifestVersion(2).Build();
    EXPECT_TRUE(
        PermissionsParser::GetOptionalPermissions(extension.get()).IsEmpty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .SetManifestVersion(2)
            .AddOptionalAPIPermission("storage")
            .AddOptionalAPIPermissions({"alarms", "idle"})
            .Build();
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("storage"));
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("alarms"));
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("idle"));
  }

  // Optional API permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").Build();
    EXPECT_TRUE(
        PermissionsParser::GetOptionalPermissions(extension.get()).IsEmpty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .AddOptionalAPIPermission("storage")
            .AddOptionalAPIPermissions({"alarms", "idle"})
            .Build();
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("storage"));
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("alarms"));
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .HasAPIPermission("idle"));
  }
}

TEST(ExtensionBuilderTest, AddHostPermission) {
  // MV2 host permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").SetManifestVersion(2).Build();
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .effective_hosts()
                    .is_empty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .SetManifestVersion(2)
            .AddHostPermission("*://one.example/*")
            .AddHostPermissions({"*://two.example/*", "*://three.example/*"})
            .Build();
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://one.example")));
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://two.example")));
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://three.example")));
    EXPECT_FALSE(extension->permissions_data()
                     ->active_permissions()
                     .HasExplicitAccessToOrigin(GURL("http://four.example")));
  }

  // Required host permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").Build();
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .effective_hosts()
                    .is_empty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .AddHostPermission("*://one.example/*")
            .AddHostPermissions({"*://two.example/*", "*://three.example/*"})
            .Build();
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://one.example")));
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://two.example")));
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .HasExplicitAccessToOrigin(GURL("http://three.example")));
    EXPECT_FALSE(extension->permissions_data()
                     ->active_permissions()
                     .HasExplicitAccessToOrigin(GURL("http://four.example")));
  }
}

TEST(ExtensionBuilderTest, AddOptionalHostPermission) {
  // MV2 optional host permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").SetManifestVersion(2).Build();
    EXPECT_TRUE(PermissionsParser::GetOptionalPermissions(extension.get())
                    .effective_hosts()
                    .is_empty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .SetManifestVersion(2)
            .AddOptionalHostPermission("*://one.example/*")
            .AddOptionalHostPermissions(
                {"*://two.example/*", "*://three.example/*"})
            .Build();
    const PermissionSet& optional_permissions =
        PermissionsParser::GetOptionalPermissions(extension.get());
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://one.example")));
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://two.example")));
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://three.example")));
    EXPECT_FALSE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://four.example")));
  }

  // Optional host permissions.
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no permissions").Build();
    EXPECT_TRUE(extension->permissions_data()
                    ->active_permissions()
                    .effective_hosts()
                    .is_empty());
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("api permissions")
            .AddOptionalHostPermission("*://one.example/*")
            .AddOptionalHostPermissions(
                {"*://two.example/*", "*://three.example/*"})
            .Build();
    const PermissionSet& optional_permissions =
        PermissionsParser::GetOptionalPermissions(extension.get());
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://one.example")));
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://two.example")));
    EXPECT_TRUE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://three.example")));
    EXPECT_FALSE(optional_permissions.HasExplicitAccessToOrigin(
        GURL("http://four.example")));
  }
}

TEST(ExtensionBuilderTest, Actions) {
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no action").Build();
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kPageAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kBrowserAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kAction));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("page action")
            .SetManifestVersion(2)
            .SetAction(ActionInfo::Type::kPage)
            .Build();
    EXPECT_TRUE(extension->manifest()->FindKey(manifest_keys::kPageAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kBrowserAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kAction));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("browser action")
            .SetManifestVersion(2)
            .SetAction(ActionInfo::Type::kBrowser)
            .Build();
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kPageAction));
    EXPECT_TRUE(extension->manifest()->FindKey(manifest_keys::kBrowserAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kAction));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("action").SetAction(ActionInfo::Type::kAction).Build();
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kPageAction));
    EXPECT_FALSE(extension->manifest()->FindKey(manifest_keys::kBrowserAction));
    EXPECT_TRUE(extension->manifest()->FindKey(manifest_keys::kAction));
  }
}

TEST(ExtensionBuilderTest, Background) {
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("no background").Build();
    EXPECT_FALSE(BackgroundInfo::HasBackgroundPage(extension.get()));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("persistent background page")
            .SetManifestVersion(2)
            .SetBackgroundContext(
                ExtensionBuilder::BackgroundContext::BACKGROUND_PAGE)
            .Build();
    EXPECT_TRUE(BackgroundInfo::HasBackgroundPage(extension.get()));
    EXPECT_TRUE(BackgroundInfo::HasPersistentBackgroundPage(extension.get()));
    EXPECT_FALSE(BackgroundInfo::IsServiceWorkerBased(extension.get()));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("event page")
            .SetManifestVersion(2)
            .SetBackgroundContext(
                ExtensionBuilder::BackgroundContext::EVENT_PAGE)
            .Build();
    EXPECT_TRUE(BackgroundInfo::HasBackgroundPage(extension.get()));
    EXPECT_TRUE(BackgroundInfo::HasLazyBackgroundPage(extension.get()));
    EXPECT_FALSE(BackgroundInfo::IsServiceWorkerBased(extension.get()));
  }
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("service worker")
            .SetBackgroundContext(
                ExtensionBuilder::BackgroundContext::SERVICE_WORKER)
            .Build();
    EXPECT_FALSE(BackgroundInfo::HasBackgroundPage(extension.get()));
    EXPECT_FALSE(BackgroundInfo::HasLazyBackgroundPage(extension.get()));
    EXPECT_FALSE(BackgroundInfo::HasPersistentBackgroundPage(extension.get()));
    EXPECT_TRUE(BackgroundInfo::IsServiceWorkerBased(extension.get()));
    EXPECT_EQ(ExtensionBuilder::kServiceWorkerScriptFile,
              file_util::ExtensionURLToRelativeFilePath(
                  BackgroundInfo::GetBackgroundServiceWorkerScriptURL(
                      extension.get()))
                  .AsUTF8Unsafe());
  }
}

TEST(ExtensionBuilderTest, MergeManifest) {
  auto connectable = base::Value::Dict().Set(
      "matches", base::Value::List().Append("*://example.com/*"));
  base::Value::Dict connectable_value =
      base::Value::Dict().Set("externally_connectable", std::move(connectable));
  scoped_refptr<const Extension> extension =
      ExtensionBuilder("extra")
          .MergeManifest(std::move(connectable_value))
          .Build();
  EXPECT_TRUE(ExternallyConnectableInfo::Get(extension.get()));
}

TEST(ExtensionBuilderTest, IDUniqueness) {
  scoped_refptr<const Extension> a = ExtensionBuilder("a").Build();
  scoped_refptr<const Extension> b = ExtensionBuilder("b").Build();
  scoped_refptr<const Extension> c = ExtensionBuilder("c").Build();

  std::set<ExtensionId> ids = {a->id(), b->id(), c->id()};
  EXPECT_EQ(3u, ids.size());
}

TEST(ExtensionBuilderTest, SetManifestAndMergeManifest) {
  auto manifest = base::Value::Dict()
                      .Set("name", "some name")
                      .Set("manifest_version", 2)
                      .Set("description", "some description");
  scoped_refptr<const Extension> extension =
      ExtensionBuilder()
          .SetManifest(std::move(manifest))
          .MergeManifest(base::Value::Dict().Set("version", "0.1"))
          .Build();
  EXPECT_EQ("some name", extension->name());
  EXPECT_EQ(2, extension->manifest_version());
  EXPECT_EQ("some description", extension->description());
  EXPECT_EQ("0.1", extension->version().GetString());
}

TEST(ExtensionBuilderTest, MergeManifestOverridesValues) {
  {
    scoped_refptr<const Extension> extension =
        ExtensionBuilder("foo")
            .MergeManifest(base::Value::Dict().Set("version", "52.0.9"))
            .Build();
    // MergeManifest() should have overwritten the default 0.1 value for
    // version.
    EXPECT_EQ("52.0.9", extension->version().GetString());
  }

  {
    auto manifest = base::Value::Dict()
                        .Set("name", "some name")
                        .Set("manifest_version", 2)
                        .Set("description", "some description")
                        .Set("version", "0.1");
    scoped_refptr<const Extension> extension =
        ExtensionBuilder()
            .SetManifest(std::move(manifest))
            .MergeManifest(base::Value::Dict().Set("version", "42.1"))
            .Build();
    EXPECT_EQ("42.1", extension->version().GetString());
  }
}

TEST(ExtensionBuilderTest, SetManifestKey) {
  scoped_refptr<const Extension> extension =
      ExtensionBuilder("foo")
          .SetManifestKey("short_name", "short name")
          .Build();
  EXPECT_EQ("short name", extension->short_name());
}

TEST(ExtensionBuilderTest, AddContentScript) {
  constexpr char kScriptOne[] = "one.js";
  const std::vector<std::string> script_one_patterns = {
      "https://example.com/*", "https://chromium.org/foo"};
  constexpr char kScriptTwo[] = "two.js";
  const std::vector<std::string> script_two_patterns = {"https://google.com/*"};
  scoped_refptr<const Extension> extension =
      ExtensionBuilder("foo")
          .AddContentScript(kScriptOne, script_one_patterns)
          .AddContentScript(kScriptTwo, script_two_patterns)
          .Build();

  const UserScriptList& content_scripts =
      ContentScriptsInfo::GetContentScripts(extension.get());
  auto script_by_name =
      [&content_scripts](const char* name) -> const extensions::UserScript* {
    for (const auto& script : content_scripts) {
      if (script->js_scripts()[0]->relative_path().AsUTF8Unsafe() == name) {
        return script.get();
      }
    }
    return nullptr;
  };

  auto patterns_as_strings = [](const URLPatternSet& patterns) {
    std::vector<std::string> strings;
    for (const auto& pattern : patterns)
      strings.push_back(pattern.GetAsString());
    return strings;
  };

  {
    const UserScript* script_one = script_by_name(kScriptOne);
    ASSERT_TRUE(script_one);
    EXPECT_THAT(patterns_as_strings(script_one->url_patterns()),
                testing::UnorderedElementsAreArray(script_one_patterns));
  }

  {
    const UserScript* script_two = script_by_name(kScriptTwo);
    ASSERT_TRUE(script_two);
    EXPECT_THAT(patterns_as_strings(script_two->url_patterns()),
                testing::UnorderedElementsAreArray(script_two_patterns));
  }
}

TEST(ExtensionBuilderTest, SetVersion) {
  constexpr char kVersion[] = "42.0.99.1";
  scoped_refptr<const Extension> extension =
      ExtensionBuilder("foo").SetVersion(kVersion).Build();
  EXPECT_EQ(kVersion, extension->VersionString());
}

}  // namespace extensions