Python utils.expect_fails_rule函数代码示例

def test_no_spreading_itself_deeply():
    expect_fails_rule(
        NoFragmentCycles, '''
    fragment fragA on Dog { ...fragB }
    fragment fragB on Dog { ...fragC }
    fragment fragC on Dog { ...fragO }
    fragment fragX on Dog { ...fragY }
    fragment fragY on Dog { ...fragZ }
    fragment fragZ on Dog { ...fragO }
    fragment fragO on Dog { ...fragP }
    fragment fragP on Dog { ...fragA, ...fragX }
    ''', [
            cycle_error_message(
                'fragA', [
                    'fragB', 'fragC', 'fragO', 'fragP'], L(
                    2, 29), L(
                        3, 29), L(
                            4, 29), L(
                                8, 29), L(
                                    9, 29)), cycle_error_message(
                                        'fragO', [
                                            'fragP', 'fragX', 'fragY', 'fragZ'], L(
                                                8, 29), L(
                                                    9, 39), L(
                                                        5, 29), L(
                                                            6, 29), L(
                                                                7, 29))])

def test_contains_unknown_fragments_with_ref_cycle():
    expect_fails_rule(NoUnusedFragments, '''
      query Foo {
        human(id: 4) {
          ...HumanFields1
        }
      }
      query Bar {
        human(id: 4) {
          ...HumanFields2
        }
      }
      fragment HumanFields1 on Human {
        name
        ...HumanFields3
      }
      fragment HumanFields2 on Human {
        name
      }
      fragment HumanFields3 on Human {
        name
      }
      fragment Unused1 on Human {
        name
        ...Unused2
      }
      fragment Unused2 on Human {
        name
        ...Unused1
      }
    ''', [
        unused_fragment('Unused1', 22, 7),
        unused_fragment('Unused2', 26, 7),
    ])

def test_with_misplaced_directives():
    expect_fails_rule(KnownDirectives, '''
      query Foo @include(if: true) {
        name
        ...Frag
      }
    ''', [misplaced_directive('include', 'operation', 2, 17)])

def test_reports_each_conflict_once():
    expect_fails_rule(OverlappingFieldsCanBeMerged, '''
    {
        f1 {
            ...A
            ...B
        }
        f2 {
            ...B
            ...A
        }
        f3 {
            ...A
            ...B
            x: c
        }
    }
    fragment A on Type {
        x: a
    }
    fragment B on Type {
        x: b
    }
    ''', [
        fields_conflict('x', 'a and b are different fields', L(18, 9), L(21, 9)),
        fields_conflict('x', 'a and c are different fields', L(18, 9), L(14, 13)),
        fields_conflict('x', 'b and c are different fields', L(21, 9), L(14, 13))
    ], sort_list=False)

def test_unknown_args_amongst_known_args():
    expect_fails_rule(KnownArgumentNames, '''
      fragment oneGoodArgOneInvalidArg on Dog {
        doesKnowCommand(whoknows: 1, dogCommand: SIT, unknown: true)
      }
    ''', [unknown_arg('whoknows', 'doesKnowCommand', 'Dog', 3, 25),
          unknown_arg('unknown', 'doesKnowCommand', 'Dog', 3, 55)])

def test_interface_into_non_overlapping_interface():
    expect_fails_rule(PossibleFragmentSpreads, '''
      fragment invalidInterfaceWithinInterface on Pet {
        ...intelligentFragment
      }
      fragment intelligentFragment on Intelligent { iq }
    ''', [error('intelligentFragment', 'Pet', 'Intelligent', 3, 9)])

def test_duplicate_field_arguments():
  expect_fails_rule(UniqueArgumentNames, '''
    {
      field(arg1: "value", arg1: "value")
    }
  ''', [duplicate_arg('arg1', 3, 13, 3, 28)]
  )

def test_no_spreading_itself_indirectly_reports_opposite_order():
    expect_fails_rule(NoFragmentCycles, '''
    fragment fragB on Dog { ...fragA }
    fragment fragA on Dog { ...fragB }
    ''', [
        cycle_error_message('fragB', ['fragA'], L(2, 29), L(3, 29))
    ])

def test_duplicate_directive_arguments():
  expect_fails_rule(UniqueArgumentNames, '''
    {
      field @directive(arg1: "value", arg1: "value")
    }
  ''', [duplicate_arg('arg1', 3, 24, 3, 39)]
  )

def test_variable_not_used():
    expect_fails_rule(NoUnusedVariables, '''
      query Foo($a: String, $b: String, $c: String) {
        field(a: $a, b: $b)
      }
    ''', [
        unused_variable('c', 2, 41)
    ])

def test_field_not_defined_on_fragment():
    expect_fails_rule(FieldsOnCorrectType, '''
      fragment fieldNotDefined on Dog {
        meowVolume
      }
    ''', [
        undefined_field('meowVolume', 'Dog', 3, 9)
    ])

def test_defined_on_implementors_queried_on_union():
    expect_fails_rule(FieldsOnCorrectType, '''
      fragment definedOnImplementorsQueriedOnUnion on CatOrDog {
        name
      }
    ''', [
        undefined_field('name', 'CatOrDog', 3, 9)
    ])

def test_scalar_selection_not_allowed_on_enum():
    expect_fails_rule(ScalarLeafs, '''
      fragment scalarSelectionsNotAllowedOnEnum on Cat {
        furColor { inHexdec }
      }
    ''', [
        no_scalar_subselection('furColor', 'FurColor', 3, 18)
    ])

def test_input_object_is_invalid_fragment_type():
    expect_fails_rule(FragmentsOnCompositeTypes, '''
      fragment inputFragment on ComplexInput {
        stringField
      }
    ''', [
        fragment_on_non_composite_error('inputFragment', 'ComplexInput', 2, 33)
    ])

def test_scalar_selection_not_allowed_with_directives():
    expect_fails_rule(ScalarLeafs, '''
      fragment scalarSelectionsNotAllowedWithDirectives on Dog {
        name @include(if: true) { isAlsoHumanName }
      }
    ''', [
        no_scalar_subselection('name', 'String', 3, 33)
    ])