auth_delete_test.yaml

- name: "Delete with auth"
  gqlquery: |
    mutation deleteUserSecret($filter: UserSecretFilter!) {
      deleteUserSecret(filter: $filter) {
        msg
      }
    }
  jwtvar:
    USER: "user1"
  variables: |
    { "filter": { "aSecret": { "anyofterms": "auth is applied" } } }
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" }
        ]
  dgquery: |-
    query {
      x as deleteUserSecret(func: uid(UserSecretRoot)) {
        uid
      }
      UserSecretRoot as var(func: uid(UserSecret1)) @filter(uid(UserSecretAuth2))
      UserSecret1 as var(func: type(UserSecret)) @filter(anyofterms(UserSecret.aSecret, "auth is applied"))
      UserSecretAuth2 as var(func: uid(UserSecret1)) @filter(eq(UserSecret.ownedBy, "user1")) @cascade
    }

- name: "Delete with inverse field and RBAC true"
  gqlquery: |
    mutation {
      deleteTweets(
        filter: {
          text: {anyoftext: "abc"}
        }) {
        tweets {
          text
        }
      }
    }
  jwtvar:
    USER: "foo"
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" },
          {
            "User.tweets" : [{"uid":"uid(x)"}],
            "uid" : "uid(User2)"
          }
        ]
  dgquery: |-
    query {
      x as deleteTweets(func: uid(TweetsRoot)) {
        uid
        User2 as Tweets.user
      }
      TweetsRoot as var(func: uid(Tweets1))
      Tweets1 as var(func: type(Tweets)) @filter(anyoftext(Tweets.text, "abc"))
      tweets(func: uid(Tweets3)) {
        text : Tweets.text
        dgraph.uid : uid
      }
      Tweets3 as var(func: uid(Tweets4))
      Tweets4 as var(func: uid(x))
    }

- name: "Delete with inverse field and RBAC false"
  gqlquery: |
    mutation {
      deleteTweets(
        filter: {
          text: {anyoftext: "abc"}
        }) {
        tweets {
          text
        }
      }
    }
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" }
        ]
  dgquery: |-
    query {
      x as deleteTweets()
      tweets(func: uid(Tweets1)) {
        text : Tweets.text
        dgraph.uid : uid
      }
      Tweets1 as var(func: uid(Tweets2))
      Tweets2 as var(func: uid(x))
    }

