def test_urn_recursive(self): # Setup: # ... Create a node object with a parent server = Server(utils.MockConnection(None)) 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 _get_mock_node_generator(): server = Server(utils.MockConnection(None)) mock_object1 = utils.MockNodeObject(server, None, 'a') mock_object1._oid = 123 mock_object2 = utils.MockNodeObject(server, None, 'b') mock_object2._oid = 456 mock_objects = [mock_object1, mock_object2] return mock.MagicMock(return_value=mock_objects), mock_objects
def test_get_obj_by_urn_recurses(self): # Setup: Create a node object with a collection under it server = Server(utils.MockConnection(None)) 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_register_child_collection(self): # Setup: Create a node object server = Server(utils.MockConnection(None)) 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 test_register_property_collection(self): # Setup: Create a node object server = Server(utils.MockConnection(None)) 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_from_node_query(self): # If: I create a new object from a node row with the expected parent type mock_server = Server(utils.MockConnection(None)) mock_parent = utils.MockNodeObject( mock_server, None, 'parent') if not self.parent_expected_to_be_none else None obj = self.class_for_test._from_node_query(mock_server, mock_parent, **self.node_query) # Then: # ... The returned object must be an instance of the class NodeObjectTestBase.unittest.assertIsInstance(obj, NodeObject) NodeObjectTestBase.unittest.assertIsInstance(obj, self.class_for_test) # ... Validate the node object properties utils.assert_threeway_equals(mock_server, obj._server, obj.server) utils.assert_threeway_equals(self.node_query['oid'], obj._oid, obj.oid) utils.assert_threeway_equals(self.node_query['name'], obj._name, obj.name) # ... Validate the basic properties for attr, value in self.basic_properties.items(): NodeObjectTestBase.unittest.assertEqual(getattr(obj, attr), value) # ... Validate the collections for attr in self.collections: NodeObjectTestBase.unittest.assertIsInstance( getattr(obj, attr), NodeCollection) # ... Call the validation function self._custom_validate_from_node(obj, mock_server)
def test_get_obj_by_urn_invalid_collection(self): # Setup: Create a node object (without any collections under it) server = Server(utils.MockConnection(None)) 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_init(self): # If: I create a node object server = Server(utils.MockConnection(None)) 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_scripting_mixins(self): # Setup: Create an instance of the object mock_server = Server(utils.MockConnection(None)) mock_grand_parent = utils.MockNodeObject( mock_server, None, 'grandparent') if not self.parent_expected_to_be_none else None mock_parent = utils.MockNodeObject( mock_server, mock_grand_parent, 'parent') if not self.parent_expected_to_be_none else None name = 'test' obj = self.init_lambda(mock_server, mock_parent, name) obj._full_properties = self.property_query if isinstance(obj, ScriptableCreate): # If: I script for create script = obj.create_script() # Then: The script should successfully return utils.assert_is_not_none_or_whitespace(script) if isinstance(obj, ScriptableDelete): # If: I script for delete script = obj.delete_script() # Then: The script should successfully return utils.assert_is_not_none_or_whitespace(script) if isinstance(obj, ScriptableUpdate): # If: I script for update script = obj.update_script() # Then: The script should successfully return utils.assert_is_not_none_or_whitespace(script) if isinstance(obj, ScriptableSelect): # If: I script for select script = obj.select_script() # Then: The script should successfully return utils.assert_is_not_none_or_whitespace(script)
def test_get_obj_by_urn_base_case(self): # Setup: Create a node object server = Server(utils.MockConnection(None)) 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_full_properties(self): # Setup: # NOTE: We're *not* mocking out the template rendering b/c this will verify that there's a template # ... Create a mock query execution that will return the properties mock_exec_dict = mock.MagicMock(return_value=([], [self.property_query])) # ... Create an instance of the class mock_server = Server(utils.MockConnection(None)) mock_server.connection.execute_dict = mock_exec_dict mock_grand_grand_parent = utils.MockNodeObject( mock_server, None, 'grandgrandparent' ) if not self.parent_expected_to_be_none else None mock_grand_parent = utils.MockNodeObject( mock_server, mock_grand_grand_parent, 'grandparent') if not self.parent_expected_to_be_none else None mock_parent = utils.MockNodeObject( mock_server, mock_grand_parent, 'parent') if not self.parent_expected_to_be_none else None name = 'test' obj = self.init_lambda(mock_server, mock_parent, name) self._full_properties_helper(obj, mock_server)
def test_init(self): # If: I create an instance of the provided class mock_server = Server(utils.MockConnection(None)) mock_parent = utils.MockNodeObject( mock_server, None, 'parent') if not self.parent_expected_to_be_none else None name = 'test' obj = self.init_lambda(mock_server, mock_parent, name) # Then: # ... Perform the init validation # noinspection PyTypeChecker self._init_validation(obj, mock_server, mock_parent, name) # ... Call the custom validation function self._custom_validate_init(obj, mock_server)
def test_urn_basecase(self): # Setup: # ... Create a node object server = Server(utils.MockConnection(None)) 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.MockConnection(None)) 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()