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

#include "content/browser/web_exposed_isolation_info.h"

#include <sstream>

#include "base/test/gtest_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/origin.h"

namespace content {

using WebExposedIsolationInfoTest = testing::Test;

TEST_F(WebExposedIsolationInfoTest, NonIsolated) {
  WebExposedIsolationInfo info = WebExposedIsolationInfo::CreateNonIsolated();
  EXPECT_FALSE(info.is_isolated());
  EXPECT_FALSE(info.is_isolated_application());
  ASSERT_DCHECK_DEATH(info.origin());
}

TEST_F(WebExposedIsolationInfoTest, Isolated) {
  url::Origin origin =
      url::Origin::CreateFromNormalizedTuple("https", "example.com", 443);
  WebExposedIsolationInfo info =
      WebExposedIsolationInfo::CreateIsolated(origin);

  EXPECT_TRUE(info.is_isolated());
  EXPECT_FALSE(info.is_isolated_application());
  EXPECT_EQ(origin, info.origin());
}

TEST_F(WebExposedIsolationInfoTest, IsolatedApplication) {
  url::Origin origin =
      url::Origin::CreateFromNormalizedTuple("https", "example.com", 443);
  WebExposedIsolationInfo info =
      WebExposedIsolationInfo::CreateIsolatedApplication(origin);

  EXPECT_TRUE(info.is_isolated());
  EXPECT_TRUE(info.is_isolated_application());
  EXPECT_EQ(origin, info.origin());
}

TEST_F(WebExposedIsolationInfoTest, Comparisons) {
  WebExposedIsolationInfo nonA = WebExposedIsolationInfo::CreateNonIsolated();
  WebExposedIsolationInfo nonB = WebExposedIsolationInfo::CreateNonIsolated();

  // All non-isolated COII are equivalennt.
  EXPECT_EQ(nonA, nonA);
  EXPECT_EQ(nonA, nonB);
  EXPECT_EQ(nonB, nonA);
  EXPECT_FALSE(nonA < nonB);
  EXPECT_FALSE(nonB < nonA);

  url::Origin originA =
      url::Origin::CreateFromNormalizedTuple("https", "aaa.example", 443);
  url::Origin originB =
      url::Origin::CreateFromNormalizedTuple("https", "bbb.example", 443);
  WebExposedIsolationInfo isolatedA =
      WebExposedIsolationInfo::CreateIsolated(originA);
  WebExposedIsolationInfo isolatedB =
      WebExposedIsolationInfo::CreateIsolated(originB);

  // Isolated == self.
  EXPECT_EQ(isolatedA, isolatedA);
  // Non-isolated COII are < isolated COII (note that WebExposedIsolationInfo
  // only implements <, so we can't use EXPECT_GT here and below).
  EXPECT_LT(nonA, isolatedA);
  EXPECT_FALSE(isolatedA < nonA);
  // Origin comparison for isolated < isolated
  EXPECT_LT(isolatedA, isolatedB);
  EXPECT_FALSE(isolatedB < isolatedA);

  WebExposedIsolationInfo appA =
      WebExposedIsolationInfo::CreateIsolatedApplication(originA);
  WebExposedIsolationInfo appB =
      WebExposedIsolationInfo::CreateIsolatedApplication(originB);

  // Isolated app == self.
  EXPECT_EQ(appA, appA);
  // Non-isolated COII are < isolated app COII.
  EXPECT_LT(nonA, appA);
  EXPECT_FALSE(appA < nonA);
  // Non-isolated COII are < isolated app COII.
  EXPECT_LT(isolatedA, appA);
  EXPECT_FALSE(appA < isolatedA);
  // Origin comparison for isolated app < isolated app
  EXPECT_LT(appA, appB);
  EXPECT_FALSE(appB < appA);
}

TEST_F(WebExposedIsolationInfoTest, ComparisonsWithOptionals) {
  WebExposedIsolationInfo value = WebExposedIsolationInfo::CreateNonIsolated();
  std::optional<WebExposedIsolationInfo> optional_value =
      WebExposedIsolationInfo::CreateNonIsolated();

  ASSERT_DCHECK_DEATH(operator==(value, optional_value));
  ASSERT_DCHECK_DEATH(operator==(optional_value, value));
  ASSERT_DCHECK_DEATH(operator==(optional_value, optional_value));

  ASSERT_DCHECK_DEATH(operator!=(value, optional_value));
  ASSERT_DCHECK_DEATH(operator!=(optional_value, value));
  ASSERT_DCHECK_DEATH(operator!=(optional_value, optional_value));
}

TEST_F(WebExposedIsolationInfoTest, AreCompatibleFunctions) {
  url::Origin originA =
      url::Origin::CreateFromNormalizedTuple("https", "aaa.example", 443);
  url::Origin originB =
      url::Origin::CreateFromNormalizedTuple("https", "bbb.example", 443);
  WebExposedIsolationInfo nonIsolated =
      WebExposedIsolationInfo::CreateNonIsolated();
  WebExposedIsolationInfo isolatedA =
      WebExposedIsolationInfo::CreateIsolated(originA);
  WebExposedIsolationInfo isolatedB =
      WebExposedIsolationInfo::CreateIsolated(originB);
  WebExposedIsolationInfo appA =
      WebExposedIsolationInfo::CreateIsolatedApplication(originA);
  WebExposedIsolationInfo appB =
      WebExposedIsolationInfo::CreateIsolatedApplication(originB);

  // Compare nullopt with a range of different values.
  std::optional<WebExposedIsolationInfo> optionalEmpty = std::nullopt;
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalEmpty, nonIsolated));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalEmpty, isolatedA));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalEmpty, appA));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(nonIsolated, optionalEmpty));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(isolatedA, optionalEmpty));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(appA, optionalEmpty));

  // Compare a non isolated optional with a range of different values.
  std::optional<WebExposedIsolationInfo> optionalNonIsolated =
      WebExposedIsolationInfo::CreateNonIsolated();
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalNonIsolated, nonIsolated));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalNonIsolated, isolatedA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalNonIsolated, appA));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(nonIsolated, optionalNonIsolated));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(isolatedA, optionalNonIsolated));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(appA, optionalNonIsolated));

  // Compare an isolated optional with a range of different values.
  std::optional<WebExposedIsolationInfo> optionalIsolatedA =
      WebExposedIsolationInfo::CreateIsolated(originA);
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, nonIsolated));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, isolatedA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, isolatedB));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, appA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(nonIsolated, optionalIsolatedA));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(isolatedA, optionalIsolatedA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(isolatedB, optionalIsolatedA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(appA, optionalIsolatedA));

  // Compare an isolated application optional with a range of different values.
  std::optional<WebExposedIsolationInfo> optionalAppA =
      WebExposedIsolationInfo::CreateIsolatedApplication(originA);
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalAppA, nonIsolated));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalAppA, isolatedA));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalAppA, appA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalAppA, appB));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(nonIsolated, optionalAppA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(isolatedA, optionalAppA));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(appA, optionalAppA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(appB, optionalAppA));

  // Comparisons between optionals.
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalEmpty, optionalEmpty));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalEmpty,
                                                     optionalNonIsolated));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalEmpty, optionalIsolatedA));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalEmpty, optionalAppA));

  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalNonIsolated,
                                                     optionalEmpty));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalNonIsolated,
                                                     optionalNonIsolated));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalNonIsolated,
                                                      optionalIsolatedA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalNonIsolated,
                                                      optionalAppA));

  std::optional<WebExposedIsolationInfo> optionalIsolatedB =
      WebExposedIsolationInfo::CreateIsolated(originB);
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, optionalEmpty));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalIsolatedA,
                                                      optionalNonIsolated));
  EXPECT_TRUE(WebExposedIsolationInfo::AreCompatible(optionalIsolatedA,
                                                     optionalIsolatedA));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalIsolatedA,
                                                      optionalIsolatedB));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalIsolatedB,
                                                      optionalIsolatedA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalIsolatedA, optionalAppA));

  std::optional<WebExposedIsolationInfo> optionalAppB =
      WebExposedIsolationInfo::CreateIsolatedApplication(originB);
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalAppA, optionalEmpty));
  EXPECT_FALSE(WebExposedIsolationInfo::AreCompatible(optionalAppA,
                                                      optionalNonIsolated));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalAppA, optionalIsolatedA));
  EXPECT_TRUE(
      WebExposedIsolationInfo::AreCompatible(optionalAppA, optionalAppA));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalAppA, optionalAppB));
  EXPECT_FALSE(
      WebExposedIsolationInfo::AreCompatible(optionalAppB, optionalAppA));
}

TEST_F(WebExposedIsolationInfoTest, StreamOutput) {
  std::stringstream dump;

  WebExposedIsolationInfo nonIsolated =
      WebExposedIsolationInfo::CreateNonIsolated();
  dump << nonIsolated;
  EXPECT_EQ(dump.str(), "{}");
  dump.str("");

  url::Origin originA =
      url::Origin::CreateFromNormalizedTuple("https", "aaa.example", 443);
  WebExposedIsolationInfo isolatedA =
      WebExposedIsolationInfo::CreateIsolated(originA);
  dump << isolatedA;
  EXPECT_EQ(dump.str(), "{https://aaa.example}");
  dump.str("");

  WebExposedIsolationInfo appA =
      WebExposedIsolationInfo::CreateIsolatedApplication(originA);
  dump << appA;
  EXPECT_EQ(dump.str(), "{https://aaa.example (application)}");
  dump.str("");
}

}  // namespace content