- name: unique fields
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment uniqueFields on Dog {
            name
            nickname
          }
          
  errors: []
- name: identical fields
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment mergeIdenticalFields on Dog {
            name
            name
          }
          
  errors: []
- name: identical fields with identical args
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment mergeIdenticalFieldsWithIdenticalArgs on Dog {
            doesKnowCommand(dogCommand: SIT)
            doesKnowCommand(dogCommand: SIT)
          }
          
  errors: []
- name: identical fields with identical directives
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment mergeSameFieldsWithSameDirectives on Dog {
            name @include(if: true)
            name @include(if: true)
          }
          
  errors: []
- name: different args with different aliases
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment differentArgsWithDifferentAliases on Dog {
            knowsSit: doesKnowCommand(dogCommand: SIT)
            knowsDown: doesKnowCommand(dogCommand: DOWN)
          }
          
  errors: []
- name: different directives with different aliases
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment differentDirectivesWithDifferentAliases on Dog {
            nameIfTrue: name @include(if: true)
            nameIfFalse: name @include(if: false)
          }
          
  errors: []
- name: different skip/include directives accepted
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment differentDirectivesWithDifferentAliases on Dog {
            name @include(if: true)
            name @include(if: false)
          }
          
  errors: []
- name: Same aliases with different field targets
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment sameAliasesWithDifferentFieldTargets on Dog {
            fido: name
            fido: nickname
          }
          
  errors:
    - message: Fields "fido" conflict because name and nickname are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 9}
- name: Same aliases allowed on non-overlapping fields
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment sameAliasesWithDifferentFieldTargets on Pet {
            ... on Dog {
              name
            }
            ... on Cat {
              name: nickname
            }
          }
          
  errors: []
- name: Alias masking direct field access
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment aliasMaskingDirectFieldAccess on Dog {
            name: nickname
            name
          }
          
  errors:
    - message: Fields "name" conflict because nickname and name are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 9}
- name: 'different args, second adds an argument'
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment conflictingArgs on Dog {
            doesKnowCommand
            doesKnowCommand(dogCommand: HEEL)
          }
          
  errors:
    - message: Fields "doesKnowCommand" conflict because they have differing arguments. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 9}
- name: 'different args, second missing an argument'
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment conflictingArgs on Dog {
            doesKnowCommand(dogCommand: SIT)
            doesKnowCommand
          }
          
  errors:
    - message: Fields "doesKnowCommand" conflict because they have differing arguments. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 9}
- name: conflicting args
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment conflictingArgs on Dog {
            doesKnowCommand(dogCommand: SIT)
            doesKnowCommand(dogCommand: HEEL)
          }
          
  errors:
    - message: Fields "doesKnowCommand" conflict because they have differing arguments. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 9}
- name: allows different args where no conflict is possible
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment conflictingArgs on Pet {
            ... on Dog {
              name(surname: true)
            }
            ... on Cat {
              name
            }
          }
          
  errors: []
- name: encounters conflict in fragments
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            ...A
            ...B
          }
          fragment A on Type {
            x: a
          }
          fragment B on Type {
            x: b
          }
          
  errors:
    - message: Fields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 7, column: 9}
        - {line: 10, column: 9}
- name: reports each conflict once
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            f1 {
              ...A
              ...B
            }
            f2 {
              ...B
              ...A
            }
            f3 {
              ...A
              ...B
              x: c
            }
          }
          fragment A on Type {
            x: a
          }
          fragment B on Type {
            x: b
          }
          
  errors:
    - message: Fields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 18, column: 9}
        - {line: 21, column: 9}
    - message: Fields "x" conflict because c and a are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 14, column: 11}
        - {line: 18, column: 9}
    - message: Fields "x" conflict because c and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 14, column: 11}
        - {line: 21, column: 9}
- name: deep conflict
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              x: a
            },
            field {
              x: b
            }
          }
          
  errors:
    - message: Fields "field" conflict because subfields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 11}
        - {line: 6, column: 9}
        - {line: 7, column: 11}
- name: deep conflict with multiple issues
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              x: a
              y: c
            },
            field {
              x: b
              y: d
            }
          }
          
  errors:
    - message: Fields "field" conflict because subfields "x" conflict because a and b are different fields and subfields "y" conflict because c and d are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 11}
        - {line: 5, column: 11}
        - {line: 7, column: 9}
        - {line: 8, column: 11}
        - {line: 9, column: 11}
