def test_serialize_simple(self):
f = OxidizedFinder()
m = OxidizedResource()
m.name = "my_module"
m.flavor = "module"
m.in_memory_source = b"import io"
f.add_resource(m)
m = OxidizedResource()
m.name = "module_b"
m.flavor = "module"
m.in_memory_bytecode = b"dummy bytecode"
f.add_resource(m)
serialized = f.serialize_indexed_resources()
self.assertIsInstance(serialized, bytes)
f2 = OxidizedFinder(resources_data=serialized)
modules = {
r.name: r
for r in f2.indexed_resources() if r.flavor == "module"
}
self.assertEqual(len(modules), 2)
self.assertIn("my_module", modules)
self.assertIn("module_b", modules)
self.assertEqual(modules["my_module"].in_memory_source, b"import io")
self.assertEqual(modules["module_b"].in_memory_bytecode,
b"dummy bytecode")
def test_resource_set_name(self):
resource = OxidizedResource()
resource.name = "foobar"
self.assertEqual(resource.name, "foobar")
with self.assertRaises(TypeError):
del resource.name
with self.assertRaises(TypeError):
resource.name = None
def test_resource_set_is_shared_library(self):
resource = OxidizedResource()
resource.is_shared_library = True
self.assertTrue(resource.is_shared_library)
resource.is_shared_library = False
self.assertFalse(resource.is_shared_library)
with self.assertRaises(TypeError):
del resource.is_shared_library
with self.assertRaises(TypeError):
resource.is_shared_library = None
def test_resource_set_is_builtin_extension_module(self):
resource = OxidizedResource()
resource.is_builtin_extension_module = True
self.assertTrue(resource.is_builtin_extension_module)
resource.is_builtin_extension_module = False
self.assertFalse(resource.is_builtin_extension_module)
with self.assertRaises(TypeError):
del resource.is_builtin_extension_module
with self.assertRaises(TypeError):
resource.is_builtin_extension_module = None
def test_resource_set_namespace_package(self):
resource = OxidizedResource()
resource.is_namespace_package = True
self.assertTrue(resource.is_namespace_package)
resource.is_namespace_package = False
self.assertFalse(resource.is_namespace_package)
with self.assertRaises(TypeError):
del resource.is_namespace_package
with self.assertRaises(TypeError):
resource.is_namespace_package = "foo"
def test_resource_shared_library_dependency_names(self):
resource = OxidizedResource()
resource.shared_library_dependency_names = []
self.assertEqual(resource.shared_library_dependency_names, [])
resource.shared_library_dependency_names = None
self.assertIsNone(resource.shared_library_dependency_names)
resource.shared_library_dependency_names = ["foo"]
self.assertEqual(resource.shared_library_dependency_names, ["foo"])
# List mutation is not reflected in original object.
resource.shared_library_dependency_names[:] = []
resource.shared_library_dependency_names.append("bar")
self.assertEqual(resource.shared_library_dependency_names, ["foo"])
with self.assertRaises(TypeError):
del resource.shared_library_dependency_names
with self.assertRaises(TypeError):
resource.shared_library_dependency_names = True
with self.assertRaises(TypeError):
resource.shared_library_dependency_names = [b"foo"]
def test_resource_in_memory_shared_library(self):
resource = OxidizedResource()
resource.in_memory_shared_library = b"ELF"
self.assertEqual(resource.in_memory_shared_library, b"ELF")
resource.in_memory_shared_library = None
self.assertIsNone(resource.in_memory_shared_library)
with self.assertRaises(TypeError):
del resource.in_memory_shared_library
with self.assertRaises(TypeError):
resource.in_memory_shared_library = "ELF"
def test_resource_set_in_memory_source(self):
resource = OxidizedResource()
# bytes works.
resource.in_memory_source = b"import os"
self.assertEqual(resource.in_memory_source, b"import os")
# memoryview works.
resource.in_memory_source = memoryview(b"import io")
self.assertEqual(resource.in_memory_source, b"import io")
# bytearray works.
resource.in_memory_source = bytearray(b"foo bar")
self.assertEqual(resource.in_memory_source, b"foo bar")
resource.in_memory_source = None
self.assertIsNone(resource.in_memory_source)
with self.assertRaises(TypeError):
del resource.in_memory_source
with self.assertRaises(TypeError):
resource.in_memory_source = True
with self.assertRaises(TypeError):
resource.in_memory_source = "import foo"
def test_relative_path_extension_module_shared_library(self):
resource = OxidizedResource()
resource.relative_path_extension_module_shared_library = "lib/foo.so"
self.assertEqual(
resource.relative_path_extension_module_shared_library,
pathlib.Path("lib/foo.so"),
)
resource.relative_path_extension_module_shared_library = pathlib.Path(
"bar.so")
self.assertEqual(
resource.relative_path_extension_module_shared_library,
pathlib.Path("bar.so"),
)
resource.relative_path_extension_module_shared_library = b"foo.so"
self.assertEqual(
resource.relative_path_extension_module_shared_library,
pathlib.Path("foo.so"),
)
resource.relative_path_extension_module_shared_library = None
self.assertIsNone(
resource.relative_path_extension_module_shared_library)
with self.assertRaises(TypeError):
del resource.relative_path_extension_module_shared_library
with self.assertRaises(TypeError):
resource.relative_path_extension_module_shared_library = True
def test_resource_constructor(self):
resource = OxidizedResource()
self.assertIsInstance(resource, OxidizedResource)
self.assertFalse(resource.is_module)
self.assertFalse(resource.is_builtin_extension_module)
self.assertFalse(resource.is_frozen_module)
self.assertFalse(resource.is_extension_module)
self.assertFalse(resource.is_shared_library)
self.assertEqual(resource.name, "")
def test_add_resource_module(self):
f = OxidizedFinder()
resource = OxidizedResource()
resource.name = "my_module"
resource.flavor = "module"
source = b"print('hello from my_module')"
code = compile(source, "my_module.py", "exec")
bytecode = marshal.dumps(code)
resource.in_memory_source = source
resource.in_memory_bytecode = bytecode
f.add_resource(resource)
resources = [r for r in f.indexed_resources() if r.name == "my_module"]
self.assertEqual(len(resources), 1)
spec = f.find_spec("my_module", None)
self.assertIsInstance(spec, importlib.machinery.ModuleSpec)
self.assertEqual(spec.name, "my_module")
self.assertIsNone(spec.loader_state)
self.assertIsNone(spec.submodule_search_locations)
self.assertEqual(f.get_source("my_module"), source.decode("utf-8"))
self.assertEqual(f.get_code("my_module"), code)
def test_resource_set_flavor(self):
resource = OxidizedResource()
for flavor in (
"module",
"none",
"builtin",
"frozen",
"extension",
"shared_library",
):
resource.flavor = flavor
self.assertEqual(resource.flavor, flavor)
with self.assertRaises(TypeError):
del resource.flavor
with self.assertRaises(TypeError):
resource.flavor = None
with self.assertRaisesRegex(ValueError, "unknown resource flavor"):
resource.flavor = "foo"
def test_add_resources(self):
f = OxidizedFinder()
a = OxidizedResource()
a.name = "foo_a"
a.flavor = "module"
b = OxidizedResource()
b.name = "foo_b"
b.flavor = "module"
f.add_resources([a, b])
resources = [
r for r in f.indexed_resources() if r.name in ("foo_a", "foo_b")
]
self.assertEqual(len(resources), 2)
def make_finder(*modules: Tuple[str, str, bool]) -> OxidizedFinder:
"""Create an ``OxidizedFinder`` with modules defined by ``modules``.
``modules`` must be tuples of the form (name, source_code, is_package).
"""
mpf = OxidizedFinder()
for module_name, source, is_pkg in modules:
# See example in OxidizedFinder.add_resource
resource = OxidizedResource()
resource.is_module = True
resource.name = module_name
resource.is_package = is_pkg
resource.in_memory_source = source.encode("utf-8")
resource.in_memory_bytecode = marshal.dumps(
compile(source, module_name, "exec"))
mpf.add_resource(resource)
return mpf
def test_resource_relative_path_module_source(self):
resource = OxidizedResource()
resource.relative_path_module_source = "lib/foo.py"
self.assertEqual(resource.relative_path_module_source,
pathlib.Path("lib/foo.py"))
resource.relative_path_module_source = pathlib.Path("bar.py")
self.assertEqual(resource.relative_path_module_source,
pathlib.Path("bar.py"))
resource.relative_path_module_source = b"foo.py"
self.assertEqual(resource.relative_path_module_source,
pathlib.Path("foo.py"))
resource.relative_path_module_source = None
self.assertIsNone(resource.relative_path_module_source)
with self.assertRaises(TypeError):
del resource.relative_path_module_source
with self.assertRaises(TypeError):
resource.relative_path_module_source = True
def test_resource_relative_path_module_bytecode_opt2(self):
resource = OxidizedResource()
resource.relative_path_module_bytecode_opt2 = "lib/foo.pyc"
self.assertEqual(resource.relative_path_module_bytecode_opt2,
pathlib.Path("lib/foo.pyc"))
resource.relative_path_module_bytecode_opt2 = pathlib.Path("bar.pyc")
self.assertEqual(resource.relative_path_module_bytecode_opt2,
pathlib.Path("bar.pyc"))
resource.relative_path_module_bytecode_opt2 = b"foo.pyc"
self.assertEqual(resource.relative_path_module_bytecode_opt2,
pathlib.Path("foo.pyc"))
resource.relative_path_module_bytecode_opt2 = None
self.assertIsNone(resource.relative_path_module_bytecode_opt2)
with self.assertRaises(TypeError):
del resource.relative_path_module_bytecode_opt2
with self.assertRaises(TypeError):
resource.relative_path_module_bytecode_opt2 = True
def test_resource_set_in_memory_bytecode(self):
resource = OxidizedResource()
resource.in_memory_bytecode = b"b0"
resource.in_memory_bytecode_opt1 = b"b1"
resource.in_memory_bytecode_opt2 = b"b2"
self.assertEqual(resource.in_memory_bytecode, b"b0")
self.assertEqual(resource.in_memory_bytecode_opt1, b"b1")
self.assertEqual(resource.in_memory_bytecode_opt2, b"b2")
resource.in_memory_bytecode = None
self.assertIsNone(resource.in_memory_bytecode)
resource.in_memory_bytecode_opt1 = None
self.assertIsNone(resource.in_memory_bytecode_opt1)
resource.in_memory_bytecode_opt2 = None
self.assertIsNone(resource.in_memory_bytecode_opt2)
with self.assertRaises(TypeError):
del resource.in_memory_bytecode
with self.assertRaises(TypeError):
del resource.in_memory_bytecode_opt1
with self.assertRaises(TypeError):
del resource.in_memory_bytecode_opt2
with self.assertRaises(TypeError):
resource.in_memory_bytecode = True
with self.assertRaises(TypeError):
resource.in_memory_bytecode_opt1 = "foo"
with self.assertRaises(TypeError):
resource.in_memory_bytecode_opt2 = False
def test_resource_constructor(self):
resource = OxidizedResource()
self.assertIsInstance(resource, OxidizedResource)
self.assertEqual(resource.flavor, "none")
self.assertEqual(resource.name, "")
def test_in_memory_distribution_resources(self):
resource = OxidizedResource()
resource.in_memory_distribution_resources = {}
self.assertEqual(resource.in_memory_distribution_resources, {})
resource.in_memory_distribution_resources = None
self.assertIsNone(resource.in_memory_distribution_resources)
resource.in_memory_distribution_resources = {"foo": b"foo value"}
self.assertEqual(resource.in_memory_distribution_resources,
{"foo": b"foo value"})
# Updating the dict does *not* work.
resource.in_memory_distribution_resources["foo"] = "ignored"
resource.in_memory_distribution_resources["ignored"] = None
self.assertEqual(resource.in_memory_distribution_resources,
{"foo": b"foo value"})
with self.assertRaises(TypeError):
del resource.in_memory_distribution_resources
with self.assertRaises(TypeError):
resource.in_memory_distribution_resources = True
with self.assertRaises(TypeError):
resource.in_memory_distribution_resources = []
with self.assertRaises(TypeError):
resource.in_memory_distribution_resources = {b"foo": b"bar"}
with self.assertRaises(TypeError):
resource.in_memory_distribution_resources = {"foo": None}
def test_relative_path_distribution_resources(self):
resource = OxidizedResource()
resource.relative_path_distribution_resources = {}
self.assertEqual(resource.relative_path_distribution_resources, {})
resource.relative_path_distribution_resources = None
self.assertIsNone(resource.relative_path_distribution_resources)
resource.relative_path_distribution_resources = {"foo": "resource.txt"}
self.assertEqual(
resource.relative_path_distribution_resources,
{"foo": pathlib.Path("resource.txt")},
)
resource.relative_path_distribution_resources = {
"resource.txt": pathlib.Path("path/to/resource")
}
self.assertEqual(
resource.relative_path_distribution_resources,
{"resource.txt": pathlib.Path("path/to/resource")},
)
# Updating the dict does *not* work.
resource.relative_path_distribution_resources["foo"] = "ignored"
resource.relative_path_distribution_resources["ignored"] = None
self.assertEqual(
resource.relative_path_distribution_resources,
{"resource.txt": pathlib.Path("path/to/resource")},
)
with self.assertRaises(TypeError):
del resource.relative_path_distribution_resources
with self.assertRaises(TypeError):
resource.relative_path_distribution_resources = True
with self.assertRaises(TypeError):
resource.relative_path_distribution_resources = []
with self.assertRaises(TypeError):
resource.relative_path_distribution_resources = {b"foo": b"bar"}
with self.assertRaises(TypeError):
resource.relative_path_distribution_resources = {"foo": None}
