def setUp(self): # Find the schema directory dir = os.path.join(".") while SCHEMA_FOLDER not in os.listdir(dir): dir = os.path.join(dir, "..") self.fileIO = MockSynopticFileIO() self.bs = MockBlockServer() self.sm = SynopticManager(self.bs, os.path.join(dir, SCHEMA_FOLDER), MockVersionControl(), None, self.fileIO)
def setUp(self): self.bs = MockBlockServer() self.file_manager = MockConfigurationFileManager() self.clm = ConfigListManager(self.bs, SCHEMA_PATH, MockVersionControl(), self.file_manager)
class TestInactiveConfigsSequence(unittest.TestCase): def setUp(self): self.bs = MockBlockServer() self.file_manager = MockConfigurationFileManager() self.clm = ConfigListManager(self.bs, SCHEMA_PATH, MockVersionControl(), self.file_manager) def tearDown(self): pass # Helper methods def _create_inactive_config_holder(self): configserver = InactiveConfigHolder(MACROS, MockVersionControl(), self.file_manager) return configserver def _does_pv_exist(self, name): fullname = self._correct_pv_name(name) return self.bs.does_pv_exist(fullname) def _correct_pv_name(self, name): return BlockserverPVNames.prepend_blockserver(name) def _create_configs(self, names): configserver = self._create_inactive_config_holder() for name in names: conf = create_dummy_config(name) configserver.set_config(conf) configserver.save_inactive(name) self.clm.update_a_config_in_list(configserver) def _create_components(self, names): configserver = self._create_inactive_config_holder() for name in names: conf = create_dummy_component(name) configserver.set_config(conf, True) configserver.save_inactive(name, True) self.clm.update_a_config_in_list(configserver, True) def _create_pvs(self, pv_names, suffix=""): pvs = list() for name in pv_names: pvs.append(create_pv_name(name, pvs, "DEFAULT")) pvs = [pv + suffix for pv in pvs] return pvs def _check_no_configs_deleted(self, is_component=False): if is_component: config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 3) self.assertTrue("TEST_COMPONENT1" in config_names) self.assertTrue("TEST_COMPONENT2" in config_names) self.assertTrue("TEST_COMPONENT3" in config_names) else: config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 3) self.assertTrue("TEST_CONFIG2" in config_names) self.assertTrue("TEST_CONFIG1" in config_names) self.assertTrue("TEST_ACTIVE" in config_names) def _check_pv_changed_but_not_name(self, config_name, expected_pv_name): self._create_configs([config_name]) confs = self.clm.get_configs() self.assertEqual(len(confs), 1) self.assertEqual(confs[0]["pv"], expected_pv_name) self.assertEqual(confs[0]["name"], config_name) self.assertTrue(self._does_pv_exist(expected_pv_name + GET_CONFIG_PV)) self.assertFalse(self._does_pv_exist(config_name + GET_CONFIG_PV)) # Tests def test_initialisation_with_no_configs(self): confs = self.clm.get_configs() self.assertEqual(len(confs), 0) comps = self.clm.get_components() self.assertEqual(len(comps), 0) def test_initialisation_with_configs(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2"]) confs = self.clm.get_configs() self.assertEqual(len(confs), 2) self.assertTrue("TEST_CONFIG1" in [c["name"] for c in confs]) self.assertTrue("TEST_CONFIG2" in [c["name"] for c in confs]) def test_initialisation_with_components(self): self._create_components(["TEST_COMPONENT1", "TEST_COMPONENT2"]) confs = self.clm.get_components() self.assertEqual(len(confs), 2) self.assertTrue("TEST_COMPONENT1" in [c["name"] for c in confs]) self.assertTrue("TEST_COMPONENT2" in [c["name"] for c in confs]) def test_initialisation_with_configs_creates_pvs(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2"]) pvs = self._create_pvs(["TEST_CONFIG1", "TEST_CONFIG2"], GET_CONFIG_PV) pvs += self._create_pvs(["TEST_CONFIG1", "TEST_CONFIG2"], GET_COMPONENT_PV) for pv in pvs[:2]: self.assertTrue(self._does_pv_exist(pv)) for pv in pvs[2:]: self.assertFalse(self._does_pv_exist(pv)) def test_initialisation_with_components_creates_pv(self): comps = ["TEST_COMPONENT1", "TEST_COMPONENT2"] self._create_components(comps) pvs = self._create_pvs(comps, GET_COMPONENT_PV) pvs += self._create_pvs(comps, DEPENDENCIES_PV) pvs += self._create_pvs(comps, GET_CONFIG_PV) for pv in pvs[:4]: self.assertTrue(self._does_pv_exist(pv)) for pv in pvs[4:]: self.assertFalse(self._does_pv_exist(pv)) def test_update_config_from_object(self): self.icm = self._create_inactive_config_holder() self.icm.set_config_details(VALID_CONFIG) self.clm.update_a_config_in_list(self.icm) confs = self.clm.get_configs() self.assertEqual(len(confs), 1) self.assertTrue("TEST_CONFIG" in [conf.get('name') for conf in confs]) self.assertTrue(create_pv_name("TEST_CONFIG", [], "") in [conf.get('pv') for conf in confs]) self.assertTrue("A Test Configuration" in [conf.get('description') for conf in confs]) self.assertTrue("TEST_SYNOPTIC" in [conf.get('synoptic') for conf in confs]) comps = self.clm.get_components() self.assertEqual(len(comps), 0) def test_add_a_new_component_to_list(self): self.icm = self._create_inactive_config_holder() self.icm.set_config_details(VALID_CONFIG) self.clm.update_a_config_in_list(self.icm, True) confs = self.clm.get_components() self.assertEqual(len(confs), 1) self.assertTrue("TEST_CONFIG" in [conf.get('name') for conf in confs]) self.assertTrue(create_pv_name("TEST_CONFIG", [], "") in [conf.get('pv') for conf in confs]) self.assertTrue("A Test Configuration" in [conf.get('description') for conf in confs]) self.assertTrue("TEST_SYNOPTIC" in [conf.get('synoptic') for conf in confs]) comps = self.clm.get_configs() self.assertEqual(len(comps), 0) def test_add_multiple_components(self): self._create_components(["TEST_COMPONENT1", "TEST_COMPONENT2"]) comps = self.clm.get_components() for comp in comps: self.assertEqual(len(comp), 5) self.assertTrue("name" in comp) self.assertTrue("pv" in comp) self.assertTrue("description" in comp) self.assertTrue("synoptic" in comp) self.assertTrue("history" in comp) self.assertTrue("TEST_COMPONENT1" in [comp.get('name') for comp in comps]) self.assertTrue("TEST_COMPONENT2" in [comp.get('name') for comp in comps]) def test_pv_of_lower_case_name(self): config_name = "test_CONfig1" self._check_pv_changed_but_not_name(config_name, create_pv_name(config_name, [], "")) def test_config_and_component_allowed_same_pv(self): self._create_configs(["TEST_CONFIG_AND_COMPONENT1", "TEST_CONFIG_AND_COMPONENT2"]) self._create_components(["TEST_CONFIG_AND_COMPONENT1", "TEST_CONFIG_AND_COMPONENT2"]) confs = self.clm.get_configs() self.assertEqual(len(confs), 2) pvs = self._create_pvs(["TEST_CONFIG_AND_COMPONENT1", "TEST_CONFIG_AND_COMPONENT2"], "") self.assertTrue(pvs[0] in [m["pv"] for m in confs]) self.assertTrue(pvs[1] in [m["pv"] for m in confs]) comps = self.clm.get_components() self.assertEqual(len(comps), 2) self.assertTrue(pvs[0] in [m["pv"] for m in comps]) self.assertTrue(pvs[1] in [m["pv"] for m in comps]) def test_delete_configs_with_empty_list_does_nothing(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2"]) self.clm.active_config_name = "TEST_ACTIVE" self.clm.delete([]) config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 2) self.assertTrue("TEST_CONFIG1" in config_names) self.assertTrue("TEST_CONFIG2" in config_names) def test_delete_components_with_empty_list_does_nothing(self): comp_names = ["TEST_COMPONENT1", "TEST_COMPONENT2"] self._create_components(comp_names) self.clm.active_config_name = "TEST_ACTIVE" self.clm.delete([], True) config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 2) self.assertTrue(comp_names[0] in config_names) self.assertTrue(comp_names[1] in config_names) pvs = self._create_pvs(comp_names, GET_COMPONENT_PV) pvs += self._create_pvs(comp_names, DEPENDENCIES_PV) for pv in pvs: self.assertTrue(self._does_pv_exist(pv)) def test_delete_active_config_throws(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2"]) active = ActiveConfigHolder(MACROS, ArchiverManager(None, None, MockArchiverWrapper()), MockVersionControl(), self.file_manager, MockIocControl("")) active.save_active("TEST_ACTIVE") self.clm.update_a_config_in_list(active) self.clm.active_config_name = "TEST_ACTIVE" self._check_no_configs_deleted() self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_ACTIVE"]) self._check_no_configs_deleted() self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_ACTIVE", "TEST_CONFIG1"]) self._check_no_configs_deleted() self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_CONFIG1", "TEST_ACTIVE"]) self._check_no_configs_deleted() def test_delete_active_component_throws(self): self._create_components(["TEST_COMPONENT1", "TEST_COMPONENT2", "TEST_COMPONENT3"]) active = ActiveConfigHolder(MACROS, ArchiverManager(None, None, MockArchiverWrapper()), MockVersionControl(), self.file_manager, MockIocControl("")) active.add_component("TEST_COMPONENT1", Configuration(MACROS)) active.save_active("TEST_ACTIVE") self.clm.active_config_name = "TEST_ACTIVE" self.clm.update_a_config_in_list(active) self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_COMPONENT1"], True) self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_COMPONENT1", "TEST_COMPONENT2"], True) self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_CONFIG2", "TEST_COMPONENT1"], True) self._check_no_configs_deleted(True) def test_delete_used_component_throws(self): self._create_components(["TEST_COMPONENT3", "TEST_COMPONENT2", "TEST_COMPONENT1"]) inactive = self._create_inactive_config_holder() inactive.add_component("TEST_COMPONENT1", Configuration(MACROS)) inactive.save_inactive("TEST_INACTIVE") self.clm.update_a_config_in_list(inactive) self.clm.active_config_name = "TEST_ACTIVE" self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_COMPONENT1"], True) self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_COMPONENT1", "TEST_COMPONENT2"], True) self._check_no_configs_deleted(True) self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_CONFIG2", "TEST_COMPONENT1"], True) self._check_no_configs_deleted(True) def test_delete_one_inactive_config_works(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2"]) self.clm.delete(["TEST_CONFIG1"]) self.clm.active_config_name = "TEST_ACTIVE" config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 1) self.assertTrue("TEST_CONFIG2" in config_names) self.assertFalse("TEST_CONFIG1" in config_names) def test_delete_one_inactive_component_works(self): comps = ["TEST_COMPONENT1", "TEST_COMPONENT2"] self._create_components(comps) self.clm.delete(["TEST_COMPONENT1"], True) self.clm.active_config_name = "TEST_ACTIVE" config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 1) self.assertTrue("TEST_COMPONENT2" in config_names) self.assertFalse("TEST_COMPONENT1" in config_names) pvs = self._create_pvs(comps, GET_COMPONENT_PV) pvs += self._create_pvs(comps, DEPENDENCIES_PV) self.assertFalse(self._does_pv_exist(pvs[0])) self.assertTrue(self._does_pv_exist(pvs[1])) self.assertFalse(self._does_pv_exist(pvs[2])) self.assertTrue(self._does_pv_exist(pvs[3])) def test_delete_many_inactive_configs_works(self): self._create_configs(["TEST_CONFIG1", "TEST_CONFIG2", "TEST_CONFIG3"]) self.clm.active_config_name = "TEST_ACTIVE" config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 3) self.assertTrue("TEST_CONFIG1" in config_names) self.assertTrue("TEST_CONFIG2" in config_names) self.assertTrue("TEST_CONFIG3" in config_names) self.clm.delete(["TEST_CONFIG1", "TEST_CONFIG3"]) config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 1) self.assertTrue("TEST_CONFIG2" in config_names) self.assertFalse("TEST_CONFIG1" in config_names) self.assertFalse("TEST_CONFIG3" in config_names) def test_delete_many_inactive_components_works(self): all_comp_names = ["TEST_COMPONENT1", "TEST_COMPONENT2", "TEST_COMPONENT3"] self._create_components(all_comp_names) self.clm.active_config_name = "TEST_ACTIVE" config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 3) self.assertTrue("TEST_COMPONENT1" in config_names) self.assertTrue("TEST_COMPONENT2" in config_names) self.assertTrue("TEST_COMPONENT3" in config_names) self.clm.delete(["TEST_COMPONENT2", "TEST_COMPONENT3"], True) config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 1) self.assertTrue("TEST_COMPONENT1" in config_names) self.assertFalse("TEST_COMPONENT2" in config_names) self.assertFalse("TEST_COMPONENT3" in config_names) pvs = self._create_pvs(all_comp_names, GET_COMPONENT_PV) pvs += self._create_pvs(all_comp_names, DEPENDENCIES_PV) self.assertTrue(self._does_pv_exist(pvs[0])) self.assertTrue(self._does_pv_exist(pvs[3])) self.assertFalse(self._does_pv_exist(pvs[1])) self.assertFalse(self._does_pv_exist(pvs[2])) for pv in pvs[4:]: self.assertFalse(self._does_pv_exist(pv)) def test_cant_delete_non_existent_config(self): self.clm.active_config_name = "TEST_ACTIVE" self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_CONFIG1"]) config_names = [c["name"] for c in self.clm.get_configs()] self.assertEqual(len(config_names), 0) def test_cant_delete_non_existent_component(self): self.clm.active_config_name = "TEST_ACTIVE" self.assertRaises(InvalidDeleteException, self.clm.delete, ["TEST_COMPONENT1"], True) config_names = [c["name"] for c in self.clm.get_components()] self.assertEqual(len(config_names), 0) def test_required_pvs_are_created(self): comp_names = ["TEST_COMPONENT1"] self._create_components(comp_names) pvs = self._create_pvs(comp_names, GET_COMPONENT_PV) pvs += self._create_pvs(comp_names, DEPENDENCIES_PV) for pv in pvs: self.assertTrue(self._does_pv_exist(pv)) def test_required_pvs_are_deleted_when_component_deleted(self): comp_names = ["TEST_COMPONENT1"] self._create_components(comp_names) pvs = self._create_pvs(comp_names, GET_COMPONENT_PV) pvs += self._create_pvs(comp_names, DEPENDENCIES_PV) for pv in pvs: self.assertTrue(self._does_pv_exist(pv)) self.clm.delete(comp_names, True) for pv in pvs: self.assertFalse(self._does_pv_exist(pv)) def test_dependencies_updates_when_component_added_to_config(self): self._create_components(["TEST_COMPONENT1"]) inactive = self._create_inactive_config_holder() inactive.add_component("TEST_COMPONENT1", Configuration(MACROS)) inactive.save_inactive("TEST_INACTIVE") self.clm.update_a_config_in_list(inactive) self.assertTrue("TEST_INACTIVE" in self.clm.get_dependencies("TEST_COMPONENT1")) def test_dependencies_updates_remove(self): self._create_components(["TEST_COMPONENT1"]) inactive = self._create_inactive_config_holder() inactive.add_component("TEST_COMPONENT1", Configuration(MACROS)) inactive.save_inactive("TEST_INACTIVE", False) self.clm.update_a_config_in_list(inactive) inactive.remove_comp("TEST_COMPONENT1") inactive.save_inactive("TEST_INACTIVE", False) self.clm.update_a_config_in_list(inactive) self.assertFalse("TEST_INACTIVE" in self.clm.get_dependencies("TEST_COMPONENT1")) def test_delete_config_deletes_dependency(self): self._create_components(["TEST_COMPONENT1"]) inactive = self._create_inactive_config_holder() self.clm.active_config_name = "TEST_ACTIVE" inactive.add_component("TEST_COMPONENT1", Configuration(MACROS)) inactive.save_inactive("TEST_INACTIVE", False) self.clm.update_a_config_in_list(inactive) self.clm.delete(["TEST_INACTIVE"]) self.assertFalse("TEST_INACTIVE" in self.clm.get_dependencies("TEST_COMPONENT1")) def test_cannot_delete_default(self): self._create_components(["TEST_COMPONENT1"]) self.assertRaises(InvalidDeleteException, self.clm.delete, [DEFAULT_COMPONENT], True) def test_update_inactive_config_from_filewatcher(self): inactive = self._create_inactive_config_holder() self.bs.set_config_list(self.clm) inactive.save_inactive("TEST_INACTIVE") self.clm.update(inactive) self.assertEqual(len(self.clm.get_components()), 0) self.assertEqual(len(self.clm.get_configs()), 1) self.assertTrue("TEST_INACTIVE" in [x['name'] for x in self.clm.get_configs()]) def test_update_inactive_component_from_filewatcher(self): inactive = self._create_inactive_config_holder() self.bs.set_config_list(self.clm) inactive.save_inactive("TEST_INACTIVE_COMP", True) self.clm.update(inactive, True) self.assertEqual(len(self.clm.get_components()), 1) self.assertEqual(len(self.clm.get_configs()), 0) self.assertTrue("TEST_INACTIVE_COMP" in [x['name'] for x in self.clm.get_components()]) def test_update_active_config_from_filewatcher(self): active = self._create_inactive_config_holder() active_config_name = "TEST_ACTIVE" self.bs.set_config_list(self.clm) self.clm.active_config_name = active_config_name active.save_inactive(active_config_name) self.clm.update(active) self.assertEqual(len(self.clm.get_components()), 0) self.assertEqual(len(self.clm.get_configs()), 1) self.assertTrue("TEST_ACTIVE" in [x['name'] for x in self.clm.get_configs()]) def test_update_active_component_from_filewatcher(self): inactive = self._create_inactive_config_holder() active_config_name = "TEST_ACTIVE" active_config_comp = "TEST_ACTIVE_COMP" self.bs.set_config_list(self.clm) self.clm.active_config_name = active_config_name self.clm.active_components = [active_config_comp] inactive.save_inactive(active_config_comp, True) self.clm.update(inactive, True) self.assertEqual(len(self.clm.get_components()), 1) self.assertEqual(len(self.clm.get_configs()), 0) self.assertTrue("TEST_ACTIVE_COMP" in [x['name'] for x in self.clm.get_components()]) def test_default_filtered(self): comps = self.clm.get_components() self.assertTrue(DEFAULT_COMPONENT not in comps)
class TestSynopticManagerSequence(unittest.TestCase): def setUp(self): # Find the schema directory dir = os.path.join(".") while SCHEMA_FOLDER not in os.listdir(dir): dir = os.path.join(dir, "..") self.fileIO = MockSynopticFileIO() self.bs = MockBlockServer() self.sm = SynopticManager(self.bs, os.path.join(dir, SCHEMA_FOLDER), MockVersionControl(), None, self.fileIO) def tearDown(self): pass def _create_a_synoptic(self, name): self.sm.save_synoptic_xml(EXAMPLE_SYNOPTIC % name) def test_get_synoptic_names_returns_names_alphabetically(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) self._create_a_synoptic(SYNOPTIC_2) # Act s = self.sm.get_synoptic_list() # Assert self.assertTrue(len(s) > 0) n = [x['name'] for x in s] print n self.assertEqual("-- NONE --", n[0]) self.assertEqual(SYNOPTIC_1, n[1]) self.assertEqual(SYNOPTIC_2, n[2]) def test_create_pvs_is_okay(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) # Act self.sm._load_initial() # Assert self.assertTrue(self.bs.does_pv_exist("%sSYNOP1%s" % (SYNOPTIC_PRE, SYNOPTIC_GET))) def test_get_default_synoptic_xml_returns_nothing(self): # Arrange # Act xml = self.sm.get_default_synoptic_xml() # Assert self.assertEqual(xml, "") def test_set_default_synoptic_xml_sets_something(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) # Act self.sm.save_synoptic_xml(EXAMPLE_SYNOPTIC % "synoptic0") self.sm.set_default_synoptic("synoptic0") # Assert xml = self.sm.get_default_synoptic_xml() self.assertTrue(len(xml) > 0) # Check the correct name appears in the xml self.assertTrue("synoptic0" in xml) def test_set_current_synoptic_xml_creates_pv(self): # Arrange syn_name = "synopt" # Act self.sm.save_synoptic_xml(EXAMPLE_SYNOPTIC % syn_name) # Assert self.assertTrue(self.bs.does_pv_exist("%sSYNOPT%s" % (SYNOPTIC_PRE, SYNOPTIC_GET))) def test_delete_synoptics_empty(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) self._create_a_synoptic(SYNOPTIC_2) initial_len = len(self.sm.get_synoptic_list()) # Act self.sm.delete([]) # Assert synoptic_names = [c["name"] for c in self.sm.get_synoptic_list()] self.assertEqual(len(synoptic_names), initial_len) self.assertTrue(SYNOPTIC_1 in synoptic_names) self.assertTrue(SYNOPTIC_2 in synoptic_names) self.assertTrue(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_1.upper()))) self.assertTrue(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_2.upper()))) def test_delete_one_synoptic(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) self._create_a_synoptic(SYNOPTIC_2) initial_len = len(self.sm.get_synoptic_list()) # Act self.sm.delete([SYNOPTIC_1]) # Assert synoptic_names = [c["name"] for c in self.sm.get_synoptic_list()] self.assertEqual(len(synoptic_names), initial_len - 1) self.assertFalse(SYNOPTIC_1 in synoptic_names) self.assertTrue(SYNOPTIC_2 in synoptic_names) self.assertFalse(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_1.upper()))) self.assertTrue(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_2.upper()))) def test_delete_many_synoptics(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) self._create_a_synoptic(SYNOPTIC_2) initial_len = len(self.sm.get_synoptic_list()) # Act self.sm.delete([SYNOPTIC_1, SYNOPTIC_2]) # Assert synoptic_names = [c["name"] for c in self.sm.get_synoptic_list()] self.assertEqual(len(synoptic_names), initial_len - 2) self.assertFalse(SYNOPTIC_1 in synoptic_names) self.assertFalse(SYNOPTIC_2 in synoptic_names) self.assertFalse(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_1.upper()))) self.assertFalse(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_2.upper()))) def test_cannot_delete_non_existent_synoptic(self): # Arrange self._create_a_synoptic(SYNOPTIC_1) self._create_a_synoptic(SYNOPTIC_2) initial_len = len(self.sm.get_synoptic_list()) # Act self.assertRaises(InvalidDeleteException, self.sm.delete, ["invalid"]) # Assert synoptic_names = [c["name"] for c in self.sm.get_synoptic_list()] self.assertEqual(len(synoptic_names), initial_len) self.assertTrue(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_1.upper()))) self.assertTrue(self.bs.does_pv_exist(construct_pv_name(SYNOPTIC_2.upper())))