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 load_bedrock_from_github(bedrock_process_name):
""" Load bedrock from GitHub as TM1py.Process instance
:param bedrock_process_name:
:return:
"""
import requests
from TM1py.Objects import Process
url = 'https://raw.githubusercontent.com/MariusWirtz/bedrock/master/json/{}.json'.format(bedrock_process_name)
process_as_json = requests.get(url).text
return Process.from_json(process_as_json)
def load_all_bedrocks_from_github():
""" Load all Bedrocks from GitHub as TM1py.Process instances
:return:
"""
import requests
from TM1py.Objects import Process
# Connect to Bedrock github repo and load the names of all Bedrocks
url = "https://api.github.com/repos/MariusWirtz/bedrock/contents/json?ref=master"
raw_github_data = requests.get(url).json()
all_bedrocks = [entry['name'] for entry in raw_github_data]
# instantiate TM1py.Process instances from github-json content
url_to_bedrock = 'https://raw.githubusercontent.com/MariusWirtz/bedrock/master/json/{}'
return [Process.from_json(requests.get(url_to_bedrock.format(bedrock)).text) for bedrock in all_bedrocks]
def get(self, name_process):
""" Get a process from TM1 Server
:param name_process:
:return: Instance of the TM1py.Process
"""
request = "/api/v1/Processes('{}')?$select=*,UIData,VariablesUIData," \
"DataSource/dataSourceNameForServer," \
"DataSource/dataSourceNameForClient," \
"DataSource/asciiDecimalSeparator," \
"DataSource/asciiDelimiterChar," \
"DataSource/asciiDelimiterType," \
"DataSource/asciiHeaderRecords," \
"DataSource/asciiQuoteCharacter," \
"DataSource/asciiThousandSeparator," \
"DataSource/view," \
"DataSource/query," \
"DataSource/userName," \
"DataSource/password," \
"DataSource/usesUnicode," \
"DataSource/subset".format(name_process)
response = self._rest.GET(request, "")
return Process.from_json(process_as_json=response)
def setUpClass(cls):
# Namings
cls.expand_process_name = str(uuid.uuid4())
cls.expand_process_name_obf = str(uuid.uuid4())
cls.process_name = str(uuid.uuid4())
cls.process_name_obf = str(uuid.uuid4())
cls.dimension_name = str(uuid.uuid4())
cls.dimension_name_cloned = str(uuid.uuid4())
cls.cube_name = str(uuid.uuid4())
cls.cube_name_cloned = str(uuid.uuid4())
# Connect to TM1
cls.tm1 = TM1Service(**config['tm1srv01'])
# create process
prolog = "\r\nSaveDataAll;\r\nsText='abcABC';\r\n"
epilog = "SaveDataAll;"
cls.process = Process(
name=cls.process_name,
prolog_procedure=prolog,
epilog_procedure=epilog)
# create process with expand in TM1
if cls.tm1.processes.exists(cls.process.name):
cls.tm1.processes.delete(cls.process.name)
cls.tm1.processes.create(cls.process)
# create process with expand
prolog = "\r\nnRevenue = 20;\r\nsRevenue = EXPAND('%nrevenue%');\r\nIF(sRevenue @ <> '20.000');\r\n" \
"ProcessBreak;\r\nENDIF;"
cls.expand_process = Process(
name=cls.expand_process_name,
prolog_procedure=prolog)
# create process with expand in TM1
if cls.tm1.processes.exists(cls.expand_process.name):
cls.tm1.processes.delete(cls.expand_process.name)
cls.tm1.processes.create(cls.expand_process)
# create dimension that we clone through obfuscated bedrock as part of the test
if not cls.tm1.dimensions.exists(cls.dimension_name):
d = Dimension(cls.dimension_name)
h = Hierarchy(cls.dimension_name, cls.dimension_name)
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)
# Create 2 Attributes through TI
ti_statements = ["AttrInsert('{}','','Previous Year', 'S')".format(cls.dimension_name),
"AttrInsert('{}','','Next Year', 'S');".format(cls.dimension_name)]
ti = ';'.join(ti_statements)
cls.tm1.processes.execute_ti_code(lines_prolog=ti)
# create }ElementAttribute values
cellset = {}
for year in range(1989, 2040, 1):
cellset[(str(year), 'Previous Year')] = year - 1
cellset[(str(year), 'Next Year')] = year + 1
cls.tm1.cubes.cells.write_values("}ElementAttributes_" + cls.dimension_name, cellset)
# create a simple cube to be cloned through bedrock
if not cls.tm1.cubes.exists(cls.cube_name):
cube = Cube(cls.cube_name, ["}Dimensions", "}Cubes"], "[]=S:'TM1py';")
cls.tm1.cubes.create(cube)
# create bedrocks if they doesn't exist
for bedrock in ("Bedrock.Dim.Clone", "Bedrock.Cube.Clone"):
if not cls.tm1.processes.exists(bedrock):
with open(os.path.join("resources", bedrock + ".json"), "r") as file:
process = Process.from_json(file.read())
cls.tm1.processes.create(process)
def setUpClass(cls):
cls.tm1 = TM1Service(**config['tm1srv01'])
cls.some_name = "some_name"
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.some_name, datasource_type='None')
# ACII process
cls.p_ascii = Process(name=PROCESS_PREFIX + '_ascii_' + cls.some_name,
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.some_name,
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.some_name,
datasource_type='ODBC',
datasource_password='******',
datasource_user_name='user')
# Subset process
cls.subset_name = PROCESS_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.create(cls.subset, False)
cls.p_subset = Process(name=PROCESS_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())
