path: root/buildscripts/idl/tests/compatibility_test_fail/new/compatibility_test_fail_new.idl

# Copyright (C) 2021-present MongoDB, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the Server Side Public License, version 1,
# as published by MongoDB, Inc.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# Server Side Public License for more details.
#
# You should have received a copy of the Server Side Public License
# along with this program. If not, see
# <http://www.mongodb.com/licensing/server-side-public-license>.
#
# As a special exception, the copyright holders give permission to link the
# code of portions of this program with the OpenSSL library under certain
# conditions as described in each individual source file and distribute
# linked combinations including the program with the OpenSSL library. You
# must comply with the Server Side Public License in all respects for
# all of the code used other than as permitted herein. If you modify file(s)
# with this exception, you may extend this exception to your version of the
# file(s), but you are not obligated to do so. If you do not wish to do so,
# delete this exception statement from your version. If you delete this
# exception statement from all source files in the program, then also delete
# it in the license file.
#

global:
    cpp_namespace: "mongo"

imports:
    - "mongo/idl/basic_types.idl"
    - "../buildscripts/idl/tests/compatibility_test_fail/new/imports.idl"

types:
    intToIntString:
        bson_serialization_type:
                                - int
                                - string
        description: "The bson_serialization_type changes from int in the old command's reply
                      field type to [int, string] in the new command's reply field type"
        cpp_type: "std::int32_t"
    
    intStringToIntStringBool:
        bson_serialization_type:
                                - int
                                - string
                                - bool
        description: "The bson_serialization_type changes from [int, string] in the old command's
                      reply field type to [int, string, bool] in the new command's reply field
                      type"
        cpp_type: "std::int32_t"

    oldBsonSerializationTypeAny:
        bson_serialization_type:
                                - int
        description: "The old bson_serialization_type contains 'any'"
        cpp_type: "std::int32_t"
    
    newBsonSerializationTypeAny:
        bson_serialization_type:
                                - int
                                - any
        description: "The new bson_serialization_type contains 'any'"
        cpp_type: "std::int32_t"

    bsonSerializationTypeAny:
        bson_serialization_type:
                                - int
                                - any
        description: "The old and new bson_serialization_type contains 'any'"
        cpp_type: "std::int32_t"

    bsonSerializationTypeAnyCppTypeNotEqual:
        bson_serialization_type:
                                - int
                                - any
        description: "The old and new bson_serialization_type contains 'any'"
        cpp_type: "std::int32_t"

    intStringBoolToIntString:
        bson_serialization_type:
                                - int
                                - string
        description: "The bson_serialization_type changes from [int, string, bool] in the old
                      command's reply field type to [int, string] in the new command's reply
                      field type"
        cpp_type: "std::int32_t"

    intStringToInt:
        bson_serialization_type:
                                - int
        description: "The bson_serialization_type changes from [int, string] in the old command
                      parameter's type to [int] in the new command parameter's type"
        cpp_type: "std::int32_t"

enums:
    NewReplyFieldEnumNotSubset:
        description: "The new reply type is an enum that is not a subset of the old reply type's 
                      enum values"
        type: string
        values:
            valueOne: "one"
            valueTwo: "two"
            valueThree: "three"

    EnumNotSuperset:
        description: "The new enum is not a superset of the old enum values"
        type: string
        values:
            valueOne: "one"
            valueTwo: "two"

