def generate_fake(cls, count=100, org=None):
import uuid
import datetime
from orgs.models import Organization
from common.utils import random_string
if not org:
org = Organization.default()
d = datetime.datetime.now() - datetime.timedelta(days=1)
commands = [
cls(**{
'user': random_string(6),
'asset': random_string(10),
'system_user': random_string(6),
'session': str(uuid.uuid4()),
'input': random_string(16),
'output': random_string(64),
'timestamp': int(d.timestamp()),
'org_id': str(org.id)
})
for i in range(count)
]
cls.objects.bulk_create(commands)
print(f'Create {len(commands)} commands of org ({org})')
def create_token(self, user, asset, application, system_user, ttl=5 * 60):
# 再次强调一下权限
perm_required = 'authentication.add_superconnectiontoken'
if user != self.request.user and not self.request.user.has_perm(perm_required):
raise PermissionDenied('Only can create user token')
self.check_resource_permission(user, asset, application, system_user)
token = random_string(36)
secret = random_string(16)
value = {
'id': token,
'secret': secret,
'user': str(user.id),
'username': user.username,
'system_user': str(system_user.id),
'system_user_name': system_user.name,
'created_by': str(self.request.user),
'date_created': str(timezone.now())
}
if asset:
value.update({
'type': 'asset',
'asset': str(asset.id),
'hostname': asset.hostname,
})
elif application:
value.update({
'type': 'application',
'application': application.id,
'application_name': str(application)
})
key = self.CACHE_KEY_PREFIX.format(token)
cache.set(key, value, timeout=ttl)
return token, secret
def create_token(self, user, asset, application, system_user, ttl=None):
self.check_resource_permission(user, asset, application, system_user)
token = random_string(36)
secret = random_string(16)
value = {
'id': token,
'secret': secret,
'user': str(user.id),
'username': user.username,
'system_user': str(system_user.id),
'system_user_name': system_user.name,
'created_by': str(self.request.user),
'date_created': str(timezone.now())
}
if asset:
value.update({
'type': 'asset',
'asset': str(asset.id),
'hostname': asset.hostname,
})
elif application:
value.update({
'type': 'application',
'application': application.id,
'application_name': str(application)
})
self.set_token_to_cache(token, value, ttl)
return token, secret
def test_aes_encrypt_decrypt(self):
cls = self.__class__
key = random_string(crypto.AES_KEY_SIZE)
iv = random_string(crypto.AES_IV_SIZE)
plain_text = random_string(crypto.AES_BLOCK_SIZE
* random.randint(0, 1023))
# Encrypt the same plain text using all the available methods,
# and ensure all the results match.
results = {name: encrypt(key, iv, plain_text)
for name, (avail, encrypt, decrypt)
in cls.__AES_METHODS.iteritems()}
encrypted_text = results.values()[0]
self.assertEqual(len(encrypted_text),
len(plain_text))
for k, v in results.iteritems():
self.assertEqual(v, encrypted_text, msg = k)
# Now decrypt the same encrypted text using all the available methods,
# and ensure all the results match to the original plain text.
results = {name: decrypt(key, iv, encrypted_text)
for name, (avail, encrypt, decrypt)
in cls.__AES_METHODS.iteritems()}
for k, v in results.iteritems():
self.assertEqual(v, plain_text, msg = k)
def get(request):
data = {
"access_token": random_string(100),
"expires_in": 7200,
"refresh_token": random_string(100),
"openid": random_string(28),
"scope": "SCOPE"
}
return Response(data)
def __init__(self,
email=None,
password="******",
confirm_password="******",
first_name="James",
last_name="Brown",
address_1="Jacksonville 779",
address_2="Suite 120",
city="Los Angeles",
state="CA",
zip_code="12345",
country="US",
phone="876-55-44-33",
user_level="admin"):
if email:
self.email = email
else:
self.email = "myemail+" + random_string(6) + "@gmail.com"
self.password = password
self.confirm_password = confirm_password
self.first_name = first_name
self.last_name = last_name
self.address_1 = address_1
self.address_2 = address_2
self.city = city
self.state = state
self.zip_code = zip_code
self.country = country
self.phone = phone
self.user_level = user_level
super().__init__()
def get(request):
subscribe = random.randint(0, 1)
if subscribe:
data = {
"subscribe": subscribe,
"openid": request.query_params["openid"],
"nickname": random_string(6),
"sex": 1,
"language": "zh_CN",
"city": "广州",
"province": "广东",
"country": "中国",
"headimgurl": "http://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc5"
"6vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/0",
"subscribe_time": 1382694957,
"unionid": " o6_bmasdasdsad6_2sgVt7hMZOPfL",
"remark": "",
"groupid": 0,
"tagid_list": [128, 2],
"subscribe_scene": "ADD_SCENE_QR_CODE",
"qr_scene": 98765,
"qr_scene_str": ""
}
else:
data = {
"subscribe": subscribe
}
return Response(data)
def test_email_is_lowercased(self, users_api):
user = users_api.create_user()
email = "MYEMAIL+" + random_string(6) + "@gmail.com"
users_api.payload.email = email
response = users_api.update_user(user.json()['id'])
assert response.status_code == 200
assert response.json()['email'] == email.lower()
def create_token(self, user, asset, application, system_user, ttl=5 * 60):
if not self.request.user.is_superuser and user != self.request.user:
raise PermissionDenied('Only super user can create user token')
self.check_resource_permission(user, asset, application, system_user)
token = random_string(36)
value = {
'user': str(user.id),
'username': user.username,
'system_user': str(system_user.id),
'system_user_name': system_user.name
}
if asset:
value.update({
'type': 'asset',
'asset': str(asset.id),
'hostname': asset.hostname,
})
elif application:
value.update({
'type': 'application',
'application': application.id,
'application_name': str(application)
})
key = self.CACHE_KEY_PREFIX.format(token)
cache.set(key, value, timeout=ttl)
return token
def get(request):
data = {
"errcode": 0,
"errmsg": "ok",
"ticket": random_string(86),
"expires_in": 7200
}
return Response(data)
def __init__(self, handler, stream, storage):
super().__init__()
self._id = random_string(40)
self._stream = stream
self._handler = handler
self._storage = storage()
self._stream.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self._stream.socket.setsockopt(socket.IPPROTO_TCP, socket.SO_KEEPALIVE, 1)
self._stream.set_close_callback(self.on_disconnect)
def create(self, validated_data):
request = self.context.get('request')
if not request or not request.user:
raise PermissionError()
secret = random_string(36)
username = request.user.username
kwargs = {
'username': username, 'secret': secret,
'date_expired': timezone.now() + timezone.timedelta(seconds=5*60),
}
token = TempToken(**kwargs)
token.save()
return token
def create_bearer_token(self, request=None):
expiration = settings.TOKEN_EXPIRATION or 3600
if request:
remote_addr = request.META.get('REMOTE_ADDR', '')
else:
remote_addr = '0.0.0.0'
if not isinstance(remote_addr, bytes):
remote_addr = remote_addr.encode("utf-8")
remote_addr = base64.b16encode(remote_addr) # .replace(b'=', '')
cache_key = '%s_%s' % (self.id, remote_addr)
token = cache.get(cache_key)
if not token:
token = random_string(36)
cache.set(token, self.id, expiration)
cache.set('%s_%s' % (self.id, remote_addr), token, expiration)
date_expired = timezone.now() + timezone.timedelta(seconds=expiration)
return token, date_expired
def get(request):
data = {
"openid":
request.query_params["openid"],
"nickname":
random_string(6),
"sex":
"1",
"province":
"广东",
"city":
"深圳",
"country":
"中国",
"headimgurl":
"http://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaF"
"qAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
"privilege": []
}
return Response(data)
def test_able_to_update_user(self, users_api):
user = users_api.create_user()
users_api.payload.email = "myemail+" + random_string(6) + "@gmail.com"
users_api.payload.password = '******'
users_api.payload.confirm_password = '******'
users_api.payload.first_name = 'John'
users_api.payload.last_name = 'Doe'
users_api.payload.address_1 = 'Charleston 87'
users_api.payload.address_2 = 'St 88'
users_api.payload.city = 'Austin'
users_api.payload.state = 'Texas'
users_api.payload.zip_code = '88769'
users_api.payload.country = 'USA'
users_api.payload.phone = '111222333'
users_api.payload.user_level = 'user'
sent_data = users_api.payload
update_response = users_api.update_user(user.json()['id'])
assert update_response.status_code == 200
get_user = users_api.get_user(user.json()['id'])
updated_user = get_user.json()
assert_that(updated_user).contains('id')
assert_that(updated_user['email']).is_equal_to(sent_data.email)
assert_that(updated_user).does_not_contain('password')
assert_that(updated_user).does_not_contain('confirm_password')
assert_that(updated_user['first_name']).is_equal_to(
sent_data.first_name)
assert_that(updated_user['last_name']).is_equal_to(sent_data.last_name)
assert_that(updated_user['address_1']).is_equal_to(sent_data.address_1)
assert_that(updated_user['address_2']).is_equal_to(sent_data.address_2)
assert_that(updated_user['city']).is_equal_to(sent_data.city)
assert_that(updated_user['state']).is_equal_to(sent_data.state)
assert_that(updated_user['country']).is_equal_to(sent_data.country)
assert_that(updated_user['zip_code']).is_equal_to(sent_data.zip_code)
assert_that(updated_user['country']).is_equal_to(sent_data.country)
assert_that(updated_user['phone']).is_equal_to(sent_data.phone)
assert_that(updated_user['user_level']).is_equal_to(
sent_data.user_level)
assert_that(updated_user).contains('created_at_utc')
def token(self):
if self._token is None:
self._token = random_string(32)
return self._token
def set_pairing_code(item_):
time.sleep(randrange(2, 9)) # [2, 8]
item_.pairing_code = random_string(8, charset='1234567890')
item_.save_to_db()
def banner_name(instance, filename):
return random_string(40) + '.jpg'
def save(self, *args, **kwargs):
if not self.id:
self.slug = slugify(self.title) + '-' + random_string()
super(Post, self).save(*args, **kwargs)
def get_slug(slug: str) -> str:
return random_string() if slug == '' else slug
def gen_password(length=36):
return random_string(length, special_char=True)
assert_that(created_user['email']).is_equal_to(sent_data.email)
assert_that(created_user['first_name']).is_equal_to(
sent_data.first_name)
assert_that(created_user['last_name']).is_equal_to(sent_data.last_name)
assert_that(created_user['address_1']).is_equal_to(sent_data.address_1)
assert_that(created_user['address_2']).is_equal_to(sent_data.address_2)
assert_that(created_user['city']).is_equal_to(sent_data.city)
assert_that(created_user['state']).is_equal_to(sent_data.state)
assert_that(created_user['country']).is_equal_to(sent_data.country)
assert_that(created_user['zip_code']).is_equal_to(sent_data.zip_code)
assert_that(created_user['country']).is_equal_to(sent_data.country)
assert_that(created_user['phone']).is_equal_to(sent_data.phone)
max_length_exceed_cases = [
("email", '{}@gmail.com'.format(random_string(241)),
"Length must be between 1 and 250."),
("confirm_password", random_string(129),
"Length must be between 1 and 128."),
("password", random_string(129), "Length must be between 1 and 128."),
("first_name", random_string(129), "Longer than maximum length 128."),
("last_name", random_string(129), "Longer than maximum length 128."),
("address_1", random_string(251), "Longer than maximum length 250."),
("address_2", random_string(251), "Longer than maximum length 250."),
("city", random_string(81), "Longer than maximum length 80."),
("state", random_string(81), "Longer than maximum length 80."),
("zip_code", random_string(21), "Longer than maximum length 20."),
("country", random_string(81), "Longer than maximum length 80."),
("phone", random_string(129), "Longer than maximum length 80.")
]
def avatar_name(instance, filename):
return random_string(40) + '.jpg'
def test_user_max_length_values_accepted(self, users_api):
post_response = users_api.create_user()
assert post_response.status_code == 201
users_api.payload.email = '{}@gmail.com'.format(random_string(240))
users_api.payload.password = random_string(128)
users_api.payload.confirm_password = users_api.payload.password
users_api.payload.first_name = random_string(128)
users_api.payload.last_name = random_string(128)
users_api.payload.address_1 = random_string(250)
users_api.payload.address_2 = random_string(250)
users_api.payload.city = random_string(80)
users_api.payload.state = random_string(80)
users_api.payload.zip_code = random_string(20)
users_api.payload.country = random_string(80)
users_api.payload.phone = random_string(80)
sent_data = users_api.payload
update_response = users_api.update_user(post_response.json()['id'])
assert update_response.status_code == 200
get_response = users_api.get_user(post_response.json()['id'])
assert get_response.status_code == 200
updated_user = get_response.json()
assert_that(updated_user['email']).is_equal_to(sent_data.email)
assert_that(updated_user['first_name']).is_equal_to(
sent_data.first_name)
assert_that(updated_user['last_name']).is_equal_to(sent_data.last_name)
assert_that(updated_user['address_1']).is_equal_to(sent_data.address_1)
assert_that(updated_user['address_2']).is_equal_to(sent_data.address_2)
assert_that(updated_user['city']).is_equal_to(sent_data.city)
assert_that(updated_user['state']).is_equal_to(sent_data.state)
assert_that(updated_user['country']).is_equal_to(sent_data.country)
assert_that(updated_user['zip_code']).is_equal_to(sent_data.zip_code)
assert_that(updated_user['country']).is_equal_to(sent_data.country)
assert_that(updated_user['phone']).is_equal_to(sent_data.phone)
def get(request):
data = {
"access_token": random_string(32),
"expires_in": 7200
}
return Response(data)
