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)