add_mutation_test.yaml

-
  name: "Add mutation with variables"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          name
        }
      }
    }
  gqlvariables: |
    { "auth":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": []
      }
    }
  explanation: "A uid and type should get injected and all data transformed to
    underlying Dgraph edge names"
  dgmutations:
    - setjson: |
        { "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.dob":"2000-01-01",
          "Author.posts":[]
        }

-
  name: "Add deep mutation with variables"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          name
        }
      }
    }
  gqlvariables: |
    { "auth":
      { "name": "A.N. Author",
        "posts": [{
                "title": "post1",
                "ps": {"title": "ps1"}
        }, {
                "title": "post2",
                "ps": {"title": "ps2"}
        }, {
                "title": "post3",
                "ps": {"title": "ps3"}
        }, {
                "title": "post4",
                "ps": {"title": "ps4"}
        }, {
                "title": "post5",
                "ps": {"title": "ps5"}
        }, {
                "title": "post6",
                "ps": {"title": "ps6"}
        }, {
                "title": "post7",
                "ps": {"title": "ps7"}
        }, {
                "title": "post8",
                "ps": {"title": "ps8"}
        }]
      }
    }
  explanation: "A uid and type should get injected and all data transformed to
    underlying Dgraph edge names"
  dgquery: |-
    query {
      PostSecret4 as PostSecret4(func: eq(PostSecret.title, "ps1")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret7 as PostSecret7(func: eq(PostSecret.title, "ps2")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret10 as PostSecret10(func: eq(PostSecret.title, "ps3")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret13 as PostSecret13(func: eq(PostSecret.title, "ps4")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret16 as PostSecret16(func: eq(PostSecret.title, "ps5")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret19 as PostSecret19(func: eq(PostSecret.title, "ps6")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret22 as PostSecret22(func: eq(PostSecret.title, "ps7")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret25 as PostSecret25(func: eq(PostSecret.title, "ps8")) @filter(type(PostSecret)) {
        uid
      }
    }
  dgquerysec: |-
    query {
      PostSecret4 as PostSecret4(func: eq(PostSecret.title, "ps1")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret7 as PostSecret7(func: eq(PostSecret.title, "ps2")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret10 as PostSecret10(func: eq(PostSecret.title, "ps3")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret13 as PostSecret13(func: eq(PostSecret.title, "ps4")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret16 as PostSecret16(func: eq(PostSecret.title, "ps5")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret19 as PostSecret19(func: eq(PostSecret.title, "ps6")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret22 as PostSecret22(func: eq(PostSecret.title, "ps7")) @filter(type(PostSecret)) {
        uid
      }
      PostSecret25 as PostSecret25(func: eq(PostSecret.title, "ps8")) @filter(type(PostSecret)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        {
          "PostSecret.title": "ps1",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret4"
        }
      cond: "@if(eq(len(PostSecret4), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps2",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret7"
        }
      cond: "@if(eq(len(PostSecret7), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps3",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret10"
        }
      cond: "@if(eq(len(PostSecret10), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps4",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret13"
        }
      cond: "@if(eq(len(PostSecret13), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps5",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret16"
        }
      cond: "@if(eq(len(PostSecret16), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps6",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret19"
        }
      cond: "@if(eq(len(PostSecret19), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps7",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret22"
        }
      cond: "@if(eq(len(PostSecret22), 0))"
    - setjson: |
        {
          "PostSecret.title": "ps8",
          "dgraph.type": [
            "PostSecret"
            ],
          "uid": "_:PostSecret25"
        }
      cond: "@if(eq(len(PostSecret25), 0))"
  dgmutationssec:
    - setjson: |
        {
          "Author.name": "A.N. Author",
          "Author.posts": [{
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret4)"
            },
            "Post.title": "post1",
            "dgraph.type": ["Post"],
            "uid": "_:Post2"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret7)"
            },
            "Post.title": "post2",
            "dgraph.type": ["Post"],
            "uid": "_:Post5"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret10)"
            },
            "Post.title": "post3",
            "dgraph.type": ["Post"],
            "uid": "_:Post8"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret13)"
            },
            "Post.title": "post4",
            "dgraph.type": ["Post"],
            "uid": "_:Post11"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret16)"
            },
            "Post.title": "post5",
            "dgraph.type": ["Post"],
            "uid": "_:Post14"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret19)"
            },
            "Post.title": "post6",
            "dgraph.type": ["Post"],
            "uid": "_:Post17"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret22)"
            },
            "Post.title": "post7",
            "dgraph.type": ["Post"],
            "uid": "_:Post20"
          }, {
            "Post.author": {
              "uid": "_:Author1"
            },
            "Post.ps": {
              "uid": "uid(PostSecret25)"
            },
            "Post.title": "post8",
            "dgraph.type": ["Post"],
            "uid": "_:Post23"
          }],
          "dgraph.type": ["Author"],
          "uid": "_:Author1"
        }
      cond: "@if(eq(len(PostSecret4), 1) AND eq(len(PostSecret7), 1) AND eq(len(PostSecret10), 1) AND eq(len(PostSecret13), 1) AND eq(len(PostSecret16), 1) AND eq(len(PostSecret19), 1) AND eq(len(PostSecret22), 1) AND eq(len(PostSecret25), 1))"

-
  name: "Add mutation for predicates with special characters having @dgraph directive."
  gqlmutation: |
    mutation {
      addMessage(input : [{content : "content1", author: "author1"}]) {
        message {
          content
          author
        }
      }
    }
  dgmutations:
    - setjson: |
        {
          "uid":"_:Message1",
          "dgraph.type":["Message"],
          "职业":"author1",
          "post":"content1"
        }

-
  name: "Add multiple mutation with variables"
  gqlmutation: |
    mutation addAuthor($auth: [AddAuthorInput!]!) {
      addAuthor(input: $auth) {
        author {
          name
        }
      }
    }
  gqlvariables: |
    {
      "auth": [{
          "name": "A.N. Author"
        },
        {
          "name": "Different Author"
        }
      ]
    }
  explanation: "A uid and type should get injected and all data transformed to
    underlying Dgraph edge names"
  dgmutations:
    - setjson: |
        { "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author"
        }
    - setjson: |
        { "uid":"_:Author2",
          "dgraph.type":["Author"],
          "Author.name":"Different Author"
        }

