def test_detect_model_dir(self):
# Make sure we can detect all of our valid model dirs
# Note: the problem model has an sdml definition, so we're testing python and sdml here
for model_dir in CORE_DIRS:
dir_path = os.path.join(settings.CORE_DATAMODEL_DIRS[0], model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
for model_dir in TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
# Make sure we can detect an invalid dir
for model_dir in INVALID_TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertFalse(valid_p)
self.assertEqual(module_name, None)
self.assertEqual(ext, None)
def setUp(self):
super(DataModelLoaderUnitTests, self).setUp()
self.core_loader = IndivoDataModelLoader(
settings.CORE_DATAMODEL_DIRS[0])
self.test_dir = os.path.join(settings.APP_HOME,
'indivo/tests/data_models/test')
self.test_loader = IndivoDataModelLoader(self.test_dir)
def test_detect_model_dir(self):
# Make sure we can detect all of our valid model dirs
# Note: the problem model has an sdml definition, so we're testing python and sdml here
for model_dir in CORE_DIRS:
dir_path = os.path.join(settings.CORE_DATAMODEL_DIRS[0], model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
for model_dir in TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
# Make sure we can detect an invalid dir
for model_dir in INVALID_TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertFalse(valid_p)
self.assertEqual(module_name, None)
self.assertEqual(ext, None)
def unload_model_dir(self, dirpath):
""" Unload data models that have been loaded from a directory."""
loader = IndivoDataModelLoader(dirpath)
models = [
model_class
for model_name, model_class in loader.discover_data_models()
]
self.unload_models(models)
def load_model_dir(self, dirpath):
""" Load data models from a directory (like we do when running Indivo normally). """
loader = IndivoDataModelLoader(dirpath)
models = [
model_class
for model_name, model_class in loader.discover_data_models()
]
self.load_models(models)
return models
def load_models(self, models):
""" Do the heavy lifting for loading data models.
Registers the models, then migrates the DB to support them.
"""
loader = IndivoDataModelLoader('')
for m in models:
# Register the model in indivo.models
loader.add_model_to_module(m.__name__, m, self.TEST_MODEL_MODULE)
# Migrate the database to contain the model
db.start_transaction()
try:
self.create_db_model(m)
except Exception, e:
db.rollback_transaction()
else:
db.commit_transaction()
def unload_model_dir(self, dirpath):
""" Unload data models that have been loaded from a directory."""
loader = IndivoDataModelLoader(dirpath)
models = [model_class for model_name, model_class in loader.discover_data_models()]
self.unload_models(models)
def load_model_dir(self, dirpath):
""" Load data models from a directory (like we do when running Indivo normally). """
loader = IndivoDataModelLoader(dirpath)
models = [model_class for model_name, model_class in loader.discover_data_models()]
self.load_models(models)
return models
def setUp(self):
super(DataModelLoaderUnitTests, self).setUp()
self.test_dir = os.path.join(settings.APP_HOME, 'indivo/tests/data_models/test')
self.test_loader = IndivoDataModelLoader(self.test_dir)
class DataModelLoaderUnitTests(InternalTests):
def setUp(self):
super(DataModelLoaderUnitTests, self).setUp()
self.test_dir = os.path.join(settings.APP_HOME, 'indivo/tests/data_models/test')
self.test_loader = IndivoDataModelLoader(self.test_dir)
def tearDown(self):
super(DataModelLoaderUnitTests,self).tearDown()
def test_import_data_models(self):
# get the core modules, and make sure we imported them all
self.assertModuleContains(TEST_MODULE, CORE_MODELS)
# get the test modules, and make sure we imported them all
self.test_loader.import_data_models(TEST_MODULE)
self.assertModuleContains(TEST_MODULE, TEST_MODELS)
# make sure the serializers were loaded correctly
for model_name in TEST_MODELS:
model_cls = getattr(TEST_MODULE, model_name, None)
rdf_ser = getattr(model_cls, 'to_rdf', None)
self.assertTrue(rdf_ser)
# Dummy input to the serializers, which produce dummy output
rdf_output = rdf_ser(model_cls.objects.none(), 0, Record())
self.assertTrue(rdf_output.startswith(model_name))
def _find_indivo_validator(validators, validator_class):
for v in validators:
if isinstance(v, validator_class):
return v
# make sure the field validators were loaded correctly
# validator on TestMed.name should accept 'med1', 'med2', or None
test_med_class = getattr(TEST_MODULE, 'TestMed')
field = test_med_class._meta.get_field('name')
validator = _find_indivo_validator(field.validators, ValueInSetValidator)
self.assertNotRaises(ValidationError, validator, 'med1')
self.assertNotRaises(ValidationError, validator, 'med2')
self.assertNotRaises(ValidationError, validator, None)
self.assertRaises(ValidationError, validator, 'med3')
# validator on TestFill.supply_days should accept 30
test_med_class = getattr(TEST_MODULE, 'TestFill')
field = test_med_class._meta.get_field('supply_days')
validator = _find_indivo_validator(field.validators, ExactValueValidator)
self.assertNotRaises(ValidationError, validator, 30)
self.assertRaises(ValidationError, validator, 29)
self.assertRaises(ValidationError, validator, '30')
self.assertRaises(ValidationError, validator, None)
def test_detect_model_dir(self):
# Make sure we can detect all of our valid model dirs
# Note: the problem model has an sdml definition, so we're testing python and sdml here
for model_dir in CORE_DIRS:
dir_path = os.path.join(settings.CORE_DATAMODEL_DIRS[0], model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
for model_dir in TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
# Make sure we can detect an invalid dir
for model_dir in INVALID_TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(dir_path)
self.assertFalse(valid_p)
self.assertEqual(module_name, None)
self.assertEqual(ext, None)
def test_discover_data_models(self):
# Make sure we got all the test datamodels, and they are all Fact subclasses
test_models = dict([(name, cls) for name, cls in self.test_loader.discover_data_models()])
self.assertEqual(set(test_models.keys()), set(TEST_MODELS))
for cls in test_models.values():
self.assertTrue(issubclass(cls, Fact))
def assertModuleContains(self, module, member_list):
self.assertNotRaises(ImportError, __import__, module, fromlist=member_list)
class DataModelLoaderUnitTests(InternalTests):
def setUp(self):
super(DataModelLoaderUnitTests, self).setUp()
self.core_loader = IndivoDataModelLoader(
settings.CORE_DATAMODEL_DIRS[0])
self.test_dir = os.path.join(settings.APP_HOME,
'indivo/tests/data_models/test')
self.test_loader = IndivoDataModelLoader(self.test_dir)
def test_import_data_models(self):
# get the core modules, and make sure we imported them all
self.core_loader.import_data_models(TEST_MODULE)
self.assertModuleContains(TEST_MODULE, CORE_MODELS)
# get the test modules, and make sure we imported them all
self.test_loader.import_data_models(TEST_MODULE)
self.assertModuleContains(TEST_MODULE, TEST_MODELS)
# make sure the serializers were loaded correctly
for model_name in TEST_MODELS:
model_cls = getattr(TEST_MODULE, model_name, None)
rdf_ser = getattr(model_cls, 'to_rdf', None)
self.assertTrue(rdf_ser)
# Dummy input to the serializers, which produce dummy output
rdf_output = rdf_ser(model_cls.objects.none(), 0, Record())
self.assertTrue(rdf_output.startswith(model_name))
def _find_indivo_validator(validators, validator_class):
for v in validators:
if isinstance(v, validator_class):
return v
# make sure the field validators were loaded correctly
# validator on TestMed.name should accept 'med1', 'med2', or None
test_med_class = getattr(TEST_MODULE, 'TestMed')
field = test_med_class._meta.get_field('name')
validator = _find_indivo_validator(field.validators,
ValueInSetValidator)
self.assertNotRaises(ValidationError, validator, 'med1')
self.assertNotRaises(ValidationError, validator, 'med2')
self.assertNotRaises(ValidationError, validator, None)
self.assertRaises(ValidationError, validator, 'med3')
# validator on TestFill.supply_days should accept 30
test_med_class = getattr(TEST_MODULE, 'TestFill')
field = test_med_class._meta.get_field('supply_days')
validator = _find_indivo_validator(field.validators,
ExactValueValidator)
self.assertNotRaises(ValidationError, validator, 30)
self.assertRaises(ValidationError, validator, 29)
self.assertRaises(ValidationError, validator, '30')
self.assertRaises(ValidationError, validator, None)
def test_detect_model_dir(self):
# Make sure we can detect all of our valid model dirs
# Note: the problem model has an sdml definition, so we're testing python and sdml here
for model_dir in CORE_DIRS:
dir_path = os.path.join(settings.CORE_DATAMODEL_DIRS[0], model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
for model_dir in TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertTrue(valid_p)
self.assertEqual(module_name, MODULE_NAME)
self.assertTrue(ext in MODULE_EXTENSIONS)
# Make sure we can detect an invalid dir
for model_dir in INVALID_TEST_DIRS:
dir_path = os.path.join(self.test_dir, model_dir)
valid_p, module_name, ext = IndivoDataModelLoader.detect_model_dir(
dir_path)
self.assertFalse(valid_p)
self.assertEqual(module_name, None)
self.assertEqual(ext, None)
def test_discover_data_models(self):
# Make sure we got all the core datamodels, and they are all Fact subclasses
core_models = dict([
(name, cls)
for name, cls in self.core_loader.discover_data_models()
])
self.assertEqual(set(core_models.keys()), set(CORE_MODELS))
for cls in core_models.values():
self.assertTrue(issubclass(cls, Fact))
# Make sure we got all the test datamodels, and they are all Fact subclasses
test_models = dict([
(name, cls)
for name, cls in self.test_loader.discover_data_models()
])
self.assertEqual(set(test_models.keys()), set(TEST_MODELS))
for cls in test_models.values():
self.assertTrue(issubclass(cls, Fact))
def assertModuleContains(self, module, member_list):
self.assertNotRaises(ImportError,
__import__,
module,
fromlist=member_list)
