class TestTM1pyDictMethods(unittest.TestCase): tm1 = TM1Service(address=address, port=port, user=user, password=pwd, ssl=ssl) def test_stuff(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.data.execute_mdx(mdx) # Get self.assertIsNotNone(data[('[}Clients].[ad min]', '[}Groups].[ADM IN]')]) # Delete self.assertTrue(('[}clients].[admin]', '[}groups].[admin]') in data) del data[('[}Clients].[ad min]', '[}Groups].[ADM IN]')] self.assertFalse(('[}clients].[admin]', '[}groups].[admin]') in data) # Copy data_cloned = data.copy() self.assertTrue(data_cloned == data) self.assertFalse(data_cloned is data)
def setUpClass(cls): """ Establishes a connection to TM1 and creates a dimensions and a cube to use across all tests """ # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) # Build Dimensions cls.dimension_names = ("TM1py_tests_annotations_dimension1", "TM1py_tests_annotations_dimension2", "TM1py_tests_annotations_dimension3") for dimension_name in cls.dimension_names: elements = [ Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001) ] hierarchy = Hierarchy(dimension_name=dimension_name, name=dimension_name, elements=elements) dimension = Dimension(dimension_name, [hierarchy]) cls.tm1.dimensions.update_or_create(dimension) # Build Cube cls.cube_name = "TM1py_tests_annotations" cube = Cube(cls.cube_name, cls.dimension_names) cls.tm1.cubes.update_or_create(cube)
def setUpClass(cls): """ Establishes a connection to TM1 and creates TM! objects to use across all tests """ # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) cls.all_dimension_names = cls.tm1.dimensions.get_all_names() cls.random_dimension = cls.tm1.dimensions.get(random.choice(cls.all_dimension_names)) cls.random_dimension_all_elements = cls.random_dimension.default_hierarchy.elements cls.random_dimension_elements = [element for element in cls.random_dimension_all_elements][0:2] # Subset process cls.subset_name = cls.prefix + '_subset_' + cls.some_name cls.subset = Subset(dimension_name=cls.random_dimension.name, subset_name=cls.subset_name, elements=cls.random_dimension_elements) cls.tm1.dimensions.subsets.update_or_create(cls.subset, False) cls.p_subset = Process(name=cls.prefix + '_subset_' + cls.some_name, datasource_type='TM1DimensionSubset', datasource_data_source_name_for_server=cls.subset.dimension_name, datasource_subset=cls.subset.name, metadata_procedure="sTest = 'abc';") with open(Path(__file__).parent.joinpath('resources', 'Bedrock.Server.Wait.json'), 'r') as file: cls.p_bedrock_server_wait = Process.from_json(file.read())
def setup_class(cls): cls.tm1 = TM1Service(**config['tm1srv01']) # Define Names cls.dimension_name = PREFIX + "Dimension" cls.subset_name_static = PREFIX + "static" cls.subset_name_dynamic = PREFIX + "dynamic"
def setUpClass(cls): """ Establishes a connection to TM1 and creates TM! objects to use across all tests """ # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) # Build Dimensions for i in range(3): elements = [ Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001) ] hierarchy = Hierarchy(dimension_name=cls.dimension_names[i], name=cls.dimension_names[i], elements=elements) dimension = Dimension(name=cls.dimension_names[i], hierarchies=[hierarchy]) if not cls.tm1.dimensions.exists(dimension_name=dimension.name): cls.tm1.dimensions.create(dimension=dimension) # Build Cube cube = Cube(cls.cube_name, cls.dimension_names) if not cls.tm1.cubes.exists(cls.cube_name): cls.tm1.cubes.create(cube) # Write data into cube cellset = {} for i in range(20000): element1 = 'Element ' + str(random.randint(1, 1000)) element2 = 'Element ' + str(random.randint(1, 1000)) element3 = 'Element ' + str(random.randint(1, 1000)) cellset[(element1, element2, element3)] = random.randint(1, 1000) cls.tm1.cells.write_values(cls.cube_name, cellset)
def setUpClass(cls): """ Establishes a connection to TM1 and creates TM! objects to use across all tests """ # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) cls.user_name = PREFIX + "Us'er1" cls.user_name_exotic_password = "******" cls.enabled = True cls.user = User(name=cls.user_name, groups=[], password='******', enabled=cls.enabled) cls.group_name1 = PREFIX + "Gro'up1" cls.group_name2 = PREFIX + "Group2" cls.user.add_group(cls.group_name1) if cls.user_name in CaseAndSpaceInsensitiveSet( *cls.tm1.security.get_all_user_names()): cls.tm1.security.delete_user(cls.user_name) for group in (cls.group_name1, cls.group_name2): if group in CaseAndSpaceInsensitiveSet( *cls.tm1.security.get_all_groups()): cls.tm1.security.delete_group(group)
async def main(): loop = asyncio.get_event_loop() with TM1Service(address='localhost', port=12354, user='******', password='******', ssl=True) as tm1: with ThreadPoolExecutor(max_workers=10) as executor: futures = [loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(0, 9999), range(0, 9999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(9999, 19999), range(9999, 19999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(19999, 39999), range(19999, 29999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(29999, 49999), range(29999, 39999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(39999, 59999), range(39999, 49999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(49999, 69999), range(49999, 59999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(59999, 79999), range(59999, 69999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(69999, 89999), range(69999, 79999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(79999, 99999), range(79999, 89999)), loop.run_in_executor(executor, write_values, tm1, MDX_TEMPLATE.format(89999, 99999), range(89999, 99999))] for future in futures: await future
def setUpClass(cls): cls.tm1 = TM1Service(**config['tm1srv01']) # Build Dimensions for dimension_name in cls.dimension_names: elements = [ Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001) ] hierarchy = Hierarchy(dimension_name=dimension_name, name=dimension_name, elements=elements) dimension = Dimension(dimension_name, [hierarchy]) if not cls.tm1.dimensions.exists(dimension.name): cls.tm1.dimensions.create(dimension) # Build Cube cube = Cube(cls.cube_name, cls.dimension_names) if not cls.tm1.cubes.exists(cls.cube_name): cls.tm1.cubes.create(cube) c = Cube(cls.cube_name, dimensions=cls.dimension_names, rules=Rules('')) if cls.tm1.cubes.exists(c.name): cls.tm1.cubes.delete(c.name) cls.tm1.cubes.create(c)
def main(params): # 3. Get credentials creds = { 'user':params['pauser'], 'password':params['papassword'], 'port':params['paport'], 'ssl':'False', 'address':params['paaddress'] } # 4. Get cellset cellset = { ( params['Month'], params['Version'], params['Currency'], params['CostCentre'], params['Account'], params['Project'], params['GeneralLedgerSource'], params['GeneralLedgerMeasure'], ):params['Value'] } # 5. Write to cube with TM1Service(**creds) as tm1: tm1.cubes.cells.write_values('General Ledger', cellset, dimensions=['Time Month', 'Version', 'Currency', 'Cost Centre', 'Account', 'Project', 'General Ledger Source', 'General Ledger Measure']) # 6. Return result print('Data loaded.') return { 'headers':{'Content-Type':'application/json'}, 'body':{'message':'Commentary loaded.'} }
def setup_class(cls): cls.tm1 = TM1Service(**test_config) # Do random stuff cls.private = bool(random.getrandbits(1)) # Define Names cls.prefix = 'TM1py_unittest_dimension_' cls.dimension_name = cls.prefix + str(uuid.uuid4()) cls.subset_name_static = cls.prefix + str(uuid.uuid4()) cls.subset_name_dynamic = cls.prefix + str(uuid.uuid4()) # Instantiate Subsets cls.static_subset = Subset(dimension_name=cls.dimension_name, subset_name=cls.subset_name_static, elements=['USD', 'EUR', 'NZD']) cls.dynamic_subset = Subset( dimension_name=cls.dimension_name, subset_name=cls.subset_name_dynamic, expression='{ HIERARCHIZE( {TM1SUBSETALL( [' + cls.dimension_name + '] )} ) }') elements = [ Element('USD', 'Numeric'), Element('EUR', 'Numeric'), Element('JPY', 'Numeric'), Element('CNY', 'Numeric'), Element('GBP', 'Numeric'), Element('NZD', 'Numeric') ] element_attributes = [ElementAttribute('Currency Name', 'String')] h = Hierarchy(cls.dimension_name, cls.dimension_name, elements, element_attributes) d = Dimension(cls.dimension_name, hierarchies=[h]) cls.tm1.dimensions.create(d)
def setUp(cls): # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) cls.prefix = "TM1py_Tests_Cube_" cls.cube_name = cls.prefix + "some_name" cls.dimension_names = [ cls.prefix + "dimension1", cls.prefix + "dimension2", cls.prefix + "dimension3"] for dimension_name in cls.dimension_names: elements = [Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001)] hierarchy = Hierarchy(dimension_name=dimension_name, name=dimension_name, elements=elements) dimension = Dimension(dimension_name, [hierarchy]) if not cls.tm1.dimensions.exists(dimension.name): cls.tm1.dimensions.create(dimension) # Build Cube cube = Cube(cls.cube_name, cls.dimension_names) if not cls.tm1.cubes.exists(cls.cube_name): cls.tm1.cubes.create(cube) c = Cube(cls.cube_name, dimensions=cls.dimension_names, rules=Rules('')) if cls.tm1.cubes.exists(c.name): cls.tm1.cubes.delete(c.name) cls.tm1.cubes.create(c)
class TestAnnotationMethods(unittest.TestCase): tm1 = TM1Service(**test_config) # Get Random Cube + Intersection all_cube_names = tm1.cubes.get_all_names() cube_name = random.choice(all_cube_names) random_intersection = tm1.cubes.get_random_intersection(cube_name, False) random_text = "".join([random.choice(string.printable) for i in range(100)]) def test1_create_annotation(self): annotation = Annotation(comment_value=self.random_text, object_name=self.cube_name, dimensional_context=self.random_intersection) response = self.tm1.cubes.annotations.create(annotation) annotation_id = response.json()['ID'] # test, if it exists all_annotations = self.tm1.cubes.annotations.get_all(self.cube_name) if len(all_annotations) > 0: annotation = self.tm1.cubes.annotations.get(annotation_id) self.assertEqual(self.random_text, annotation.comment_value) def test2_get_all_annotations_from_cube(self): annotations = self.tm1.cubes.annotations.get_all(self.cube_name) for a in annotations: b = self.tm1.cubes.annotations.get(a.id) self.assertEqual(a.body, b.body) def test3_update_annotation(self): annotations = self.tm1.cubes.annotations.get_all(self.cube_name) for a in annotations: # Get the anntoation that was created in test1 if a.dimensional_context == self.random_intersection and a.comment_value == self.random_text: # Update Value and Coordinates new_random_text = "".join([random.choice(string.printable) for _ in range(100)]) a.comment_value = new_random_text response = self.tm1.cubes.annotations.update(a) annotation_id = json.loads(response.text)['ID'] a_updated = self.tm1.cubes.annotations.get(annotation_id) self.assertEqual(a_updated.comment_value, new_random_text) def test4_delete_annotation(self): # get Annotations annotations = self.tm1.cubes.annotations.get_all(self.cube_name) # sort Them annotations = sorted(annotations, key=lambda a: str(a.last_updated if a.last_updated else a.created)) # First count number_annotations_at_start = len(annotations) last_annotation = annotations[-1] self.tm1.cubes.annotations.delete(last_annotation._id) # get Annotations again annotations = self.tm1.cubes.annotations.get_all(self.cube_name) # Second count number_annotations_at_end = len(annotations) self.assertEqual(number_annotations_at_start, number_annotations_at_end + 1) self.tm1.logout()
def setup_class(cls): # hard coded stuff cls.dimension_name = dimension_prefix.format(uuid.uuid4()) cls.hierarchy_name = cls.dimension_name # Connection to TM1 cls.tm1 = TM1Service(**config['tm1srv01']) # Elements cls.years = ("No Year", "1989", "1990", "1991", "1992") cls.extra_year = "4321" # Element Attributes cls.attributes = ('Previous Year', 'Next Year') # create dimension with a default hierarchy d = Dimension(cls.dimension_name) h = Hierarchy(cls.dimension_name, cls.hierarchy_name) h.add_element('Total Years', 'Consolidated') h.add_element('All Consolidations', 'Consolidated') h.add_edge("All Consolidations", "Total Years", 1) for year in cls.years: h.add_element(year, 'Numeric') h.add_edge('Total Years', year, 1) for attribute in cls.attributes: h.add_element_attribute(attribute, "String") d.add_hierarchy(h) cls.tm1.dimensions.create(d) # write one element attribute value cls.tm1.cubes.cells.write_value('1988', '}ElementAttributes_' + cls.dimension_name, ('1989', 'Previous Year'))
def setUpClass(cls): # Namings cls.prefix = "TM1py_unittest_server_" cls.dimension_name1 = cls.prefix + str(uuid.uuid4()) cls.dimension_name2 = cls.prefix + str(uuid.uuid4()) cls.cube_name = cls.prefix + str(uuid.uuid4()) cls.process_name1 = cls.prefix + str(uuid.uuid4()) cls.process_name2 = cls.prefix + str(uuid.uuid4()) # Connect to TM1 cls.tm1 = TM1Service(**config['tm1srv01']) # create a simple cube with dimensions to test transactionlog methods if not cls.tm1.dimensions.exists(cls.dimension_name1): d = Dimension(cls.dimension_name1) h = Hierarchy(cls.dimension_name1, cls.dimension_name1) h.add_element('Total Years', 'Consolidated') h.add_element('No Year', 'Numeric') for year in range(1989, 2040, 1): h.add_element(str(year), 'Numeric') h.add_edge('Total Years', str(year), 1) d.add_hierarchy(h) cls.tm1.dimensions.create(d) if not cls.tm1.dimensions.exists(cls.dimension_name2): d = Dimension(cls.dimension_name2) h = Hierarchy(cls.dimension_name2, cls.dimension_name2) h.add_element('Value', 'Numeric') d.add_hierarchy(h) cls.tm1.dimensions.create(d) if not cls.tm1.cubes.exists(cls.cube_name): cube = Cube(cls.cube_name, [cls.dimension_name1, cls.dimension_name2]) cls.tm1.cubes.create(cube)
def setUp(cls): # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath('config.ini')) cls.tm1 = TM1Service(**cls.config['tm1srv01']) for dimension_name in cls.dimension_names: elements = [ Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001) ] hierarchy = Hierarchy(dimension_name=dimension_name, name=dimension_name, elements=elements) dimension = Dimension(dimension_name, [hierarchy]) if not cls.tm1.dimensions.exists(dimension.name): cls.tm1.dimensions.create(dimension) # Build Cube cube = Cube(cls.cube_name, cls.dimension_names) if not cls.tm1.cubes.exists(cls.cube_name): cls.tm1.cubes.create(cube) c = Cube(cls.cube_name, dimensions=cls.dimension_names, rules=Rules('')) if cls.tm1.cubes.exists(c.name): cls.tm1.cubes.delete(c.name) cls.tm1.cubes.create(c) if not cls.tm1.sandboxes.exists(cls.sandbox_name1): cls.tm1.sandboxes.create( Sandbox(name=cls.sandbox_name1, include_in_sandbox_dimension=True))
def setup_class(cls): cls.tm1 = TM1Service(**config['tm1srv01']) # chore properties cls.chore_name1 = 'TM1py_unittest_chore_' + str(uuid.uuid4()) cls.chore_name2 = 'TM1py_unittest_chore_' + str(uuid.uuid4()) cls.start_time = datetime.now() cls.frequency_days = int(random.uniform(0, 355)) cls.frequency_hours = int(random.uniform(0, 23)) cls.frequency_minutes = int(random.uniform(0, 59)) cls.frequency_seconds = int(random.uniform(0, 59)) cls.frequency = ChoreFrequency(days=cls.frequency_days, hours=cls.frequency_hours, minutes=cls.frequency_minutes, seconds=cls.frequency_seconds) cls.tasks = [ChoreTask(0, process_name1, parameters=[{'Name': 'pRegion', 'Value': 'UK'}]), ChoreTask(1, process_name1, parameters=[{'Name': 'pRegion', 'Value': 'FR'}]), ChoreTask(2, process_name1, parameters=[{'Name': 'pRegion', 'Value': 'CH'}])] p1 = Process(name=process_name1) p1.add_parameter('pRegion', 'pRegion (String)', value='US') if cls.tm1.processes.exists(p1.name): cls.tm1.processes.delete(p1.name) cls.tm1.processes.create(p1) p2 = Process(name=process_name2) p2.add_parameter('pRegion', 'pRegion (String)', value='UK') if cls.tm1.processes.exists(p2.name): cls.tm1.processes.delete(p2.name) cls.tm1.processes.create(p2)
def setUpClass(cls): cls.tm1 = TM1Service(**config['tm1srv01']) cls.random_string = str(uuid.uuid4()) cls.all_dimension_names = cls.tm1.dimensions.get_all_names() cls.random_dimension = cls.tm1.dimensions.get(random.choice(cls.all_dimension_names)) cls.random_dimension_all_elements = cls.random_dimension.default_hierarchy.elements cls.random_dimension_elements = [element for element in cls.random_dimension_all_elements][0:2] # None process cls.p_none = Process(name=process_prefix + '_none_' + cls.random_string, datasource_type='None') # ACII process cls.p_ascii = Process(name=process_prefix + '_ascii_' + cls.random_string, datasource_type='ASCII', datasource_ascii_delimiter_type='Character', datasource_ascii_delimiter_char=',', datasource_ascii_header_records=2, datasource_ascii_quote_character='^', datasource_ascii_thousand_separator='~', prolog_procedure="sTestProlog = 'test prolog procedure'", metadata_procedure="sTestMeta = 'test metadata procedure'", data_procedure="sTestData = 'test data procedure'", epilog_procedure="sTestEpilog = 'test epilog procedure'", datasource_data_source_name_for_server=r'C:\Data\file.csv', datasource_data_source_name_for_client=r'C:\Data\file.csv') # Variables cls.p_ascii.add_variable('v_1', 'Numeric') cls.p_ascii.add_variable('v_2', 'Numeric') cls.p_ascii.add_variable('v_3', 'Numeric') cls.p_ascii.add_variable('v_4', 'Numeric') # Parameters cls.p_ascii.add_parameter('p_Year', 'year?', '2016') cls.p_ascii.add_parameter('p_Number', 'number?', 2) # View process cls.p_view = Process(name=process_prefix + '_view_' + cls.random_string, datasource_type='TM1CubeView', datasource_view='view1', datasource_data_source_name_for_client='Plan_BudgetPlan', datasource_data_source_name_for_server='Plan_BudgetPlan') # ODBC process cls.p_odbc = Process(name=process_prefix + '_odbc_' + cls.random_string, datasource_type='ODBC', datasource_password='******', datasource_user_name='user') # Subset process cls.subset_name = process_prefix + '_subset_' + cls.random_string cls.subset = Subset(dimension_name=cls.random_dimension.name, subset_name=cls.subset_name, elements=cls.random_dimension_elements) cls.tm1.dimensions.subsets.create(cls.subset, False) cls.p_subset = Process(name=process_prefix + '_subset_' + cls.random_string, datasource_type='TM1DimensionSubset', datasource_data_source_name_for_server=cls.subset.dimension_name, datasource_subset=cls.subset.name, metadata_procedure="sTest = 'abc';")
class TestUserMethods(unittest.TestCase): tm1 = TM1Service(address=address, port=port, user=user, password=pwd, ssl=ssl) user_name = str(uuid.uuid4()) group_name = str(uuid.uuid4()) user = User(name=user_name, groups=[], password='******') # Create Group for unittests @classmethod def setup_class(cls): code = "AddGroup('{}');".format(cls.group_name) cls.tm1.processes.execute_ti_code([code]) def test1_create_user(self): all_users_before = self.tm1.security.get_all() self.tm1.security.create(self.user) all_users_after = self.tm1.security.get_all() # test it! self.assertEqual(len(all_users_before) + 1, len(all_users_after)) def test2_get_user(self): u = self.tm1.security.get(self.user_name) # Adjust it a little bit u.password = '******' u.friendly_name = None # test it ! self.assertEqual(u.body, self.user.body) def test3_update_user(self): # get user u = self.tm1.security.get(self.user_name) # update user. Add Group u.add_group(self.group_name) self.tm1.security.update(u) # test it ! groups = self.tm1.security.get_groups(u.name) self.assertIn(self.group_name, groups) # update user. Remove Group u.remove_group(self.group_name) self.tm1.security.update(u) # test it ! groups = self.tm1.security.get_groups(u.name) self.assertNotIn(self.group_name, groups) def test4_delete_user(self): users_before = self.tm1.security.get_all() self.tm1.security.delete(self.user_name) users_after = self.tm1.security.get_all() # test it ! self.assertEqual(len(users_before) - 1, len(users_after)) @classmethod def teardown_class(cls): # Delete Group code = "DeleteGroup('{}');".format(cls.group_name) cls.tm1.processes.execute_ti_code([code]) cls.tm1.logout()
def setup_class(cls): # Connection to TM1 cls.tm1 = TM1Service(**config['tm1srv01']) # generate random coordinates cls.target_coordinates = list( zip(('Element ' + str(random.randint(1, 1000)) for _ in range(100)), ('Element ' + str(random.randint(1, 1000)) for _ in range(100)), ('Element ' + str(random.randint(1, 1000)) for _ in range(100)))) # Build Dimensions for i in range(3): elements = [ Element('Element {}'.format(str(j)), 'Numeric') for j in range(1, 1001) ] hierarchy = Hierarchy(dimension_names[i], dimension_names[i], elements) dimension = Dimension(dimension_names[i], [hierarchy]) if not cls.tm1.dimensions.exists(dimension.name): cls.tm1.dimensions.create(dimension) # Build Cube cube = Cube(cube_name, dimension_names) if not cls.tm1.cubes.exists(cube_name): cls.tm1.cubes.create(cube) # Build cube view view = NativeView(cube_name=cube_name, view_name=view_name, suppress_empty_columns=True, suppress_empty_rows=True) subset = AnonymousSubset(dimension_name=dimension_names[0], expression='{[' + dimension_names[0] + '].Members}') view.add_row(dimension_name=dimension_names[0], subset=subset) subset = AnonymousSubset(dimension_name=dimension_names[1], expression='{[' + dimension_names[1] + '].Members}') view.add_row(dimension_name=dimension_names[1], subset=subset) subset = AnonymousSubset(dimension_name=dimension_names[2], expression='{[' + dimension_names[2] + '].Members}') view.add_column(dimension_name=dimension_names[2], subset=subset) cls.tm1.cubes.views.create(view, private=False) # Sum of all the values that we write in the cube. serves as a checksum cls.total_value = 0 # cellset of data that shall be written cls.cellset = {} for element1, element2, element3 in cls.target_coordinates: value = random.randint(1, 1000) cls.cellset[(element1, element2, element3)] = value # update the checksum cls.total_value += value
class TestOtherMethods(unittest.TestCase): tm1 = TM1Service(address=address, port=port, user=user, password=pwd, ssl=ssl) def test1_execute_mdx(self): cube_names = self.tm1.cubes.get_all_names() cube_name = cube_names[random.randrange(0, len(cube_names))] _, public_views = self.tm1.cubes.views.get_all(cube_name=cube_name) # if no views on cube. Recursion if len(public_views) == 0: self.test1_execute_mdx() else: # random public view on random cube view = public_views[random.randrange(0, len(public_views))] # if random view is MDXView. Recursion if isinstance(view, MDXView): self.test1_execute_mdx() else: # if native view has no dimensions on the columns. Recursion if len(view._columns) == 0: self.test1_execute_mdx() else: # sum up all numeric cells in Native View data_native_view = self.tm1.cubes.cells.get_view_content( cube_name, view.name, private=False) sum_native_view = sum([ float(cell['Value']) for cell in data_native_view.values() if str(cell['Value']).isdigit() ]) # get mdx from native view mdx = view.as_MDX # sum up all numeric cells in the response of the mdx query data_mdx = self.tm1.cubes.cells.execute_mdx(mdx) sum_mdx = sum([ float(cell['Value']) for cell in data_mdx.values() if str(cell['Value']).isdigit() ]) # test it ! self.assertEqual(sum_mdx, sum_native_view) def test2_read_cube_name_from_mdx(self): all_cube_names = self.tm1.cubes.get_all_names() all_cube_names_normalized = [ cube_name.upper().replace(" ", "") for cube_name in all_cube_names ] for cube_name in all_cube_names: private_views, public_views = self.tm1.cubes.views.get_all( cube_name) for view in private_views + public_views: mdx = view.MDX cube_name = Utils.read_cube_name_from_mdx(mdx) self.assertIn(cube_name, all_cube_names_normalized)
def setUpClass(cls): """ Establishes a connection to TM1 and creates TM1 objects to use across all tests """ # Connection to TM1 cls.config = configparser.ConfigParser() cls.config.read(Path(__file__).parent.joinpath("config.ini")) cls.tm1 = TM1Service(**cls.config["tm1srv01"])
def test_session_context_custom(self): app_name = "Some Application" with TM1Service(**config['tm1srv01'], session_context=app_name) as tm1: threads = tm1.monitoring.get_threads() for thread in threads: if "GET /api/v1/Threads" in thread["Function"] and thread["Name"] == config['tm1srv01']['user']: self.assertTrue(thread["Context"] == app_name) return raise Exception("Did not find my own Thread")
def setUpClass(cls): # Connect to TM1 cls.tm1 = TM1Service(**config['tm1srv01']) # Build 4 Dimensions cls.dim1_name = str(uuid.uuid4()) cls.dim1_element_names = [str(uuid.uuid4()) for _ in range(10)] d = Dimension(cls.dim1_name) h = Hierarchy(cls.dim1_name, cls.dim1_name) for element_name in cls.dim1_element_names: h.add_element(element_name, 'Numeric') d.add_hierarchy(h) cls.tm1.dimensions.create(d) cls.dim2_name = str(uuid.uuid4()) cls.dim2_element_names = [str(uuid.uuid4()) for _ in range(10)] d = Dimension(cls.dim2_name) h = Hierarchy(cls.dim2_name, cls.dim2_name) for element_name in cls.dim2_element_names: h.add_element(element_name, 'Numeric') d.add_hierarchy(h) cls.tm1.dimensions.create(d) cls.dim3_name = str(uuid.uuid4()) cls.dim3_element_names = [str(uuid.uuid4()) for _ in range(10)] d = Dimension(cls.dim3_name) h = Hierarchy(cls.dim3_name, cls.dim3_name) for element_name in cls.dim3_element_names: h.add_element(element_name, 'Numeric') d.add_hierarchy(h) cls.tm1.dimensions.create(d) cls.dim4_name = str(uuid.uuid4()) cls.dim4_element_names = [str(uuid.uuid4()) for _ in range(10)] d = Dimension(cls.dim4_name) h = Hierarchy(cls.dim4_name, cls.dim4_name) for element_name in cls.dim4_element_names: h.add_element(element_name, 'Numeric') d.add_hierarchy(h) cls.tm1.dimensions.create(d) # Build Subset cls.dim4_subset_Name = "TM1pyTests" cls.dim4_subset = cls.tm1.dimensions.subsets.create( Subset(subset_name=cls.dim4_subset_Name, dimension_name=cls.dim4_name, hierarchy_name=cls.dim4_name, expression="HEAD([{}].Members, 1)".format(cls.dim4_name))) # Build Cube with 4 Dimensions cls.cube_name = str(uuid.uuid4()) cube = Cube(name=cls.cube_name, dimensions=[ cls.dim1_name, cls.dim2_name, cls.dim3_name, cls.dim4_name ]) cls.tm1.cubes.create(cube)
def setup_class(cls): cls.tm1 = TM1Service(**test_config) cls.user_name = str(uuid.uuid4()) cls.user = User(name=cls.user_name, groups=[], password='******') # Create Group for unittests cls.group_name = str(uuid.uuid4()) code = "AddGroup('{}');".format(cls.group_name) cls.tm1.processes.execute_ti_code([code])
async def main(): loop = asyncio.get_event_loop() with TM1Service(**config['tm1srv01']) as tm1: future1 = loop.run_in_executor(None, execute_mdx, tm1) future2 = loop.run_in_executor(None, get_server_name, tm1) future3 = loop.run_in_executor(None, read_pnl, tm1) future4 = loop.run_in_executor(None, get_all_dimension_names, tm1) future5 = loop.run_in_executor(None, get_all_process_names, tm1) response1, response, response3, response4, response5 = \ await future1, await future2, await future3, await future4, await future5
def test_update_user_password(self): self.tm1.security.update_user_password(user_name=self.user.name, password="******") with TM1Service(user=self.user.name, password="******", base_url=self.tm1._tm1_rest._base_url, ssl=self.tm1._tm1_rest._ssl) as _: # if no exception. Login was successful pass
async def main(): loop = asyncio.get_event_loop() with TM1Service(address='localhost', port=12354, user='******', password='******', ssl=True) as tm1: future1 = loop.run_in_executor(None, get_product_version, tm1) future2 = loop.run_in_executor(None, get_server_name, tm1) future3 = loop.run_in_executor(None, read_pnl, tm1) future4 = loop.run_in_executor(None, get_all_dimension_names, tm1) future5 = loop.run_in_executor(None, get_all_process_names, tm1) response1, response, response3, response4, response5 = \ await future1, await future2, await future3, await future4, await future5
async def main(): loop = asyncio.get_event_loop() with TM1Service(**config['tm1srv01']) as tm1: future1 = loop.run_in_executor(None, execute_mdx, tm1, mdx1) future2 = loop.run_in_executor(None, execute_mdx, tm1, mdx2) future3 = loop.run_in_executor(None, execute_mdx, tm1, mdx3) future4 = loop.run_in_executor(None, execute_mdx, tm1, mdx4) future5 = loop.run_in_executor(None, execute_mdx, tm1, mdx5) response1, response, response3, response4, response5 = \ await future1, await future2, await future3, await future4, await future5
def main(): try: tm1_instance = sys.argv[1] except: logger.fatal("No Instance Specified") try: file_path = sys.argv[2] except: logger.fatal("No File Specified") if not os.path.isfile(file_path): logger.fatal("File not found, exiting") default_max_threads = 5 try: max_threads = int(sys.argv[3]) except: max_threads = default_maxthreads logger.warning( "Max Parallel Threads Not Specified, Default: {}".format( default_max_threads)) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) config = configparser.ConfigParser() config.read('config.ini') logger.info("Reading Config File") tis = create_ti_instructions(file_path) row_count = sum(1 for row in tis) logger.info("Reading file {}, {} lines read".format(file_path, row_count)) logger.info("Maximum Parallel Threads: {}".format(max_threads)) try: with TM1Service(**config[tm1_instance]) as tm1: logger.info("Connecting to: {}".format( tm1.server.get_server_name())) logger.info("Starting Processes found in: {}".format(file_path)) start_time = time.clock() result = loop.run_until_complete( execute_parallel_ti(tm1, tis, max_threads)) tm1.logout() logger.info("Logging Out") end_time = time.clock() elapsed_time = end_time - start_time logger.info("Total Time To Complete {} Processes: {}".Format( row_count, elapsed_time)) loop.close() except Exception as e: logging.fatal("Unable to Connect to TM1") logging.fatal("Connection Error: {}".format(e))
async def main(): loop = asyncio.get_event_loop() with TM1Service(**config['tm1srv01']) as tm1: outcomes = list() futures = list() for _ in range(50): futures.append(loop.run_in_executor(None, execute_mdx, tm1, mdx1)) futures.append(loop.run_in_executor(None, execute_mdx, tm1, mdx2)) futures.append(loop.run_in_executor(None, execute_mdx, tm1, mdx3)) for future in futures: outcomes.append(await future) assert all(outcomes)