test/unittest_schema.py
changeset 10193 a0a11be5a9cb
parent 10192 365e5a0287d6
child 10252 3b89cfd010a6
equal deleted inserted replaced
10192:365e5a0287d6 10193:a0a11be5a9cb
   296 
   296 
   297         class Company(EntityType):
   297         class Company(EntityType):
   298             total_salary = Int(formula='Any SUM(SA) GROUPBY X WHERE '
   298             total_salary = Int(formula='Any SUM(SA) GROUPBY X WHERE '
   299                                        'P works_for X, P salary SA')
   299                                        'P works_for X, P salary SA')
   300         good_schema = build_schema_from_namespace(vars().items())
   300         good_schema = build_schema_from_namespace(vars().items())
   301 
   301         rdef = good_schema['Company'].rdef('total_salary')
   302         # ensure 'X is Company' is added to the rqlst to avoid ambiguities, see #4901163
   302         # ensure 'X is Company' is added to the rqlst to avoid ambiguities, see #4901163
   303         self.assertEqual(str(good_schema['Company'].rdef('total_salary').formula_select),
   303         self.assertEqual(str(rdef.formula_select),
   304                          'Any SUM(SA) GROUPBY X WHERE P works_for X, P salary SA, X is Company')
   304                          'Any SUM(SA) GROUPBY X WHERE P works_for X, P salary SA, X is Company')
       
   305         # check relation definition permissions
       
   306         self.assertEqual(rdef.permissions,
       
   307                          {'add': (), 'update': (),
       
   308                           'read': ('managers', 'users', 'guests')})
   305 
   309 
   306         class Company(EntityType):
   310         class Company(EntityType):
   307             total_salary = String(formula='Any SUM(SA) GROUPBY X WHERE '
   311             total_salary = String(formula='Any SUM(SA) GROUPBY X WHERE '
   308                                           'P works_for X, P salary SA')
   312                                           'P works_for X, P salary SA')
   309 
   313 
   356                          schema['produces_and_buys'].rdefs.keys())
   360                          schema['produces_and_buys'].rdefs.keys())
   357         self.assertEqual([('Person','Service')],
   361         self.assertEqual([('Person','Service')],
   358                          schema['produces_and_buys2'].rdefs.keys())
   362                          schema['produces_and_buys2'].rdefs.keys())
   359         self.assertEqual([('Company', 'Service'), ('Person', 'Service')],
   363         self.assertEqual([('Company', 'Service'), ('Person', 'Service')],
   360                          schema['reproduce'].rdefs.keys())
   364                          schema['reproduce'].rdefs.keys())
   361         # check relations as marked infered
   365         # check relation definitions are marked infered
   362         self.assertTrue(
   366         rdef = schema['produces_and_buys'].rdefs[('Person','Service')]
   363             schema['produces_and_buys'].rdefs[('Person','Service')].infered)
   367         self.assertTrue(rdef.infered)
   364 
   368         # and have no add/delete permissions
   365         del schema
   369         self.assertEqual(rdef.permissions,
       
   370                          {'add': (),
       
   371                           'delete': (),
       
   372                           'read': ('managers', 'users', 'guests')})
       
   373 
   366         class autoname(ComputedRelation):
   374         class autoname(ComputedRelation):
   367             rule = 'S produce X, X name O'
   375             rule = 'S produce X, X name O'
   368 
   376 
   369         with self.assertRaises(BadSchemaDefinition) as cm:
   377         with self.assertRaises(BadSchemaDefinition) as cm:
   370             build_schema_from_namespace(vars().items())
   378             build_schema_from_namespace(vars().items())