コード例 #1
0
class TestCaseAndSpaceInsensitiveTuplesDict(unittest.TestCase):
    tm1: TM1Service
    map: CaseAndSpaceInsensitiveTuplesDict

    @classmethod
    def setUpClass(cls):
        """
        Establishes a connection to TM1 and creates TM! objects to use across all tests
        """

        # Connection to TM1
        config = configparser.ConfigParser()
        config.read(Path(__file__).parent.joinpath('config.ini'))
        cls.tm1 = TM1Service(**config['tm1srv01'])

    def setUp(self):
        self.map = CaseAndSpaceInsensitiveTuplesDict()
        self.map[("Elem1", "Elem1")] = "Value1"
        self.map[("Elem1", "Elem2")] = 2
        self.map[("Elem1", "Elem3")] = 3

    def tearDown(self):
        del self.map

    def test_del(self):
        self.assertIn(("Elem1", "Elem1"), self.map)
        self.assertIn(("Elem1", "Elem2"), self.map)
        self.assertIn(("Elem1", "Elem3"), self.map)
        del self.map[("El em1", "ELEM1")]
        del self.map[("El em1", "E L E M 2")]
        del self.map[("El em1", " eLEM3")]
        self.assertNotIn(("Elem1", "Elem1"), self.map)
        self.assertNotIn(("Elem1", "Elem2"), self.map)
        self.assertNotIn(("Elem1", "Elem3"), self.map)

    def test_eq(self):
        _map = CaseAndSpaceInsensitiveTuplesDict()
        _map[("Elem1", "Elem1")] = "Value1"
        _map[("Elem1", "Elem2")] = 2
        _map[("Elem1", "Elem3")] = 3
        self.assertEqual(_map, self.map)

        _map = CaseAndSpaceInsensitiveTuplesDict()
        _map[("Elem 1", "Elem1")] = "Value1"
        _map[("ELEM 1", "E L E M 2")] = 2
        _map[(" Elem1 ", "Elem 3")] = 3
        self.assertEqual(_map, self.map)

    def test_ne(self):
        _map = CaseAndSpaceInsensitiveTuplesDict()
        _map[("Elem1", "Elem1")] = "Value1"
        _map[("Elem1", "Elem2")] = 0
        _map[("Elem1", "Elem3")] = 3
        self.assertNotEqual(_map, self.map)

        _map = CaseAndSpaceInsensitiveTuplesDict()
        _map[("Elem 1", "Elem1")] = "Value1"
        _map[("ELEM 1", "E L E M 2")] = "wrong"
        _map[(" Elem1 ", "Elem 3")] = 3
        self.assertNotEqual(_map, self.map)

        _map = CaseAndSpaceInsensitiveTuplesDict()
        _map[("wrong", "Elem1")] = "Value1"
        _map[("Elem1", "Elem2")] = 2
        _map[("Elem1", "Elem3")] = 3
        self.assertNotEqual(_map, self.map)

    def test_get(self):
        self.assertEqual(self.map[("ELEM1", "ELEM1")], "Value1")
        self.assertEqual(self.map[("elem1", "e l e m 2")], 2)
        self.assertEqual(self.map[("e l e M 1", "elem3")], 3)
        self.assertNotEqual(self.map[("e l e M 1", "elem3")], 2)

    def test_iter(self):
        for tuple1, tuple2 in zip(self.map, [("Elem1", "Elem1"),
                                             ("Elem1", "Elem2"),
                                             ("Elem1", "Elem3")]):
            self.assertEqual(tuple1, tuple2)

    def test_len(self):
        self.assertEqual(len(self.map), 3)

    def test_set(self):
        self.map[("E L E M 1", "E L E M 2")] = 3
        self.assertEqual(self.map[("Elem1", "Elem2")], 3)

    def test_copy(self):
        c = self.map.copy()
        self.assertIsNot(c, self.map)
        self.assertEqual(c, self.map)

    def test_full(self):
        mdx_rows = '[}Clients].Members'
        mdx_columns = '[}Groups].Members'
        cube_name = '[}ClientGroups]'
        mdx = 'SELECT {} ON ROWS, {} ON COLUMNS FROM {}'.format(
            mdx_rows, mdx_columns, cube_name)
        data = self.tm1.cubes.cells.execute_mdx(mdx)

        # Get
        if self.tm1.version[0:2] == '10':
            coordinates = ('[}Clients].[ad min]', '[}Groups].[ADM IN]')
        else:
            coordinates = ('[}Clients].[}Clients].[ad min]',
                           '[}Groups].[}Groups].[ADM IN]')
        self.assertIsNotNone(data[coordinates])

        # Delete
        if self.tm1.version[0:2] == '10':
            coordinates = ('[}clients].[}clients].[admin]',
                           '[}groups].[}groups].[admin]')
        else:
            coordinates = ('[}clients].[}clients].[admin]',
                           '[}groups].[}groups].[admin]')
        self.assertTrue(coordinates in data)
        del data[coordinates]
        self.assertFalse(coordinates in data)

        # Copy
        data_cloned = data.copy()
        self.assertTrue(data_cloned == data)
        self.assertFalse(data_cloned is data)

    @classmethod
    def tearDownClass(cls):
        cls.tm1.logout()