structs:
    StructCommandParameterType:
        description: "This is a struct command parameter type"

    UnstableNewFieldReply:
        description: "This reply contains a field that is stable in the old command but is
                      unstable in the new command."
        fields:
            unstableNewField:
                type: string
                unstable: true
    
    OptionalNewFieldReply:
        description: "This reply contains a field that is required in the old command but is
                      optional in the new command."
        fields:
            optionalNewField:
                type: string
                optional: true
    
    MissingNewFieldReply:
        description: "This reply contains a field that exists in the old command but is
                      missing in the new command."
    
    RequiredNewField:
        description: "This struct contains a field that is optional in the old command but is
                      required in the new command."
        fields:
            requiredNewField:
                type: string

    EnumNotSubsetReply:
        description: "This reply contains an enum field where the new enum values is not a subset
                      of the old reply type's enum values"
        fields:
            enumNotSubsetReplyField:
                type: NewReplyFieldEnumNotSubset

    NotEnumFieldReply:
        description: "This reply contains a field that is an enum type in the old command but
                      is not an enum type in the new command"
        fields:
            notEnumReplyField:
                type: string

    NotStructFieldReply:
        description: "This reply contains a field that is a struct type in the old command but
                      is not a struct type in the new command"
        fields:
            notStructReplyField:
                type: string

    EnumOrStructFieldReply:
        description: "This reply contains a field that is a non-enum or struct type in the old
                      command but is an enum or struct in the new command"
        fields:
            EnumOrStructReplyField:
                type: NewReplyFieldEnumNotSubset

    BsonNotSubsetReply:
        description: "This reply contains a field type where the new bson_serialization_type
                      is not a subset of the old bson_serialization_type"
        fields:
            bsonNotSubsetReplyField:
                type: intToIntString

    BsonNotSubsetReplyTwo:
        description: "This reply contains a field type where the new bson_serialization_type
                      is not a subset of the old bson_serialization_type"
        fields:
            bsonNotSubsetReplyFieldTwo:
                type: intStringToIntStringBool

    OldBsonSerializationTypeAnyReply:
        description: "This reply contains a field whose old type has a bson_serialization_type
                      that contains 'any'"
        fields:
            oldBsonSerializationTypeAnyReplyField:
                type: oldBsonSerializationTypeAny

    NewBsonSerializationTypeAnyReply:
        description: "This reply contains a field whose new type has a bson_serialization_type
                      that contains 'any'"
        fields:
            newBsonSerializationTypeAnyReplyField:
                type: newBsonSerializationTypeAny

    BsonSerializationTypeAnyReply:
        description: "This reply contains a field whose old and new type have a bson_serialization_type
                      that contains 'any' that is not explicitly allowed."
        fields:
            bsonSerializationTypeAnyReplyField:
                type: bsonSerializationTypeAny

    BsonSerializationTypeWithVariantAnyReply:
        description: "This reply contains a field whose old and new variant types have a bson_serialization_type
                        that contains 'any' that is not compatible"
        fields:
            bsonSerializationTypeAnyReplyField:
                type:
                    variant: [oldBsonSerializationTypeAny, newBsonSerializationTypeAny]

    CppTypeNotEqualReply:
        description: "This reply contains a field whose old and new type have a bson_serialization_type
                        that contains 'any' and the cpp_types are not equal"
        fields:
            cppTypeNotEqualReplyField:
                type: bsonSerializationTypeAnyCppTypeNotEqual

    StructFieldTypeRecursiveReplyOne:
        description: "This reply contains a field whose new type is a struct that is not 
                      compatible with the old field type"
        fields:
            structReplyField:
                type: UnstableNewFieldReply
    
    StructFieldTypeRecursiveReplyTwo:
        description: "This reply contains a field whose new type is a struct that is not 
                      compatible with the old field type"
        fields:
            structReplyField:
                type: StructType

    StructType:
        description: "This struct contains a field whose new type is incompatible with the 
                      old field type"
        fields:
            fieldOne:
                type: BsonNotSubsetReply
    
    NewVariantTypeReply:
        description: "This reply contains a new field that has a variant type while the old field
                      is not a variant type"
        fields:
            newVariantTypeReplyField:
                type: 
                    variant: [int, string]

    NewVariantNotSubsetReply:
        description: "This reply contains a field whose new variant types are not a subset
                      of the old variant types"
        fields:
            variantNotSubsetReplyField:
                type: 
                    variant: [int, bool, string]

    NewVariantNotSubsetReplyTwo:
        description: "This reply contains a field whose new variant types are not a subset
                      of the old variant types"
        fields:
            variantNotSubsetReplyFieldTwo:
                type: 
                    variant: [int, bool, string, double]
    
    VariantRecursiveReply:
        description: "This reply contains a field that has a new variant type that is not
                      compatible with the old variant type"
        fields:
            variantRecursiveReplyField:
                type: 
                    variant: [int, intStringToIntStringBool]
    
    NewVariantStructNotSubsetReply:
        description: "This reply contains a field whose new variant types are not a subset
                      of the old variant types"
        fields:
            variantStructNotSubsetReplyField:
                type: 
                    variant: [int, string, StructType]
    
    VariantStructRecursiveReply:
        description: "This reply contains a field that has a new variant struct type that is not
                      compatible with the old variant struct type"
        fields:
            variantStructRecursiveReplyField:
                type: 
                    variant: [int, StructFieldTypeRecursiveReplyTwo]

    CommandParamStructRecursiveOne:
        description: "This command parameter struct type contains an unstable field while the
                      old struct field is stable"
        fields:
            stableToUnstableField:
                type: string
                unstable: true

    CommandParamStructRecursiveTwo:
        description: "This command parameter struct type contains a field that
                      is not a superset of the old struct field"
        fields:
            notSupersetField:
                type: intStringToInt

    NewValidatorStruct:
        description: "This struct contains a field where the new version contains a validator while
                      the old version does not"
        fields:
            newValidatorField:
                type: int
                validator:
                    lt: 0

    ValidatorsNotEqualStruct:
        description: "This struct contains a field where the new and old validators are not exactly equal"
        fields:
            validatorsNotEqualField:
                type: double
                validator:
                    lt: 0.0
                    gt: -1.1
                    lte: 2.0
                    gte: -2.98
                    callback: "callback"

    AddedRequiredTypeFieldStruct:
        description: "This struct contains a field that is added and required in the new version."
        fields:
            addedRequiredTypeField:
                type: string

    StableRequiredTypeFieldStruct:
        description: "This struct contains a field that is stable and required in the new version
                      that was unstable in the old version"
        fields:
            stableRequiredTypeField:
                type: string

    StructCommandParameterTypeRecursive:
        description: "This param struct type contains a field that is not compatible between the
                      old and new versions"
        fields:
            structCommandParameterTypeRecursiveField:
                type: intStringToInt

    VariantNotSupersetStruct:
        description: "This struct contains a field where the new variant types are not a superset
                      of the old variant types"
        fields:
            variantNotSupersetField:
                type: 
                    variant: [int, bool]

    VariantNotSupersetStructTwo:
        description: "This struct contains a field where the new variant types are not a superset
                      of the old variant types"
        fields:
            variantNotSupersetFieldTwo:
                type: 
                    variant: [int, bool]

    NewTypeNotVariantStruct:
        description: "This struct contains a field where the new type is not variant while the
                      old one is"
        fields:
            variantField:
                type: int

    VariantRecursiveStruct:
        description: "This struct contains a field where the new variant types are not
                      compatible with the old variant types"
        fields:
            variantRecursiveField:
                type: 
                    variant: [int, intStringBoolToIntString]

    VariantStructNotSupersetStruct:
        description: "This struct contains a field where the old variant types contains a struct
                      while the new one does not"
        fields:
            variantStructNotSupersetField:
                type: 
                    variant: [int, string]

    VariantStructRecursiveStruct:
        description: "This struct contains a field where the old variant struct and the new
                      variant struct are not compatible"
        fields:
            variantStructRecursiveField:
                type:
                    variant: [int, string, StructCommandParameterTypeRecursive]

