binary-validation.cpp File Reference

#include <iostream>
#include <nlohmann/json-schema.hpp>
#include <nlohmann/json.hpp>

Include dependency graph for binary-validation.cpp:

Go to the source code of this file.

Classes
class	store_ptr_err_handler

Macros
#define	EXPECT_EQ(a, b)
#define	EXPECT_THROW(foo)

Typedefs
using	json = nlohmann::json
using	validator = nlohmann::json_schema::json_validator

Functions
static void	content (const std::string &contentEncoding, const std::string &contentMediaType, const json &instance)
int	main ()

Variables
static int	error_count = 0
const json	bson_schema
const json	array_of_types
const json	array_of_types_without_binary

Macro Definition Documentation

EXPECT_EQ

#define EXPECT_EQ	(		a,
			b )

Value:

    do {                                                             \
        if (a != b) {                                                \
            std::cerr << "Failed: '" << a << "' != '" << b << "'\n"; \
            error_count++;                                           \
        }                                                            \
    } while (0)

Definition at line 9 of file binary-validation.cpp.

#define EXPECT_EQ(a, b)                                              \
    do {                                                             \
        if (a != b) {                                                \
            std::cerr << "Failed: '" << a << "' != '" << b << "'\n"; \
            error_count++;                                           \
        }                                                            \
    } while (0)

EXPECT_THROW

#define EXPECT_THROW

(

foo

)

Value:

    {                                \
        bool ok = false;             \
        try {                        \
            foo;                     \
        } catch (std::exception &) { \
            ok = true;               \
        }                            \
        if (ok == false) {           \
            error_count++;           \
        }                            \
    }

Definition at line 17 of file binary-validation.cpp.

#define EXPECT_THROW(foo)            \
    {                                \
        bool ok = false;             \
        try {                        \
            foo;                     \
        } catch (std::exception &) { \
            ok = true;               \
        }                            \
        if (ok == false) {           \
            error_count++;           \
        }                            \
    }

Typedef Documentation

json

using json = nlohmann::json

Definition at line 30 of file binary-validation.cpp.

validator

json_validator validator = nlohmann::json_schema::json_validator

Definition at line 31 of file binary-validation.cpp.

Function Documentation

content()

void content ( const std::string & contentEncoding, const std::string & contentMediaType, const json & instance )

static

Definition at line 94 of file binary-validation.cpp.

{
    std::cerr << "mediaType: '" << contentMediaType << "', encoding: '" << contentEncoding << "'\n";
 
    if (contentEncoding == "binary") {
        if (instance.type() != json::value_t::binary) {
            throw std::invalid_argument{"expected binary data"};
        }
    } else {
        if (instance.type() == json::value_t::binary) {
            throw std::invalid_argument{"expected string, but get binary"};
        }
    }
}

Referenced by main().

Here is the caller graph for this function:

main()

int main

(

void

)

Definition at line 109 of file binary-validation.cpp.

{
    validator val(nullptr, nullptr, content);
 
    // create some bson doc
    json::binary_t arr;
    std::string as_binary = "hello world";
    std::copy(as_binary.begin(), as_binary.end(), std::back_inserter(arr));
 
    json binary = json::binary(arr);
 
    store_ptr_err_handler err;

    val.set_root_schema(bson_schema);
 
    // all right
    val.validate({{"standard_string", "some string"}, {"binary_data", binary}}, err);
    EXPECT_EQ(err.failed_pointers.size(), 0);
    err.reset();
 
    // invalid binary data
    val.validate({{"binary_data", "string, but expect binary data"}}, err);
    EXPECT_EQ(err.failed_pointers.size(), 1);
    EXPECT_EQ(err.failed_pointers[0].to_string(), "/binary_data");
    err.reset();
 
    // also check that simple string not accept binary data
    val.validate({{"standard_string", binary}, {"binary_data", binary}}, err);
    EXPECT_EQ(err.failed_pointers.size(), 1);
    EXPECT_EQ(err.failed_pointers[0].to_string(), "/standard_string");
    err.reset();

    // check with array of types
 
    // check simple types
    val.set_root_schema(array_of_types);
    val.validate({{"something", 1}}, err);
    val.validate({{"something", false}}, err);
    // TODO when we set `string` in array and set `contentEncoding` = "binary" - what it means? We expected string or binary?
    // Or we expect only binary? Now if you set `contentEncoding` = "binary", then it means that you expect only binary data,
    // not string
    // val.validate({{"something", "string"}}, err); -> produce error about type
    EXPECT_EQ(err.failed_pointers.size(), 0);
    err.reset();
 
    // check binary data
    val.validate({{"something", binary}}, err);
    EXPECT_EQ(err.failed_pointers.size(), 0);
    err.reset();

    // and check that you can't set binary data if contentEncoding don't set
    val.set_root_schema(array_of_types_without_binary);
    val.validate({{"something", binary}}, err);
    EXPECT_EQ(err.failed_pointers.size(), 1);
    EXPECT_EQ(err.failed_pointers[0].to_string(), "/something");
    err.reset();
 
    // check that without content callback you get exception with schema with contentEncoding or contentMeditType
    validator val_no_content;
 
    EXPECT_THROW(val_no_content.set_root_schema(bson_schema));
 
    return error_count;
}

References array_of_types, array_of_types_without_binary, bson_schema, content(), error_count, store_ptr_err_handler::failed_pointers, nlohmann::json_schema::json_validator::json_validator(), store_ptr_err_handler::reset(), nlohmann::json_schema::json_validator::set_root_schema(), and nlohmann::json_schema::json_validator::validate().

Here is the call graph for this function:

Variable Documentation

array_of_types

const json array_of_types

Initial value:

= json::parse(R"(
{
  "type": "object",
  "properties": {
    "something": {
      "type": ["string", "number", "boolean"],
      "contentEncoding": "binary"
    }
  }
}
)")

Definition at line 50 of file binary-validation.cpp.

Referenced by main().

array_of_types_without_binary

const json array_of_types_without_binary

Initial value:

= json::parse(R"(
{
  "type": "object",
  "properties": {
    "something": {
      "type": ["string", "number", "boolean"]
    }
  }
}
)")

Definition at line 62 of file binary-validation.cpp.

Referenced by main().

bson_schema

const json bson_schema

Initial value:

= json::parse(R"(
{
  "type": "object",
  "properties": {
    "standard_string": {
      "type": "string"
    },
    "binary_data": {
      "type": "string",
      "contentEncoding": "binary"
    }
  },
  "additionalProperties": false
}
)")

Definition at line 34 of file binary-validation.cpp.

Referenced by main().

error_count

int error_count = 0

static

Definition at line 7 of file binary-validation.cpp.

Referenced by main().