def test_register_property_collection(self):
# Setup: Create a node object
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
# If: I register a property collection
generator = mock.MagicMock()
collection1 = node_obj._register_property_collection(generator)
# Then:
# ... The returned collection should be a collection with the provided generator
self.assertIsInstance(collection1, node.NodeLazyPropertyCollection)
self.assertIs(collection1._generator, generator)
# ... The collection should be added to the list of registered collections
self.assertEqual(len(node_obj._property_collections), 2)
self.assertIn(collection1, node_obj._property_collections)
# If: I add another one
collection2 = node_obj._register_property_collection(generator)
# Then: The collection should be appended to the list of registered collections
self.assertEqual(len(node_obj._property_collections), 3)
self.assertIn(collection1, node_obj._property_collections)
self.assertIn(collection2, node_obj._property_collections)
def test_urn_recursive(self):
# Setup:
# ... Create a node object with a parent
server = Server(utils.MockPGServerConnection())
node_obj1 = utils.MockNodeObject(server, None, 'parent_name')
node_obj1._oid = 123
node_obj2 = utils.MockNodeObject(server, node_obj1, 'obj_name')
node_obj2._oid = 456
# If: I get the URN for the child node object
urn = node_obj2.urn
# Then:
# ... I expect it to be formatted as a URL
parsed_url = parse.urlparse(urn)
# ... The netlocation should be equal to the urn base (with added slashes)
# NOTE: Server URN Base is tested in the server class unit tests
self.assertEqual(f'//{parsed_url.netloc}/', server.urn_base)
# ... The path should have multiple folders under it (list comprehension removes empty strings)
split_path = [x for x in parsed_url.path.split('/') if x]
self.assertEqual(len(split_path), 2)
# ... The parent path should be first
self.assertEqual(split_path[0],
f'{node_obj1.__class__.__name__}.{node_obj1.oid}')
# ... The child path should be second
self.assertEqual(split_path[1],
f'{node_obj2.__class__.__name__}.{node_obj2.oid}')
def test_register_child_collection(self):
# Setup: Create a node object
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
# If: I register a child collection
mock_class1 = mock.MagicMock()
mock_class1.__name__ = 'mock_class1'
mock_class1.get_nodes_for_parent = mock.MagicMock()
collection1 = node_obj._register_child_collection(mock_class1)
# Then
# ... The returned collection should be a collection with the given generator
self.assertIsInstance(collection1, node.NodeCollection)
# ... The collection should be added to the list of registered collections
self.assertEqual(len(node_obj._child_collections), 1)
# If: I add another one
mock_class2 = mock.MagicMock()
mock_class2.__name__ = 'mock_class2'
mock_class2.get_nodes_for_parent = mock.MagicMock()
collection2 = node_obj._register_child_collection(mock_class2)
# Then: The collection should be appended to the list of registered collections
self.assertEqual(len(node_obj._child_collections), 2)
self.assertTrue(
mock_class1.__name__ in node_obj._child_collections.keys())
self.assertTrue(
mock_class2.__name__ in node_obj._child_collections.keys())
self.assertIs(node_obj._child_collections[mock_class1.__name__],
collection1)
self.assertIs(node_obj._child_collections[mock_class2.__name__],
collection2)
def _get_node_for_parents_mock_connection():
# ... Create a mockup of a server connection with a mock executor
mock_action = mock.Mock()
mock_objs = [{'name': 'abc', 'oid': 123}, {'name': 'def', 'oid': 456}]
mock_executor = mock.MagicMock(return_value=([{}, {}], mock_objs))
mock_server = Server(utils.MockPGServerConnection(None, version="10101"),
mock_action)
mock_server.connection.execute_dict = mock_executor
return mock_server, mock_executor, mock_objs
def test_get_obj_by_urn_invalid_collection(self):
# Setup: Create a node object (without any collections under it)
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
with self.assertRaises(ValueError):
# If: I have a URN fragment that goes into a collection that doesn't exist
# Then: I should get an exception
fragment = '/Database.123/'
node_obj.get_object_by_urn(fragment)
def test_get_obj_by_urn_base_case(self):
# Setup: Create a node object
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
# If: I have a URN fragment that returns the object
fragment = '/'
obj = node_obj.get_object_by_urn(fragment)
# Then: I should get that object back
self.assertIs(obj, node_obj)
def test_role_get_database_node(self):
# If: I create a DB that is connected
name = 'dbname'
mock_server = Server(
utils.MockPGServerConnection(None, name='not_connected'))
db = Role(mock_server, name)
# Then:
node = db.get_database_node()
# assert:
self.assertIsNone(node)
def test_get_nodes_for_parent_with_parent(self):
# Setup:
# ... Create a server connection that will return some mock node rows
mock_server, mock_executor, mock_objs = _get_node_for_parents_mock_connection(
)
# ... Create a mock _from_node generator (so we can validate calls)
mock_obj = {}
mock_from_node = mock.MagicMock(return_value=mock_obj)
# ... Create a mock template rendered
mock_render = mock.MagicMock(return_value="SQL")
mock_template_path = mock.MagicMock(return_value="path")
# ... Create an object that will be the parent of these nodes
name = 'postgres'
parent = Database(mock_server, name)
parent._oid = 123
parent._connection = utils.MockPGServerConnection(None,
version="10101")
parent._connection.execute_dict = mock_executor
# ... Patch the template rendering, and the _from_node_query
patch_render_template = 'smo.utils.templating.render_template'
patch_template_path = 'smo.utils.templating.get_template_path'
patch_from_node_query = 'tests.pgsmo_tests.utils.MockNodeObject._from_node_query'
with mock.patch(patch_render_template, mock_render, create=True), \
mock.patch(patch_template_path, mock_template_path, create=True), \
mock.patch(patch_from_node_query, mock_from_node, create=True):
# If: I ask for a collection of nodes *with a parent object*
nodes = utils.MockNodeObject.get_nodes_for_parent(
mock_server, parent)
# Then:
# ... The template path and template renderer should have been called once
mock_template_path.assert_called_once_with('template_root',
'nodes.sql',
mock_server.version)
mock_render.assert_called_once_with('path',
macro_roots=None,
**{'parent_id': 123})
# ... A query should have been executed
mock_executor.assert_called_once_with('SQL')
# ... The _from_node should have been called twice with the results of the query
mock_from_node.assert_any_call(mock_server, parent, **mock_objs[0])
mock_from_node.assert_any_call(mock_server, parent, **mock_objs[1])
# ... The output should be a list of objects the _from_node returned
self.assertIsInstance(nodes, list)
self.assertListEqual(nodes, [mock_obj, mock_obj])
def test_database_get_database_node(self):
# If: I create a DB that is connected
name = 'dbname'
mock_server = Server(
utils.MockPGServerConnection(None, name='not_connected'))
db = Database(mock_server, name)
# Then:
node = db.get_database_node()
# assert:
self.assertIsNotNone(node)
self.assertEqual(node.__class__.__name__, 'Database')
def test_get_obj_by_urn_recurses(self):
# Setup: Create a node object with a collection under it
server = Server(utils.MockPGServerConnection())
db_obj = utils.MockNodeObject(server, None, 'db_name')
sc_obj = utils.MockNodeObject(server, db_obj, 'schema_name')
db_obj._child_collections = {'Schema': {123: sc_obj}}
# If: I ask for an object that recurses
fragment = '/Schema.123/'
obj = db_obj.get_object_by_urn(fragment)
# Then: The object I get back should be the same as the one I created
self.assertIs(obj, sc_obj)
def test_init(self):
# If: I create a node object
server = Server(utils.MockPGServerConnection())
parent = utils.MockNodeObject(server, None, 'parent')
node_obj = utils.MockNodeObject(server, parent, 'abc')
# Then: The properties should be assigned as defined
utils.assert_threeway_equals(None, node_obj._oid, node_obj.oid)
utils.assert_threeway_equals('abc', node_obj._name, node_obj.name)
utils.assert_threeway_equals(server, node_obj._server, node_obj.server)
utils.assert_threeway_equals(parent, node_obj._parent, node_obj.parent)
self.assertDictEqual(node_obj._child_collections, {})
self.assertEqual(len(node_obj._property_collections), 1)
self.assertIsInstance(node_obj._full_properties,
node.NodeLazyPropertyCollection)
self.assertEqual(node_obj._full_properties._generator,
node_obj._property_generator)
def test_table_get_database_node(self):
# If: I create a DB that is connected
mock_server = Server(
utils.MockPGServerConnection(None, name='not_connected'))
db = Database(mock_server, 'dbname')
schema = Schema(mock_server, db, 'schema')
table = Table(mock_server, schema, 'table')
# check for schema:
node = schema.get_database_node()
# assert:
self.assertIsNotNone(node)
self.assertEqual(node.__class__.__name__, 'Database')
# check for table:
node = table.get_database_node()
# assert:
self.assertIsNotNone(node)
self.assertEqual(node.__class__.__name__, 'Database')
def test_urn_basecase(self):
# Setup:
# ... Create a node object
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
node_obj._oid = 123
# If: I get the URN for a node object
urn = node_obj.urn
# Then:
# ... I expect it to be formatted as a URL
parsed_url = parse.urlparse(urn)
# ... The netlocation should be equal to the urn base (with added slashes)
# NOTE: Server URN Base is tested in the server class unit tests
self.assertEqual(f'//{parsed_url.netloc}/', server.urn_base)
# ... The path should match Class.OID (with added slashes)
self.assertEqual(parsed_url.path,
f'/{node_obj.__class__.__name__}.{node_obj.oid}/')
def test_refresh(self):
# Setup:
# ... Create a node object
server = Server(utils.MockPGServerConnection())
node_obj = utils.MockNodeObject(server, None, 'obj_name')
# ... Add a couple child collections
node_generator = mock.MagicMock()
collection1 = node.NodeCollection(node_generator)
collection1.reset = mock.MagicMock()
collection2 = node.NodeCollection(node_generator)
collection2.reset = mock.MagicMock()
node_obj._child_collections = {
'collection1': collection1,
'collection2': collection2
}
# ... Add a couple property collections
prop_generator = mock.MagicMock()
props1 = node.NodeLazyPropertyCollection(prop_generator)
props1.reset = mock.MagicMock()
props2 = node.NodeLazyPropertyCollection(prop_generator)
props2.reset = mock.MagicMock()
node_obj._property_collections = [props1, props2]
# If: I refresh the object
node_obj.refresh()
# Then: The child collections should have been reset
# noinspection PyUnresolvedReferences
collection1.reset.assert_called_once()
# noinspection PyUnresolvedReferences
collection2.reset.assert_called_once()
# noinspection PyUnresolvedReferences
props1.reset.assert_called_once()
# noinspection PyUnresolvedReferences
props2.reset.assert_called_once()
