[WIP]Support matching root path "/"

.bazelversion

@@ -0,0 +1 @@
+0.19.2

src/http_template.cc

@@ -33,7 +33,7 @@ namespace {
 //   - what are the constraints on LITERAL and IDENT?
 //   - what is the character set for the grammar?
 //
-// Template = "/" Segments [ Verb ] ;
+// Template = "/" | "/" Segments [ Verb ] ;
 // Segments = Segment { "/" Segment } ;
 // Segment  = "*" | "**" | LITERAL | Variable ;
 // Variable = "{" FieldPath [ "=" Segments ] "}" ;
@@ -368,6 +368,10 @@ const char HttpTemplate::kWildCardPathPartKey[] = "*";
 const char HttpTemplate::kWildCardPathKey[] = "**";
 
 std::unique_ptr<HttpTemplate> HttpTemplate::Parse(const std::string &ht) {
+  if (ht == "/") {
+    return std::unique_ptr<HttpTemplate>(new HttpTemplate({}, {}, {}));
+  }
+
   Parser p(ht);
   if (!p.Parse() || !p.ValidateParts()) {
     return nullptr;

test/http_template_test.cc

@@ -80,14 +80,22 @@ TEST(HttpTemplate, ParseTest2) {
   ASSERT_EQ(Variables({}), ht->Variables());
 }
 
-TEST(HttpTemplate, ParseTest3) {
+TEST(HttpTemplate, ParseTest3a) {
   auto ht = HttpTemplate::Parse("/**");
   ASSERT_NE(nullptr, ht);
   ASSERT_EQ(Segments({"**"}), ht->segments());
   ASSERT_EQ("", ht->verb());
   ASSERT_EQ(Variables(), ht->Variables());
 }
 
+TEST(HttpTemplate, ParseTest3b) {
+  auto ht = HttpTemplate::Parse("/*");
+  ASSERT_NE(nullptr, ht);
+  ASSERT_EQ(Segments({"*"}), ht->segments());
+  ASSERT_EQ("", ht->verb());
+  ASSERT_EQ(Variables(), ht->Variables());
+}
+
 TEST(HttpTemplate, ParseTest4a) {
   auto ht = HttpTemplate::Parse("/a:foo");
   ASSERT_NE(nullptr, ht);
@@ -426,9 +434,16 @@ TEST(HttpTemplate, VariableAndCustomVerbTests) {
             ht->Variables());
 }
 
+TEST(HttpTemplate, RootPATH) {
+  auto ht = HttpTemplate::Parse("/");
+  ASSERT_NE(nullptr, ht);
+  ASSERT_EQ(Segments({}), ht->segments());
+  ASSERT_EQ("", ht->verb());
+  ASSERT_EQ(Variables(), ht->Variables());
+}
+
 TEST(HttpTemplate, ErrorTests) {
   ASSERT_EQ(nullptr, HttpTemplate::Parse(""));
-  ASSERT_EQ(nullptr, HttpTemplate::Parse("/"));
   ASSERT_EQ(nullptr, HttpTemplate::Parse("//"));
   ASSERT_EQ(nullptr, HttpTemplate::Parse("/{}"));
   ASSERT_EQ(nullptr, HttpTemplate::Parse("/a/"));

test/path_matcher_test.cc

@@ -198,6 +198,7 @@ TEST_F(PathMatcherTest, WildCardMatches) {
   MethodInfo* c_d__ = AddGetPath("/c/*/d/**");
   MethodInfo* c_de = AddGetPath("/c/*/d/e");
   MethodInfo* cfde = AddGetPath("/c/f/d/e");
+  MethodInfo* root = AddGetPath("/");
   Build();
 
   EXPECT_NE(nullptr, a__);
@@ -209,6 +210,7 @@ TEST_F(PathMatcherTest, WildCardMatches) {
   EXPECT_EQ(LookupNoBindings("GET", "/a/b"), a__);
   EXPECT_EQ(LookupNoBindings("GET", "/a/b/c"), a__);
   EXPECT_EQ(LookupNoBindings("GET", "/b/c"), b_);
+  EXPECT_EQ(LookupNoBindings("GET", "/"), root);
 
   EXPECT_EQ(LookupNoBindings("GET", "b/c/d"), nullptr);
   EXPECT_EQ(LookupNoBindings("GET", "/c/u/d/v"), c_d__);

test/path_matcher_utility_test.cc

@@ -215,3 +215,21 @@ TEST_F(PathMatcherUtilityTest, RegisterAdditionalBindings) {
   ASSERT_FALSE(PathMatcherUtility::RegisterByHttpRule(pmb, http_rule, {"key"},
                                                       &method2_));
 }
+
+TEST_F(PathMatcherUtilityTest, RegisterRootPath) {
+  HttpRule http_rule;
+  http_rule.set_get("/");
+  http_rule.set_body("body");
+  EXPECT_CALL(pmb,
+              Register(Eq("GET"), Eq("/"), Eq("body"),
+                       Eq(std::unordered_set<std::string>()), Eq(&method1_)))
+      .WillOnce(Return(true));
+  ASSERT_TRUE(
+      PathMatcherUtility::RegisterByHttpRule(pmb, http_rule, &method1_));
+  EXPECT_CALL(
+      pmb, Register(Eq("GET"), Eq("/"), Eq("body"),
+                    Eq(std::unordered_set<std::string>{"key"}), Eq(&method2_)))
+      .WillOnce(Return(false));
+  ASSERT_FALSE(PathMatcherUtility::RegisterByHttpRule(pmb, http_rule, {"key"},
+                                                      &method2_));
+}