-
  name: "Add Mutation with embedded value"
  gqlmutation: |
    mutation addAuthor {
      addAuthor(input: [{ name: "A.N. Author", posts: []}]) {
        author {
          name
        }
      }
    }
  explanation: "The input should be used for the mutation, with a uid and type getting
    injected and all data transformed to underlying Dgraph edge names"
  dgmutations:
    - setjson: |
        { "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.posts":[]
        }

-
  name: "Add Mutation with Password field"
  gqlmutation: |
    mutation addUser($name: String!, $pwd: String!) {
      addUser(input: [{ name: $name, pwd: $pwd}]) {
        user {
          name
        }
      }
    }
  gqlvariables: |
    { "name":  "A.N. Author", "pwd": "Password" }
  explanation: "The input and variables should be used for the mutation, with a uid and type
    getting injected and all data transformed to underlying Dgraph edge names"
  dgmutations:
    - setjson: |
        { "uid":"_:User2",
          "dgraph.type":["User"],
          "User.name":"A.N. Author",
          "User.pwd":"Password"
        }
      cond: "@if(eq(len(User2), 0))"
  dgquery: |-
    query {
      User2 as User2(func: eq(User.name, "A.N. Author")) @filter(type(User)) {
        uid
      }
    }

-
  name: "Add Multiple Mutations with embedded value"
  gqlmutation: |
    mutation addAuthor {
      addAuthor(input: [{ name: "A.N. Author", posts: []},
                        { name: "Different Author", posts: []}]) {
        author {
          name
        }
      }
    }
  explanation: "The input should be used for the mutation, with a uid and type getting
    injected and all data transformed to underlying Dgraph edge names"
  dgmutations:
    - setjson: |
        { "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.posts":[]
        }
    - setjson: |
        { "uid":"_:Author2",
          "dgraph.type":["Author"],
          "Author.name":"Different Author",
          "Author.posts":[]
        }

-
  name: "Add mutation with reference"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          name
        }
      }
    }
  gqlvariables: |
    { "auth":
      { "name": "A.N. Author",
        "country": { "id": "0x123" },
        "posts": []
      }
    }
  explanation: "The reference to country should get transformed to 'uid' for the
    Dgraph JSON mutation"
  dgquery: |-
    query {
      Country2 as Country2(func: uid(0x123)) @filter(type(Country)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        { "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.country": { "uid": "0x123" },
          "Author.posts":[]
        }
      cond: "@if(eq(len(Country2), 1))"

-
  name: "Add mutation with invalid reference"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          name
        }
      }
    }
  gqlvariables: |
    { "auth":
      { "name": "A.N. Author",
        "country": { "id": "HI!" },
        "posts": []
      }
    }
  explanation: "A reference must be a valid UID"
  error:
    { "message":
      "failed to rewrite mutation payload because ID argument (HI!) was not able to be parsed" }

-
  name: "Add mutation with inverse reference"
  gqlmutation: |
    mutation addPost($post: AddPostInput!) {
      addPost(input: [$post]) {
        post {
          postID
        }
      }
    }
  gqlvariables: |
    { "post":
      { "title": "Exciting post",
        "text": "A really good post",
        "author": { "id": "0x2" }
      }
    }
  explanation: "The reference to the author node should be transformed to include
    a new 'posts' edge."
  dgquery: |-
    query {
      Author2 as Author2(func: uid(0x2)) @filter(type(Author)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:Post1",
          "dgraph.type" : ["Post"],
          "Post.title" : "Exciting post",
          "Post.text" : "A really good post",
          "Post.author": {
            "uid" : "0x2",
            "Author.posts" : [ { "uid": "_:Post1" } ]
          }
        }
      cond: "@if(eq(len(Author2), 1))"

-
  name: "Add mutation for a type that implements an interface"
  gqlmutation: |
    mutation addHuman($human: AddHumanInput!) {
      addHuman(input: [$human]) {
        human {
          name
          dob
          female
        }
      }
    }
  gqlvariables: |
    { "human":
      { "name": "Bob",
        "dob": "2000-01-01",
        "female": true,
        "ename": "employee no. 1"
      }
    }
  explanation: "The mutation should get rewritten with correct edges from the interface."
  dgmutations:
    - setjson: |
        { "uid" : "_:Human1",
          "Character.name": "Bob",
          "Employee.ename": "employee no. 1",
          "Human.dob": "2000-01-01",
          "Human.female": true,
          "dgraph.type": ["Human", "Character", "Employee"]
        }

-
  name: "Add mutation using xid code"
  gqlmutation: |
    mutation addState($input: AddStateInput!) {
      addState(input: [$input]) {
        state {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "code": "nsw",
        "name": "NSW",
        "country": { "id": "0x12" }
      }
    }
  explanation: "The add mutation should get rewritten into a Dgraph upsert mutation"
  dgquery: |-
    query {
      State2 as State2(func: eq(State.code, "nsw")) @filter(type(State)) {
        uid
      }
      Country3 as Country3(func: uid(0x12)) @filter(type(Country)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:State2",
          "dgraph.type": ["State"],
          "State.name": "NSW",
          "State.code": "nsw",
          "State.country": {
            "uid": "0x12",
            "Country.states": [ { "uid": "_:State2" } ]
          }
        }
      cond: "@if(eq(len(State2), 0) AND eq(len(Country3), 1))"

-
  name: "Add mutation using code on type which also has an ID field"
  gqlmutation: |
    mutation addEditor($input: AddEditorInput!) {
      addEditor(input: [$input]) {
        editor {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "code": "editor",
        "name": "A.N. Editor"
      }
    }
  explanation: "The add mutation should get rewritten into a Dgraph upsert mutation"
  dgquery: |-
    query {
      Editor2 as Editor2(func: eq(Editor.code, "editor")) @filter(type(Editor)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:Editor2",
          "dgraph.type": ["Editor"],
          "Editor.name": "A.N. Editor",
          "Editor.code": "editor"
        }
      cond: "@if(eq(len(Editor2), 0))"

-
  name: "Deep add mutation"
  gqlmutation: |
    mutation addAuthor($author: AddAuthorInput!) {
      addAuthor(input: [$author]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New post",
            "text": "A really new post"
          }
        ]
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:Author1",
          "dgraph.type" : [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type" : [ "Post" ],
              "Post.title" : "New post",
              "Post.text" : "A really new post",
              "Post.author": {
                "uid" : "_:Author1"
              }
            }
          ]
        }

-
  name: "Deep add multiple mutation"
  gqlmutation: |
    mutation addAuthor($author: [AddAuthorInput!]!) {
      addAuthor(input: $author) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author": [
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New post",
            "text": "A really new post"
          }
        ]
      },
      { "name": "Different Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New New post",
            "text": "A wonderful post"
          }
        ]
      }]
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:Author1",
          "dgraph.type" : [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type" : [ "Post" ],
              "Post.title" : "New post",
              "Post.text" : "A really new post",
              "Post.author": {
                "uid" : "_:Author1"
              }
            }
          ]
        }
    - setjson: |
        { "uid" : "_:Author3",
          "dgraph.type" : [ "Author" ],
          "Author.name": "Different Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post4",
              "dgraph.type" : [ "Post" ],
              "Post.title" : "New New post",
              "Post.text" : "A wonderful post",
              "Post.author": {
                "uid" : "_:Author3"
              }
            }
          ]
        }