- name: very deep conflict
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              deepField {
                x: a
              }
            },
            field {
              deepField {
                x: b
              }
            }
          }
          
  errors:
    - message: Fields "field" conflict because subfields "deepField" conflict because subfields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 4, column: 11}
        - {line: 5, column: 13}
        - {line: 8, column: 9}
        - {line: 9, column: 11}
        - {line: 10, column: 13}
- name: reports deep conflict to nearest common ancestor
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              deepField {
                x: a
              }
              deepField {
                x: b
              }
            },
            field {
              deepField {
                y
              }
            }
          }
          
  errors:
    - message: Fields "deepField" conflict because subfields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 4, column: 11}
        - {line: 5, column: 13}
        - {line: 7, column: 11}
        - {line: 8, column: 13}
- name: reports deep conflict to nearest common ancestor in fragments
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              ...F
            }
            field {
              ...F
            }
          }
          fragment F on T {
            deepField {
              deeperField {
                x: a
              }
              deeperField {
                x: b
              }
            },
            deepField {
              deeperField {
                y
              }
            }
          }
          
  errors:
    - message: Fields "deeperField" conflict because subfields "x" conflict because a and b are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 12, column: 11}
        - {line: 13, column: 13}
        - {line: 15, column: 11}
        - {line: 16, column: 13}
- name: reports deep conflict in nested fragments
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          {
            field {
              ...F
            }
            field {
              ...I
            }
          }
          fragment F on T {
            x: a
            ...G
          }
          fragment G on T {
            y: c
          }
          fragment I on T {
            y: d
            ...J
          }
          fragment J on T {
            x: b
          }
          
  errors:
    - message: Fields "field" conflict because subfields "x" conflict because a and b are different fields and subfields "y" conflict because c and d are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 3, column: 9}
        - {line: 11, column: 9}
        - {line: 15, column: 9}
        - {line: 6, column: 9}
        - {line: 22, column: 9}
        - {line: 18, column: 9}
- name: ignores unknown fragments
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
        
        {
          field
          ...Unknown
          ...Known
        }
        
        fragment Known on T {
          field
          ...OtherUnknown
        }
        
  errors: []
- name: return types must be unambiguous/conflicting return types which potentially overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ...on IntBox {
                  scalar
                }
                ...on NonNullStringBox1 {
                  scalar
                }
              }
            }
            
  errors:
    - message: Fields "scalar" conflict because they return conflicting types Int and String!. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 5, column: 15}
        - {line: 8, column: 15}
- name: return types must be unambiguous/compatible return shapes on different return types
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
          
          {
            someBox {
              ... on SomeBox {
                deepBox {
                  unrelatedField
                }
              }
              ... on StringBox {
                deepBox {
                  unrelatedField
                }
              }
            }
          }
          
  errors: []
- name: return types must be unambiguous/disallows differing return types despite no overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  scalar
                }
                ... on StringBox {
                  scalar
                }
              }
            }
            
  errors:
    - message: Fields "scalar" conflict because they return conflicting types Int and String. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 5, column: 15}
        - {line: 8, column: 15}
- name: return types must be unambiguous/reports correctly when a non-exclusive follows an exclusive
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  deepBox {
                    ...X
                  }
                }
              }
              someBox {
                ... on StringBox {
                  deepBox {
                    ...Y
                  }
                }
              }
              memoed: someBox {
                ... on IntBox {
                  deepBox {
                    ...X
                  }
                }
              }
              memoed: someBox {
                ... on StringBox {
                  deepBox {
                    ...Y
                  }
                }
              }
              other: someBox {
                ...X
              }
              other: someBox {
                ...Y
              }
            }
            fragment X on SomeBox {
              scalar
            }
            fragment Y on SomeBox {
              scalar: unrelatedField
            }
            
  errors:
    - message: Fields "other" conflict because subfields "scalar" conflict because scalar and unrelatedField are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 31, column: 11}
        - {line: 39, column: 11}
        - {line: 34, column: 11}
        - {line: 42, column: 11}
- name: return types must be unambiguous/disallows differing return type nullability despite no overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on NonNullStringBox1 {
                  scalar
                }
                ... on StringBox {
                  scalar
                }
              }
            }
            
  errors:
    - message: Fields "scalar" conflict because they return conflicting types String! and String. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 5, column: 15}
        - {line: 8, column: 15}
