def test_interface( self ):
type_names = builtin_type_registry()
resolver = TypeResolver([type_names])
data = t_interface_meta('unit_test_iface', None, [
t_command_meta('request', 'request_one',
[t_field_meta('req_param1', t_named('string'))],
[t_field_meta('req_result1', t_list_meta(t_named('int')))]),
t_command_meta('notification', 'notification_one',
[t_field_meta('noti_param1', t_optional_meta(t_named('bool'))),
t_field_meta('noti_param2', t_named('datetime'))]),
t_command_meta('request', 'request_open', [],
[t_field_meta('result', t_optional_meta(t_named('int')))]),
], contents_fields=[
t_field_meta('text', t_named('string')),
], diff_type=t_named('string')
)
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(Interface('unit_test_iface',
contents_fields=[
Field('text', tString),
],
diff_type=tString,
commands=[
RequestCmd('request_one',
[Field('req_param1', tString)],
[Field('req_result1', TList(tInt))]),
NotificationCmd('notification_one',
[Field('noti_param1', TOptional(tBool)),
Field('noti_param2', tDateTime)]),
RequestCmd('request_open', [],
[Field('result', TOptional(tInt))]),
]), t)
def test_record( self ):
resolver = TypeResolver([builtin_type_registry()])
data = t_record_meta([
t_field_meta('int_field', t_named('int')),
t_field_meta('string_list_field', t_list_meta(t_named('string'))),
t_field_meta('bool_optional_field', t_optional_meta(t_named('bool'))),
])
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(TRecord([
Field('int_field', tInt),
Field('string_list_field', TList(tString)),
Field('bool_optional_field', TOptional(tBool)),
]),
t)
def __init__( self ):
self.interface_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../common/interface'))
self.server_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
self.dynamic_module_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../dynamic_modules'))
self.iface_registry = IfaceRegistry()
self.type_registry_registry = TypeRegistryRegistry(dict(builtins=builtin_type_registry()))
self.type_repository = TypeRepository(self.interface_dir, self.iface_registry, self.type_registry_registry)
self.module_manager = ModuleManager(self, self.type_registry_registry)
self.route_storage = RouteStorage(PhonyRouteRepository())
self.resources_loader = PhonyResourcesLoader()
self.remoting = Remoting(self.iface_registry)
self.module_manager.register_meta_hook()
self._load_type_modules()
self._load_server_modules()
self._register_transports()
def test_yaml_module( self ):
type_resolver = TypeResolver([builtin_type_registry()])
fpath = self.make_fpath('test_module1.types.yaml')
registry = resolve_typedefs_from_yaml_file(self.meta_type_registry, type_resolver, fpath)
self.assertTrue(registry.has_name('some_int'))
self.assertEqual(tInt, registry.get_name('some_int'))
self.assertTrue(registry.has_name('object'))
object_t = registry.get_name('object')
self.assertTrue(registry.has_name('simple_class'))
simple_class = registry.get_name('simple_class')
self.assertEqual(TClass(object_t, 'simple', TRecord([])), simple_class)
self.assertTrue(registry.has_name('text_object'))
self.assertEqual(TClass(object_t, 'text', TRecord(base=simple_class, fields=[Field('text', tString)])),
registry.get_name('text_object'))
def __init__( self ):
self.interface_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../common/interface'))
self.client_module_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
self.iface_registry = IfaceRegistry()
self.type_registry_registry = TypeRegistryRegistry(dict(builtins=builtin_type_registry()), self.iface_registry)
self.type_repository = TypeRepository(self.interface_dir, self.iface_registry, self.type_registry_registry)
self.route_storage = RouteStorage(PhonyRouteRepository())
self.proxy_registry = ProxyRegistry()
self.remoting = Remoting(self.route_storage, self.proxy_registry)
self.objimpl_registry = ObjImplRegistry()
self.view_registry = ViewRegistry(self.iface_registry, self.remoting)
self.module_manager = ModuleManager(self)
self.identity_repository = PhonyIdentityRepository()
self.cache_repository = PhonyCacheRepository()
self.resources_manager = PhonyResourcesManager()
self.module_manager.register_meta_hook()
self._load_type_modules()
self._load_modules()
self.code_repository.set_url_repository(PhonyNamedUrlRepository())
self._register_transports()
def test_hierarchy( self ):
type_names = builtin_type_registry()
resolver = TypeResolver([type_names])
hdata = t_hierarchy_meta('test_hierarchy')
hierarchy = self.meta_type_registry.resolve(resolver, hdata)
type_names.register('my_test_hierarchy', hierarchy)
cdata_a = t_hierarchy_class_meta('my_test_hierarchy', 'class_a', base_name=None, fields=[
t_field_meta('field_a_1', t_named('string')),
])
cdata_b = t_hierarchy_class_meta('my_test_hierarchy', 'class_b', base_name='my_class_a', fields=[
t_field_meta('field_b_1', t_list_meta(t_named('int'))),
])
self.assertTrue(THierarchy('test_hierarchy').matches(hierarchy))
class_a = self.meta_type_registry.resolve(resolver, cdata_a)
type_names.register('my_class_a', class_a)
class_b = self.meta_type_registry.resolve(resolver, cdata_b)
self.assertEqual(TClass(hierarchy, 'class_a', TRecord([Field('field_a_1', tString)])), class_a)
self.assertEqual(TClass(hierarchy, 'class_b', TRecord([Field('field_a_1', tString),
Field('field_b_1', TList(tInt))])), class_b)
def test_list_interface( self ):
type_names = builtin_type_registry()
resolver = TypeResolver([type_names])
data = t_list_interface_meta('unit_test_list_iface', None, commands=[
t_command_meta('request', 'request_open', [],
[t_field_meta('result', t_optional_meta(t_named('int')))]),
], columns=[
t_column_meta('key', t_named('int'), is_key=True),
t_column_meta('text', t_named('string'), is_key=False),
], contents_fields=[
t_field_meta('text', t_named('string')),
])
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(ListInterface('unit_test_list_iface',
contents_fields=[
Field('text', tString),
],
commands=[
RequestCmd('request_open', [], [Field('result', TOptional(tInt))]),
], columns=[
Column('key', tInt, is_key=True),
Column('text', tString),
]), t)
def test_list( self ):
resolver = TypeResolver([builtin_type_registry()])
data = t_list_meta(t_optional_meta(t_named('datetime')))
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(TList(TOptional(tDateTime)), t)
def test_optional( self ):
resolver = TypeResolver([builtin_type_registry()])
data = t_optional_meta(t_named('string'))
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(t, TOptional(tString))
self.assertIs(t.base_t, tString)
def test_named( self ):
resolver = TypeResolver([builtin_type_registry()])
data = t_named('int')
t = self.meta_type_registry.resolve(resolver, data)
self.assertEqual(t, tInt)
self.assertIs(t, tInt) # must resolve to same instance
