xref: /aosp_15_r20/system/extras/libjsonpb/verify/test.cpp (revision 288bf5226967eb3dac5cce6c939ccc2a7f2b4fe5)

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed 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 <limits>

#include <sstream>

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <json/writer.h>
#include <jsonpb/jsonpb.h>
#include <jsonpb/verify.h>

#include "test.pb.h"

using ::android::jsonpb::internal::FormatJson;
using ::testing::ElementsAre;
using ::testing::HasSubstr;

namespace android {
namespace jsonpb {

// Unit tests for libjsonpbverify.

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

class JsonKeyTest : public LibJsonpbVerifyTest {
 public:
  template <typename T>
  std::string GetFieldJsonName(const std::string& field_name) {
    return T{}.GetDescriptor()->FindFieldByName(field_name)->json_name();
  }

  template <typename T>
  void TestParseOkWithUnknownKey(const std::string& field_name, const std::string& json_key) {
    std::string json = "{\"" + json_key + "\": \"test\"}";
    auto object = JsonStringToMessage<T>(json);
    ASSERT_TRUE(object.ok()) << object.error();
    EXPECT_EQ("test", object->GetReflection()->GetString(
                          *object, object->GetDescriptor()->FindFieldByName(field_name)));
    std::string error;
    ASSERT_FALSE(AllFieldsAreKnown(*object, json, &error))
        << "AllFieldsAreKnown should return false";
    EXPECT_THAT(error, HasSubstr("unknown keys"));
    EXPECT_THAT(error, HasSubstr(json_key));
  }
};

TEST_F(JsonKeyTest, WithJsonNameOk) {
  std::string json =
      "{\n"
      "    \"FOOBAR\": \"foo_bar\",\n"
      "    \"BarBaz\": \"barBaz\",\n"
      "    \"baz_qux\": \"BazQux\",\n"
      "    \"quxQuux\": \"QUX_QUUX\"\n"
      "\n}";
  auto object = JsonStringToMessage<WithJsonName>(json);
  ASSERT_TRUE(object.ok()) << object.error();

  EXPECT_EQ("foo_bar", object->foo_bar());
  EXPECT_EQ("barBaz", object->barbaz());
  EXPECT_EQ("BazQux", object->bazqux());
  EXPECT_EQ("QUX_QUUX", object->qux_quux());

  std::string error;
  EXPECT_TRUE(AllFieldsAreKnown(*object, json, &error)) << error;
}

// If Prototype field name as keys while json_name is present, AllFieldsAreKnown
// should return false.
TEST_F(JsonKeyTest, WithJsonNameFooBar) {
  TestParseOkWithUnknownKey<WithJsonName>("foo_bar", "foo_bar");
}

TEST_F(JsonKeyTest, WithJsonNameBarBaz) {
  TestParseOkWithUnknownKey<WithJsonName>("barBaz", "barBaz");
}

TEST_F(JsonKeyTest, WithJsonNameBazQux) {
  TestParseOkWithUnknownKey<WithJsonName>("BazQux", "BazQux");
}

TEST_F(JsonKeyTest, WithJsonNameQuxQuux) {
  TestParseOkWithUnknownKey<WithJsonName>("QUX_QUUX", "QUX_QUUX");
}

// JSON field name matches Proto field name
TEST_F(JsonKeyTest, NoJsonNameOk) {
  std::string json =
      "{\n"
      "    \"foo_bar\": \"foo_bar\",\n"
      "    \"barBaz\": \"barBaz\",\n"
      "    \"BazQux\": \"BazQux\",\n"
      "    \"QUX_QUUX\": \"QUX_QUUX\"\n"
      "\n}";
  auto object = JsonStringToMessage<NoJsonName>(json);
  ASSERT_TRUE(object.ok()) << object.error();

  EXPECT_EQ("foo_bar", object->foo_bar());
  EXPECT_EQ("barBaz", object->barbaz());
  EXPECT_EQ("BazQux", object->bazqux());
  EXPECT_EQ("QUX_QUUX", object->qux_quux());

  std::string error;
  EXPECT_TRUE(AllFieldsAreKnown(*object, json, &error)) << error;
}

// JSON field name is lower/UpperCamelCase of Proto field name;
// AllFieldsAreKnown should return false. Although the lower/UpperCamelCase name
// is a valid key accepted by Protobuf's JSON parser, we explicitly disallow the
// behavior.
TEST_F(JsonKeyTest, NoJsonNameFooBar) {
  EXPECT_EQ("fooBar", GetFieldJsonName<NoJsonName>("foo_bar"));
  TestParseOkWithUnknownKey<NoJsonName>("foo_bar", "fooBar");
}

TEST_F(JsonKeyTest, NoJsonNameBarBaz) {
  EXPECT_EQ("barBaz", GetFieldJsonName<NoJsonName>("barBaz"));
  // No test for barBaz because its JSON name is the same as field_name
}

TEST_F(JsonKeyTest, NoJsonNameBazQux) {
  EXPECT_EQ("BazQux", GetFieldJsonName<NoJsonName>("BazQux"));
  // No test for BazQux because its JSON name is the same as field_name
}

TEST_F(JsonKeyTest, NoJsonNameQuxQuux) {
  EXPECT_EQ("QUXQUUX", GetFieldJsonName<NoJsonName>("QUX_QUUX"));
  TestParseOkWithUnknownKey<NoJsonName>("QUX_QUUX", "QUXQUUX");
}

class EmbeddedJsonKeyTest : public LibJsonpbVerifyTest {
 public:
  ErrorOr<Parent> TestEmbeddedError(const std::string& json, const std::string& unknown_key) {
    auto object = JsonStringToMessage<Parent>(json);
    if (!object.ok()) return object;
    std::string error;
    EXPECT_FALSE(AllFieldsAreKnown(*object, json, &error))
        << "AllFieldsAreKnown should return false";
    EXPECT_THAT(error, HasSubstr("unknown keys"));
    EXPECT_THAT(error, HasSubstr(unknown_key));
    return object;
  }
};

TEST_F(EmbeddedJsonKeyTest, Ok) {
  std::string json =
      "{"
      "    \"with_json_name\": {\"FOOBAR\": \"foo_bar\"},\n"
      "    \"repeated_with_json_name\": [{\"BarBaz\": \"barBaz\"}],\n"
      "    \"no_json_name\": {\"BazQux\": \"BazQux\"},\n"
      "    \"repeated_no_json_name\": [{\"QUX_QUUX\": \"QUX_QUUX\"}]\n"
      "}";
  auto object = JsonStringToMessage<Parent>(json);
  ASSERT_TRUE(object.ok()) << object.error();

  EXPECT_EQ("foo_bar", object->with_json_name().foo_bar());
  ASSERT_EQ(1u, object->repeated_with_json_name().size());
  EXPECT_EQ("barBaz", object->repeated_with_json_name().begin()->barbaz());
  EXPECT_EQ("BazQux", object->no_json_name().bazqux());
  ASSERT_EQ(1u, object->repeated_no_json_name().size());
  EXPECT_EQ("QUX_QUUX", object->repeated_no_json_name().begin()->qux_quux());

  std::string error;
  EXPECT_TRUE(AllFieldsAreKnown(*object, json, &error)) << error;
}

TEST_F(EmbeddedJsonKeyTest, FooBar) {
  auto object = TestEmbeddedError("{\"with_json_name\": {\"foo_bar\": \"test\"}}", "foo_bar");
  ASSERT_TRUE(object.ok()) << object.error();
  EXPECT_EQ("test", object->with_json_name().foo_bar());
}

TEST_F(EmbeddedJsonKeyTest, BarBaz) {
  auto object =
      TestEmbeddedError("{\"repeated_with_json_name\": [{\"barBaz\": \"test\"}]}", "barBaz");
  ASSERT_TRUE(object.ok()) << object.error();
  ASSERT_EQ(1u, object->repeated_with_json_name().size());
  EXPECT_EQ("test", object->repeated_with_json_name().begin()->barbaz());
}

TEST_F(EmbeddedJsonKeyTest, NoJsonName) {
  auto object = TestEmbeddedError("{\"no_json_name\": {\"QUXQUUX\": \"test\"}}", "QUXQUUX");
  ASSERT_TRUE(object.ok()) << object.error();
  EXPECT_EQ("test", object->no_json_name().qux_quux());
}

TEST_F(EmbeddedJsonKeyTest, QuxQuux) {
  auto object =
      TestEmbeddedError("{\"repeated_no_json_name\": [{\"QUXQUUX\": \"test\"}]}", "QUXQUUX");
  ASSERT_TRUE(object.ok()) << object.error();
  ASSERT_EQ(1u, object->repeated_no_json_name().size());
  EXPECT_EQ("test", object->repeated_no_json_name().begin()->qux_quux());
}

class ScalarTest : public LibJsonpbVerifyTest {
 public:
  ::testing::AssertionResult IsJsonEq(const std::string& l, const std::string& r) {
    Json::CharReaderBuilder builder;
    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
    Json::Value lvalue;
    std::string errorMessage;
    if (!reader->parse(&*l.begin(), &*l.end(), &lvalue, &errorMessage))
      return ::testing::AssertionFailure() << errorMessage;
    Json::Value rvalue;
    if (!reader->parse(&*r.begin(), &*r.end(), &rvalue, &errorMessage))
      return ::testing::AssertionFailure() << errorMessage;
    Json::StreamWriterBuilder factory;
    return lvalue == rvalue
               ? (::testing::AssertionSuccess() << "Both are \n"
                                                << Json::writeString(factory, lvalue))
               : (::testing::AssertionFailure() << Json::writeString(factory, lvalue)
                                                << "\n does not equal \n"
                                                << Json::writeString(factory, rvalue));
  }

