def create_bool_strategy(strategy_var, strategy_op, strategy_func, strategy_threshold, strategy_name=None, strategy_desc=None): """ New bool strategy :param str|unicode strategy_var: Built_In_Variables :param str|unicode strategy_op: ActionCode :param str|unicode strategy_func: Built_In_Functions :param str|unicode strategy_threshold: Threshold for policy :param str|unicode strategy_name: PolicyName :param str|unicode strategy_desc: PolicyDescription :return: """ strategy_name = strategy_name or get_sample_str() strategy_desc = strategy_desc or get_sample_str() data = { "strategy_var": strategy_var, "strategy_op": strategy_op, "strategy_func": strategy_func, "strategy_threshold": strategy_threshold, "strategy_name": strategy_name, "strategy_desc": strategy_desc } success, strategy_uuid = _create_new_strategy(BoolStrategyForm, strategy_conf=data) return strategy_uuid
def create_freq_strategy(strategy_source, strategy_body, strategy_time, strategy_limit, strategy_name=None, strategy_desc=None): """ New time period frequency control strategy request: Request object, user information needs to be obtained from it, etc. :param str|unicode strategy_source: Escalate data source key :param str|unicode strategy_body: Limit the principal eg: ip, uid, user_id etc... :param int strategy_time: Time period (in seconds) :param int strategy_limit: Limit the number of people :param str|unicode strategy_name: PolicyName :param str|unicode strategy_desc: PolicyDescription :return: """ strategy_name = strategy_name or get_sample_str() strategy_desc = strategy_desc or get_sample_str() data = { 'strategy_source': strategy_source, 'strategy_body': strategy_body, 'strategy_time': strategy_time, 'strategy_limit': strategy_limit, 'strategy_name': strategy_name, 'strategy_desc': strategy_desc } success, strategy_uuid = _create_new_strategy(FreqStrategyForm, strategy_conf=data) return strategy_uuid
def create_user_strategy(strategy_source, strategy_body, strategy_day, strategy_limit, strategy_name=None, strategy_desc=None): """ New User-limited number-based policy :param str|unicode strategy_source: Escalate data source key :param str|unicode strategy_body: Limit the principal eg: ip, uid, user_id etc... :param int strategy_day: Natural days :param int strategy_limit: Limit the number of Users :param str|unicode strategy_name: PolicyName :param str|unicode strategy_desc: PolicyDescription :return: """ strategy_name = strategy_name or get_sample_str() strategy_desc = strategy_desc or get_sample_str() data = { 'strategy_source': strategy_source, 'strategy_body': strategy_body, 'strategy_day': strategy_day, 'strategy_limit': strategy_limit, 'strategy_name': strategy_name, 'strategy_desc': strategy_desc } success, strategy_uuid = _create_new_strategy(UserStrategyForm, strategy_conf=data) return strategy_uuid
def create_menu_strategy(event_code, dimension, menu_type, menu_op, strategy_name=None, strategy_desc=None): """ New List strategy :param str|unicode event_code: Project uuid :param str|unicode dimension: Dimensions user_id / ip / uid ... :param str|unicode menu_type: ListType black, white, gray :param str|unicode menu_op: ActionCode In/not in (is/is_not) :param str|unicode strategy_name: PolicyName :param str|unicode strategy_desc: PolicyDescription """ strategy_name = strategy_name or get_sample_str() strategy_desc = strategy_desc or get_sample_str() data = { 'strategy_name': strategy_name, 'strategy_desc': strategy_desc, 'menu_op': menu_op, 'event': event_code, 'dimension': dimension, 'menu_type': menu_type } success, strategy_uuid = _create_new_strategy(MenuStrategyForm, strategy_conf=data) return strategy_uuid
def create_rule(strategy_confs, end_time=None, title=None, describe=None, status='on', creator_name=None): creator_name = creator_name or get_sample_str() describe = describe or get_sample_str() title = title or get_sample_str() end_time = end_time or (datetime.now() + timedelta(days=10)) return RuleModel.create(creator_name, title, describe, status, end_time, strategy_confs)
def create_data_source(source_key=None, source_name=None, fields=None): source_key = source_key or get_sample_str(8) source_name = source_name or get_sample_str(8) fields = fields or ['user_id', 'uid'] # Currently only used in testing, for simplicity, type is not configurable content = {field: 'string' for field in fields} content['name_show'] = source_name map_key = 'CONFIG_SOURCE_MAP' client = get_redis_client() client.hset(map_key, source_key, json.dumps(content)) return source_key
def _test_create(self): source_key = create_data_source() data = { 'strategy_source': source_key, 'strategy_desc': get_sample_str(8), 'strategy_body': 'uid', 'strategy_name': get_sample_str(8), 'strategy_time': random.randint(1000, 10000), 'strategy_limit': random.randint(1, 3) } response = self.client.post(reverse(self.create_uri), data=data) self.assertEqual(response.status_code, 200) resp_dict = json.loads(response.content) self.strategy_uuid = resp_dict['uuid'] self.assertIs(resp_dict['state'], True)
def _test_destroy(self): # Argument incomplete resp = self.client.post(reverse(self.delete_uri)) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.content)['error'], _("id is illegal")) # ID format is wrong menu_element_id = get_sample_str(24) resp = self.client.post(reverse(self.delete_uri), data={'ids': menu_element_id}) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.content)['error'], _("id is illegal")) # Success delete menu_element_id = add_element_to_menu(self.event_code, 'black', self.dimension, 'test_value') resp = self.client.post(reverse(self.delete_uri), data={'ids': menu_element_id}) self.assertEqual(resp.status_code, 200) t = json.loads(resp.content) self.assertEqual(t['state'], True) # Delete records that do not exist resp = self.client.post(reverse(self.delete_uri), data={'ids': menu_element_id}) self.assertEqual(resp.status_code, 200) t = json.loads(resp.content) self.assertEqual(t['error'], _("Records don't exist"))
def _test_create(self): content = json.dumps({ "user_id": "string", "uid": "string", "ip": "string" }) name_show = get_sample_str(8) name_key = get_sample_str(8) response = self.client.post(reverse(self.create_uri), data={'content': content, 'name_show': name_show, 'name_key': name_key}) self.assertEqual(response.status_code, 200) resp_dict = json.loads(response.content) self.name_key = resp_dict['msg'] self.assertEqual(name_key, self.name_key) self.assertIs(resp_dict['state'], True)
def _test_create(self): data = {'event_name': get_sample_str(10)} response = self.client.post(reverse(self.create_uri), data=data) self.assertEqual(response.status_code, 200) t = json.loads(response.content) self.event_code = t['event_code'] self.assertEqual(t['state'], True) response = self.client.post(reverse(self.create_uri), data=data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False)
def setUp(self): super(TestRule, self).setUp() self.event_code = create_menu_event()['event_code'] self.menu_uuid = create_menu_strategy(event_code=self.event_code, dimension='user_id', menu_type='black', menu_op='is') self.bool_uuid = create_bool_strategy(strategy_var='user_id', strategy_op='is', strategy_func='is_abnormal', strategy_threshold='') strategy_confs = [ [ get_sample_str(), self.menu_uuid, 'deny', get_sample_str(), '100' ], [get_sample_str(), self.bool_uuid, 'log', get_sample_str(), '90'], ] self.rule_id, self.rule_uuid = create_rule(strategy_confs)
def test_hit_detail_view(self): url = reverse('log_manage:hit_list_detail') # common response = self.client.get(url) self.assertEqual(response.status_code, 200) # With User data = {'user_id': 11} response = self.client.get(url, data) self.assertEqual(response.status_code, 200) # Table does not exist with time right = datetime.now() left = right - timedelta(days=1) data = { 'user_id': 11, 'start_day': left.strftime('%Y/%m/%d'), 'end_day': right.strftime('%Y/%m/%d') } response = self.client.get(url, data=data) self.assertEqual(response.status_code, 200) # Table Exists and With Time self.create_hit_table(left) response = self.client.get(url, data=data) self.assertEqual(response.status_code, 200) # With the wrong time data = { 'user_id': 11, 'start_day': get_sample_str(8), 'end_day': get_sample_str(8) } response = self.client.get(url, data=data) self.assertEqual(response.status_code, 200)
def add_element_to_menu(event_code, menu_type, dimension, element, end_time=None, menu_desc=None): """ Add elements to the list :param str|unicode event_code: List item code :param str|unicode menu_type: ListType black white gray :param str|unicode dimension: List dimensions user_id / ip / ... :param str|unicode element: Elements placed on the list :param datetime end_time: Failure time :param str|unicode menu_desc: Note :return: """ end_time = (end_time or datetime.now() + timedelta(hours=1)) menu_desc = menu_desc or get_sample_str(15) payload = dict(end_time=end_time, menu_desc=menu_desc, menu_status='valid', create_time=datetime.now(), creator='test', value=element, event_code=event_code, dimension=dimension, menu_type=menu_type) db = get_mongo_client() insert_result = db['menus'].insert_one(payload) redis_client = get_redis_client() redis_key = build_redis_key(event_code, dimension=dimension, menu_type=menu_type) if redis_key: redis_client.sadd(redis_key, element) return str(insert_result.inserted_id)
def _test_create(self): create_url = reverse(self.create_url) # Initial page response = self.client.get(create_url) self.assertEqual(response.status_code, 200) # Create a rule # No arguments response = self.client.post(create_url) self.assertEqual(response.status_code, 200) resp_json = json.loads(response.content) self.assertEqual(resp_json['state'], False) # Normal creation event_code = create_menu_event()['event_code'] add_element_to_menu(event_code=event_code, menu_type='black', dimension='user_id', element='111111') # user_id on the blacklist represented by the event_code self.menu_strategy_uuid = create_menu_strategy(event_code=event_code, dimension='user_id', menu_type='black', menu_op='is') # Same uid, 1 User for the day data_source_key = create_data_source() self.user_strategy_uuid = create_user_strategy( strategy_source=data_source_key, strategy_body='uid', strategy_day=1, strategy_limit=1) # User is an exception ToUser self.bool_strategy_uuid = create_bool_strategy(strategy_var='user_id', strategy_op='is', strategy_func='is_abnormal', strategy_threshold='') # Same uid, in the last 86400s, limited to 1 time self.freq_strategy_uuid = create_freq_strategy( strategy_source=data_source_key, strategy_body='uid', strategy_time=24 * 60 * 60, strategy_limit=1) self.valid_post_data = { 'title': get_sample_str(10), 'describe': get_sample_str(8), 'status': 'on', 'end_time': (datetime.today() + timedelta(days=100)).strftime( '%Y-%m-%d %H:%M:%S'), 'strategys': ','.join( [self.menu_strategy_uuid, self.user_strategy_uuid, self.bool_strategy_uuid, self.freq_strategy_uuid]), 'controls': ','.join(['deny', 'log', 'number', 'pass']), 'customs': ':::'.join([get_sample_str()] * 4), 'names': ':::'.join([get_sample_str()] * 4), 'weights': ','.join(['100', '90', '80', '70']) } response = self.client.post(create_url, data=self.valid_post_data) self.assertEqual(response.status_code, 200) resp_json = json.loads(response.content) self.assertEqual(resp_json['state'], True) self.rule_uuid = resp_json['uuid']
def _test_change(self): change_url = reverse(self.change_url) valid_post_data = copy.deepcopy(self.valid_post_data) valid_post_data['id'] = self.rule_uuid # Normal request a = [[self.menu_strategy_uuid, [], get_sample_str()]] b = [[self.user_strategy_uuid, ["10", "10"], get_sample_str()]] c = [[self.bool_strategy_uuid, [], get_sample_str()]] d = [[self.freq_strategy_uuid, ["86400", "1"], get_sample_str()]] valid_post_data['strategys'] = '|'.join( [json.dumps(t) for t in (a, b, c, d)]) response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], True) # Status is not legal. status = valid_post_data.pop('status') valid_post_data['status'] = 'wrong_status' response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # Modify thresholds only valid_post_data['status'] = status end_time_str = valid_post_data.pop('end_time') response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], True) # Time format is not legal valid_post_data['end_time'] = 'xxxxx' response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # No regular name valid_post_data['end_time'] = end_time_str title = valid_post_data.pop('title') response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # No description valid_post_data['title'] = title describe = valid_post_data.pop('describe') response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # Table data left blank/length mismatch valid_post_data['describe'] = describe names = valid_post_data.pop('names') response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # Policy data error valid_post_data['names'] = names strategys_str = valid_post_data.pop('strategys') valid_post_data['strategys'] = strategys_str[:-2] response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False) # Weight non-digital valid_post_data['strategys'] = strategys_str weights = valid_post_data.pop('weights') valid_post_data['weights'] = weights + 'x' response = self.client.post(change_url, data=valid_post_data) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(response.content)['state'], False)
def create_menu_event(event_code=None, event_name=None): db = get_mongo_client() payload = dict(event_code=event_code or str(uuid.uuid4()), event_name=event_name or get_sample_str(length=8)) db['menu_event'].insert_one(payload) return payload
class TestPayMenu(TestMenuMinix, BaseTestCase): dimension = 'pay' test_cases = [(get_sample_str(10), True)] list_uri = 'menus:pay_list'
class TestUserIDMenu(TestMenuMinix, BaseTestCase): dimension = 'user_id' test_cases = [(get_sample_str(10), True)] list_uri = 'menus:userid_list'
class TestPhoneMenu(TestMenuMinix, BaseTestCase): dimension = 'phone' test_cases = [(get_sample_str(10), False), ('11111111111', True)] list_uri = 'menus:phone_list'
class TestIPMenu(TestMenuMinix, BaseTestCase): dimension = 'ip' test_cases = [(get_sample_str(7), False), ('1.1.1.1', True)] list_uri = 'menus:ip_list'