libjsonpb/verify/include/jsonpb/json_schema_test.h

/*
 * 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.
 */

#pragma once

#include <unistd.h>

#include <memory>
#include <string>

#include <android-base/file.h>
#include <android-base/strings.h>
#include <gtest/gtest.h>
#include <json/reader.h>
#include <json/writer.h>
#include <jsonpb/jsonpb.h>
#include <jsonpb/verify.h>

// JsonSchemaTest test that a given JSON file conforms to a given schema.
// This includes:
// - libprotobuf can parse the given JSON file using the given Prototype class
// - Additional checks on field names of the JSON file, and types of values.

namespace android {
namespace jsonpb {

class JsonSchemaTestConfig {
 public:
  virtual ~JsonSchemaTestConfig() = default;
  virtual std::unique_ptr<google::protobuf::Message> CreateMessage() const = 0;
  virtual std::string file_path() const = 0;
  /**
   * If it returns true, tests are skipped when the file is not found.
   */
  virtual bool optional() const { return false; }
};
using JsonSchemaTestConfigFactory = std::function<std::unique_ptr<JsonSchemaTestConfig>()>;

template <typename T>
class AbstractJsonSchemaTestConfig : public JsonSchemaTestConfig {
 public:
  AbstractJsonSchemaTestConfig(const std::string& path) : file_path_(path){};
  std::unique_ptr<google::protobuf::Message> CreateMessage() const override {
    return std::make_unique<T>();
  }
  std::string file_path() const override { return file_path_; }

 private:
  std::string file_path_;
};

template <typename T>
JsonSchemaTestConfigFactory MakeTestParam(const std::string& path) {
  return [path]() { return std::make_unique<AbstractJsonSchemaTestConfig<T>>(path); };
}

class JsonSchemaTest : public ::testing::TestWithParam<JsonSchemaTestConfigFactory> {
 public:
  void SetUp() override {
    auto&& config = ::testing::TestWithParam<JsonSchemaTestConfigFactory>::GetParam()();
    file_path_ = config->file_path();

    if (access(file_path_.c_str(), F_OK) == -1) {
      ASSERT_EQ(ENOENT, errno) << "File '" << file_path_
                               << "' is not accessible: " << strerror(errno);
      ASSERT_TRUE(config->optional()) << "Missing mandatory file " << file_path_;
      GTEST_SKIP();
    }
    ASSERT_TRUE(android::base::ReadFileToString(file_path_, &json_));
    ASSERT_FALSE(json_.empty()) << "File '" << file_path_ << "' exists but is empty";

    object_ = config->CreateMessage();
    auto res = internal::JsonStringToMessage(json_, object_.get());
    ASSERT_TRUE(res.ok()) << "Invalid format of file " << file_path_ << ": " << res.error();
  }
  google::protobuf::Message* message() const { return object_.get(); }
  std::string file_path_;
  std::string json_;
  std::unique_ptr<google::protobuf::Message> object_;
};

// Test that the JSON file has no fields unknown by the schema. See
// AllFieldsAreKnown() for more details.
TEST_P(JsonSchemaTest, NoUnknownFields) {
  std::string error;
  EXPECT_TRUE(AllFieldsAreKnown(*object_, json_, &error))
      << "File: " << file_path_ << ": " << error;
}

TEST_P(JsonSchemaTest, EqReformattedJson) {
  std::string error;
  EXPECT_TRUE(EqReformattedJson(json_, object_.get(), &error))
      << "File: " << file_path_ << ": " << error;
}

}  // namespace jsonpb
}  // namespace android