def when_factory_config(context): factory = SourceFactory() config = context.object_config config["input"]["locations"] = context.conf_files response = factory.create_from_config(config) context.root = response
def main(self): """Run the command """ sourceService = SourceService() sourceFactory = SourceFactory() config = self.get_config() sources = sourceFactory.create_from_config(config) sourceService.validate(sources) print(json_repr(sources))
def main(self): """Run the command """ sourceService = SourceService() sourceFactory = SourceFactory() templateFactory = TemplateFactory() config = self.get_config() sources = sourceFactory.create_from_config(config) sourceService.validate(sources) template = templateFactory.create_from_config(config) template.render(sources, config)
def _get_sources(self): now = datetime.now() try: sourceService = SourceService() sourceFactory = SourceFactory() sources = sourceFactory.create_from_config(self.config) sourceService.validate(sources) self.logger.debug("Parse sources in %s." % (datetime.now() - now)) except: if self.traceback: self.logger.exception("Failed to parse sources") else: self.logger.error("Failed to parse sources") raise return sources
def refresh_source(self, event): """Refresh sources then templates """ now = datetime.now() self.logger.info("Sources changed") sourceFactory = SourceFactory() sourceService = SourceService() templateFactory = TemplateFactory() try: self.sources = sourceFactory.create_from_config(self.config) sourceService.validate(self.sources) template = templateFactory.create_from_config(self.config) template.render(self.sources, self.config) self.logger.debug("Render in %s." % (datetime.now() - now)) except: self.logger.warning("Failed to render") self.logger.error(traceback.format_exc())
def setUp(self): self.source = SourceFactory()
class TestSource(unittest.TestCase): def setUp(self): self.source = SourceFactory() def test_parser(self): self.assertIsInstance(self.source.parser, Parser) self.source.parser = "foo" self.assertEqual("foo", self.source.parser) self.source.parser = None self.assertIsInstance(self.source.parser, Parser) def test_extender(self): self.assertIsInstance(self.source.extender, Extender) self.source.extender = "foo" self.assertEqual("foo", self.source.extender) self.source.extender = None self.assertIsInstance(self.source.extender, Extender) def test_merger(self): self.assertIsInstance(self.source.merger, Merger) self.source.merger = "foo" self.assertEqual("foo", self.source.merger) self.source.merger = None self.assertIsInstance(self.source.merger, Merger) @patch.object(Parser, "load_from_file", side_effect=[{"e": "f"}, {"g": "h"}, {}]) @patch.object(Parser, "load_all_from_directory", side_effect=[[{"a": "b"}, {"c": "d"}], [{"z": "y"}]]) @patch.object(Merger, "merge_sources", return_value={"i": "j"}) @patch.object(Extender, "extends", return_value={}) def test_create_from_config(self, mock_extender, mock_merger, mock_parser_directory, mock_parser_file): config = ConfigObject() init = os.path.isdir try: os.path.isdir = lambda x: x[0] == "d" config["input"]["locations"] = ["d1", "d2", "f1", "f2"] config["input"]["arguments"] = {"var": "value"} response = self.source.create_from_config(config) self.assertIsInstance(response, RootDto) mock_extender.assert_called_once_with({"i": "j"}, paths=('categories/?', 'versions/?', 'versions/?/methods/?', 'versions/?/types/?', 'versions/?/references/?')) mock_merger.assert_called_once_with([{"a": "b"}, {"c": "d"}, {"z": "y"}, {"e": "f"}, {"g": "h"}]) mock_parser_directory.assert_has_calls([call("d1"), call("d2")]) mock_parser_file.assert_has_calls([call("f1"), call("f2")]) finally: os.path.isdir = init @patch.object(Parser, "load_from_file", side_effect=[{"e": "f"}, {"g": "h"}, {}]) @patch.object(Parser, "load_all_from_directory", side_effect=[[{"a": "b"}, {"c": "d"}], [{"z": "y"}]]) @patch.object(Merger, "merge_sources", return_value={"i": "j"}) @patch.object(Extender, "extends", return_value={}) def test_create_from_config__without_validation(self, mock_extender, mock_merger, mock_parser_directory, mock_parser_file): config = ConfigObject() init = os.path.isdir try: os.path.isdir = lambda x: x[0] == "d" config["input"]["locations"] = ["d1", "d2", "f1", "f2"] config["input"]["arguments"] = {"var": "value"} config["input"]["validate"] = False response = self.source.create_from_config(config) self.assertIsInstance(response, RootDto) mock_extender.assert_called_once_with({"i": "j"}, paths=('categories/?', 'versions/?', 'versions/?/methods/?', 'versions/?/types/?', 'versions/?/references/?')) mock_merger.assert_called_once_with([{"a": "b"}, {"c": "d"}, {"z": "y"}, {"e": "f"}, {"g": "h"}]) mock_parser_directory.assert_has_calls([call("d1"), call("d2")]) mock_parser_file.assert_has_calls([call("f1"), call("f2")]) finally: os.path.isdir = init def test_get_sources_from_config(self): config = ConfigObject() response = self.source.get_sources_from_config(config) self.assertEqual([], response) def test_inject_arguments_in_sources(self): source = "foo" response = self.source.inject_arguments_in_sources(source, None) self.assertEqual("foo", response) def test_replace_argument(self): root = { "a": "${a1}", "b": [ "c", "${a1}", { "d": "${a1}", "e": "f", "g": 123, } ], } response = self.source.replace_argument(root, "a1", "v") self.assertEqual({ "a": "v", "b": [ "c", "v", { "d": "v", "e": "f", "g": 123, } ], }, response) def test_hide_filtered_elements__version(self): root = Root() version1 = Version() version2 = Version() version3 = Version() version1.name = "v1" version2.name = "v2" version3.name = "v3" root.versions = {"v1": version1, "v2": version2, "v3": version3} config = ConfigObject() self.source.hide_filtered_elements(root, config["filter"]) self.assertTrue(version1.display) self.assertTrue(version2.display) self.assertTrue(version3.display) def test_hide_filtered_elements__version_include(self): root = Root() version1 = Version() version2 = Version() version3 = Version() version1.name = "v1" version2.name = "v2" version3.name = "v3" root.versions = {"v1": version1, "v2": version2, "v3": version3} config = ConfigObject() config["filter"]["versions"]["includes"] = ["v1", "v3"] self.source.hide_filtered_elements(root, config["filter"]) self.assertTrue(version1.display) self.assertFalse(version2.display) self.assertTrue(version3.display) def test_hide_filtered_elements__version_exclude(self): root = Root() version1 = Version() version2 = Version() version3 = Version() version1.name = "v1" version2.name = "v2" version3.name = "v3" root.versions = {"v1": version1, "v2": version2, "v3": version3} config = ConfigObject() config["filter"]["versions"]["excludes"] = ["v1", "v3"] self.source.hide_filtered_elements(root, config["filter"]) self.assertFalse(version1.display) self.assertTrue(version2.display) self.assertFalse(version3.display) def test_hide_filtered_elements__category(self): root = Root() version1 = Version() category1 = Category("c") category2 = Category("c") category3 = Category("c") category1.name = "v1" category2.name = "v2" category3.name = "v3" root.versions = {"v1": version1} version1.categories = {"s1": category1, "s2": category2, "s3": category3} config = ConfigObject() self.source.hide_filtered_elements(root, config["filter"]) self.assertTrue(category1.display) self.assertTrue(category2.display) self.assertTrue(category3.display) def test_hide_filtered_elements__category_include(self): root = Root() category1 = Category("c") category2 = Category("c") category3 = Category("c") category1.name = "v1" category2.name = "v2" category3.name = "v3" root.categories = {"s1": category1, "s2": category2, "s3": category3} config = ConfigObject() config["filter"]["categories"]["includes"] = ["v1", "v3"] self.source.hide_filtered_elements(root, config["filter"]) self.assertTrue(category1.display) self.assertFalse(category2.display) self.assertTrue(category3.display) def test_hide_filtered_elements__category_exclude(self): root = Root() category1 = Category("c1") category2 = Category("c2") category3 = Category("c3") root.categories = {"c1": category1, "c2": category2, "c3": category3} config = ConfigObject() config["filter"]["categories"]["excludes"] = ["c1", "c3"] self.source.hide_filtered_elements(root, config["filter"]) self.assertFalse(category1.display) self.assertTrue(category2.display) self.assertFalse(category3.display) def test_remove_unused_types(self): root = Root() version1 = Version() type1 = Type() type2 = Type() method1 = Method() parameter1 = Parameter() parameter1.type = "t1" method1.request_parameters = {"p1": parameter1} version1.types = {"t1": type1, "t2": type2} version1.methods = {"m1": method1} root.versions = {"v1": version1} self.source.remove_unused_types(root) self.assertEqual({"t1": type1}, version1.types) def test_replace_references(self): root = Root() version1 = Version() method1 = Method() type1 = Type() object_reference1 = ObjectReference() object_reference1.reference_name = "r1" object_reference1.name = "a" object_reference2 = ObjectReference() object_reference2.reference_name = "r1" object_reference2.name = "a" object1 = ObjectObject() object1.description = "b" method1.request_body = object_reference1 type1.item = object_reference2 version1.references = {"r1": object1} version1.methods = {"m1": method1} version1.types = {"t1": type1} root.versions = {"v1": version1} self.source.replace_references(root) self.assertEqual("a", method1.request_body.name) self.assertEqual("b", method1.request_body.description) self.assertEqual("a", type1.item.name) self.assertEqual("b", type1.item.description) def test_replace_type(self): root = Root() version1 = Version() method1 = Method() object_type1 = ObjectType() object_type1.type_name = "t1" type1 = Type() parameter1 = Parameter() parameter1.type = "t1" parameter2 = Parameter() parameter2.type = "t1" method1.request_body = object_type1 method1.request_parameters = {"p1": parameter1} method1.request_headers = {"p1": parameter2} version1.types = {"t1": type1} version1.methods = {"m1": method1} root.versions = {"v1": version1} self.source.replace_types(root) self.assertEqual(type1, method1.request_body.type_object) self.assertEqual(type1, method1.request_parameters["p1"].type_object) self.assertEqual(type1, method1.request_headers["p1"].type_object) def test_replace_references_in_object__properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectReference() reference.reference_name = "r1" string1 = ObjectString() object.properties = {"p1": array} array.items = dynamic dynamic.items = reference self.source.replace_references_in_object(object, {"r1": string1}) self.assertEqual(Object.Types.string, dynamic.items.type) def test_replace_references_in_object__pattern_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectReference() reference.reference_name = "r1" string1 = ObjectString() object.pattern_properties = {"p1": array} array.items = dynamic dynamic.items = reference self.source.replace_references_in_object(object, {"r1": string1}) self.assertEqual(Object.Types.string, dynamic.items.type) def test_replace_references_in_object__additional_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectReference() reference.reference_name = "r1" string1 = ObjectString() object.additional_properties = array array.items = dynamic dynamic.items = reference self.source.replace_references_in_object(object, {"r1": string1}) self.assertEqual(Object.Types.string, dynamic.items.type) def test_replace_types_in_object__properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" type1 = Type() object.properties = {"p1": array} array.items = dynamic dynamic.items = reference self.source.replace_types_in_object(object, {"t1": type1}) self.assertEqual(type1, reference.type_object) def test_replace_types_in_object__pattern_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" type1 = Type() object.pattern_properties = {"p1": array} array.items = dynamic dynamic.items = reference self.source.replace_types_in_object(object, {"t1": type1}) self.assertEqual(type1, reference.type_object) def test_replace_types_in_object__additional_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" type1 = Type() object.additional_properties = array array.items = dynamic dynamic.items = reference self.source.replace_types_in_object(object, {"t1": type1}) self.assertEqual(type1, reference.type_object) def test_replace_types_in_object_not_an_object(self): object = ObjectString() self.source.replace_types_in_object(object, {}) self.assertEqual(vars(ObjectString()), vars(object)) def test_replace_types_in_parameter___scalara(self): object = Parameter() object.type = "string" response = self.source.replace_types_in_parameter(object, {}) self.assertEqual(object, response) def test_replace_types_in_object__unknwon(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t2" type1 = Type() object.properties = {"p1": array} array.items = dynamic dynamic.items = reference with self.assertRaises(ValueError): self.source.replace_types_in_object(object, {"t1": type1}) def test_get_used_types_in_object(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" object.properties = {"p1": array} array.items = dynamic dynamic.items = reference response = self.source.get_used_types_in_object(object) self.assertEqual(["t1"], response) def test_get_used_types_in_object__pattern_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" object.pattern_properties = {"p1": array} array.items = dynamic dynamic.items = reference response = self.source.get_used_types_in_object(object) self.assertEqual(["t1"], response) def test_get_used_types_in_object__additional_properties(self): object = ObjectObject() array = ObjectArray() dynamic = ObjectDynamic() reference = ObjectType() reference.type_name = "t1" object.additional_properties = array array.items = dynamic dynamic.items = reference response = self.source.get_used_types_in_object(object) self.assertEqual(["t1"], response) def test_get_used_types_in_object__for_scalara(self): object = ObjectString() response = self.source.get_used_types_in_object(object) self.assertEqual([], response) def test_get_reference(self): reference = ObjectReference() reference.reference_name = "r1" reference.name = "a" reference.description = "b" reference.optional = True reference1 = ObjectReference() reference1.reference_name = "r2" reference2 = ObjectString() response = self.source.get_reference(reference, {"r1": reference1, "r2": reference2}) self.assertNotEqual(reference2, response) self.assertEqual("a", response.name) self.assertEqual("b", response.description) self.assertEqual(True, response.optional) def test_remove_hidden_elements(self): root = Root() version1 = Version() version2 = Version() category1 = Category("c1") category2 = Category("c2") method1 = Method() method2 = Method() root.versions = {"v1": version1, "v2": version2} root.categories = {"c1": category1, "c2": category2} version1.methods = {"m1": method1, "m2": method2} version2.methods = {"m1": method1, "m2": method2} method1.category = "c1" method2.category = "c2" version1.display = False category2.display = False self.source.remove_hidden_elements(root) self.assertEqual(1, len(root.versions)) self.assertEqual(version2, root.versions["v2"]) self.assertEqual(1, len(root.versions["v2"].methods)) self.assertEqual(method1, root.versions["v2"].methods["m1"]) def test_add_missing_categories(self): root = Root() version1 = Version() category1 = Category("c1") method1 = Method() method2 = Method() root.versions = {"v1": version1} root.categories = {"c1": category1} version1.methods = {"m1": method1, "m2": method2} method1.category = "c1" method2.category = "c2" self.source.add_missing_categories(root) self.assertEqual(2, len(root.categories)) self.assertIsInstance(root.categories["c2"], Category) def test_sort_category_equals(self): v1 = CategoryDto(Category("a")) v1.order = 1 v2 = CategoryDto(Category("a")) v2.order = 1 self.assertEqual(v1, v2) def test_sort_category_lt(self): v1 = CategoryDto(Category("a")) v2 = CategoryDto(Category("b")) self.assertLess(v1, v2) def test_sort_category_lt__on_order(self): v1 = CategoryDto(Category("a")) v1.order = 1 v2 = CategoryDto(Category("a")) v2.order = 2 self.assertLess(v1, v2) def test_sort_method_equals(self): v1 = Method() v1.name = "a" v2 = Method() v2.name = "a" self.assertEqual(v1, v2) def test_sort_method_lt(self): v1 = Method() v1.name = "a" v2 = Method() v2.name = "b" self.assertLess(v1, v2)
def when_factory_config_directory(context): factory = SourceFactory() config = context.object_config config["input"]["locations"] = [context.temp_dir] response = factory.create_from_config(config) context.root = response