- name: return types must be unambiguous/disallows differing return type list despite no overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  box: listStringBox {
                    scalar
                  }
                }
                ... on StringBox {
                  box: stringBox {
                    scalar
                  }
                }
              }
            }
            
  errors:
    - message: 'Fields "box" conflict because they return conflicting types [StringBox] and StringBox. Use different aliases on the fields to fetch both if this was intentional.'
      locations:
        - {line: 5, column: 15}
        - {line: 10, column: 15}
- name: return types must be unambiguous/disallows differing return type list despite no overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  box: stringBox {
                    scalar
                  }
                }
                ... on StringBox {
                  box: listStringBox {
                    scalar
                  }
                }
              }
            }
            
  errors:
    - message: 'Fields "box" conflict because they return conflicting types StringBox and [StringBox]. Use different aliases on the fields to fetch both if this was intentional.'
      locations:
        - {line: 5, column: 15}
        - {line: 10, column: 15}
- name: return types must be unambiguous/disallows differing subfields
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  box: stringBox {
                    val: scalar
                    val: unrelatedField
                  }
                }
                ... on StringBox {
                  box: stringBox {
                    val: scalar
                  }
                }
              }
            }
            
  errors:
    - message: Fields "val" conflict because scalar and unrelatedField are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 6, column: 17}
        - {line: 7, column: 17}
- name: return types must be unambiguous/disallows differing deep return types despite no overlap
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  box: stringBox {
                    scalar
                  }
                }
                ... on StringBox {
                  box: intBox {
                    scalar
                  }
                }
              }
            }
            
  errors:
    - message: Fields "box" conflict because subfields "scalar" conflict because they return conflicting types String and Int. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 5, column: 15}
        - {line: 6, column: 17}
        - {line: 10, column: 15}
        - {line: 11, column: 17}
- name: return types must be unambiguous/allows non-conflicting overlaping types
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ... on IntBox {
                  scalar: unrelatedField
                }
                ... on StringBox {
                  scalar
                }
              }
            }
            
  errors: []
- name: return types must be unambiguous/same wrapped scalar return types
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ...on NonNullStringBox1 {
                  scalar
                }
                ...on NonNullStringBox2 {
                  scalar
                }
              }
            }
            
  errors: []
- name: return types must be unambiguous/allows inline typeless fragments
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              a
              ... {
                a
              }
            }
            
  errors: []
- name: return types must be unambiguous/compares deep types including list
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              connection {
                ...edgeID
                edges {
                  node {
                    id: name
                  }
                }
              }
            }
            
            fragment edgeID on Connection {
              edges {
                node {
                  id
                }
              }
            }
            
  errors:
    - message: Fields "edges" conflict because subfields "node" conflict because subfields "id" conflict because name and id are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 5, column: 13}
        - {line: 6, column: 15}
        - {line: 7, column: 17}
        - {line: 14, column: 11}
        - {line: 15, column: 13}
        - {line: 16, column: 15}
- name: return types must be unambiguous/ignores unknown types
  rule: OverlappingFieldsCanBeMerged
  schema: 1
  query: |2-
            
            {
              someBox {
                ...on UnknownType {
                  scalar
                }
                ...on NonNullStringBox2 {
                  scalar
                }
              }
            }
            
  errors: []
- name: return types must be unambiguous/works for field names that are JS keywords
  rule: OverlappingFieldsCanBeMerged
  schema: 2
  query: |2-
            
              foo {
                constructor
              }
            }
  errors: []
- name: does not infinite loop on recursive fragment
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment fragA on Human { name, relatives { name, ...fragA } }
          
  errors: []
- name: does not infinite loop on immediately recursive fragment
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment fragA on Human { name, ...fragA }
          
  errors: []
- name: does not infinite loop on transitively recursive fragment
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment fragA on Human { name, ...fragB }
          fragment fragB on Human { name, ...fragC }
          fragment fragC on Human { name, ...fragA }
          
  errors: []
- name: finds invalid case even with immediately recursive fragment
  rule: OverlappingFieldsCanBeMerged
  schema: 0
  query: |2-
          
          fragment sameAliasesWithDifferentFieldTargets on Dog {
            ...sameAliasesWithDifferentFieldTargets
            fido: name
            fido: nickname
          }
          
  errors:
    - message: Fields "fido" conflict because name and nickname are different fields. Use different aliases on the fields to fetch both if this was intentional.
      locations:
        - {line: 4, column: 9}
        - {line: 5, column: 9}