コード例 #2
0
class TestCaseAndSpaceInsensitiveTuplesDict(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.tm1 = TM1Service(**config['tm1srv01'])

    def setUp(self):
        self.map = CaseAndSpaceInsensitiveTuplesDict()
        self.map[("Elem1", "Elem1")] = "Value1"
        self.map[("Elem1", "Elem2")] = 2
        self.map[("Elem1", "Elem3")] = 3

    def tearDown(self):
        del self.map

    def test_del(self):
        self.assertIn(("Elem1", "Elem1"), self.map)
        self.assertIn(("Elem1", "Elem2"), self.map)
        self.assertIn(("Elem1", "Elem3"), self.map)
        del self.map[("El em1", "ELEM1")]
        del self.map[("El em1", "E L E M 2")]
        del self.map[("El em1", " eLEM3")]
        self.assertNotIn(("Elem1", "Elem1"), self.map)
        self.assertNotIn(("Elem1", "Elem2"), self.map)
        self.assertNotIn(("Elem1", "Elem3"), self.map)

    def test_eq(self):
        map = CaseAndSpaceInsensitiveTuplesDict()
        map[("Elem1", "Elem1")] = "Value1"
        map[("Elem1", "Elem2")] = 2
        map[("Elem1", "Elem3")] = 3
        self.assertEqual(map, self.map)

        map = CaseAndSpaceInsensitiveTuplesDict()
        map[("Elem 1", "Elem1")] = "Value1"
        map[("ELEM 1", "E L E M 2")] = 2
        map[(" Elem1 ", "Elem 3")] = 3
        self.assertEqual(map, self.map)

    def test_ne(self):
        map = CaseAndSpaceInsensitiveTuplesDict()
        map[("Elem1", "Elem1")] = "Value1"
        map[("Elem1", "Elem2")] = 0
        map[("Elem1", "Elem3")] = 3
        self.assertNotEqual(map, self.map)

        map = CaseAndSpaceInsensitiveTuplesDict()
        map[("Elem 1", "Elem1")] = "Value1"
        map[("ELEM 1", "E L E M 2")] = "wrong"
        map[(" Elem1 ", "Elem 3")] = 3
        self.assertNotEqual(map, self.map)

        map = CaseAndSpaceInsensitiveTuplesDict()
        map[("wrong", "Elem1")] = "Value1"
        map[("Elem1", "Elem2")] = 2
        map[("Elem1", "Elem3")] = 3
        self.assertNotEqual(map, self.map)

    def test_get(self):
        self.assertEqual(self.map[("ELEM1", "ELEM1")], "Value1")
        self.assertEqual(self.map[("elem1", "e l e m 2")], 2)
        self.assertEqual(self.map[("e l e M 1", "elem3")], 3)
        self.assertNotEqual(self.map[("e l e M 1", "elem3")], 2)

    def test_iter(self):
        for tuple1, tuple2 in zip(self.map, [("Elem1", "Elem1"), ("Elem1", "Elem2"), ("Elem1", "Elem3")]):
            self.assertEqual(tuple1, tuple2)

    def test_len(self):
        self.assertEqual(len(self.map), 3)

    def test_set(self):
        self.map[("E L E M 1", "E L E M 2")] = 3
        self.assertEqual(self.map[("Elem1", "Elem2")], 3)

    def test_copy(self):
        c = self.map.copy()
        self.assertIsNot(c, self.map)
        self.assertEqual(c, self.map)

    def test_full(self):
        mdx_rows = '[}Clients].Members'
        mdx_columns = '[}Groups].Members'
        cube_name = '[}ClientGroups]'
        mdx = 'SELECT {} ON ROWS, {} ON COLUMNS FROM {}'.format(mdx_rows, mdx_columns, cube_name)
        data = self.tm1.cubes.cells.execute_mdx(mdx)

        # Get
        if self.tm1.version[0:2] == '10':
            coordinates = ('[}Clients].[ad min]', '[}Groups].[ADM IN]')
        else:
            coordinates = ('[}Clients].[}Clients].[ad min]', '[}Groups].[}Groups].[ADM IN]')
        self.assertIsNotNone(data[coordinates])

        # Delete
        if self.tm1.version[0:2] == '10':
            coordinates = ('[}clients].[}clients].[admin]', '[}groups].[}groups].[admin]')
        else:
            coordinates = ('[}clients].[}clients].[admin]', '[}groups].[}groups].[admin]')
        self.assertTrue(coordinates in data)
        del data[coordinates]
        self.assertFalse(coordinates in data)

        # Copy
        data_cloned = data.copy()
        self.assertTrue(data_cloned == data)
        self.assertFalse(data_cloned is data)

    @classmethod
    def tearDownClass(cls):
        cls.tm1.logout()