github.com/unigraph-dev/dgraph@v1.1.1-0.20200923154953-8b52b426f765/gql/upsert_test.go (about)

     1  /*
     2   * Copyright 2019 Dgraph Labs, Inc. and Contributors
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package gql
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/stretchr/testify/require"
    23  )
    24  
    25  func TestInvalidBlockErr(t *testing.T) {
    26  	query := `
    27  query {
    28    me(func: eq(age, 34)) {
    29      uid
    30      friend {
    31        uid
    32        age
    33      }
    34    }
    35  }`
    36  	_, err := ParseMutation(query)
    37  	require.Error(t, err)
    38  	require.Contains(t, err.Error(), "Invalid block: [query]")
    39  }
    40  
    41  func TestExtraRightCurlErr(t *testing.T) {
    42  	query := `
    43  upsert {
    44    query {
    45      me(func: eq(age, 34)) {
    46        uid
    47        friend {
    48          uid
    49          age
    50        }
    51      }
    52    }
    53  }
    54  }
    55  `
    56  	_, err := ParseMutation(query)
    57  	require.Error(t, err)
    58  	require.Contains(t, err.Error(), "Too many right curl")
    59  }
    60  
    61  func TestNoMutationErr(t *testing.T) {
    62  	query := `
    63  upsert {
    64    query {
    65      me(func: eq(age, 34)) {
    66        uid
    67        friend {
    68          uid age
    69        }
    70      }
    71    }
    72  }
    73  `
    74  	_, err := ParseMutation(query)
    75  	require.Error(t, err)
    76  	require.Contains(t, err.Error(), "Empty mutation block")
    77  }
    78  
    79  func TestMultipleQueryErr(t *testing.T) {
    80  	query := `
    81  upsert {
    82    query {
    83      me(func: eq(age, 34)) {
    84        uid
    85        friend {
    86          uid
    87          age
    88        }
    89      }
    90    }
    91  
    92    query {
    93      me2(func: eq(age, 34)) {
    94        uid
    95        friend {
    96          uid
    97          age
    98        }
    99      }
   100    }
   101  
   102    mutation {
   103      set {
   104        "_:user1" <age> "45" .
   105      }
   106    }
   107  }
   108  `
   109  	_, err := ParseMutation(query)
   110  	require.Error(t, err)
   111  	require.Contains(t, err.Error(), "Multiple query ops inside upsert block")
   112  }
   113  
   114  func TestEmptyUpsertErr(t *testing.T) {
   115  	query := `upsert {}`
   116  	_, err := ParseMutation(query)
   117  	require.Error(t, err)
   118  	require.Contains(t, err.Error(), "Empty mutation block")
   119  }
   120  
   121  func TestNoRightCurlErr(t *testing.T) {
   122  	query := `upsert {`
   123  	_, err := ParseMutation(query)
   124  	require.Contains(t, err.Error(), "Unclosed upsert block")
   125  }
   126  
   127  func TestIncompleteBlockErr(t *testing.T) {
   128  	query := `
   129  upsert {
   130    mutation {
   131      set {
   132        "_:user1" <age> "45" .
   133      }
   134    }
   135  
   136    query {
   137      me(func: eq(age, "{
   138  `
   139  	_, err := ParseMutation(query)
   140  	require.Error(t, err)
   141  	require.Contains(t, err.Error(), "Unexpected end of input")
   142  }
   143  
   144  func TestMissingQueryErr(t *testing.T) {
   145  	query := `
   146  upsert {
   147    mutation {
   148      set {
   149        "_:user1" <age> "45" .
   150      }
   151    }
   152  }
   153  `
   154  	_, err := ParseMutation(query)
   155  	require.Error(t, err)
   156  	require.Contains(t, err.Error(), "Query op not found in upsert block")
   157  }
   158  
   159  func TestUpsertWithFragment(t *testing.T) {
   160  	query := `
   161  upsert {
   162    query {
   163      me(func: eq(age, 34)) {
   164        ...fragmentA
   165        friend {
   166          ...fragmentA
   167          age
   168        }
   169      }
   170    }
   171  
   172    fragment fragmentA {
   173      uid
   174    }
   175  
   176    mutation {
   177      set {
   178        "_:user1" <age> "45" .
   179      }
   180    }
   181  }
   182  `
   183  	_, err := ParseMutation(query)
   184  	require.Nil(t, err)
   185  }
   186  
   187  func TestUpsertEx1(t *testing.T) {
   188  	query := `
   189  upsert {
   190    query {
   191      me(func: eq(age, "{")) {
   192        uid
   193        friend {
   194          uid
   195          age
   196        }
   197      }
   198    }
   199  
   200    mutation {
   201      set {
   202        "_:user1" <age> "45" .
   203      }
   204    }
   205  }
   206  `
   207  	_, err := ParseMutation(query)
   208  	require.Nil(t, err)
   209  }
   210  
   211  func TestUpsertWithSpaces(t *testing.T) {
   212  	query := `
   213  upsert
   214  
   215  {
   216    query
   217  
   218    {
   219      me(func: eq(age, "{")) {
   220        uid
   221        friend {
   222          uid
   223          age
   224        }
   225      }
   226    }
   227  
   228    mutation
   229  
   230    {
   231      set
   232      {
   233        "_:user1" <age> "45" .
   234  
   235        # This is a comment
   236        "_:user1" <name> "{vishesh" .
   237      }}
   238  }
   239  `
   240  	_, err := ParseMutation(query)
   241  	require.Nil(t, err)
   242  }
   243  
   244  func TestUpsertWithBlankNode(t *testing.T) {
   245  	query := `
   246  upsert {
   247    mutation {
   248      set {
   249        "_:user1" <age> "45" .
   250      }
   251    }
   252  
   253    query {
   254      me(func: eq(age, 34)) {
   255        uid
   256        friend {
   257          uid
   258          age
   259        }
   260      }
   261    }
   262  }
   263  `
   264  	_, err := ParseMutation(query)
   265  	require.Nil(t, err)
   266  }
   267  
   268  func TestUpsertMutationThenQuery(t *testing.T) {
   269  	query := `
   270  upsert {
   271    query {
   272      me(func: eq(age, 34)) {
   273        uid
   274        friend {
   275          uid
   276          age
   277        }
   278      }
   279    }
   280  
   281    mutation {
   282      set {
   283        "_:user1" <age> "45" .
   284      }
   285    }
   286  }
   287  `
   288  	_, err := ParseMutation(query)
   289  	require.Nil(t, err)
   290  }
   291  
   292  func TestUpsertWithFilter(t *testing.T) {
   293  	query := `
   294  upsert {
   295    query {
   296      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   297        uid
   298        friend {
   299          uid
   300          age
   301        }
   302      }
   303    }
   304  
   305    mutation {
   306      set {
   307        uid(a) <age> "45"
   308        uid(b) <age> "45" .
   309      }
   310    }
   311  }
   312  `
   313  	_, err := ParseMutation(query)
   314  	require.Nil(t, err)
   315  }
   316  
   317  func TestConditionalUpsertWithNewlines(t *testing.T) {
   318  	query := `
   319  upsert {
   320    query {
   321      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   322        m as uid
   323        friend {
   324          f as uid
   325          age
   326        }
   327      }
   328    }
   329  
   330    mutation @if(eq(len(m), 1)
   331                 AND
   332                 gt(len(f), 0)) {
   333      set {
   334        uid(m) <age> "45" .
   335        uid(f) <age> "45" .
   336      }
   337    }
   338  }
   339  `
   340  	_, err := ParseMutation(query)
   341  	require.Nil(t, err)
   342  }
   343  
   344  func TestConditionalUpsertFuncTree(t *testing.T) {
   345  	query := `
   346  upsert {
   347    query {
   348      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   349        uid
   350        friend {
   351          uid
   352          age
   353        }
   354      }
   355    }
   356  
   357    mutation @if( ( eq(len(m), 1)
   358                    OR
   359                    lt(90, len(h)))
   360                  AND
   361                  gt(len(f), 0)) {
   362      set {
   363        uid(m) <age> "45" .
   364        uid(f) <age> "45" .
   365      }
   366    }
   367  }
   368  `
   369  	_, err := ParseMutation(query)
   370  	require.Nil(t, err)
   371  }
   372  
   373  func TestConditionalUpsertMultipleFuncArg(t *testing.T) {
   374  	query := `
   375  upsert {
   376    query {
   377      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   378        uid
   379        friend {
   380          uid
   381          age
   382        }
   383      }
   384    }
   385  
   386    mutation @if( ( eq(len(m), len(t))
   387                    OR
   388                    lt(90, len(h)))
   389                  AND
   390                  gt(len(f), 0)) {
   391      set {
   392        uid(m) <age> "45" .
   393        uid(f) <age> "45" .
   394      }
   395    }
   396  }
   397  `
   398  	_, err := ParseMutation(query)
   399  	require.Nil(t, err)
   400  }
   401  
   402  func TestConditionalUpsertErrMissingRightRound(t *testing.T) {
   403  	query := `
   404  upsert {
   405    query {
   406      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   407        uid
   408        friend {
   409          uid
   410          age
   411        }
   412      }
   413    }
   414  
   415    mutation @if(eq(len(m, 1)
   416                 AND
   417                 gt(len(f), 0)) {
   418      set {
   419        uid(m) <age> "45" .
   420        uid(f) <age> "45" .
   421      }
   422    }
   423  }
   424  `
   425  	_, err := ParseMutation(query)
   426  	require.Contains(t, err.Error(), "Matching brackets not found")
   427  }
   428  
   429  func TestConditionalUpsertErrUnclosed(t *testing.T) {
   430  	query := `upsert {
   431    mutation @if(eq(len(m), 1) AND gt(len(f), 0))`
   432  	_, err := ParseMutation(query)
   433  	require.Contains(t, err.Error(), "Unclosed mutation action")
   434  }
   435  
   436  func TestConditionalUpsertErrInvalidIf(t *testing.T) {
   437  	query := `upsert {
   438    mutation @if`
   439  	_, err := ParseMutation(query)
   440  	require.Contains(t, err.Error(), "Matching brackets not found")
   441  }
   442  
   443  func TestConditionalUpsertErrWrongIf(t *testing.T) {
   444  	query := `upsert {
   445    mutation @fi( ( eq(len(m), 1)
   446                    OR
   447                    lt(len(h), 90))
   448                  AND
   449                  gt(len(f), 0)) {
   450      set {
   451        uid(m) <age> "45" .
   452        uid(f) <age> "45" .
   453      }
   454    }
   455  
   456    query {
   457      me(func: eq(age, 34)) @filter(ge(name, "user")) {
   458        uid
   459        friend {
   460          uid
   461          age
   462        }
   463      }
   464    }
   465  }
   466  `
   467  	_, err := ParseMutation(query)
   468  	require.Contains(t, err.Error(), "Expected @if, found [@fi]")
   469  }