def test_create_single_file_nofile(self): '''Test create_single_file() ''' rootdir = random_string(16) path_a = os.path.join(rootdir, 'a') with self.assertRaises(IOError): entree.utils.create_single_file(path_a, '', '')
def authorize(client_id, client_secret, config): """ A module method to authorize Spotify using a OAuth client ID and client secret. """ state = util.random_string(14) scope = 'playlist-modify-private' authorization_url = '{}?client_id={}&response_type=code'.format( REQUEST_TOKEN_URL, client_id ) authorization_url += '&redirect_uri={}&state={}&scope={}'.format( CALLBACK_URI, state, scope ) if config.verbose: util.debug('Authorization URL constructed: {}'.format(authorization_url)) # Prompt the user to authorize via a browser: util.info('Now opening a browser to authorize your Spotify account.') util.info('Once authorized, copy/paste the URL of that browser window here.') util.info('Finally, hit enter to complete the auhtorization process.') util.confirm('Do you want to continue?') util.open_url(authorization_url) # Deal with the return code: authorization_response = util.prompt('Enter the URL', None) parsed = urlparse.urlparse(authorization_response) authorization_args = urlparse.parse_qs(parsed.query) if config.verbose: util.debug('Authorization arguments: {}'.format(authorization_args)) # Check to make sure the states between request and response match: if state == authorization_args.get('state')[0]: if 'code' in authorization_args: # The authorization succeeded: params = { 'client_id': client_id, 'client_secret': client_secret, 'grant_type': 'authorization_code', 'code': authorization_args.get('code')[0], 'redirect_uri': CALLBACK_URI } r = requests.post(ACCESS_TOKEN_URL, data=params) if config.verbose: util.debug('Access response: {}'.format(r.content)) return r.json() else: # The authorization failed: if 'error' in authorization_args: raise music_service.AuthorizationError(authorization_args.get('error')[0]) else: raise music_service.AuthorizationError('unknown authorization error') else: raise SpotifyStateError()
def test_rootdir_doesntexist(self): '''`entree python -d blah -s blah.py` should raise an error if directory blah doesn't exist. ''' rootdir = random_string(16) code = run_command('entree python -d {0} blah'.format(rootdir)) self.assertEqual(code, 1)
def generante_storage_url_job(file_path, preferred_format, bot, user): try: secretUrl, file_id, owner_token = upload.send_file( 'https://send.firefox.com/', open(file_path, 'rb'), ignoreVersion=False, fileName='{}.{}'.format(utils.random_string(32), preferred_format)) delete_button = InlineKeyboardMarkup([[ InlineKeyboardButton( CronJobManager.lang[user.language_code]['delete_url'], callback_data=str({ 'cmd': CallbackCommand.remove_url.value, 'id': file_id, 'own': owner_token })) ]]) bot.send_message(chat_id=user.id, text=CronJobManager.lang[user.language_code]['url_send'] \ .format(secretUrl), disable_web_page_preview=True, parse_mode=ParseMode.HTML, reply_markup=delete_button ) except: bot.send_message(chat_id=user.id, text=CronJobManager.lang[user.language_code] \ ['error_generate_url'].format(secretUrl), )
def add_patient_answers(answers): """ Inserts new answers from a patient. :param answers: patient answers :param session: current session :return: patient with anonymous name """ session = init() new_answers = [] for key in answers.keys(): new_answers.append(answers[key]) new_entity = Entity(name=random_string(get_all_entities()), type="patient") new_patient = Patient(date_of_birth="11.11.11", entity=new_entity) new_address = Address(post_code="1337", entity=new_entity) session.add(new_address) session.add(new_patient) session.add(new_entity) for answer in answers: q = session.query(Question).filter(Question.id == answer).first() if q is not None: try: new_score = Score(entity=new_entity, question=q, score=answers[answer]) session.add(new_score) session.commit() except: session.rollback() print("Error: Could not save patient scores to database") return new_entity.name
def test_default_projtype_toomany_args(self): '''check status code of `entree blah blah` ''' modname = random_string(16) code = run_command('entree {0} {0}'.format(modname)) self.assertEqual(code, 6) if os.path.exists(modname): shutil.rmtree(modname)
def test_no_projtype_single(self): '''check status code of `entree blah.py -s` ''' modname = random_string(16) code = run_command('entree {0} -s'.format(modname)) self.assertEqual(code, 0) if os.path.exists(modname): os.remove(modname)
def make_payload(size): wrapper_overhead = len(json.dumps(minimum_payload)) if size == 0: return zero_size_payload elif size <= wrapper_overhead: return minimum_payload else: return {"payload": random_string(length=size - wrapper_overhead - 7)}
def test_create_general_file_nofile(self): '''Test create_dirs() ''' rootdir = random_string(16) path_a = os.path.join(rootdir, 'a') with self.assertRaises(IOError): entree.utils.create_general_file(path_a, "AAAAA") self.assertFalse(os.path.exists(path_a))
def test_no_projtype_dir(self): '''check status code of `entree blah.py -d blah` ''' with TMPFile() as rootdir: modname = random_string(16) code = run_command('entree {0} -d {1}'.format(modname, rootdir)) self.assertEqual(code, 0) if os.path.exists(modname): os.remove(modname)
def test_simple(self): '''check status code of `entree python blah` ''' for project_cls in CLSNAMES: modname = random_string(16) code = run_command('entree {0} {1}'.format(project_cls, modname)) self.assertEqual(code, 0) if os.path.exists(modname): shutil.rmtree(modname)
def test_add(self): '''check status code of `entree python -a -d rootdir blah` ''' for project_cls in CLSNAMES: modname = random_string(16) with TMPFile() as rootdir: cmd = 'entree {0} -a -d {1} {2}'.format(project_cls, rootdir, modname) code = run_command(cmd) self.assertEqual(code, 0)
def test_add(self): '''check status code of `entree python -a -d rootdir blah` ''' for project_cls in CLSNAMES: modname = random_string(16) with TMPFile() as rootdir: cmd = 'entree {0} -a -d {1} {2}'.format( project_cls, rootdir, modname) code = run_command(cmd) self.assertEqual(code, 0)
def test_random_string(self): import string self.assertEqual(len(utilities.random_string(15)), 15) self.assertEqual(utilities.random_string(5, ['a']), 'aaaaa') # Verify distribution is reasonably random letter_frequencies = collections.defaultdict(lambda: 0) for _ in range(1, 10000): for letter in utilities.random_string(16): letter_frequencies[letter] += 1 standard_deviation = self.__standard_deviation( letter_frequencies.values()) self.assertLessEqual( standard_deviation, 100, "Standard deviation of letter frequency is too high! Are you sure it is random?" )
def test_single(self): '''check status code of `entree python -s blah` ''' for project_cls in CLASSES: clsname = project_cls.__name__.lower() modname = random_string(16) cmd = 'entree {0} -s {1}'.format(clsname, modname) if project_cls.single_file: code = run_command(cmd) self.assertEqual(code, 0) if os.path.exists(modname): os.remove(modname)
def test_create_dirs_norootdir(self): '''Test create_dirs() ''' rootdir = random_string(16) path_a = os.path.join(rootdir, 'a') path_b = os.path.join(rootdir, 'b') path_c = os.path.join(rootdir, 'c') with self.assertRaises(IOError): entree.utils.create_dirs(rootdir, path_a, path_b, path_c) self.assertFalse(os.path.exists(rootdir)) self.assertFalse(os.path.exists(path_a)) self.assertFalse(os.path.exists(path_b)) self.assertFalse(os.path.exists(path_c))
def make_message_payload(size=64): """ make a random message payload with the given size """ wrapper_overhead = len(json.dumps({"payload": ""})) if size == 0: return zero_size_payload elif size <= wrapper_overhead: return minimum_payload else: return { "payload": utilities.random_string(length=size - wrapper_overhead) }
def test_partial2(self): '''check status code of `entree python -d dir -p partial blah` Status should be 1 if there is no `partial_builds` in the project config or if the partial name does not exist in `partial_builds`, should be 0 otherwise. ''' for project_cls in CLASSES: clsname = project_cls.__name__.lower() modname = random_string(16) with TMPFile() as rootdir: config = project_cls.get_config() if 'partial_builds' in config: cmd = 'entree {0} -d {1} -p {2} {2}'.format( clsname, rootdir, modname) code = run_command(cmd) self.assertEqual(code, 1)
def test_partial2(self): '''check status code of `entree python -d dir -p partial blah` Status should be 1 if there is no `partial_builds` in the project config or if the partial name does not exist in `partial_builds`, should be 0 otherwise. ''' for project_cls in CLASSES: clsname = project_cls.__name__.lower() modname = random_string(16) with TMPFile() as rootdir: config = project_cls.get_config() if 'partial_builds' in config: cmd = 'entree {0} -d {1} -p {2} {2}'.format( clsname, rootdir, modname ) code = run_command(cmd) self.assertEqual(code, 1)
def setUp(self): '''Create a fake file structure to test ''' self.template_dir = random_string(16) os.makedirs(self.template_dir) self.path_a = os.path.join(self.template_dir, 'a') self.path_b = os.path.join(self.template_dir, 'b') self.path_c = os.path.join(self.template_dir, 'c') entree.utils.create_dirs(self.template_dir, self.path_a, self.path_b, self.path_c) self.file_a = os.path.join(self.path_a, 'a.txt') self.file_b = os.path.join(self.path_b, 'b.md') self.file_c = os.path.join(self.path_c, 'c_py.template') entree.utils.create_general_file(self.file_a, "My name is") entree.utils.create_general_file(self.file_b, "{{ name }}") entree.utils.create_general_file(self.file_c, "I'm {{ blah['age'] }} years old.")
def test_string(): return random_string("String1")
def setUp(self): '''Setting up ''' self.modname = random_string(16)
def blob_name(self): return utilities.random_string()
def next_random_string(prefix): global string_index string_index = string_index + 1 return random_string("{} {}".format(prefix, string_index))
# Copyright (c) Microsoft. All rights reserved. # Licensed under the MIT license. See LICENSE file in the project root for # full license information. from utilities import random_string import pytest import json string_1K = random_string(prefix="1K-chars", length=1024) string_64K = random_string(prefix="64K-chars", length=64 * 1024) object_with_3_layers = { "layer_1_string": random_string("1"), "layer_2": { "layer_2_string": random_string("2"), "layer3": {"fake_number": 3, "fake_real_number": 1.87}, }, } telemetry_test_objects = [ pytest.param(string_1K, id="1K character string"), pytest.param(string_64K, id="64k character string"), pytest.param(object_with_3_layers, id="object with 3 layers"), ]
def test_string_2(): return random_string("String2")