def test_sub_schemas(self): imports = [ Import.create(schema_location="../foo.xsd"), Import.create(schema_location="../bar.xsd"), ] includes = [ Include.create(schema_location="common.xsd"), Include.create(schema_location="uncommon.xsd"), ] redefines = [ Redefine.create(schema_location="a.xsd"), Redefine.create(schema_location="b.xsd"), ] overrides = [ Override.create(schema_location="a.xsd"), Override.create(schema_location="b.xsd"), ] schema = Schema.create(imports=imports, includes=includes, redefines=redefines, overrides=overrides) actual = schema.included() expected = imports + includes + redefines + overrides self.assertIsInstance(actual, Iterator) self.assertEqual(expected, list(actual)) schema = Schema.create() self.assertEqual([], list(schema.included()))
def test_process_schema( self, mock_parse_schema, mock_process_included, mock_generate_classes, mock_logger_info, ): include = Include.create() override = Override.create() schema = Schema.create(target_namespace="thug") schema.includes.append(include) schema.overrides.append(override) mock_process_included.side_effect = [ ClassFactory.list(2), ClassFactory.list(3) ] mock_generate_classes.return_value = ClassFactory.list(4) mock_parse_schema.return_value = schema path = Path(__file__) result = self.transformer.process_schema(path, package="foo.bar", target_namespace="foo-bar") self.assertEqual(9, len(result)) self.assertTrue(path in self.transformer.processed) mock_parse_schema.assert_called_once_with(path, "foo-bar") mock_process_included.assert_has_calls([ mock.call(include, "foo.bar", schema.target_namespace), mock.call(override, "foo.bar", schema.target_namespace), ]) self.transformer.process_schema(path, None, None) mock_logger_info.assert_called_once_with("Parsing schema...")
def test_process_included_skip_when_location_is_missing( self, mock_logger_warning): include = Include.create() result = self.transformer.process_included(include, "foo.bar", "thug") self.assertIsInstance(result, list) self.assertEqual(0, len(result)) mock_logger_warning.assert_called_once_with( "%s: %s unresolved schema location..", include.class_name, include.schema_location, )
def test_resolve_schemas_locations(self, mock_resolve_path, mock_resolve_local_path): schema = Schema.create() self.parser.resolve_schemas_locations(schema) self.parser.schema_location = Path.cwd() mock_resolve_path.side_effect = lambda x: Path.cwd().joinpath(x) mock_resolve_local_path.side_effect = lambda x, y: Path.cwd().joinpath( x) schema.overrides.append(Override.create(schema_location="o1")) schema.overrides.append(Override.create(schema_location="o2")) schema.redefines.append(Redefine.create(schema_location="r1")) schema.redefines.append(Redefine.create(schema_location="r2")) schema.includes.append(Include.create(schema_location="i1")) schema.includes.append(Include.create(schema_location="i2")) schema.imports.append( Import.create(schema_location="i3", namespace="ns_i3")) schema.imports.append( Import.create(schema_location="i4", namespace="ns_i4")) self.parser.resolve_schemas_locations(schema) mock_resolve_path.assert_has_calls([ mock.call("o1"), mock.call("o2"), mock.call("r1"), mock.call("r2"), mock.call("i1"), mock.call("i2"), ]) mock_resolve_local_path.assert_has_calls( [mock.call("i3", "ns_i3"), mock.call("i4", "ns_i4")]) for sub in schema.included(): self.assertEqual(Path.cwd().joinpath(sub.schema_location), sub.location)
def test_process_included(self, mock_adjust_package, mock_process_schema): path = Path(__file__) include = Include.create(location=path, schema_location="foo.xsd") mock_adjust_package.return_value = "adjusted.foo.bar" mock_process_schema.return_value = ClassFactory.list(2) result = self.transformer.process_included(include, "foo.bar", "thug") self.assertEqual(2, len(result)) mock_adjust_package.assert_called_once_with("foo.bar", include.schema_location) mock_process_schema.assert_called_once_with(path, "adjusted.foo.bar", "thug")
def test_process_included_skip_when_location_already_imported( self, mock_logger_debug): path = Path(__file__) include = Include.create(location=path) self.transformer.processed.append(path) result = self.transformer.process_included(include, "foo.bar", "thug") self.assertIsInstance(result, list) self.assertEqual(0, len(result)) mock_logger_debug.assert_called_once_with( "%s: %s already included skipping..", include.class_name, include.schema_location, )