-
  name: "Deep add with existing"
  gqlmutation: |
    mutation addAuthor($author: AddAuthorInput!) {
      addAuthor(input: [$author]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New post",
            "text": "A really new post"
          },
          {
            "postID": "0x123",
            "title": "Old post",
            "text": "A really old post"
          }
        ]
      }
    }
  dgquery: |-
    query {
      Post3 as Post3(func: uid(0x123)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post3)) {
        Author4 as Post.author
      }
    }
  dgmutations:
    - setjson: |
        { "uid": "_:Author1",
          "dgraph.type": [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type": [ "Post" ],
              "Post.title": "New post",
              "Post.text": "A really new post",
              "Post.author": {
                "uid": "_:Author1"
              }
            },
            {
              "uid": "0x123",
              "Post.author": {
                "uid": "_:Author1"
              }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Author4)",
            "Author.posts": [{"uid": "uid(Post3)"}]
          }
        ]
      cond: "@if(eq(len(Post3), 1))"

-
  name: "Deep add multiple with existing"
  gqlmutation: |
    mutation addAuthor($author: [AddAuthorInput!]!) {
      addAuthor(input: $author) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author": [
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New post",
            "text": "A really new post"
          },
          {
            "postID": "0x123",
            "title": "Old post",
            "text": "A really old post"
          }
        ]
      },
      { "name": "Different Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "New new post",
            "text": "A wonderful post"
          },
          {
            "postID": "0x124",
            "title": "Another Old post",
            "text": "Another old post text"
          }
        ]
      }]
    }
  dgquery: |-
    query {
      Post3 as Post3(func: uid(0x123)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post3)) {
        Author4 as Post.author
      }
      Post7 as Post7(func: uid(0x124)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post7)) {
        Author8 as Post.author
      }
    }
  dgmutations:
    - setjson: |
        { "uid": "_:Author1",
          "dgraph.type": [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type": [ "Post" ],
              "Post.title": "New post",
              "Post.text": "A really new post",
              "Post.author": {
                "uid": "_:Author1"
              }
            },
            {
              "uid": "0x123",
              "Post.author": {
                "uid": "_:Author1"
              }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Author4)",
            "Author.posts": [
              {
              "uid": "uid(Post3)"
              }
            ]
          }
        ]
      cond: "@if(eq(len(Post3), 1))"
    - setjson: |
        { "uid": "_:Author5",
          "dgraph.type": [ "Author" ],
          "Author.name": "Different Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post6",
              "dgraph.type": [ "Post" ],
              "Post.title": "New new post",
              "Post.text": "A wonderful post",
              "Post.author": {
                "uid": "_:Author5"
              }
            },
            {
              "uid": "0x124",
              "Post.author": {
                "uid": "_:Author5"
              }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Author8)",
            "Author.posts": [
              {
              "uid": "uid(Post7)"
              }
            ]
          }
        ]
      cond: "@if(eq(len(Post7), 1))"

-
  name: "Deep add with two existing"
  gqlmutation: |
    mutation addAuthor($author: AddAuthorInput!) {
      addAuthor(input: [$author]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "postID": "0x123",
            "title": "Old post",
            "text": "A really old post"
          },
          {
            "postID": "0x456"
          }
        ]
      }
    }
  dgquery: |-
    query {
      Post2 as Post2(func: uid(0x123)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post2)) {
        Author3 as Post.author
      }
      Post4 as Post4(func: uid(0x456)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post4)) {
        Author5 as Post.author
      }
    }
  dgmutations:
    - setjson: |
        { "uid": "_:Author1",
          "dgraph.type": [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "0x123",
              "Post.author": {
                "uid": "_:Author1"
              }
            },
            {
              "uid": "0x456",
              "Post.author": {
                "uid": "_:Author1"
              }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Author3)",
            "Author.posts": [{"uid": "uid(Post2)"}]
          },
          {
            "uid": "uid(Author5)",
            "Author.posts": [{"uid": "uid(Post4)"}]
          }
        ]
      cond: "@if(eq(len(Post2), 1) AND eq(len(Post4), 1))"

-
  name: "Deep add with null"
  gqlmutation: |
    mutation addAuthor($author: AddAuthorInput!) {
      addAuthor(input: [$author]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "postID": null,
            "title": "New post",
            "text": "A really new post"
          }
        ]
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:Author1",
          "dgraph.type" : [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type" : [ "Post" ],
              "Post.title" : "New post",
              "Post.text" : "A really new post",
              "Post.author": {
                "uid" : "_:Author1"
              }
            }
          ]
        }