- name: "Delete with deep auth"
  gqlquery: |
    mutation deleteTicket($filter: TicketFilter!) {
      deleteTicket(filter: $filter) {
        msg
      }
    }
  jwtvar:
    USER: "user1"
  variables: |
    { "filter": { "title": { "anyofterms": "auth is applied" } } }
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" },
          { 
            "uid":"uid(Column3)",
            "Column.tickets": [ { "uid":"uid(x)" } ]
          },
          {
            "uid":"uid(User4)",
            "User.tickets": [ { "uid":"uid(x)" } ]
          }
        ]
  dgquery: |-
    query {
      x as deleteTicket(func: uid(TicketRoot)) {
        uid
        Column3 as Ticket.onColumn
        User4 as Ticket.assignedTo
      }
      TicketRoot as var(func: uid(Ticket1)) @filter(uid(TicketAuth2))
      Ticket1 as var(func: type(Ticket)) @filter(anyofterms(Ticket.title, "auth is applied"))
      TicketAuth2 as var(func: uid(Ticket1)) @cascade {
        onColumn : Ticket.onColumn {
          inProject : Column.inProject {
            roles : Project.roles @filter(eq(Role.permission, "EDIT")) {
              assignedTo : Role.assignedTo @filter(eq(User.username, "user1"))
              dgraph.uid : uid
            }
            dgraph.uid : uid
          }
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
    }


- name: "Delete with deep query"
  gqlquery: |
    mutation deleteTicket($filter: TicketFilter!) {
      deleteTicket(filter: $filter) {
        msg
        numUids
        ticket {
          title
          onColumn {
            inProject {
              roles {
                assignedTo {
                  username
                  age
                }
              }
            }
          }
        }
      }
    }
  jwtvar:
    USER: "user1"
  variables: |
    { "filter": { "title": { "anyofterms": "auth is applied" } } }
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" },
          {
            "uid":"uid(Column3)",
            "Column.tickets": [ { "uid":"uid(x)" } ]
          },
          {
            "uid":"uid(User4)",
            "User.tickets": [ { "uid":"uid(x)" } ]
          }
        ]
  dgquery: |-
    query {
      x as deleteTicket(func: uid(TicketRoot)) {
        uid
        Column3 as Ticket.onColumn
        User4 as Ticket.assignedTo
      }
      TicketRoot as var(func: uid(Ticket1)) @filter(uid(TicketAuth2))
      Ticket1 as var(func: type(Ticket)) @filter(anyofterms(Ticket.title, "auth is applied"))
      TicketAuth2 as var(func: uid(Ticket1)) @cascade {
        onColumn : Ticket.onColumn {
          inProject : Column.inProject {
            roles : Project.roles @filter(eq(Role.permission, "EDIT")) {
              assignedTo : Role.assignedTo @filter(eq(User.username, "user1"))
              dgraph.uid : uid
            }
            dgraph.uid : uid
          }
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
      ticket(func: uid(Ticket5)) {
        title : Ticket.title
        onColumn : Ticket.onColumn @filter(uid(Column15)) {
          inProject : Column.inProject @filter(uid(Project13)) {
            roles : Project.roles @filter(uid(Role11)) {
              assignedTo : Role.assignedTo @filter(uid(User10)) {
                username : User.username
                age : User.age
                dgraph.uid : uid
              }
              dgraph.uid : uid
            }
            dgraph.uid : uid
          }
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
      Ticket5 as var(func: uid(Ticket16)) @filter(uid(TicketAuth17))
      Ticket16 as var(func: uid(x))
      TicketAuth17 as var(func: uid(Ticket16)) @cascade {
        onColumn : Ticket.onColumn {
          inProject : Column.inProject {
            roles : Project.roles @filter(eq(Role.permission, "VIEW")) {
              assignedTo : Role.assignedTo @filter(eq(User.username, "user1"))
              dgraph.uid : uid
            }
            dgraph.uid : uid
          }
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
      var(func: uid(Ticket5)) {
        Column6 as Ticket.onColumn
      }
      Column15 as var(func: uid(Column6)) @filter(uid(ColumnAuth14))
      var(func: uid(Column6)) {
        Project7 as Column.inProject
      }
      Project13 as var(func: uid(Project7)) @filter(uid(ProjectAuth12))
      var(func: uid(Project7)) {
        Role8 as Project.roles
      }
      Role11 as var(func: uid(Role8))
      var(func: uid(Role8)) {
        User9 as Role.assignedTo
      }
      User10 as var(func: uid(User9))
      ProjectAuth12 as var(func: uid(Project7)) @cascade {
        roles : Project.roles @filter(eq(Role.permission, "VIEW")) {
          assignedTo : Role.assignedTo @filter(eq(User.username, "user1"))
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
      ColumnAuth14 as var(func: uid(Column6)) @cascade {
        inProject : Column.inProject {
          roles : Project.roles @filter(eq(Role.permission, "VIEW")) {
            assignedTo : Role.assignedTo @filter(eq(User.username, "user1"))
            dgraph.uid : uid
          }
          dgraph.uid : uid
        }
        dgraph.uid : uid
      }
    }

- name: "Delete with top level RBAC true."
  gqlquery: |
    mutation($projs: [ID!]) {
      deleteProject (filter: { projID: $projs}) {
          numUids
        }
    }
  variables: |
    {
      "projs" : ["0x01", "0x02"]
    }
  jwtvar:
    ROLE: "ADMIN"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         },
         {
           "Column.inProject": {
             "uid": "uid(x)"
           },
           "uid": "uid(Column2)"
         }
        ]
  dgquery: |-
    query {
      x as deleteProject(func: uid(0x1, 0x2)) @filter(type(Project)) {
        uid
        Column2 as Project.columns
      }
    }

- name: "Delete with top level RBAC false."
  gqlquery: |
    mutation deleteLog($filter: LogFilter!) {
      deleteLog(filter: $filter) {
        msg
        log {
          logs
          random
        }
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "USER"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteLog()
      log()
    }

- name: "multiple rule in delete mutation"
  gqlquery: |
    mutation deleteUser($filter: UserFilter!) {
      deleteUser(filter: $filter) {
        msg
      }
    }
  variables: |
    { "filter":
      {
        "username": { "eq": "userxyz" }
      }
    }
  jwtvar:
    USER: "user1"
  dgmutations:
    - deletejson: |
        [
          { "uid" : "uid(x)" },
          {
            "Ticket.assignedTo" : [ {"uid":"uid(x)"} ],
            "uid" : "uid(Ticket4)"
          },
          {
            "Tweets.user" : {"uid":"uid(x)"},
            "uid" : "uid(Tweets5)"
          }
        ]
  dgquery: |-
    query {
      x as deleteUser(func: uid(UserRoot)) {
        uid
        Ticket4 as User.tickets
        Tweets5 as User.tweets
      }
      UserRoot as var(func: uid(User1)) @filter((uid(UserAuth2) AND uid(UserAuth3)))
      User1 as var(func: type(User)) @filter(eq(User.username, "userxyz"))
      UserAuth2 as var(func: uid(User1)) @filter(eq(User.username, "user1")) @cascade
      UserAuth3 as var(func: uid(User1)) @filter(eq(User.isPublic, true)) @cascade
    }

- name: "Filtering by ID"
  gqlquery: |
    mutation deleteRegion($filter: RegionFilter!) {
      deleteRegion(filter: $filter) {
        msg
      }
    }
  jwtvar:
    USER: "user1"
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  dgmutations:
    - deletejson: |
        [
          { "uid": "uid(x)" }
        ]
  dgquery: |-
    query {
      x as deleteRegion(func: uid(RegionRoot)) {
        uid
      }
      RegionRoot as var(func: uid(Region1)) @filter(uid(RegionAuth2))
      Region1 as var(func: uid(0x1, 0x2)) @filter(type(Region))
      RegionAuth2 as var(func: uid(Region1)) @filter(eq(Region.global, true)) @cascade
    }

- name: "Delete with top level RBAC false."
  gqlquery: |
    mutation deleteLog($filter: LogFilter!) {
      deleteLog(filter: $filter) {
        msg
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "USER"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteLog()
    }

- name: "Delete with top level RBAC true."
  gqlquery: |
    mutation deleteLog($filter: LogFilter!) {
      deleteLog(filter: $filter) {
        msg
        log (order: { asc: logs }) {
          logs
          random
        }
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "ADMIN"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteLog(func: uid(LogRoot)) {
        uid
      }
      LogRoot as var(func: uid(Log1))
      Log1 as var(func: uid(0x1, 0x2)) @filter(type(Log))
      log(func: uid(Log2), orderasc: Log.logs) {
        logs : Log.logs
        random : Log.random
        dgraph.uid : uid
      }
      Log2 as var(func: uid(Log3))
      Log3 as var(func: uid(x))
    }

- name: "Delete with top level OR RBAC true."
  gqlquery: |
    mutation($ids: [ID!]) {
      deleteComplexLog (filter: { id: $ids}) {
        numUids
      }
    }
  variables: |
    {
      "ids" : ["0x01", "0x02"]
    }
  jwtvar:
    ROLE: "ADMIN"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{ "uid": "uid(x)" }]
  dgquery: |-
    query {
      x as deleteComplexLog(func: uid(ComplexLogRoot)) {
        uid
      }
      ComplexLogRoot as var(func: uid(ComplexLog1))
      ComplexLog1 as var(func: uid(0x1, 0x2)) @filter(type(ComplexLog))
    }

- name: "Delete with top level OR RBAC false."
  gqlquery: |
    mutation($ids: [ID!]) {
      deleteComplexLog (filter: { id: $ids}) {
        numUids
      }
    }
  variables: |
    {
      "ids" : ["0x01", "0x02"]
    }
  jwtvar:
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{ "uid": "uid(x)" }]
  dgquery: |-
    query {
      x as deleteComplexLog(func: uid(ComplexLogRoot)) {
        uid
      }
      ComplexLogRoot as var(func: uid(ComplexLog1)) @filter(uid(ComplexLogAuth2))
      ComplexLog1 as var(func: uid(0x1, 0x2)) @filter(type(ComplexLog))
      ComplexLogAuth2 as var(func: uid(ComplexLog1)) @filter(eq(ComplexLog.visible, true)) @cascade
    }

- name: "Delete with top level AND RBAC true."
  gqlquery: |
    mutation ($ids: [ID!]) {
      deleteIssue(filter: {id: $ids}) {
    	numUids
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "ADMIN"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteIssue(func: uid(IssueRoot)) {
        uid
      }
      IssueRoot as var(func: uid(Issue1)) @filter(uid(IssueAuth2))
      Issue1 as var(func: type(Issue))
      IssueAuth2 as var(func: uid(Issue1)) @cascade {
        owner : Issue.owner @filter(eq(User.username, "user1"))
        dgraph.uid : uid
      }
    }

- name: "Delete with top level AND RBAC false."
  gqlquery: |
    mutation ($ids: [ID!]) {
      deleteIssue(filter: {id: $ids}) {
    	numUids
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "USER"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteIssue()
    }

- name: "Delete with top level not RBAC false."
  gqlquery: |
    mutation ($ids: [ID!]) {
      deleteRole(filter: {id: $ids}) {
    	numUids
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "USER"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteRole()
    }

- name: "Delete with top level not RBAC true."
  gqlquery: |
    mutation ($ids: [ID!]) {
      deleteRole(filter: {id: $ids}) {
    	numUids
      }
    }
  variables: |
    { "filter":
      {
        "id": ["0x1", "0x2"]
      }
    }
  jwtvar:
    ROLE: "ADMIN"
    USER: "user1"
  dgmutations:
    - deletejson: |
        [{
           "uid": "uid(x)"
         }]
  dgquery: |-
    query {
      x as deleteRole(func: type(Role)) {
        uid
      }
    }