Ejemplo n.º 1
0
def test_fetch_id_query_persistence():
    swsetup()
    hpsetup()
    client = Client(schema)
    query = """
      query FetchSomeIDQuery($someId: String!) {
        human(id: $someId) {
          name
        }
      }
  """
    params = {"someId": "3000"}
    con = {"trace": []}
    result = schema.execute(query, context=con)
 def test_correctly_fetches_id_name_empire(self):
     empire_key = to_global_id('Faction',
                               ndb.Key('Faction', 'empire').urlsafe())
     query = '''
       query EmpireQuery {
         empire {
           id
           name
         }
       }
     '''
     expected = {'empire': {'id': empire_key, 'name': 'Galactic Empire'}}
     result = schema.execute(query)
     self.assertFalse(result.errors, msg=str(result.errors))
     self.assertDictEqual(result.data, expected)
 def test_correctly_fetches_id_name_rebels(self):
     query = '''
         query RebelsQuery {
           rebels {
             id,
             name
           }
         }
       '''
     expected = {
         'rebels': {
             'id': to_global_id('Faction', ndb.Key('Faction', 'rebels').urlsafe()),
             'name': 'Alliance to Restore the Republic'
         }
     }
     result = schema.execute(query)
     self.assertFalse(result.errors, msg=str(result.errors))
     self.assertDictEqual(result.data, expected)
 def test_correctly_fetches_id_name_empire(self):
     empire_key = to_global_id('Faction', ndb.Key('Faction', 'empire').urlsafe())
     query = '''
       query EmpireQuery {
         empire {
           id
           name
         }
       }
     '''
     expected = {
         'empire': {
             'id': empire_key,
             'name': 'Galactic Empire'
         }
     }
     result = schema.execute(query)
     self.assertFalse(result.errors, msg=str(result.errors))
     self.assertDictEqual(result.data, expected)
 def test_correctly_fetches_id_name_rebels(self):
     query = '''
         query RebelsQuery {
           rebels {
             id,
             name
           }
         }
       '''
     expected = {
         'rebels': {
             'id':
             to_global_id('Faction',
                          ndb.Key('Faction', 'rebels').urlsafe()),
             'name':
             'Alliance to Restore the Republic'
         }
     }
     result = schema.execute(query)
     self.assertFalse(result.errors, msg=str(result.errors))
     self.assertDictEqual(result.data, expected)
    def test_correctly_refetches_rebels(self):
        rebels_key = to_global_id('Faction', ndb.Key('Faction', 'rebels').urlsafe())
        query = '''
            query RebelsRefetchQuery {
              node(id: "%s") {
                id
                ... on Faction {
                  name
                }
              }
            }
          ''' % rebels_key

        expected = {
            'node': {
                'id': rebels_key,
                'name': 'Alliance to Restore the Republic'
            }
        }
        result = schema.execute(query)
        self.assertFalse(result.errors, msg=str(result.errors))
        self.assertDictEqual(result.data, expected)
    def test_correctly_refetches_rebels(self):
        rebels_key = to_global_id('Faction',
                                  ndb.Key('Faction', 'rebels').urlsafe())
        query = '''
            query RebelsRefetchQuery {
              node(id: "%s") {
                id
                ... on Faction {
                  name
                }
              }
            }
          ''' % rebels_key

        expected = {
            'node': {
                'id': rebels_key,
                'name': 'Alliance to Restore the Republic'
            }
        }
        result = schema.execute(query)
        self.assertFalse(result.errors, msg=str(result.errors))
        self.assertDictEqual(result.data, expected)
Ejemplo n.º 8
0
 def testConnection(self):
     query = '''
         query RebelsShipsQuery {
           rebels {
             name,
             hero {
               name
             }
             ships(first: 1) {
               edges {
                 node {
                   name
                 }
               }
             }
           }
         }
         '''
     expected = {
         'rebels': {
             'name': 'Alliance to Restore the Republic',
             'hero': {
                 'name': 'Human'
             },
             'ships': {
                 'edges': [{
                     'node': {
                         'name': 'X-Wing'
                     }
                 }]
             }
         }
     }
     result = schema.execute(query)
     self.assertFalse(result.errors, msg=str(result.errors))
     self.assertDictEqual(result.data, expected)
Ejemplo n.º 9
0
    def testIntroduceShip(self):
        query = '''
            mutation MyMutation {
              introduceShip(input:{clientMutationId:"abc", shipName: "XYZWing", factionId: "rebels"}) {
                ship {
                  id
                  name
                }
                faction {
                  name
                  ships {
                    edges {
                      node {
                        id
                        name
                      }
                    }
                  }
                }
              }
            }
            '''

        expected = {
            'introduceShip': {
                'ship': {
                    'id': 'U2hpcDoxMQ==',
                    'name': 'XYZWing'
                },
                'faction': {
                    'name': 'Alliance to Restore the Republic',
                    'ships': {
                        'edges': [{
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdEREE=',
                                'name': 'X-Wing'
                            }
                        }, {
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdFREE=',
                                'name': 'Y-Wing'
                            }
                        }, {
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdGREE=',
                                'name': 'A-Wing'
                            }
                        }, {
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdHREE=',
                                'name': 'Millenium Falcon'
                            }
                        }, {
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdIREE=',
                                'name': 'Home One'
                            }
                        }, {
                            'node': {
                                'id': 'U2hpcDphaEZuY21Gd2FHVnVaUzFuWVdVdGRHVnpkSElLQ3hJRVUyaHBjQmdMREE=',
                                'name': 'XYZWing'
                            }
                        }]
                    },
                }
            }
        }
        result = schema.execute(query)
        ship_in_db = Ship.query().filter(Ship.name == 'XYZWing', Ship.faction_key == ndb.Key('Faction', 'rebels')).fetch(1)

        self.assertIsNotNone(ship_in_db)
        self.assertLength(ship_in_db, 1)

        new_ship = ship_in_db[0]
        self.assertEqual(new_ship.name, 'XYZWing')

        expected['introduceShip']['ship']['id'] = to_global_id('Ship', new_ship.key.urlsafe())

        self.assertFalse(result.errors, msg=str(result.errors))
        self.assertDictEqual(result.data, expected)