commands:
    invalidAPIVersionNew:
        description: "new command fails because of invalid API version"
        command_name: invalidAPIVersionNew
        namespace: ignored
        cpp_name: invalidAPIVersionNew
        strict: true
        api_version: "whatever"
        reply_type: OkReply

    duplicateCommandNew:
        description: "duplicate command in new commands fails because a command with the same name
                      is in duplicate_command_fail_new.idl"
        command_name: duplicateCommandNew
        namespace: ignored
        cpp_name: duplicateCommandNew
        strict: true
        api_version: "1"
        reply_type: OkReply

    invalidAPIVersionOld:
        description: "old version of this command in compatibility_test_fail_old.idl fails because
                      of invalid API version"
        command_name: invalidAPIVersionOld
        namespace: ignored
        cpp_name: invalidAPIVersionOld
        strict: true
        api_version: "1"
        reply_type: OkReply

    duplicateCommandOld:
        description: "old version of this command in compatibility_test_fail_old.idl fails because
                      a command with the same name is in duplicate_command_fail_old.idl"
        command_name: duplicateCommandOld
        namespace: ignored
        cpp_name: duplicateCommandOld
        strict: true
        api_version: "1"
        reply_type: OkReply
    
    removedCommandParameter:
        description: "parameter will be removed from command in compatibility_test_fail/new
                      which results in an error"
        command_name: removedCommandParameter
        namespace: ignored
        cpp_name: removedCommandParameter
        strict: true
        api_version: "1"
        reply_type: OkReply

    addedNewCommandParameterRequired:
        description: "new command parameter fails because it is required when
                      it should be optional"
        command_name: addedNewCommandParameterRequired
        namespace: ignored
        cpp_name: addedNewCommandParameterRequired
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newRequiredParam:
                type: string

    commandParameterUnstable:
        description: "new unstable command parameter fails because it is stable
                      in the corresponding old command"
        command_name: commandParameterUnstable
        namespace: ignored
        cpp_name: commandParameterUnstable
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newUnstableParameter:
                type: string
                unstable: true

    commandParameterStableRequired:
        description: "new required stable command parameter fails because it is unstable
                      in the corresponding old command"
        command_name: commandParameterStableRequired
        namespace: ignored
        cpp_name: commandParameterStableRequired
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newRequiredStableParam:
                type: string

    commandParameterRequired:
        description: "new required command parameter fails because it is optional
                      in the corresponding old command"
        command_name: commandParameterRequired
        namespace: ignored
        cpp_name: commandParameterRequired
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newRequiredParam:
                type: string
                optional: false

    oldCommandParameterTypeBsonSerializationAny:
        description: "old command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any'"
        command_name: oldCommandParameterTypeBsonSerializationAny
        namespace: ignored
        cpp_name: oldCommandParameterTypeBsonSerializationAny
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonTypeAnyParam:
                type: oldBsonSerializationTypeAny

    newCommandParameterTypeBsonSerializationAny:
        description: "new command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any'"
        command_name: newCommandParameterTypeBsonSerializationAny
        namespace: ignored
        cpp_name: newCommandParameterTypeBsonSerializationAny
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonTypeAnyParam:
                type: newBsonSerializationTypeAny

    oldParamTypeBsonAnyAllowList:
        description: "old command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any' even when it is
                      on the allow list"
        command_name: oldParamTypeBsonAnyAllowList
        namespace: ignored
        cpp_name: oldParamTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonTypeAnyParam:
                type: oldBsonSerializationTypeAny

    newParamTypeBsonAnyAllowList:
        description: "new command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any' even when it is
                      on the allow list"
        command_name: newParamTypeBsonAnyAllowList
        namespace: ignored
        cpp_name: newParamTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonTypeAnyParam:
                type: newBsonSerializationTypeAny

    commandParameterTypeBsonSerializationAnyNotAllowed:
        description: "command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any' that is not
                      explicitly allowed"
        command_name: commandParameterTypeBsonSerializationAnyNotAllowed
        namespace: ignored
        cpp_name: commandParameterTypeBsonSerializationAnyNotAllowed
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonTypeAnyParam:
                type: bsonSerializationTypeAny

    commandParameterCppTypeNotEqual:
        description: "command fails because it has a parameter type that has a
                      bson_serialization_type that contains 'any' and where the cpp_types
                      are not equal"
        command_name: commandParameterCppTypeNotEqual
        namespace: ignored
        cpp_name: commandParameterCppTypeNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            cppTypeNotEqualParam:
                type: bsonSerializationTypeAnyCppTypeNotEqual

    newCommandParameterTypeEnumNotSuperset:
        description: "new command fails because its parameter type is an enum that is not
                      a superset of the corresponding old parameter type's enum values"
        command_name: newCommandParameterTypeEnumNotSuperset
        namespace: ignored
        cpp_name: newCommandParameterTypeEnumNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            enumNotSupersetParam:
                type: EnumNotSuperset

    newCommandParameterTypeNotEnum:
        description: "new command fails because its parameter type is not an enum when the
                      old command parameter type is an enum"
        command_name: newCommandParameterTypeNotEnum
        namespace: ignored
        cpp_name: newCommandParameterTypeNotEnum
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParamNotEnum:
                type: string

    newCommandParameterTypeNotStruct:
        description: "new command fails because its parameter type is not a struct when the
                      old command parameter type is a struct"
        command_name: newCommandParameterTypeNotStruct
        namespace: ignored
        cpp_name: newCommandParameterTypeNotStruct
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParamNotStruct:
                type: string

    newCommandParameterTypeEnumOrStructOne:
        description: "new command fails because its parameter type is an enum while the
                      parameter type in the old command is an non-enum or non-struct"
        command_name: newCommandParameterTypeEnumOrStructOne
        namespace: ignored
        cpp_name: newCommandParameterTypeEnumOrStructOne
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParamEnum:
                type: EnumNotSuperset

    newCommandParameterTypeEnumOrStructTwo:
        description: "new command fails because its parameter type is a struct while the
                      parameter type in the old command is an non-enum or non-struct"
        command_name: newCommandParameterTypeEnumOrStructTwo
        namespace: ignored
        cpp_name: newCommandParameterTypeEnumOrStructTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParamStruct:
                type: StructCommandParameterType

    newCommandParameterTypeBsonNotSuperset:
        description: "new command fails because its parameter type has a bson_serialization_type
                      that is not a superset of the corresponding old command parameter type's
                      bson_serialization_type"
        command_name: newCommandParameterTypeBsonNotSuperset
        namespace: ignored
        cpp_name: newCommandParameterTypeBsonNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParamBsonNotSuperset:
                type: intStringToInt

    newCommandParameterTypeStructRecursiveOne:
        description: "new command fails because its parameter type is a struct that is
                      not compatible with the old command parameter type struct"
        command_name: newCommandParameterTypeStructRecursiveOne
        namespace: ignored
        cpp_name: newCommandParameterTypeStructRecursiveOne
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            stableToUnstableStructParameter:
                type: CommandParamStructRecursiveOne

    newCommandParameterTypeStructRecursiveTwo:
        description: "new command fails because its parameter type is a struct that is
                      not compatible with the old command parameter type struct"
        command_name: newCommandParameterTypeStructRecursiveTwo
        namespace: ignored
        cpp_name: newCommandParameterTypeStructRecursiveTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            notSupersetStructParameter:
                type: CommandParamStructRecursiveTwo

    newCommandParameterValidator:
        description: "new command fails because it contains a parameter that contains a validator
                      that is not present in the old parameter"
        command_name: newCommandParameterValidator
        namespace: ignored
        cpp_name: newCommandParameterValidator
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParam:
                type: int
                validator:
                    lt: 0

    commandParameterValidatorsNotEqual:
        description: "new command fails because it contains a parameter that contains a validator
                      that is not exactly equal to the old parameter validator"
        command_name: commandParameterValidatorsNotEqual
        namespace: ignored
        cpp_name: commandParameterValidatorsNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParam:
                type: double
                validator:
                    lt: 0.0
                    gt: -1.1
                    lte: 2.0
                    gte: -2.98
                    callback: "callback"

    newCommandTypeValidator:
        description: "new command fails because it contains a type that contains a validator
                      that is not present in the old type"
        command_name: newCommandTypeValidator
        namespace: type
        type: NewValidatorStruct
        cpp_name: newCommandTypeValidator
        strict: true
        api_version: "1"
        reply_type: OkReply

    commandTypeValidatorsNotEqual:
        description: "new command fails because it contains a type that contains a validator
                      that is not exactly equal to the old type validator"
        command_name: commandTypeValidatorsNotEqual
        namespace: type
        type: ValidatorsNotEqualStruct
        cpp_name: commandTypeValidatorsNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply

    newReplyFieldUnstable:
        description: "new command fails because it contains an unstable reply field that is stable
                      in the corresponding old command"
        command_name: newReplyFieldUnstable
        namespace: ignored
        cpp_name: newReplyFieldUnstable
        strict: true
        api_version: "1"
        reply_type: UnstableNewFieldReply
    
    newReplyFieldOptional:
        description: "new command fails because it contains an optional reply field that is
                      required in the corresponding old command"
        command_name: newReplyFieldOptional
        namespace: ignored
        cpp_name: newReplyFieldOptional
        strict: true
        api_version: "1"
        reply_type: OptionalNewFieldReply

    newReplyFieldMissing:
        description: "new command fails because it is missing a reply field that exists in
                      the corresponding old command"
        command_name: newReplyFieldMissing
        namespace: ignored
        cpp_name: newReplyFieldMissing
        strict: true
        api_version: "1"
        reply_type: MissingNewFieldReply

    importedReplyCommand:
        description: "reply is imported and should fail"
        command_name: importedReplyCommand
        namespace: ignored
        cpp_name: importedReplyCommand
        strict: true
        api_version: "1"
        reply_type: ImportedUnstableNewFieldReply

    newReplyFieldTypeEnumNotSubset:
        description: "new command fails because its reply field type is an enum that is not
                      a subset of the corresponding old reply field type's enum values"
        command_name: newReplyFieldTypeEnumNotSubset
        namespace: ignored
        cpp_name: newReplyFieldTypeEnumNotSubset
        strict: true
        api_version: "1"
        reply_type: EnumNotSubsetReply

    newReplyFieldTypeNotEnum:
        description: "new command fails because its reply field type is not an enum when the
                      old reply field type is an enum"
        command_name: newReplyFieldTypeNotEnum
        namespace: ignored
        cpp_name: newReplyFieldTypeNotEnum
        strict: true
        api_version: "1"
        reply_type: NotEnumFieldReply

    newReplyFieldTypeNotStruct:
        description: "new command fails because its reply field type is not a struct when the
                      old reply field type is a struct"
        command_name: newReplyFieldTypeNotStruct
        namespace: ignored
        cpp_name: newReplyFieldTypeNotStruct
        strict: true
        api_version: "1"
        reply_type: NotStructFieldReply

    newReplyFieldTypeEnumOrStruct:
        description: "new command fails because it contains a field that is a non-enum or struct
                      type in the old command, and an enum or struct in the new command"
        command_name: newReplyFieldTypeEnumOrStruct
        namespace: ignored
        cpp_name: newReplyFieldTypeEnumOrStruct
        strict: true
        api_version: "1"
        reply_type: EnumOrStructFieldReply

    newReplyFieldTypeBsonNotSubset:
        description: "new command fails because its reply field type has a bson_serialization_type
                      that is not a subset of the corresponding old reply field type's
                      bson_serialization_type"
        command_name: newReplyFieldTypeBsonNotSubset
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonNotSubset
        strict: true
        api_version: "1"
        reply_type: BsonNotSubsetReply

    newReplyFieldTypeBsonNotSubsetTwo:
        description: "new command fails because its reply field type has a bson_serialization_type
                      that is not a subset of the corresponding old reply field type's
                      bson_serialization_type"
        command_name: newReplyFieldTypeBsonNotSubsetTwo
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonNotSubsetTwo
        strict: true
        api_version: "1"
        reply_type: BsonNotSubsetReplyTwo

    oldReplyFieldTypeBsonAny:
        description: "old command fails because its reply field type has a bson_serialization_type
                      that contains 'any'"
        command_name: oldReplyFieldTypeBsonAny
        namespace: ignored
        cpp_name: oldReplyFieldTypeBsonAny
        strict: true
        api_version: "1"
        reply_type: OldBsonSerializationTypeAnyReply

    newReplyFieldTypeBsonAny:
        description: "new command fails because its reply field type has a bson_serialization_type
                      that contains 'any'"
        command_name: newReplyFieldTypeBsonAny
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonAny
        strict: true
        api_version: "1"
        reply_type: NewBsonSerializationTypeAnyReply

    oldReplyFieldTypeBsonAnyAllowList:
        description: "old command fails when its reply field type has a bson_serialization_type
                      that contains 'any' even when on the allow list"
        command_name: oldReplyFieldTypeBsonAnyAllowList
        namespace: ignored
        cpp_name: oldReplyFieldTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OldBsonSerializationTypeAnyReply

    newReplyFieldTypeBsonAnyAllowList:
        description: "new command fails when its reply field type has a bson_serialization_type
                      that contains 'any' even when on the allow list"
        command_name: newReplyFieldTypeBsonAnyAllowList
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: NewBsonSerializationTypeAnyReply

    replyFieldTypeBsonAnyNotAllowed:
        description: "command fails because its reply field type has a bson_serialization_type
                      that contains 'any' that is not explicitly allowed"
        command_name: replyFieldTypeBsonAnyNotAllowed
        namespace: ignored
        cpp_name: replyFieldTypeBsonAnyNotAllowed
        strict: true
        api_version: "1"
        reply_type: BsonSerializationTypeAnyReply

    replyFieldTypeBsonAnyWithVariant:
        description: "command fails when its reply field variant types have bson_serialization_type
                      'any' that is not compatible with each other"
        command_name: replyFieldTypeBsonAnyWithVariant
        namespace: ignored
        cpp_name: replyFieldTypeBsonAnyWithVariant
        strict: true
        api_version: "1"
        reply_type: BsonSerializationTypeWithVariantAnyReply

    replyFieldCppTypeNotEqual:
        description: "command fails because its reply field type has a bson_serialization_type
                      that contains 'any', and the cpp_types are not equal"
        command_name: replyFieldCppTypeNotEqual
        namespace: ignored
        cpp_name: replyFieldCppTypeNotEqual
        strict: true
        api_version: "1"
        reply_type: CppTypeNotEqualReply

    newReplyFieldTypeStructRecursiveOne:
        description: "new command fails because its reply field type is a struct that is
                      incompatible with the old reply field type struct"
        command_name: newReplyFieldTypeStructRecursiveOne
        namespace: ignored
        cpp_name: newReplyFieldTypeStructRecursiveOne
        strict: true
        api_version: "1"
        reply_type: StructFieldTypeRecursiveReplyOne

    newReplyFieldTypeStructRecursiveTwo:
        description: "new command fails because its reply field type is a struct that is
                      incompatible with the old reply field type struct"
        command_name: newReplyFieldTypeStructRecursiveTwo
        namespace: ignored
        cpp_name: newReplyFieldTypeStructRecursiveTwo
        strict: true
        api_version: "1"
        reply_type: StructFieldTypeRecursiveReplyTwo

    newNamespaceNotIgnored:
        description: "new command fails because its namespace is not ignored"
        command_name: newNamespaceNotIgnored
        namespace: concatenate_with_db_or_uuid
        cpp_name: newNamespaceNotIgnored
        strict: true
        api_version: "1"
        reply_type: OkReply

    newNamespaceNotConcatenateWithDbOrUuid:
        description: "new command fails because its namespace is not concatenate_with_db_or_uuid
                      or ignored"
        command_name: newNamespaceNotConcatenateWithDbOrUuid
        namespace: concatenate_with_db
        cpp_name: newNamespaceNotConcatenateWithDbOrUuid
        strict: true
        api_version: "1"
        reply_type: OkReply

    newNamespaceNotConcatenateWithDb:
        description: "new command fails because its namespace changes to type"
        command_name: newNamespaceNotConcatenateWithDb
        namespace: type
        type: string
        cpp_name: newNamespaceNotConcatenateWithDb
        strict: true
        api_version: "1"
        reply_type: OkReply

    newNamespaceNotType:
        description: "new command fails because its namespace changes from type in
                      an incompatible way"
        command_name: newNamespaceNotType
        namespace: concatenate_with_db
        cpp_name: newNamespaceNotType
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldTypeBsonAny:
        description: "old command fails because its type has a bson_serialization_type
                      that contains 'any'"
        command_name: oldTypeBsonAny
        namespace: type
        type: oldBsonSerializationTypeAny
        cpp_name: oldTypeBsonAny
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeBsonAny:
        description: "new command fails because its type has a bson_serialization_type
                      that contains 'any'"
        command_name: newTypeBsonAny
        namespace: type
        type: newBsonSerializationTypeAny
        cpp_name: newTypeBsonAny
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldTypeBsonAnyAllowList:
        description: "old command fails because its type has a bson_serialization_type
                      that contains 'any' even when on the allow list"
        command_name: oldTypeBsonAnyAllowList
        namespace: type
        type: oldBsonSerializationTypeAny
        cpp_name: oldTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeBsonAnyAllowList:
        description: "new command fails because its type has a bson_serialization_type
                      that contains 'any' even when on the allow list"
        command_name: newTypeBsonAnyAllowList
        namespace: type
        type: newBsonSerializationTypeAny
        cpp_name: newTypeBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply

    typeBsonAnyNotAllowed:
        description: "command fails because its type has a bson_serialization_type
                      that contains 'any' that is not explicitly allowed"
        command_name: typeBsonAnyNotAllowed
        namespace: type
        type: bsonSerializationTypeAny
        cpp_name: typeBsonAnyNotAllowed
        strict: true
        api_version: "1"
        reply_type: OkReply

    commandCppTypeNotEqual:
        description: "command fails because its type has a bson_serialization_type
                      that contains 'any' and the cpp_types are not equal"
        command_name: commandCppTypeNotEqual
        namespace: type
        type: bsonSerializationTypeAnyCppTypeNotEqual
        cpp_name: commandCppTypeNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeNotSuperset:
        description: "new command fails because its type is not a superset
                      of the old type"
        command_name: newTypeNotSuperset
        namespace: type
        type: intStringBoolToIntString
        cpp_name: newTypeNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeEnumNotSuperset:
        description: "new command fails because its type is an enum that is not
                      a superset of the corresponding old type's enum values"
        command_name: newTypeEnumNotSuperset
        namespace: type
        type: EnumNotSuperset
        cpp_name: newTypeEnumNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeNotEnum:
        description: "new command fails because its type is not an enum when the
                      old type is an enum"
        command_name: newTypeNotEnum
        namespace: type
        type: StructType
        cpp_name: newTypeNotEnum
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeNotStruct:
        description: "new command fails because its type is not a struct when the
                      old type is a struct"
        command_name: newTypeNotStruct
        namespace: type
        type: EnumNotSuperset
        cpp_name: newTypeNotStruct
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeEnumOrStruct:
        description: "new command fails because the type is a non-enum or struct
                      type in the old command, and an enum or struct in the new command"
        command_name: newTypeEnumOrStruct
        namespace: type
        type: StructType
        cpp_name: newTypeEnumOrStruct
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeStructRecursive:
        description: "new command fails because its type is a struct that is
                      incompatible with the old type struct"
        command_name: newTypeStructRecursive
        namespace: type
        type: StructFieldTypeRecursiveReplyOne
        cpp_name: newTypeStructRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldUnstable:
        description: "new command fails because it contains an unstable type field that is stable
                      in the corresponding old command"
        command_name: newTypeFieldUnstable
        namespace: type
        type: UnstableNewFieldReply
        cpp_name: newTypeFieldUnstable
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldRequired:
        description: "new command fails because it contains a required reply field that is
                      optional in the corresponding old command"
        command_name: newTypeFieldRequired
        namespace: type
        type: RequiredNewField
        cpp_name: newTypeFieldRequired
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldMissing:
        description: "new command fails because it is missing a type field that exists in
                      the corresponding old command"
        command_name: newTypeFieldMissing
        namespace: type
        type: MissingNewFieldReply
        cpp_name: newTypeFieldMissing
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldAddedRequired:
        description: "new command fails because it has an added type field that is required
                      when it should be optional"
        command_name: newTypeFieldAddedRequired
        namespace: type
        type: AddedRequiredTypeFieldStruct
        cpp_name: newTypeFieldAddedRequired
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldStableRequired:
        description: "new required stable type field fails because it is unstable
                      in the corresponding old command"
        command_name: newTypeFieldStableRequired
        namespace: type
        type: StableRequiredTypeFieldStruct
        cpp_name: newTypeFieldStableRequired
        strict: true
        api_version: "1"
        reply_type: OkReply

    newReplyFieldVariantType:
        description: "new command fails because its reply field type is a variant type while
                      the old reply field is not a variant type"
        command_name: newReplyFieldVariantType
        namespace: ignored
        cpp_name: newReplyFieldVariantType
        strict: true
        api_version: "1"
        reply_type: NewVariantTypeReply
    
    newReplyFieldVariantNotSubset:
        description: "new command fails because its reply field type is a variant type that is not
                      a subset of the old reply field variant types"
        command_name: newReplyFieldVariantNotSubset
        namespace: ignored
        cpp_name: newReplyFieldVariantNotSubset
        strict: true
        api_version: "1"
        reply_type: NewVariantNotSubsetReply

    newReplyFieldVariantNotSubsetTwo:
        description: "new command fails because its reply field type is a variant type that is not
                      a subset of the old reply field variant types"
        command_name: newReplyFieldVariantNotSubsetTwo
        namespace: ignored
        cpp_name: newReplyFieldVariantNotSubsetTwo
        strict: true
        api_version: "1"
        reply_type: NewVariantNotSubsetReplyTwo

    replyFieldVariantRecursive:
        description: "new command fails because its reply field type is a variant type that is not
                      compatible with the old reply field variant type"
        command_name: replyFieldVariantRecursive
        namespace: ignored
        cpp_name: replyFieldVariantRecursive
        strict: true
        api_version: "1"
        reply_type: VariantRecursiveReply

    newReplyFieldVariantStructNotSubset:
        description: "new command fails because its reply field type is a variant type that is not
                      a subset of the old reply field variant types"
        command_name: newReplyFieldVariantStructNotSubset
        namespace: ignored
        cpp_name: newReplyFieldVariantStructNotSubset
        strict: true
        api_version: "1"
        reply_type: NewVariantStructNotSubsetReply
    
    replyFieldVariantStructRecursive:
        description: "new command fails because its reply field type has a variant
                      struct type that is not compatible with the old reply field variant
                      struct type"
        command_name: replyFieldVariantStructRecursive
        namespace: ignored
        cpp_name: replyFieldVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: VariantStructRecursiveReply

    newParamVariantNotSuperset:
        description: "new command fails because its parameter type is a variant type that is not
                      a superset of the old parameter variant types"
        command_name: newParamVariantNotSuperset
        namespace: ignored
        cpp_name: newParamVariantNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantNotSupersetParam:
                type: 
                    variant: [int, bool]

    newParamVariantNotSupersetTwo:
        description: "new command fails because its parameter type is a variant type that is not
                      a superset of the old parameter variant types"
        command_name: newParamVariantNotSupersetTwo
        namespace: ignored
        cpp_name: newParamVariantNotSupersetTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantNotSupersetParamTwo:
                type: 
                    variant: [int, string]

    newParamTypeNotVariant:
        description: "new command fails because its parameter type is not variant while the old
                      param type is"
        command_name: newParamTypeNotVariant
        namespace: ignored
        cpp_name: newParamTypeNotVariant
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantParam:
                type: int

    newParamVariantRecursive:
        description: "new command fails because its param type is a variant type that is not
                      compatible with the old param variant type"
        command_name: newParamVariantRecursive
        namespace: ignored
        cpp_name: newParamVariantRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantRecursiveParam:
                type: 
                    variant: [int, intStringBoolToIntString]

    newParamVariantStructNotSuperset:
        description: "new command fails because its parameter type is a variant type that is not
                      a subset of the old parameter variant types"
        command_name: newParamVariantStructNotSuperset
        namespace: ignored
        cpp_name: newParamVariantStructNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantStructNotSupersetParam:
                type: 
                    variant: [int, string]

    newParamVariantStructRecursive:
        description: "new command fails because its parameter type has a variant
                      struct type that is not compatible with the old parameter variant
                      struct type"
        command_name: newParamVariantStructRecursive
        namespace: ignored
        cpp_name: newParamVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantStructRecursiveParam:
                type:
                    variant: [int, string, StructCommandParameterTypeRecursive]

    newCommandTypeVariantNotSuperset:
        description: "new command fails because its type is a variant type that is not
                      a superset of the old type variant types"
        command_name: newCommandTypeVariantNotSuperset
        namespace: type
        type: VariantNotSupersetStruct
        cpp_name: newCommandTypeVariantNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantNotSupersetTwo:
        description: "new command fails because its type is a variant type that is not
                      a superset of the old command type variant types"
        command_name: newCommandTypeVariantNotSupersetTwo
        namespace: type
        type: VariantNotSupersetStructTwo
        cpp_name: newCommandTypeVariantNotSupersetTwo
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeNotVariant:
        description: "new command fails because its type is not variant while the old
                      type is"
        command_name: newCommandTypeNotVariant
        namespace: type
        type: NewTypeNotVariantStruct
        cpp_name: newCommandTypeNotVariant
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantRecursive:
        description: "new command fails because its type is a variant type that is not
                      compatible with the old command type variant type"
        command_name: newCommandTypeVariantRecursive
        namespace: type
        type: VariantRecursiveStruct
        cpp_name: newCommandTypeVariantRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantStructNotSuperset:
        description: "new command fails because its type is a variant type that is not
                      a superset of the old command type variant types"
        command_name: newCommandTypeVariantStructNotSuperset
        namespace: type
        type: VariantStructNotSupersetStruct
        cpp_name: newCommandTypeVariantStructNotSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantStructRecursive:
        description: "new command fails because its type has a variant
                      struct type that is not compatible with the old command type variant
                      struct type"
        command_name: newCommandTypeVariantStructRecursive
        namespace: type
        type: VariantStructRecursiveStruct
        cpp_name: newCommandTypeVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply

    newReplyFieldValidator:
        description: "new command fails because it contains a reply field that contains a validator
                      that is not present in the old reply field"
        command_name: newReplyFieldValidator
        namespace: ignored
        cpp_name: newReplyFieldValidator
        strict: true
        api_version: "1"
        reply_type: NewValidatorStruct

    replyFieldValidatorsNotEqual:
        description: "new command fails because it contains a reply field that contains a validator
                      that is not exactly equal to the old reply field validator"
        command_name: replyFieldValidatorsNotEqual
        namespace: ignored
        cpp_name: replyFieldValidatorsNotEqual
        strict: true
        api_version: "1"
        reply_type: ValidatorsNotEqualStruct

    simpleCheckNotEqual:
        description: "new command fails because its simple check is not equal to
                      the old check"
        command_name: simpleCheckNotEqual
        namespace: ignored
        cpp_name: simpleCheckNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                check: new

    simpleCheckNotEqualTwo:
        description: "new command fails because it has a privilege while the old command
                      has a check"
        command_name: simpleCheckNotEqualTwo
        namespace: ignored
        cpp_name: simpleCheckNotEqualTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                privilege:
                    resource_pattern: resourcePattern
                    action_type: actionType

    simpleCheckNotEqualThree:
        description: "new command fails because its simple check is not equal to
                      the old check"
        command_name: simpleCheckNotEqualThree
        namespace: ignored
        cpp_name: simpleCheckNotEqualThree
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                check: None

    simpleResourcePatternNotEqual:
        description: "new command fails because its simple privilege resource_pattern is not
                      equal to the old resource_pattern"
        command_name: simpleResourcePatternNotEqual
        namespace: ignored
        cpp_name: simpleResourcePatternNotEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                privilege:
                    resource_pattern: new
                    action_type: actionType

    newSimpleActionTypesNotSubset:
        description: "new command fails because its simple privilege resource_pattern is not
                      equal to the old resource_pattern"
        command_name: newSimpleActionTypesNotSubset
        namespace: ignored
        cpp_name: newSimpleActionTypesNotSubset
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionType, actionTypeThree]