  bool EqReformattedJson(const std::string& json, std::string* error) {
    return android::jsonpb::EqReformattedJson(json, &scalar_, error);
  }

  Scalar scalar_;
  std::string error_;
};

TEST_F(ScalarTest, Ok) {
  std::string json =
      "{\n"
      "    \"i32\": 1,\n"
      "    \"si32\": 1,\n"
      "    \"i64\": \"1\",\n"
      "    \"si64\": \"1\",\n"
      "    \"f\": 1.5,\n"
      "    \"d\": 1.5,\n"
      "    \"e\": \"FOO\"\n"
      "}";
  auto formatted = FormatJson(json, &scalar_);
  ASSERT_TRUE(formatted.ok()) << formatted.error();
  EXPECT_TRUE(IsJsonEq(json, *formatted));

  EXPECT_TRUE(EqReformattedJson(json, &error_)) << error_;
}

using ScalarTestErrorParam = std::tuple<const char*, const char*>;
class ScalarTestError : public ScalarTest,
                        public ::testing::WithParamInterface<ScalarTestErrorParam> {};

TEST_P(ScalarTestError, Test) {
  std::string json;
  std::string message;
  std::tie(json, message) = GetParam();
  auto formatted = FormatJson(json, &scalar_);
  ASSERT_TRUE(formatted.ok()) << formatted.error();
  EXPECT_FALSE(IsJsonEq(json, *formatted)) << message;
  EXPECT_FALSE(EqReformattedJson(json, &error_)) << "EqReformattedJson should return false";
}

static const std::vector<ScalarTestErrorParam> gScalarTestErrorParams = {
    {"{\"i32\": \"1\"}", "Should not allow int32 values to be quoted"},
    {"{\"si32\": \"1\"}", "Should not allow sint32 values to be quoted"},
    {"{\"i64\": 1}", "Should require int64 values to be quoted"},
    {"{\"si64\": 1}", "Should require sint64 values to be quoted"},
    {"{\"f\": \"1.5\"}", "Should not allow float values to be quoted"},
    {"{\"d\": \"1.5\"}", "Should not allow double values to be quoted"},
    {"{\"e\": 1}", "Should not allow integers for enums"},
};

INSTANTIATE_TEST_SUITE_P(Jsonpb, ScalarTestError, ::testing::ValuesIn(gScalarTestErrorParams));

int main(int argc, char** argv) {
  using ::testing::AddGlobalTestEnvironment;
  using ::testing::InitGoogleTest;

  InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

}  // namespace jsonpb
}  // namespace android