chrome/browser/ui/startup/focus/selector_unittest.cc

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

#include "chrome/browser/ui/startup/focus/selector.h"

#include <string>
#include <vector>

#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"

namespace focus {

class SelectorTest : public testing::Test {
 public:
  SelectorTest() = default;
  ~SelectorTest() override = default;
};

TEST_F(SelectorTest, ParseSelectorsBasic) {
  std::vector<Selector> selectors = ParseSelectors("https://example.com");
  ASSERT_EQ(1u, selectors.size());
  EXPECT_EQ(SelectorType::kUrlExact, selectors[0].type);
  EXPECT_EQ("https://example.com/", selectors[0].url.spec());
}

TEST_F(SelectorTest, ParseSelectorsWildcard) {
  std::vector<Selector> selectors = ParseSelectors("https://example.com/*");
  ASSERT_EQ(1u, selectors.size());
  EXPECT_EQ(SelectorType::kUrlPrefix, selectors[0].type);
  EXPECT_EQ("https://example.com/", selectors[0].url.spec());
}

TEST_F(SelectorTest, ParseSelectorsApp) {
  std::vector<Selector> selectors = ParseSelectors("app:test-app-id");
  ASSERT_EQ(1u, selectors.size());
  EXPECT_EQ(SelectorType::kApp, selectors[0].type);
  EXPECT_EQ("test-app-id", selectors[0].app_id);
}

TEST_F(SelectorTest, ParseSelectorsMultiple) {
  std::vector<Selector> selectors =
      ParseSelectors("app:test-app,https://example.com,https://test.com/*");
  ASSERT_EQ(3u, selectors.size());

  EXPECT_EQ(SelectorType::kApp, selectors[0].type);
  EXPECT_EQ("test-app", selectors[0].app_id);

  EXPECT_EQ(SelectorType::kUrlExact, selectors[1].type);
  EXPECT_EQ("https://example.com/", selectors[1].url.spec());

  EXPECT_EQ(SelectorType::kUrlPrefix, selectors[2].type);
  EXPECT_EQ("https://test.com/", selectors[2].url.spec());
}

TEST_F(SelectorTest, ParseSelectorsInvalid) {
  // Empty string.
  EXPECT_TRUE(ParseSelectors("").empty());

  // Invalid URL.
  EXPECT_TRUE(ParseSelectors("not-a-url").empty());

  // Empty app ID.
  EXPECT_TRUE(ParseSelectors("app:").empty());

  // Invalid URL prefix.
  EXPECT_TRUE(ParseSelectors("url:").empty());
}

TEST_F(SelectorTest, ParseSelectorsWhitespaceOnly) {
  // Whitespace-only input.
  EXPECT_TRUE(ParseSelectors("   ").empty());
  EXPECT_TRUE(ParseSelectors("\t\t").empty());
  EXPECT_TRUE(ParseSelectors(" \t \n ").empty());

  // Comma separated whitespace.
  EXPECT_TRUE(ParseSelectors(" , , ").empty());
  EXPECT_TRUE(ParseSelectors("\t,\t,\t").empty());
}

TEST_F(SelectorTest, ParseSelectorsMixedValidInvalid) {
  // Valid URL mixed with invalid.
  std::vector<Selector> selectors =
      ParseSelectors("https://example.com,not-a-url,app:valid-app");
  ASSERT_EQ(2u, selectors.size());

  EXPECT_EQ(SelectorType::kUrlExact, selectors[0].type);
  EXPECT_EQ("https://example.com/", selectors[0].url.spec());

  EXPECT_EQ(SelectorType::kApp, selectors[1].type);
  EXPECT_EQ("valid-app", selectors[1].app_id);

  // Invalid app mixed with valid URL.
  selectors = ParseSelectors("app:,https://test.com/*,invalid-url");
  ASSERT_EQ(1u, selectors.size());

  EXPECT_EQ(SelectorType::kUrlPrefix, selectors[0].type);
  EXPECT_EQ("https://test.com/", selectors[0].url.spec());
}

TEST_F(SelectorTest, SelectorToString) {
  Selector app_selector(SelectorType::kApp, "test-app");
  EXPECT_EQ("app:test-app", app_selector.ToString());

  Selector url_selector(SelectorType::kUrlExact, GURL("https://example.com"));
  EXPECT_EQ("https://example.com/", url_selector.ToString());

  Selector prefix_selector(SelectorType::kUrlPrefix,
                           GURL("https://example.com"));
  EXPECT_EQ("https://example.com/*", prefix_selector.ToString());
}

TEST_F(SelectorTest, SelectorIsValid) {
  Selector valid_app(SelectorType::kApp, "test-app");
  EXPECT_TRUE(valid_app.IsValid());

  Selector invalid_app(SelectorType::kApp, "");
  EXPECT_FALSE(invalid_app.IsValid());

  Selector valid_url(SelectorType::kUrlExact, GURL("https://example.com"));
  EXPECT_TRUE(valid_url.IsValid());

  Selector invalid_url(SelectorType::kUrlExact, GURL("not-a-url"));
  EXPECT_FALSE(invalid_url.IsValid());
}

}  // namespace focus