def genid(doc_tag):
"""
Doc Tags: String( doc, app, key, job, user, item, code,task,name)
UseCase:
>>> import genny
>>> from genny import genid
>>> from genny import genid as gi
>>> id = genny.genid('user')
>>> id = genid('user')
>>> id = gi('user')
Yeilds ... U474390
... U77301642
... U1593055
"""
tags = dict(
doc='[h-z5-9]{8:16}',
app='[a-z0-9]{16:32}',
key='[a-z0-9]{32:32}',
job='[a-j0-7]{8:8}',
user='******',
item='[a-n1-9]{8:8}',
code='[a-x2-8]{24:32}'
)
if doc_tag == 'user':
u_id = StringGenerator(str(tags[doc_tag])).render(unique=True)
u_id = 'U{}'.format(u_id)
else:
u_id = StringGenerator(str(tags[doc_tag])).render(unique=True)
return u_id
def generate(self):
discordToken = StringGenerator(self.regularExpression).render()
discordToken = discordToken.replace("..", ".")
discordToken = str(id) + discordToken
print(discordToken)
self.generated += 1
self.write(discordToken)
def buildDig(self):
strdig = ''
if random.randint(1, 2) % 2 == 0:
strdig += '-'
strdig += StringGenerator('[1-9]{1}').render()
strdig += StringGenerator('[0-9]{1:15}').render()
return strdig
def generate_string(amount):
for _count in range(amount):
result = StringGenerator(r'<-[!\l]{1}[\l0-9]{0:15}').render()
for i in range(rn.choice(range(5))):
variable = StringGenerator(r'[!\l]{1}[\l0-9]{0:15}').render()
operator = StringGenerator(r'[\&\|^]').render()
result += (operator + variable)
result += '#'
yield result
def buildStrLit(self):
strlit = ''
if random.randint(1, 2) % 2 == 0:
strlit += '-'
if random.randint(1, 2) % 2 == 0:
strlit += str(random.randint(1, 9))
strlit += StringGenerator('[\d]{1:3}').render()
else:
strlit = StringGenerator('[a-zA-Z]{1}').render()
strlit += StringGenerator('[\w]{1:15}').render()
return strlit
def test_RegistrationSellerSuccess(self):
url = self.base_url + '/signup'
url2 = self.base_url + '/login'
text1 = 'Success!'
text2 = 'Please, check your email and follow the verification link to complete you registration.'
text3 = 'After you finish, come back and'
# Get random string ( \c: lowercase, \l: - letters, {5} - number of leters)
x = StringGenerator('[\c]{3}').render()
# Get random numbers string ( \d: digits, {9} - number of leters)
y = StringGenerator('[\d]{9}').render()
z = StringGenerator('[\d]{5}').render()
firstName = 'Sveta' + x
lastName = 'Test' + x
login = '******' + x
login2 = login
password = '******'
password2 = 'Ss123456'
email = 'svetatestbox' + "+" + z + '@gmail.com'
phone = '+380' + y
address = "New Street 567"
address2 = address
city = 'Boston'
state = '22'
code = '8765'
country = '199'
ppFirstName = 'Sveta'
ppLastName = 'Stepanova'
ppEmail = '*****@*****.**'
driver = self.driver
driver.get(self.base_url)
HelperTestBase.clickAndWait(self, "[data-test-id='signupBtn']")
self.assertEqual(url, HelperTestBase.getURL(self))
RegistrationPage.switchShopperSeller(self)
RegistrationPage.registration(self, firstName, lastName, login, login2,
password, password2, ppFirstName,
ppLastName, ppEmail, email, phone,
address, address2, city, state, code,
country)
time.sleep(7)
self.assertIn(text1, self.driver.page_source)
self.assertIn(text2, self.driver.page_source)
self.assertIn(text3, self.driver.page_source)
HelperTestBase.wait(self, "[data-test-id='loginLink2']")
HelperTestBase.click(self, "[data-test-id='loginLink2']")
HelperTestBase.wait(self, "[data-test-id='loginBtn']")
self.assertEqual(url2, HelperTestBase.getURL(self))
def setUp(self):
xbridge_utils.generate_new_set_of_data(
data_nature=xbridge_utils.INVALID_DATA,
char_min_size=1,
char_max_size=10000)
# Valid data
self.valid_txid = xbridge_utils.generate_random_valid_txid()
self.valid_src_Address = xbridge_utils.generate_random_valid_address()
self.valid_dest_Address = xbridge_utils.generate_random_valid_address()
# Invalid data from garbage character classes
self.invalid_txid = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(1, 5000))
self.invalid_src_Address = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(1, 5000))
self.invalid_dest_Address = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(1, 5000))
self.long_txid = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(10000, 12000))
self.long_src_Address = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(10000, 12000))
self.long_dest_Address = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(10000, 12000))
# Invalid data from random character classes
self.input_str_from_random_classes_1 = xbridge_utils.generate_input_from_random_classes_combinations(
1, 4000)
self.input_str_from_random_classes_2 = xbridge_utils.generate_input_from_random_classes_combinations(
9000, 12000)
self.input_str_from_random_classes_3 = xbridge_utils.generate_input_from_random_classes_combinations(
1, 100)
valid_token = xbridge_utils.generate_random_valid_token()
self.token_pool = [valid_token, xbridge_utils.c_src_Token]
valid_address = xbridge_utils.generate_random_valid_address()
invalid_address_short = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(1, 40))
invalid_address_med = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(1, 5000))
invalid_address_long = xbridge_utils.generate_garbage_input(
xbridge_utils.generate_random_number(5000, 15000))
self.address_pool = [
valid_address, invalid_address_short, invalid_address_med,
invalid_address_long
]
# Test many combinations of 0 to 10 000 white spaces
self.simple_whitespace = ""
self.whitespace_str_1 = StringGenerator('[\s]{1:10000}').render()
self.whitespace_str_2 = StringGenerator('[\s]{1:10000}').render()
self.whitespace_str_3 = StringGenerator('[\s]{1:10000}').render()
self.whitespace_pool = [
self.simple_whitespace, self.whitespace_str_1,
self.whitespace_str_2, self.whitespace_str_3
]
def buildFalseStr(self, num):
choice = random.randint(1, 14)
choice1 = random.randint(2, 14)
# print(num, ' : ', choice, ' ', choice1)
if choice == 12 or choice1 == 12:
nstr = 'a'
elif choice == 13 or choice1 == 13:
nstr = ''
elif choice == 14 or choice1 == 14:
nstr = '-' + str(num) + ' '
else:
nstr = str(num) + ' '
if choice == 2 or choice1 == 2:
namevar = self.digNameVar()
elif choice == 3 or choice1 == 3:
namevar = self._longNameVar()
else:
namevar = self.buildNameVar()
if choice == 4 or choice1 == 4:
nstr += namevar + StringGenerator(' [\&\/\{\)] ').render()
elif choice == 5 or choice1 == 5:
nstr += namevar + '='
elif choice == 6 or choice1 == 6:
nstr += namevar + ' '
else:
nstr += namevar + ' = '
if random.randint(1, 2) % 2 == 0:
nstr += namevar
else:
nstr += self.buildStrLit()
if choice == 7 or choice1 == 7:
nstr += StringGenerator(' [\&\#\{\)] ').render()
elif choice == 11 or choice1 == 11:
nstr += ' '
else:
nstr += self.chooseOperator()
if choice == 8 or choice1 == 8:
nstr += self.chooseOperator()
return nstr
elif choice == 9 or choice1 == 9:
strlit = '0' + StringGenerator('[\d]{1:3}').render()
elif choice == 10 or choice1 == 10:
strlit = StringGenerator('[\d]{1:3}').render() + '-'
else:
strlit = self.buildStrLit()
nstr += strlit
i = random.randint(0, 10)
while i > 0:
nstr += self.buildOperLitstr(namevar)
i -= 1
return nstr
def uu_id(doc_tag):
"""
Doc Tags: String( doc, app, job, user, item)
"""
tags = dict(doc='[h-z5-9]{8:16}',
app='[a-z0-9]{16:32}',
job='[a-j0-7]{8:8}',
user='******',
item='[a-n1-9]{8:8}')
if doc_tag == 'user':
u_id = StringGenerator(tags[doc_tag]).render(unique=True)
u_id = 'U{}'.format(u_id)
else:
u_id = StringGenerator(tags[doc_tag]).render(unique=True)
return u_id
def nameid(fn='Jane',ln='Dear',sec=5):
"""
Name Identification by initials fn='Jane', ln='Dear' and given number sequence sec=5.
UseCase:
>>> import genny
>>> from genny import nameid
>>> from genny import nameid as nid
>>> id = genny.nameid('Peter','Built',6)
>>> id = nameid('Peter','Built',5)
>>> id = nid('Peter','Built',4)
>>> id = nid() # default false id
Yeilds ... PB474390
... PB77301
... PB1593
... JD1951
"""
code = '[0-9]{4:%s}'% int(sec)
prefix = '{fni}{lni}'.format(fni=fn[0].capitalize(),lni=ln[0].capitalize())
u_id = StringGenerator(str(code)).render(unique=True)
u_id = '{pre}{id}'.format(pre=prefix,id=u_id)
return u_id
def shorteventid(event,event_code,sec=2):
"""
Event Identification by initials fn='Jane', ln='Dear' and given number sequence sec=2.
UseCase:
>>> import genny
>>> from genny import shorteventid
>>> from genny import shorteventid as id
>>> id = genny.shorteventid('Product','LAUNCH',2)
>>> id = shorteventid('Product','LAUNCH')
>>> id = id('Product', 'LAUNCH',3)
Yeilds ... PROLAUNCH-88
... PROLAUNCH-90
... PROLAUNCH-461
"""
code = '[0-9]{2:%s}'% int(sec)
prefix = '{fni}{lni}'.format(fni=event[:3].upper(),lni=event_code)
u_id = StringGenerator(str(code)).render(unique=True)
u_id = '{pre}-{id}'.format(pre=prefix,id=u_id)
return u_id
def get_words():
"""Returns 300 random words based on query's mode."""
mode = request.args.get('mode')
if mode is None or mode not in ['basic', 'numerical', 'random']:
logging.error('Missing "mode" parameter when retrieving random words.')
raise BadRequest('Unknown mode')
if mode == 'basic':
size = 200
collection = WordModel.query.limit(size)
words = [
collection[random.randint(0, size - 1)].value for i in range(300)
]
return jsonify(words), 200
elif mode == 'numerical':
words = []
size = 18
collection = UnitModel.query.all()
for i in range(300):
prefix = str(random.randint(1, 1000))
suffix = str(collection[random.randint(0, size - 1)].value)
words.append(prefix + suffix)
return jsonify(words), 200
elif mode == 'random':
words = []
for i in range(300):
words.append(
StringGenerator('[\w\p\d]{'
f'{random.randint(1, 8)}'
'}').render())
return jsonify(words), 200
def parsing():
while True:
val = StringGenerator("[\d\w]{6}").render().lower()
url = domlink + val
r = requests.get(url, headers=user_agents)
if r.status_code == 200:
html = r.text
soup = BeautifulSoup(html, 'lxml')
try:
t = soup.find("img",
crossorigin="anonymous",
alt="Lightshot screenshot",
id="screenshot-image")
link = t["src"]
except:
continue
name = link.split('/')[-1]
if link.split("/")[0] == "https:":
urllib.request.urlretrieve(link, name)
print(Fore.BLUE + "found: " + url + ". " + name +
" saved to " + os.getcwd())
def generador():
contenido = StringGenerator(
"[\A\B\C\D\E\F\G\H\I\J\K\L\M]{20}").render_list(1, unique=True)
arch = open("./111.txt", "w")
cont = str(contenido)
arch.write(cont)
arch.close()
def shortnameid(fn='Jane',ln='Dear',sec=2):
"""
Name Identification by initials fn='Jane', ln='Dear' and given number sequence sec=5.
UseCase:
>>> import genny
>>> from genny import shortnameid
>>> from genny import shortnameid as id
>>> id = genny.shortnameid('Peter','Built',2)
>>> id = shortnameid('Peter','Built')
>>> id = id(p','b',3)
>>> id = id() # default false id
Yeilds ... PB47
... PB54
... PB69
... JD19
"""
code = '[0-9]{2:%s}'% int(sec)
prefix = '{fni}{lni}'.format(fni=fn[0].capitalize(),lni=ln[0].capitalize())
u_id = StringGenerator(str(code)).render(unique=True)
u_id = '{pre}{id}'.format(pre=prefix,id=u_id)
return u_id
def test_invalid_accept_tx_2(self):
# Test many combinations of 0 to 10 000 white spaces
self.assertIsInstance(
xbridge_client.CHECK_ACCEPT_TX(
StringGenerator('[\s]{0:10000}').render(),
StringGenerator('[\s]{0:10000}').render(),
StringGenerator('[\s]{0:10000}').render()), dict)
self.assertIsInstance(
xbridge_client.CHECK_ACCEPT_TX("", self.valid_src_Address,
self.valid_dest_Address), dict)
self.assertIsInstance(
xbridge_client.CHECK_ACCEPT_TX(self.valid_txid, "",
self.valid_dest_Address), dict)
self.assertIsInstance(
xbridge_client.CHECK_ACCEPT_TX(self.valid_txid,
self.invalid_src_Address, ""), dict)
self.assertIsInstance(xbridge_client.CHECK_ACCEPT_TX("", "", ""), dict)
def rex_gen(rex_arg):
"""
Repackage string generator render functionality to generate words based on regexp pattern
:return: regexp word
:example: Playground.rex_gen('[a-zA-Z0-9]{19}')
"""
rex_word = StringGenerator(rex_arg).render()
return rex_word
def __init__(self, category=None, *args, **kwargs):
super(EsmoSpider, self).__init__(*args, **kwargs)
unique_id = SG("[\l\d]{10}").render()
date_object = str(datetime.now().day) + str(
datetime.now().month) + str(datetime.now().year)
date_object = str(date_object) + "_" + str(
datetime.now().time()).replace(":", "_").split(".")[0]
unique_id = date_object + "_" + unique_id
unique_id = unique_id.replace(" ", "_").strip()
self.CRAWL_NEW_ID = unique_id
data_dict = {
"crawl_id": self.CRAWL_NEW_ID,
"conf": "esmo",
"start_datetime": datetime.now(),
"end_datetime": "",
"status": "running",
}
my_database.crawl_initiate.insert_one(data_dict)
def main():
create_topic('Apache')
count = 1
while(1):
msgs = StringGenerator('[\\w\\p\\d]{20}').render_list(10,unique=True)
msgs = [publisher_name + "-" + str(count) + ":" + msg for msg in msgs]
print(msgs)
publish_to_topic('Apache',msgs)
count += 1
sleep(1)
def get_order(request) -> Order:
session = request.session
session['user_id'] = session.get('user_id', StringGenerator('[\w\p\d]{32}').render())
session.set_expiry(0)
user_id, created = UserID.objects.get_or_create(user_id=session['user_id'])
order, created = Order.objects.get_or_create(user_id=user_id,
defaults={'customer_name': '',
'customer_address': '',
'order_date': datetime.now()})
return order
def test_invalid_get_tx_info_6(self):
string_lower_bound = 1
string_upper_bound = 4000
for itm in [
xbridge_utils.one_classes_list, xbridge_utils.two_classes_list,
xbridge_utils.three_classes_list,
xbridge_utils.four_classes_list,
xbridge_utils.five_classes_list
]:
for sub_item in itm:
with self.subTest(sub_item=sub_item):
try:
clss_str = sub_item + "{" + str(
string_lower_bound) + ":" + str(
string_upper_bound) + "}"
generated_str = StringGenerator(clss_str).render()
self.assertIsInstance(
xbridge_rpc.get_tx_info(generated_str), list)
log_json = {
"group": "test_invalid_get_tx_info_6",
"success": 1,
"failure": 0,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {
"group": "test_invalid_get_tx_info_6",
"success": 0,
"failure": 1,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_invalid_get_tx_info_6 FAILED: %s' %
str(json_excpt))
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'param: %s \n' %
str(generated_str)[:MAX_LOG_LENGTH])
except JSONRPCException as json_excpt:
log_json = {
"group": "test_invalid_get_tx_info_6",
"success": 0,
"failure": 0,
"error": 1
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_invalid_get_tx_info_6 ERROR: %s' %
str(json_excpt))
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'param: %s \n' %
str(generated_str)[:MAX_LOG_LENGTH])
def test_registrationUnSuccess8(self):
url = self.base_url + '/signup'
text1 = 'Error:'
text2 = 'Please, check all the fields for completeness or typos.'
# Get random letters string ( \c: lowercase, \l: - letters, {5} - number of leters)
x = StringGenerator('[\c]{5}').render()
# Get random numbers string ( \d: digits, {9} - number of leters)
y = StringGenerator('[\d]{9}').render()
firstName = 'sveta' + x
lastName = 'test' + x
login = '******' + x
login2 = login
password = '******'
password2 = 'Ff123456'
ppEmail = x + '@gmail.com'
ppFirstName = 'Svitlana'
ppLastName = 'Stepanova'
phone = '+380' + y
address = "Nauky Street"
address2 = "Street"
city = 'Kharkov'
state = '15'
code = '8765'
email = 'test' + x + '@example.com'
country = '11'
driver = self.driver
driver.get(self.base_url)
LoginPage.clickSignUpButton(self)
self.assertEqual(url, HelperTestBase.getURL(self))
RegistrationPage.registration(self, firstName, lastName, login, login2,
password, password2, ppFirstName,
ppLastName, ppEmail, email, phone,
address, address2, city, state, code,
country)
self.assertEqual(text1, HelperTestBase.getModalHeader(self))
self.assertEqual(text2, HelperTestBase.getModalMessage(self))
HelperTestBase.clickYesButton(self)
self.assertEqual(url, HelperTestBase.getURL(self))
def test_invalid_sign_4(self):
string_lower_bound = 1
string_upper_bound = 4000
for itm in [
xbridge_utils.one_classes_list, xbridge_utils.two_classes_list,
xbridge_utils.three_classes_list,
xbridge_utils.four_classes_list,
xbridge_utils.five_classes_list
]:
for sub_item in itm:
with self.subTest(sub_item=sub_item):
clss_str = sub_item + "{" + str(
string_lower_bound) + ":" + str(
string_upper_bound) + "}"
try:
generated_str = StringGenerator(clss_str).render()
self.assertRaises(
xbridge_custom_exceptions.ValidBlockNetException,
xbridge_rpc.signrawtransaction, generated_str)
log_json = {
"group": "test_invalid_sign_4",
"success": 1,
"failure": 0,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
except AssertionError as ass_err:
log_json = {
"group": "test_invalid_sign_4",
"success": 0,
"failure": 1,
"error": 0
}
xbridge_utils.ERROR_LOG.append(log_json)
xbridge_logger.logger.info(
'test_invalid_sign_4 FAILED: %s' % ass_err)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'param: %s \n' %
str(generated_str)[:MAX_LOG_LENGTH])
except JSONRPCException as json_excpt:
log_json = {
"group": "test_invalid_sign_4",
"success": 0,
"failure": 0,
"error": 1
}
xbridge_logger.logger.info(
'test_invalid_sign_4 ERROR: %s' % json_excpt)
if MAX_LOG_LENGTH > 0:
xbridge_logger.logger.info(
'param: %s \n' %
str(generated_str)[:MAX_LOG_LENGTH])
xbridge_utils.ERROR_LOG.append(log_json)
def generate_token_and_secret(reader):
""" Generates a JWT for a user, according to the common standards. """
secret = StringGenerator("[a-zA-Z1-9]{255}").render()
header = {'alg': 'HS256', 'typ': 'JWT'}
payload = {'id': reader.id, 'pseudo': reader.pseudo}
token = jwt.encode(payload, secret, algorithm='HS256', headers=header)
return token, secret
def test_registrationInvalidFields2(self):
pageTitle = 'BiziBAZA'
text1 = 'Error:'
text2 = 'Please, check all the fields for completeness or typos.'
# Get random letters string ( \c: lowercase, \l: - letters, {5} - number of leters)
x = StringGenerator('[\c]{5}').render()
# Get random numbers string ( \d: digits, {9} - number of leters)
z = StringGenerator('[\d]{3}').render()
y = StringGenerator('[\d]{9}').render()
firstName = ' curubo'
lastName = ' curubo'
login = '******'
login2 = login
password = '******'
password2 = password
email = 'stepanova+' + z + '@dnt-lab.com'
ppEmail = ' [email protected]'
ppFirstName = ' curubo'
ppLastName = ' curubo'
phone = '+380' + y
address = ' curubo'
address2 = address
city = ' curubo'
state = '15'
code = '8765'
country = '11'
driver = self.driver
driver.get(self.base_url)
LoginPage.clickSignUpButton(self)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
RegistrationPage.registration(self, firstName, lastName, login, login2,
password, password2, ppFirstName,
ppLastName, ppEmail, email, phone,
address, address2, city, state, code,
country)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
self.assertEqual(text1, HelperTestBase.getModalHeader(self))
self.assertEqual(text2, HelperTestBase.getModalMessage(self))
HelperTestBase.clickYesButton(self)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
def test_registrationWithoutCountry(self):
pageTitle = 'BiziBAZA'
text1 = 'Error:'
text2 = 'Please, check all the fields for completeness or typos.'
# Get random letters string ( \c: lowercase, \l: - letters, {5} - number of leters)
x = StringGenerator('[\c]{5}').render()
# Get random numbers string ( \d: digits, {9} - number of leters)
y = StringGenerator('[\d]{9}').render()
firstName = 'sveta' + x
lastName = 'test' + x
login = '******' + x
login2 = login
password = '******'
password2 = 'Ss1234567'
phone = '+380' + y
address = "Street 1"
address2 = "apppartment 23"
city = 'Boston'
state = '15'
code = '8765'
email = 'test' + x + '@example.com'
country = '0'
ppFirstName = 'Svitlana'
ppLastName = 'Stepanova'
ppEmail = '*****@*****.**'
driver = self.driver
driver.get(self.base_url)
LoginPage.clickSignUpButton(self)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
RegistrationPage.registrationWitoutCountry(self, firstName, lastName,
login, login2, password,
password2, ppFirstName,
ppLastName, ppEmail, email,
phone, address, address2,
city, state, code, country)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
self.assertEqual(text1, HelperTestBase.getModalHeader(self))
self.assertEqual(text2, HelperTestBase.getModalMessage(self))
HelperTestBase.clickYesButton(self)
self.assertEqual(pageTitle, RegistrationPage.getTitle(self))
def test_unseeded_randomizer(self):
# provide a seed to get consistent results
pattern = r"[\w]{10}&([\d]{10}|M3W9MF_lH3906I14O50)"
sg = SG(pattern)
s1 = sg.render()
sg = SG(pattern)
s2 = sg.render()
assert s1 != s2
sg = SG(pattern)
list1 = sg.render_list(100)
sg = SG(pattern)
list2 = sg.render_list(100)
assert collections.Counter(list1) != collections.Counter(list2)
def generate(cls, app, user, invalid_usernames=None):
"""Generate account credentials for user."""
from strgen import StringGenerator
invalid_usernames = invalid_usernames or []
username = user.username
for c in ['@', ':', '/']:
username = username.replace(c, ".")
base_username = username
unique_counter = 1
while username in invalid_usernames:
username = "******" % (base_username, unique_counter)
unique_counter += 1
password = StringGenerator("[\w\d]{20}").render()
return cls(user=user, app=app, username=username, password=password)
def test_invalid_cancel_2(self):
string_length=64
for itm in [xbridge_utils.one_classes_list, xbridge_utils.two_classes_list, xbridge_utils.three_classes_list, xbridge_utils.four_classes_list, xbridge_utils.five_classes_list]:
for sub_item in itm:
with self.subTest(sub_item=sub_item):
clss_str = sub_item + "{" + str(string_length) + "}"
try:
generated_str = StringGenerator(clss_str).render()
self.assertIsInstance(xbridge_rpc.cancel_tx(generated_str), dict)
xbridge_logger.XLOG("test_invalid_cancel_2", 0)
except AssertionError as ass_err:
xbridge_logger.XLOG("test_invalid_cancel_2", 1, ass_err, [generated_str])
except JSONRPCException as json_excpt:
xbridge_logger.XLOG("test_invalid_cancel_2", 2, json_excpt, [generated_str])
def test_seeded_randomizer(self):
# provide a seed to get consistent results
pattern = r"[\w]{10}&([\d]{10}|M3W9MF_lH3906I14O50)"
for seed in [random.randint(1, 100000000) for _ in range(100)]:
sg = SG(pattern, seed=seed)
s1 = sg.render()
sg = SG(pattern, seed=seed)
s2 = sg.render()
assert s1 == s2
sg = SG(pattern, seed=seed)
list1 = sg.render_list(100)
sg = SG(pattern, seed=seed)
list2 = sg.render_list(100)
assert collections.Counter(list1) == collections.Counter(list2)
case2 = timeit.timeit(
'shuffle(["".join(choice(string.letters) for i in xrange(10))]+["".join(choice(string.digits) for i in xrange(2))])',
setup='import string;import random;choice = random.SystemRandom().choice;shuffle = random.SystemRandom().shuffle',
number=r)
print("Standard method (complex): %s seconds" % round(case2, 2))
print("Standard method - StringGenerator (complex): %s (%s%%)" %
(str((case1 - case2)), str(round(100 * (case1 - case2) / case1, 2))))
from strgen import StringGenerator as SGPIP
import time
import imp
strgen = imp.load_source('strgen', 'strgen/__init__.py')
sg1 = strgen.StringGenerator('[\d]{100}')
sg2 = SGPIP('[\d]{100}')
s = time.time()
for i in xrange(10000):
sg1.render()
c1 = time.time() - s
print("StringGenerator: %s seconds" % round(c1, 2))
s = time.time()
for i in xrange(10000):
sg2.render()
c2 = time.time() - s
print("StringGenerator PIP: %s seconds" % round(c2, 2))
