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 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 Add"
  gqlmutation: |
    mutation addAuthor($auth: AddLabInput!) {
      addLab(input: [$auth]) {
        lab {
          name
        }
      }
    }
  gqlvariables: |
    {
      "auth": {
        "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.name": "owner1",
            "dgraph.type": [
                "ComputerOwner"
            ],
            "uid": "_:ComputerOwner6"
        }
      cond: "@if(eq(len(ComputerOwner6), 0))"

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


  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
      }
      ComputerOwner6 as ComputerOwner6(func: eq(ComputerOwner.name, "owner1")) @filter(type(ComputerOwner)) {
        uid
      }
      var(func: uid(ComputerOwner6)) {
        Computer7 as ComputerOwner.computers
      }
    }

  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
      }
    }

- 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
      }
    }