-
  name: "Add three deep"
  gqlmutation: |
    mutation addAuthor($author: AddAuthorInput!) {
      addAuthor(input: [$author]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    { "author":
      { "name": "A.N. Author",
        "dob": "2000-01-01",
        "posts": [
          {
            "title": "Exciting post",
            "text": "A really good post",
            "category": {
              "name": "New Category"
            }
          }
        ]
      }
    }
  dgmutations:
    - setjson: |
        { "uid": "_:Author1",
          "dgraph.type": [ "Author" ],
          "Author.name": "A.N. Author",
          "Author.dob": "2000-01-01",
          "Author.posts": [
            {
              "uid": "_:Post2",
              "dgraph.type": [ "Post" ],
              "Post.title": "Exciting post",
              "Post.text": "A really good post",
              "Post.author": {
                "uid": "_:Author1"
              },
              "Post.category": {
                "uid": "_:Category3",
                "dgraph.type": [ "Category" ],
                "Category.name": "New Category",
                "Category.posts": [
                  { "uid": "_:Post2" }
                ]
              }
            }
          ]
        }

-
  name: "Add mutation with deep xid choices"
  gqlmutation: |
    mutation addCountry($input: AddCountryInput!) {
      addCountry(input: [$input]) {
        country {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "name": "Dgraph Land",
        "states": [ {
          "code": "dg",
          "name": "Dgraph"
        } ]
      }
    }
  explanation: "The add mutation has two options depending on if dg exists"
  dgquery: |-
    query {
      State3 as State3(func: eq(State.code, "dg")) @filter(type(State)) {
        uid
      }
    }

  dgmutations:
    - setjson: |
        {
          "State.code": "dg",
          "State.name": "Dgraph",
          "dgraph.type": [
            "State"
          ],
          "uid": "_:State3"
        }
      cond: "@if(eq(len(State3), 0))"

  dgquerysec: |-
    query {
      State3 as State3(func: eq(State.code, "dg")) @filter(type(State)) {
        uid
      }
      var(func: uid(State3)) {
        Country4 as State.country
      }
    }

  dgmutationssec:
    - setjson: |
        {
          "uid": "_:Country1",
          "dgraph.type": ["Country"],
          "Country.name": "Dgraph Land",
          "Country.states": [ {
            "uid": "uid(State3)",
            "State.country": {
              "uid": "_:Country1"
            }
          } ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Country4)",
            "Country.states": [{"uid": "uid(State3)"}]
          }
        ]
      cond: "@if(eq(len(State3), 1))"

-
  name: "Add mutation with deep xid that must be reference"
  gqlmutation: |
    mutation addCountry($input: AddCountryInput!) {
      addCountry(input: [$input]) {
        country {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "name": "Dgraph Land",
        "states": [ {
          "code": "dg"
        } ]
      }
    }
  explanation: "The add mutation has only one option because the state isn't a valid create
    because it's missing required field name"
  dgquery: |-
    query {
      State3 as State3(func: eq(State.code, "dg")) @filter(type(State)) {
        uid
      }
      var(func: uid(State3)) {
        Country4 as State.country
      }
    }
  dgmutations:
    - setjson: |
        {
          "uid": "_:Country1",
          "dgraph.type": ["Country"],
          "Country.name": "Dgraph Land",
          "Country.states": [ {
            "uid": "uid(State3)",
            "State.country": {
              "uid": "_:Country1"
            }
          } ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Country4)",
            "Country.states": [{"uid": "uid(State3)"}]
          }
        ]
      cond: "@if(eq(len(State3), 1))"


-
  name: "deprecated fields can be mutated"
  gqlmutation: |
    mutation addCategory($cat: AddCategoryInput!) {
      addCategory(input: [$cat]) {
        category {
          name
          iAmDeprecated
        }
      }
    }
  gqlvariables: |
    { "cat":
      { "name": "A Category",
        "iAmDeprecated": "but I can be written to"
      }
    }
  dgmutations:
    - setjson: |
        { "uid": "_:Category1",
          "dgraph.type": ["Category"],
          "Category.name": "A Category",
          "Category.iAmDeprecated": "but I can be written to"
        }

-
  name: "Add mutation with reverse predicate"
  gqlmutation: |
    mutation addMovieDirector($dir: AddMovieDirectorInput!) {
      addMovieDirector(input: [$dir]) {
        movieDirector {
          id
        }
      }
    }
  gqlvariables: |
    { "dir":
      { "name": "Steven Spielberg",
        "directed": [{ "id": "0x2" }]
      }
    }
  explanation: "The reference to the directed.movies edge node should not add a new movie edge."
  dgquery: |-
    query {
      Movie2 as Movie2(func: uid(0x2)) @filter(type(Movie)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        { "uid" : "_:MovieDirector1",
          "dgraph.type" : ["MovieDirector"],
          "MovieDirector.name" : "Steven Spielberg",
          "directed.movies": [{
            "uid" : "0x2"
          }]
        }
      cond: "@if(eq(len(Movie2), 1))"

- name: "Top Level Duplicate XIDs with same object Test"
  gqlmutation: |
    mutation addState($input: [AddStateInput!]!) {
      addState(input: $input) {
        state {
          code
          name
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {"name": "State1", "code": "S1"},
        {"name": "State1", "code": "S1"}
      ]
    }
  explanation: "When duplicate XIDs are given as input at top level, but the object structure is
  same, it should return error."
  error:
    message: "failed to rewrite mutation payload because duplicate XID found: S1"

- name: "Top Level Duplicate XIDs with different object Test"
  gqlmutation: |
    mutation addState($input: [AddStateInput!]!) {
      addState(input: $input) {
        state {
          code
          name
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {"name": "State1", "code": "S1"},
        {"name": "State2", "code": "S1"}
      ]
    }
  explanation: "When duplicate XIDs are given as input at top level, but the object structure is
  different, it should still return error."
  error:
    message: "failed to rewrite mutation payload because duplicate XID found: S1"

- name: "Deep Mutation Duplicate XIDs with same object Test"
  gqlmutation: |
    mutation addCity($input: [AddCityInput!]!) {
      addCity(input: $input) {
        city {
          name
          district {
            code
            name
          }
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {
          "name": "Bengaluru",
          "district": {"code": "D1", "name": "Dist1"}
        },
        {
          "name": "NY",
          "district": {"code": "D1", "name": "Dist1"}
        }
      ]
    }
  explanation: "When duplicate XIDs are given as input to deep mutation but the object structure
  is same, it should not return error."
  dgquery: |-
    query {
      District3 as District3(func: eq(District.code, "D1")) @filter(type(District)) {
        uid
      }
    }
  dgquerysec: |-
    query {
      District3 as District3(func: eq(District.code, "D1")) @filter(type(District)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        {
          "District.code": "D1",
          "District.name": "Dist1",
          "dgraph.type": [
            "District"
          ],
          "uid": "_:District3"
        }
      cond: "@if(eq(len(District3), 0))"

  dgmutationssec:
    - setjson: |
        {
          "City.name":"Bengaluru",
          "City.district":{
              "District.cities":[{"uid":"_:City1"}],
              "uid":"uid(District3)"
            },
          "dgraph.type":["City"],
          "uid":"_:City1"
        }
      cond: "@if(eq(len(District3), 1))"
    - setjson: |
        {
          "City.name":"NY",
          "City.district":{
              "District.cities":[{"uid":"_:City4"}],
              "uid":"uid(District3)"
            },
          "dgraph.type":["City"],
          "uid":"_:City4"
        }
      cond: "@if(eq(len(District3), 1))"



- name: "Deep Mutation Duplicate XIDs with same object with @hasInverse Test"
  gqlmutation: |
    mutation addCountry($input: [AddCountryInput!]!) {
      addCountry(input: $input) {
        country {
          id
          name
          states {
            code
            name
            capital
          }
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {
          "name": "Country1",
          "states": [
            {"code": "S1", "name": "State1", "capital": "Cap1"},
            {"code": "S1", "name": "State1", "capital": "Cap1"}
          ]
        },
        {
          "name": "Country2",
          "states": [
            {"code": "S2", "name": "State2", "capital": "Cap2"}
          ]
        },
        {
          "name": "Country3",
          "states": [
            {"code": "S2", "name": "State2", "capital": "Cap2"}
          ]
        }
      ]
    }
  explanation: "When duplicate XIDs are given as input to deep mutation and the object structure
  is same and the containing object has @hasInverse on its xid object field, but the xid object
  does not have the @hasInverse field of List type, it should return error."
  error:
    message: |-
      failed to rewrite mutation payload because duplicate XID found: S1
      failed to rewrite mutation payload because duplicate XID found: S2

- name: "Deep Mutation Duplicate XIDs with different object Test"
  gqlmutation: |
    mutation addStudent($input: [AddStudentInput!]!) {
      addStudent(input: $input) {
        student {
          xid
          name
          taughtBy {
            xid
            name
            subject
          }
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {
          "xid": "S1",
          "name": "Stud1",
          "taughtBy": [
            {"xid": "T1", "name": "Teacher1", "subject": "Sub1"}
          ]
        },
        {
          "xid": "S2",
          "name": "Stud2",
          "taughtBy": [
            {"xid": "T1", "name": "Teacher1", "subject": "Sub2"}
          ]
        },
        {
          "xid": "S3",
          "name": "Stud3",
          "taughtBy": [
            {"xid": "T1", "name": "Teacher1"}
          ]
        }
      ]
    }
  explanation: "When duplicate XIDs are given as input to deep mutation but the object structure
  is different, it should return error."
  error:
    message: |-
      failed to rewrite mutation payload because duplicate XID found: T1
      failed to rewrite mutation payload because duplicate XID found: T1

- name: "Circular Duplicate XIDs in single mutation"
  gqlmutation: |
    mutation addStudent($input: [AddStudentInput!]!) {
      addStudent(input: $input) {
        student {
          xid
          name
          taughtBy {
            xid
            name
            subject
          }
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {
          "xid": "S1",
          "name": "Stud1",
          "taughtBy": [
            {"xid": "T1", "name": "Teacher1", "teaches": [{"xid": "S1", "name": "Stud1"}]}
          ]
        }
      ]
    }
  explanation: "When duplicate XIDs are given as input circularly in a single mutation, it
  should return error."
  error:
    message: |-
      failed to rewrite mutation payload because duplicate XID found: S1

- name: "Duplicate XIDs in single mutation for Interface"
  gqlmutation: |
    mutation addStudent($input: [AddStudentInput!]!) {
      addStudent(input: $input) {
        student {
          xid
          name
          taughtBy {
            xid
            name
            subject
          }
        }
      }
    }
  gqlvariables: |
    {
      "input": [
        {
          "xid": "S1",
          "name": "Stud1"
        },
        {
          "xid": "S2",
          "name": "Stud2",
          "taughtBy": [
            {"xid": "S1", "name": "Teacher1", "subject": "Sub1"}
          ]
        }
      ]
    }
  explanation: "When duplicate XIDs are given as input for an Interface in a single mutation, it
  should return error."
  error:
    message: |-
      failed to rewrite mutation payload because duplicate XID found: S1

# Additional Deletes
#
# If we have
#
# type Post { ... author: Author @hasInverse(field: posts) ... }
# type Author { ... posts: [Post] ... }
#
# and existing edge
#
# Post1 --- author --> Author1
#
# there must also exist edge
#
# Author1 --- posts --> Post1
#
# So if we did an add Author2 and connect the author to Post1, that changes the
# author of Post1 to Author2, we need to
#  * add edge Post1 --- author --> Author2 (done by asIDReference/asXIDReference)
#  * add edge Author2 --- posts --> Post1 (done by addInverseLink)
#  * delete edge Author1 --- posts --> Post1 (done by addAdditionalDeletes)
#
# This delete only needs to be done when there is a singular edge in the mutation:
# i.e. if both directions of the edge are [], then it's just an add.
#
# There's three cases to consider: add by ID, add by XID, deep add

- name: "Additional Deletes - Add connects to existing node by ID"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    {
      "auth": {
        "name": "A.N. Author",
        "posts": [ { "postID": "0x456" } ]
      }
    }
  dgmutations:
    - setjson: |
        {
          "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.posts": [
            {
              "uid": "0x456",
              "Post.author": { "uid": "_:Author1" }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Author3)",
            "Author.posts": [ { "uid": "uid(Post2)" } ]
          }
        ]
      cond: "@if(eq(len(Post2), 1))"
  dgquery: |-
    query {
      Post2 as Post2(func: uid(0x456)) @filter(type(Post)) {
        uid
      }
      var(func: uid(Post2)) {
        Author3 as Post.author
      }
    }

- name: "Additional Deletes - Add connects to existing node by XID"
  gqlmutation: |
    mutation addCountry($inp: AddCountryInput!) {
      addCountry(input: [$inp]) {
        country {
          id
        }
      }
    }
  gqlvariables: |
    {
      "inp": {
        "name": "A Country",
        "states": [ { "code": "abc", "name": "Alphabet" } ]
      }
    }

  dgquery: |-
    query {
      State3 as State3(func: eq(State.code, "abc")) @filter(type(State)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        {
          "State.code": "abc",
          "State.name": "Alphabet",
          "dgraph.type": [
            "State"
          ],
          "uid": "_:State3"
        }
      cond: "@if(eq(len(State3), 0))"

  dgquerysec: |-
    query {
      State3 as State3(func: eq(State.code, "abc")) @filter(type(State)) {
        uid
      }
      var(func: uid(State3)) {
        Country4 as State.country
      }
    }
  dgmutationssec:
    - setjson: |
        {
          "uid" : "_:Country1",
          "dgraph.type": ["Country"],
          "Country.name": "A Country",
          "Country.states": [
            {
              "uid": "uid(State3)",
              "State.country": { "uid": "_:Country1" }
            }
          ]
        }
      deletejson: |
        [
          {
            "uid": "uid(Country4)",
            "Country.states": [ { "uid": "uid(State3)" } ]
          }
        ]
      cond: "@if(eq(len(State3), 1))"

- name: "Deep XID 4 level deep"
  gqlmutation: |
    mutation addStudent($student: AddStudentInput!) {
      addStudent(input: [$student]) {
        student {
          name
        }
      }
    }
  gqlvariables: |
    {
      "student": {
        "xid": "S0",
        "name": "Student0",
        "taughtBy": [{
                "xid": "T0",
                "name": "teacher0",
                "teaches": [{
                        "xid": "S1",
                        "name": "Student1",
                        "taughtBy": [{
                                "xid": "T1",
                                "name": "teacher1"
                        }]
                }]
        }]
      }
    }
  dgquery: |-
    query {
      Teacher4 as Teacher4(func: eq(People.xid, "T0")) @filter(type(Teacher)) {
        uid
      }
      Teacher8 as Teacher8(func: eq(People.xid, "T1")) @filter(type(Teacher)) {
        uid
      }
      Student6 as Student6(func: eq(People.xid, "S1")) @filter(type(Student)) {
        uid
      }
    }

  dgmutations:
    - setjson: |
        {
                "People.name":"teacher0",
                "People.xid":"T0",
                "dgraph.type":["Teacher","People"],
                "uid":"_:Teacher4"
        }

      cond: "@if(eq(len(Teacher4), 0))"

    - setjson: |
        {
            "People.name": "Student1",
            "People.xid": "S1",
            "Student.taughtBy": [{"uid": "_:Teacher4"}],
            "dgraph.type": ["Student","People"],
            "uid": "_:Student6"
        }
      cond: "@if(eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "People.name": "teacher1",
            "People.xid": "T1",
            "Teacher.teaches": [{"uid": "_:Student6"}],
            "dgraph.type": ["Teacher","People"],
            "uid": "_:Teacher8"
        }
      cond:  "@if(eq(len(Teacher8), 0) AND eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Student.taughtBy": [{"uid": "uid(Teacher8)"}],
            "uid": "_:Student6"
        }
      cond:  "@if(eq(len(Teacher8), 1) AND eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Student.taughtBy": [{"uid": "_:Teacher8"}],
            "uid": "_:Student6"
        }
      cond:  "@if(eq(len(Teacher8), 0) AND eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Teacher.teaches": [{"uid": "_:Student6"}],
            "uid": "uid(Teacher8)"
        }
      cond:  "@if(eq(len(Teacher8), 1) AND eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Teacher.teaches": [{"uid": "uid(Student6)"}],
            "uid": "_:Teacher4"
        }
      cond:  "@if(eq(len(Student6), 1) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Teacher.teaches": [{"uid": "_:Student6"}],
            "uid": "_:Teacher4"
        }
      cond:  "@if(eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
            "Student.taughtBy": [{"uid": "_:Teacher4"}],
            "uid": "uid(Student6)"
        }
      cond: "@if(eq(len(Student6), 1) AND eq(len(Teacher4), 0))"

  dgquerysec: |-
    query {
      Student2 as Student2(func: eq(People.xid, "S0")) @filter(type(Student)) {
        uid
      }
      Teacher4 as Teacher4(func: eq(People.xid, "T0")) @filter(type(Teacher)) {
        uid
      }
    }

  dgmutationssec:
    - setjson: |
        {
            "People.name": "Student0",
            "People.xid": "S0",
            "Student.taughtBy": [{
                    "Teacher.teaches": [{"uid": "_:Student2"}],
                    "uid": "uid(Teacher4)"
            }],
            "dgraph.type": ["Student","People"],
            "uid": "_:Student2"
        }
      cond: "@if(eq(len(Student2), 0) AND eq(len(Teacher4), 1))"

- name: "Deep XID Add top level hasInverse"
  gqlmutation: |
    mutation addStudent($student: AddStudentInput!) {
      addStudent(input: [$student]) {
        student {
          name
        }
      }
    }
  gqlvariables: |
    {
      "student": {
        "xid": "S0",
        "name": "Student0",
        "taughtBy": [{
                "xid": "T0",
                "name": "teacher0",
                "teaches": [{
                        "xid": "S1",
                        "name": "Student1"
                }]
        }]
      }
    }
  dgquery: |-
    query {
      Teacher4 as Teacher4(func: eq(People.xid, "T0")) @filter(type(Teacher)) {
        uid
      }
      Student6 as Student6(func: eq(People.xid, "S1")) @filter(type(Student)) {
        uid
      }
    }

  dgmutations:
    - setjson: |
        {
                "People.name":"teacher0",
                "People.xid":"T0",
                "dgraph.type":["Teacher","People"],
                "uid":"_:Teacher4"
        }

      cond: "@if(eq(len(Teacher4), 0))"

    - setjson: |
        {
                "People.name":"Student1",
                "People.xid":"S1",
                "Student.taughtBy":[{"uid":"_:Teacher4"}],
                "dgraph.type":["Student","People"],
                "uid":"_:Student6"
        }
      cond: "@if(eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
                "Teacher.teaches":[{"uid":"uid(Student6)"}],
                "uid":"_:Teacher4"
        }
      deletejson: |
      cond: "@if(eq(len(Student6), 1) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
                "Teacher.teaches":[{"uid":"_:Student6"}],
                "uid":"_:Teacher4"
        }
      deletejson: |
      cond: "@if(eq(len(Student6), 0) AND eq(len(Teacher4), 0))"

    - setjson: |
        {
                "Student.taughtBy":[{"uid":"_:Teacher4"}],
                "uid":"uid(Student6)"
        }
      deletejson: |
      cond: "@if(eq(len(Student6), 1) AND eq(len(Teacher4), 0))"

  dgquerysec: |-
    query {
      Student2 as Student2(func: eq(People.xid, "S0")) @filter(type(Student)) {
        uid
      }
      Teacher4 as Teacher4(func: eq(People.xid, "T0")) @filter(type(Teacher)) {
        uid
      }
    }

  dgmutationssec:
    - setjson: |
        {
                "People.name":"Student0",
                "People.xid":"S0",
                "Student.taughtBy":[{"Teacher.teaches":[{"uid":"_:Student2"}],"uid":"uid(Teacher4)"}],
                "dgraph.type":["Student","People"],
                "uid":"_:Student2"
        }
      cond: "@if(eq(len(Student2), 0) AND eq(len(Teacher4), 1))"


- name: "Deep XID Add lower level hasInvsere"
  gqlmutation: |
    mutation addLab($lab: AddLabInput!) {
      addLab(input: [$lab]) {
        lab {
          name
        }
      }
    }
  gqlvariables: |
    {
      "lab": {
        "name": "Lab1",
        "computers": [{
                "name": "computer1",
                "owners": [{
                        "name": "owner1"
                }]
        }]
      }
    }
  dgmutations:
    - setjson: |
        {
            "Computer.name": "computer1",
            "dgraph.type": [
                "Computer"
            ],
            "uid": "_:Computer4"
        }
      cond: "@if(eq(len(Computer4), 0))"

    - setjson: |
        {
                "ComputerOwner.computers":{"uid":"_:Computer4"},
                "ComputerOwner.name":"owner1",
                "dgraph.type":["ComputerOwner"],
                "uid":"_:ComputerOwner6"
        }
      cond: "@if(eq(len(ComputerOwner6), 0) AND eq(len(Computer4), 0))"

    - setjson: |
        {
                "Computer.owners":[{"uid":"uid(ComputerOwner6)"}],
                "uid":"_:Computer4"
        }
      cond: "@if(eq(len(ComputerOwner6), 1) AND eq(len(Computer4), 0))"

    - setjson: |
        {
                "Computer.owners":[{"uid":"_:ComputerOwner6"}],
                "uid":"_:Computer4"
        }
      cond: "@if(eq(len(ComputerOwner6), 0) AND eq(len(Computer4), 0))"

    - setjson: |
        {
            "ComputerOwner.computers": {
                "uid": "_:Computer4"
            },
            "uid": "uid(ComputerOwner6)"
        }
      deletejson: |-
        [{
            "Computer.owners": [
                {
                    "uid": "uid(ComputerOwner6)"
                }
            ],
            "uid": "uid(Computer7)"
        }]
      cond: "@if(eq(len(ComputerOwner6), 1) AND eq(len(Computer4), 0))"


  dgmutationssec:
    - setjson: |-
        {
            "Lab.computers": [
                {
                    "uid": "uid(Computer4)"
                }
            ],
            "Lab.name": "Lab1",
            "dgraph.type": ["Lab"],
            "uid": "_:Lab2"
        }
      cond: "@if(eq(len(Lab2), 0) AND eq(len(Computer4), 1))"

  dgquerysec: |-
    query {
      Lab2 as Lab2(func: eq(Lab.name, "Lab1")) @filter(type(Lab)) {
        uid
      }
      Computer4 as Computer4(func: eq(Computer.name, "computer1")) @filter(type(Computer)) {
        uid
      }
    }

  dgquery: |-
    query {
      Computer4 as Computer4(func: eq(Computer.name, "computer1")) @filter(type(Computer)) {
        uid
      }
      ComputerOwner6 as ComputerOwner6(func: eq(ComputerOwner.name, "owner1")) @filter(type(ComputerOwner)) {
        uid
      }
      var(func: uid(ComputerOwner6)) {
        Computer7 as ComputerOwner.computers
      }
    }

- name: "Deep mutation alternate id xid"
  gqlmutation: |
    mutation addAuthor($city: AddCityInput!) {
      addCity(input: [$city]) {
        city {
          name
          district {
            code
            name
            cities {
              name
              district {
                code
                name
              }
            }
          }
        }
      }
    }
  gqlvariables: |
    {
      "city": {
        "name": "c1",
        "district":{
                "name":"d1",
                "code":"d1",
                "cities":[{"name": "c2"}]
        }
      }
    }
  dgquery: |-
    query {
      District3 as District3(func: eq(District.code, "d1")) @filter(type(District)) {
        uid
      }
    }
  dgmutations:
    - setjson: |
        {
            "District.cities": [
                {
                    "City.district": {
                        "uid": "_:District3"
                    },
                    "City.name": "c2",
                    "dgraph.type": [
                        "City"
                    ],
                    "uid": "_:City4"
                }
            ],
            "District.code": "d1",
            "District.name": "d1",
            "dgraph.type": [
                "District"
            ],
            "uid": "_:District3"
        }

      cond: "@if(eq(len(District3), 0))"

  dgquerysec: |-
    query {
      District3 as District3(func: eq(District.code, "d1")) @filter(type(District)) {
        uid
      }
    }

  dgmutationssec:
    - setjson: |
        {
            "City.district": {
                "District.cities": [
                    {
                        "uid": "_:City1"
                    }
                ],
                "uid": "uid(District3)"
            },
            "City.name": "c1",
            "dgraph.type": [
                "City"
            ],
            "uid": "_:City1"
        }

      cond: "@if(eq(len(District3), 1))"


- name: "Additional Deletes - deep mutation"
  gqlmutation: |
    mutation addAuthor($auth: AddAuthorInput!) {
      addAuthor(input: [$auth]) {
        author {
          id
        }
      }
    }
  gqlvariables: |
    {
      "auth": {
        "name": "A.N. Author",
        "country": {
          "name": "A Country",
          "states": [ { "code": "abc", "name": "Alphabet" } ]
        }
      }
    }
  dgmutations:
    - setjson: |
        {
          "State.code": "abc",
          "State.name": "Alphabet",
          "dgraph.type": [
            "State"
          ],
          "uid": "_:State4"
        }
      cond: "@if(eq(len(State4), 0))"

  dgmutationssec:
    - setjson: |
        {
          "uid":"_:Author1",
          "dgraph.type":["Author"],
          "Author.name":"A.N. Author",
          "Author.country": {
            "uid" : "_:Country2",
            "dgraph.type": ["Country"],
            "Country.name": "A Country",
            "Country.states": [
              {
                "uid": "uid(State4)",
                "State.country": { "uid": "_:Country2" }
              }
            ]
          }
        }
      deletejson: |
        [
          {
            "uid": "uid(Country5)",
            "Country.states": [ { "uid": "uid(State4)" } ]
          }
        ]
      cond: "@if(eq(len(State4), 1))"

  dgquerysec: |-
    query {
      State4 as State4(func: eq(State.code, "abc")) @filter(type(State)) {
        uid
      }
      var(func: uid(State4)) {
        Country5 as State.country
      }
    }
  dgquery: |-
    query {
      State4 as State4(func: eq(State.code, "abc")) @filter(type(State)) {
        uid
      }
    }

- name: "Deep mutation three level xid"
  gqlmutation: |
    mutation($auth: [AddPost1Input!]!) {
      addPost1(input: $auth) {
        post1 {
          id
          comments {
            id
            replies {
              id
            }
          }
        }
      }
    }

  gqlvariables: |
    {
      "auth": [{
        "id": "post1",
        "comments": [{
          "id": "comment1",
          "replies": [{
            "id": "reply1"
          }]
        }]
      },
      {
        "id": "post2",
        "comments": [{
          "id": "comment2",
          "replies": [{
            "id": "reply1"
          }]
        }]
      }]
    }
  dgquery: |-
    query {
      Comment14 as Comment14(func: eq(Comment1.id, "comment1")) @filter(type(Comment1)) {
        uid
      }
      Comment16 as Comment16(func: eq(Comment1.id, "reply1")) @filter(type(Comment1)) {
        uid
      }
      Comment110 as Comment110(func: eq(Comment1.id, "comment2")) @filter(type(Comment1)) {
        uid
      }
    }
  dgmutations:
    # Create comment1 if it doesn't exist.
    - setjson: |
        {
          "Comment1.id": "comment1",
          "dgraph.type": [
            "Comment1"
          ],
          "uid": "_:Comment14"
        }
      cond: "@if(eq(len(Comment14), 0))"
    # Create reply1 if it doesn't exist.
    - setjson: |
        {
          "Comment1.id": "reply1",
          "dgraph.type": [
            "Comment1"
          ],
          "uid": "_:Comment16"
        }
      cond: "@if(eq(len(Comment16), 0) AND eq(len(Comment14), 0))"
    # Link comment1 and reply1 if reply exists but comment doesn't.
    - setjson: |
        {"uid":"_:Comment14", "Comment1.replies": [{"uid": "uid(Comment16)"}]}
      cond: "@if(eq(len(Comment16), 1) AND eq(len(Comment14), 0))"
    # Link comment1 and reply1 if both don't exist.
    - setjson: |
        {"uid":"_:Comment14", "Comment1.replies": [{"uid": "_:Comment16"}]}
      cond: "@if(eq(len(Comment16), 0) AND eq(len(Comment14), 0))"
    # useless mutation which needs investigation
    - setjson: |
        {"uid":"uid(Comment16)"}
      cond: "@if(eq(len(Comment16), 1) AND eq(len(Comment14), 0))"
    # create comment2 if it doesn't exist
    - setjson: |
        {
          "Comment1.id": "comment2",
          "dgraph.type": [
            "Comment1"
          ],
          "uid": "_:Comment110"
        }
      cond: "@if(eq(len(Comment110), 0))"
    # Link comment1 and reply1 if reply exists but comment doesn't.
    - setjson: |
        {"uid":"_:Comment110", "Comment1.replies": [{"uid": "uid(Comment16)"}]}
      cond: "@if(eq(len(Comment16), 1) AND eq(len(Comment110), 0))"
    # Link comment2 and reply1 if both don't exist.
    - setjson: |
        {"uid":"_:Comment110", "Comment1.replies": [{"uid": "_:Comment16"}]}
      cond: "@if(eq(len(Comment16), 0) AND eq(len(Comment110), 0))"
    # useless mutation which needs investigation

    - setjson: |
        {"uid":"uid(Comment16)"}
      cond: "@if(eq(len(Comment16), 1) AND eq(len(Comment110), 0))"
  dgquerysec: |-
    query {
      Post12 as Post12(func: eq(Post1.id, "post1")) @filter(type(Post1)) {
        uid
      }
      Comment14 as Comment14(func: eq(Comment1.id, "comment1")) @filter(type(Comment1)) {
        uid
      }
      Post18 as Post18(func: eq(Post1.id, "post2")) @filter(type(Post1)) {
        uid
      }
      Comment110 as Comment110(func: eq(Comment1.id, "comment2")) @filter(type(Comment1)) {
        uid
      }
    }
  dgmutationssec:
    - setjson: |
        {
          "Post1.comments":
            [{
              "uid":"uid(Comment14)"
            }],
          "Post1.id":"post1",
          "dgraph.type":["Post1"],
          "uid":"_:Post12"
        }
      cond: "@if(eq(len(Post12), 0) AND eq(len(Comment14), 1))"
    - setjson: |
        {
          "Post1.comments":
            [{
              "uid":"uid(Comment110)"
            }],
          "Post1.id":"post2",
          "dgraph.type":["Post1"],
          "uid":"_:Post18"
        }
      cond: "@if(eq(len(Post18), 0) AND eq(len(Comment110), 1))"

-
  name: "Add mutation error on @id field for empty value"
  gqlmutation: |
    mutation addState($input: AddStateInput!) {
      addState(input: [$input]) {
        state {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "code": "",
        "name": "NSW",
        "country": { "id": "0x12" }
      }
    }
  explanation: "The add mutation should not be allowed since value of @id field is empty."
  error:
    { "message": "failed to rewrite mutation payload because encountered an empty value for @id field `State.code`" }

-
  name: "Add mutation error on @id field for empty value (Nested)"
  gqlmutation: |
    mutation addCountry($input: AddCountryInput!) {
      addCountry(input: [$input]) {
        country {
          name
        }
      }
    }
  gqlvariables: |
    { "input":
      {
        "name": "Dgraph Land",
        "states": [ {
          "code": "",
          "name": "Dgraph"
        } ]
      }
    }
  explanation: "The add mutation should not be allowed since value of @id field is empty."
  error:
    { "message": "failed to rewrite mutation payload because encountered an empty value for @id field `State.code`" }