def test_doublereload(self):
"""force-reloading a not yet been imported module causes one load"""
# TODO: implementation specific use of __builtins__.
assert dynamicloader.__builtins__
assert "whichdb" not in sys.modules
# Wrap reload to work out how many times it was called.
def new_reload(*args, **kwargs):
new_reload.hits += 1
return new_reload.old(*args, **kwargs)
new_reload.hits = 0
new_reload.old = dynamicloader.__builtins__["reload"]
dynamicloader.__builtins__["reload"] = new_reload
assert dynamicloader.load("whichdb", force_reload=True).whichdb
assert new_reload.hits == 0
assert dynamicloader.load("whichdb", force_reload=True).whichdb
assert new_reload.hits == 1
dynamicloader.__builtins__["reload"] = new_reload.old
assert dynamicloader.load("whichdb", force_reload=True).whichdb
assert new_reload.hits == 1 # no change; no longer wrapped
def test_can_load_generator(self):
a = dynamicloader.load(dynamicloadme.GFunction.__fullname__)
b = dynamicloader.load(dynamicloadme.GFunction)
t = ["Hello", "World"]
ta = [i for i in a()]
tb = [i for i in b()]
assert ta == tb == t
def test_load_gets_correct_object(self):
# This tests calls of the format load(MyClass) and
# load("packagea.packageb.aclass")
for i in [dynamicloadme.AClass, dynamicloadme.BClass,
dynamicloadme.AFunction, dynamicloadme.BFunction]:
assert dynamicloader.load(i) == i
# if nosetests is running --with-isolation, this is required:
realitem = getattr(sys.modules[i.__module__], i.__name__)
assert dynamicloader.load(i.__fullname__) == realitem
def test_can_use_loaded_class(self):
# CClass is subclass of AClass; CClass is callable
a = dynamicloader.load(dynamicloadme.AClass.__fullname__)
c = dynamicloader.load(dynamicloadme.CClass.__fullname__)
assert issubclass(c, a)
oa = a()
oc = c()
assert isinstance(oa, a)
assert isinstance(oc, c)
assert isinstance(oc, a)
assert oc(None, None) == None
def test_can_load_notyetimported_module(self):
"""can load a module that has not yet been imported once"""
# I picked something that probably won't have been loaded yet
assert "anydbm" not in sys.modules
# Check to see httplib2.Authentication exists (if it does we've
# probably got the right module)
assert dynamicloader.load("anydbm").error
def check_reload_module(self, modname, modulecode_1, modulecode_2):
rmod = ReloadableModuleWriter(modname, 'asdf')
assert not rmod.is_loaded()
roundabout_mod = ReloadableModuleWriter(modname + "_alias", "asdf")
assert not roundabout_mod.is_loaded()
roundabout_mod.write_code("from {0} import asdf".format(modname))
rmod.write_code(modulecode_1)
asdf_1a = dynamicloader.load(rmod.loadable)
asdf_1a_object = asdf_1a()
assert asdf_1a_object.test == 1
rmod.write_code(modulecode_2)
# Should not cause a reload, should just re-use sys.moudles[loadable]
asdf_1b = dynamicloader.load(rmod.loadable)
assert asdf_1b == asdf_1a
asdf_1b_object = asdf_1b()
assert asdf_1b_object.test == asdf_1a_object.test == 1
# This time we want a reload
asdf_2a = dynamicloader.load(rmod.loadable, force_reload=True)
assert asdf_2a != asdf_1b
asdf_2a_object = asdf_2a()
assert asdf_2a_object.test == 2
# It should stay reloaded, even without force_reload
asdf_2b = dynamicloader.load(rmod.loadable)
assert asdf_2b == asdf_2a
asdf_2b_object = asdf_2a()
assert asdf_2b_object.test == asdf_2a_object.test == 2
# asdf_1b should still be the old module, though in typical use it
# would have been discarded by now
asdf_1b_object = asdf_1b()
assert asdf_1b_object.test == 1
rmod.write_code(modulecode_1)
# We should also be able to reload like this:
asdf_1c = dynamicloader.load(asdf_2b, force_reload=True)
assert asdf_1c != asdf_2a
asdf_1c_object = asdf_1c()
assert asdf_1c_object.test == 1
rmod.write_code(modulecode_2)
# And finally like this:
asdf_2c = dynamicloader.load(roundabout_mod.loadable,
force_reload=True)
assert asdf_2c != asdf_1c
asdf_2c_object = asdf_2c()
assert asdf_2c_object.test == 2
def test_can_load_module(self):
# Test a call in the form load("datetime")
assert dynamicloader.load("datetime") == datetime
def chcek_load_gets_correct_object(self, loadable, target):
assert dynamicloader.load(loadable) == target
def test_refuses_to_load_empty_str(self):
dynamicloader.load("")
def test_refuses_to_load_garbage_loadable(self):
dynamicloader.load(1234)
def test_load_does_not_recurse_into_classes(self):
dynamicloader.load(dynamicloadme.__name__ + ".AClass.afunc")
def test_load_rejects_nonexistent_class(self):
dynamicloader.load(dynamicloadme.__name__ + ".nothingasdf")
def test_load_rejects_nonexistent_module(self):
dynamicloader.load("nonexistant_module_asdf.apath.aclass")
def test_load_rejects_garbage_argument(self):
dynamicloader.load(1234)
def test_load_rejects_garbage_target(self):
"""load rejects a target that is neither a function nor a class"""
dynamicloader.load(dynamicloadme.__name__ + ".avariable")
def test_can_load_module_not_imported_by_parent_module(self):
dynamicloader.load(unimp_b_name)
def test_can_load_notyetimported_function(self):
"""can load an object from a module that has not been imported yet"""
f = dynamicloader.load(unimp_name + ".AFunction")
assert f() == 412314
def check_refuses_to_load_str_with_empty_components(self, name):
dynamicloader.load(name)
