def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'name': 'policy1',
'ruleobject_id': '72231461-aae9-4059-a5f1-7934ba969d3c'
}]
self.data1 = [{
'id': self.uuid1,
'name': 'policy2',
'ruleobject_id': '85671461-aae9-4059-a5f1-7934ba969b4d'
}]
self.data2 = [{
'id': self.uuid,
'name': 'policy3',
'ruleobject_id': '72231461-aae9-4059-a5f1-7934ba969d3c'
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = PolicySerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{'id': self.uuid,
'name': 'collector1',
'ip_address': '10.42.0.11',
'udp_port': 2055,
'col_type': 'rawforward',
'encapsulation_protocol': 'udp',
}]
self.data1 = [{'id': self.uuid1,
'name': 'collector2',
'ip_address': '10.42.0.12',
'udp_port': 2056,
'col_type': 'netflow',
}]
self.data2 = [{'id': self.uuid,
'name': 'collector2',
'ip_address': '10.42.0.12',
'udp_port': 2057,
'col_type': 'rawforward',
'encapsulation_protocol': 'udp',
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = CollectorSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
# Collector test record
self.data = {
'name': 'nfcol1',
'ip_address': '10.10.21.21',
'udp_port': 2055,
'col_type': 'rawforward',
'encapsulation_protocol': 'udp',
}
self.url_prefix = '/v1.0/secmon/collector/'
self.notification_url_prefix = '/v1.0/secmon/notification/'
# Store the test record in storage
if not self._testMethodName.startswith('test_post_'):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid()
self.data.update({'id': self.uuid})
self.collector = Collector(**self.data)
self.collector.save()
# For POST & List,
# Use the url with name 'collector_list' in urls.py file
if self._testMethodName.startswith('test_post_') or \
self._testMethodName.startswith('test_list_'):
self.url = reverse('collector_list', kwargs={'version': 'v1.0',
'namespace': 'secmon'
})
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'scope_id': 'a05fa20f-662c-4e9d-83b3-8186bea5d680',
'match_fields': 'TOS,PROTOCOL,MAC-ADDRESS',
'collect_fields': 'COLLECT COUNTER,FLOW ACCESS TIMESTAMP',
}]
self.data1 = [{
'id': self.uuid1,
'scope_id': '4b63d4b9-fbd2-4b47-86a1-912ecae3b79e',
'match_fields': 'TOS,SOURCE-ADDRESS,DESTINATION-ADDRESS',
'collect_fields': 'FLOW ACCESS TIMESTAMP,VLAN',
}]
self.data2 = [{
'id': self.uuid,
'scope_id': '8769c99f-afa1-4da0-86d4-0fdd66d028a9',
'match_fields': 'PROTOCOL,VLAN',
'collect_fields': 'COLLECT COUNTER,MAC-ADDRESS',
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = NetFlowMonitorSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self._uuid = generate_uuid()
self._url = reverse('collector_list', kwargs={'version': 'v1.0',
'namespace': 'secmon'})
self.uuid1 = generate_uuid()
self._url_prefix = '/v1.0/secmon/collector/'
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = {'id': self.uuid,
'name': u'nfcol1',
'ip_address': u'10.10.21.21',
'udp_port': 2055,
'col_type': u'netflow',
'encapsulation_protocol': u'',
}
collector = Collector(**self.data)
collector.save()
self.data1 = {'id': self.uuid1,
'name': u'nfcol2',
'ip_address': u'10.10.21.21',
'udp_port': 2055,
'col_type': u'rawforward',
'encapsulation_protocol': u'udp',
}
self.data2 = {}
self.data3 = {'id': self.uuid,
'name': u'nfcol3',
'ip_address': u'10.42.0.21',
'udp_port': 6343,
'col_type': u'sflow',
'encapsulation_protocol': u'',
}
self.listdata = []
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'name': 'scope1',
'sflowstatus': 'enable',
'netflowstatus': 'disable',
'rawforwardstatus': 'disable',
}]
self.data1 = [{
'id': self.uuid1,
'name': 'scope2',
'sflowstatus': 'disable',
'netflowstatus': 'enable',
'rawforwardstatus': 'enable',
}]
self.data2 = [{
'id': self.uuid,
'name': 'scope1',
'sflowstatus': 'enable',
'netflowstatus': 'disable',
'rawforwardstatus': 'enable',
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = ScopeSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'name': 'classificationobject1',
'src_ip': '10.42.0.11',
'src_mac': '00:A0:C9:14:C8:29',
'src_ip_subnet': 24,
'minimum_src_port': 1,
'maximum_src_port': 30000,
'dst_ip': '10.42.0.15',
'dst_mac': '00:A0:C9:14:C8:45',
'dst_ip_subnet': 24,
'minimum_dst_port': 1,
'maximum_dst_port': 20000,
'protocol': 17,
}]
self.data1 = [{
'id': self.uuid1,
'name': 'classificationobject2',
'src_ip': '10.42.0.13',
'src_mac': '00:A0:C9:14:C8:18',
'src_ip_subnet': 24,
'minimum_src_port': 1,
'maximum_src_port': 25000,
'dst_ip': '10.42.0.14',
'dst_mac': '00:A0:C9:14:C8:d4',
'dst_ip_subnet': 24,
'minimum_dst_port': 1,
'maximum_dst_port': 35000,
'protocol': 17,
}]
self.data2 = [{
'id': self.uuid,
'name': 'classificationobject3',
'src_ip': '10.42..0.103',
'src_mac': '00:A0:C9:14:C8:2b',
'src_ip_subnet': 24,
'minimum_src_port': 1,
'maximum_src_port': 25000,
'dst_ip': '10.42.0.15',
'dst_mac': '00:A0:C9:14:C8:2c',
'dst_ip_subnet': 24,
'minimum_dst_port': 1,
'maximum_dst_port': 20000,
'protocol': 1,
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
print("serializer_data in setup:", serializer_data)
# for serializerdata in serializer_data:
serializer = ClassificationObjectSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def test_post_collector_with_id(self):
# 'id' provided
self.uuid = generate_uuid()
self.data.update({'id': self.uuid})
response = self.client.post(self.url, self.data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(unicode_to_ascii_dict(response.data),
unicode_to_ascii_dict(self.data))
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'name': 'ruleobject1',
'classificationobject_id': '80837097-00f1-4182-8daa-ccd2394d48cd',
'priority': 1,
'truncate_to_size': 128,
'action': 0,
}]
self.data1 = [{
'id': self.uuid1,
'name': 'ruleobject2',
'classificationobject_id': '80837097-00f1-4182-8daa-ccd2394d48cd',
'priority': 2,
'truncate_to_size': 128,
'action': 0,
}]
self.data2 = [{
'id': self.uuid,
'name': 'ruleobject3',
'classificationobject_id': 'ccfe9ea1-5ccf-4876-8028-39d256ebcac6',
'priority': 3,
'truncate_to_size': 200,
'action': 1,
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
print("serializer_data in setup ruleobject:", serializer_data[0])
serializer = RuleObjectSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
print("RuleObject.get(self.uuid):", RuleObject.get(self.uuid))
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'table_name': 'netflowconfig',
'row_id': '72231461-aae9-4059-a5f1-7934ba969d3c',
'operation': 'PUT',
}]
self.data1 = [{
'id': self.uuid1,
'table_name': 'netflowconfig',
'row_id': '04df6a37-cf8e-4511-9387-f78325336776',
'operation': 'PUT',
}]
self.data2 = [{
'id': self.uuid,
'table_name': 'collector',
'row_id': '33264640-302f-456c-ac0e-f06cc13a6a47',
'operation': 'DELETE',
'row_data': {
u'name': u'nfcol2',
u'udp_port': 2055,
u'encapsulation_protocol': u'',
u'col_type': u'netflow',
u'ip_address': u'172.16.98.11',
u'id': u'be2e94b6-9a36-4ec4-a763-87bb486f06b8'
},
}]
self.data3 = [{}]
# print("inside notification setup:", Notification.get_all())
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = NotificationSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{'id': self.uuid,
'active_timeout': 20,
'scope_id': '04df6a37-cf8e-4511-9387-f78325336776',
'inactive_timeout': 30,
'refresh_rate': 20,
'timeout_rate': 20,
'maxflows': 30,
}]
self.data1 = [{'id': self.uuid1,
'active_timeout': 40,
'scope_id': '12cf6a37-cf8e-4511-9387-f78325336598',
'inactive_timeout': 30,
'refresh_rate': 30,
'timeout_rate': 20,
'maxflows': 30,
}]
self.data2 = [{'id': self.uuid,
'active_timeout': 30,
'scope_id': '12cf6a37-cf8e-4511-9387-f78325336598',
'inactive_timeout': 40,
'refresh_rate': 30,
'timeout_rate': 30,
'maxflows': 20,
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# print("serializer_data in setup:", serializer_data)
# for serializerdata in serializer_data:
serializer = NetFlowConfigSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'scope_id': '04df6a37-cf8e-4511-9387-f78325336776',
'agent_ip': '10.204.21.91',
'agent_subid': 0,
'sampling_rate': 20,
'truncate_to_size': 128,
}]
self.data1 = [{
'id': self.uuid1,
'scope_id': '04df6a37-cf8e-4511-9387-f78325336776',
'agent_ip': '10.204.21.19',
'agent_subid': 0,
'sampling_rate': 30,
'truncate_to_size': 320,
}]
self.data2 = [{
'id': self.uuid,
'scope_id': '04df6a37-cf8e-4511-9387-f78325336776',
'agent_ip': '10.204.21.96',
'agent_subid': 1,
'sampling_rate': 40,
'truncate_to_size': 128,
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = SflowConfigSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'originator_vm_id': '9662b088-74b4-40df-9769-c8f435d7f16f',
'collector_id': 'Collector:33264640-302f-456c-ac0e-f06cc13a6a47',
'direction': 'INGRESS',
'policy_id': '72231461-aae9-4059-a5f1-7934ba969d3c',
'scope_id': '04df6a37-cf8e-4511-9387-f78325336776',
}]
self.data1 = [{
'id': self.uuid1,
'originator_vm_id': '2372b088-74b4-40df-9769-c8f435d7f16a',
'collector_id': 'Collector:56434640-302f-456c-ac0e-f06cc13a6a76',
'direction': 'BOTH',
'policy_id': '85671461-aae9-4059-a5f1-7934ba969b4d',
'scope_id': '12cf6a37-cf8e-4511-9387-f78325336598',
}]
self.data2 = [{
'id': self.uuid,
'originator_vm_id': '2372b088-74b4-40df-9769-c8f435d7f16a',
'collector_id': 'Collector:33264640-302f-456c-ac0e-f06cc13a6a47',
'direction': 'EGRESS',
'policy_id': '72231461-aae9-4059-a5f1-7934ba969d3c',
'scope_id': '12cf6a37-cf8e-4511-9387-f78325336598',
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = RawForwardAssociationSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data = [{
'id': self.uuid,
'scope_name': 'scope1',
'ip_address': '10.42.0.11',
'mac_address': '00:A0:C9:14:C8:29',
'port': 2055,
}]
self.data1 = [{
'id': self.uuid1,
'scope_name': 'scope2',
'ip_address': '10.42.0.105',
'mac_address': '00:A0:C9:14:C8:14',
'port': 2254,
}]
self.data2 = [{
'id': self.uuid,
'scope_name': 'scope3',
'ip_address': '10.42.0.103',
'mac_address': '00:A0:C9:14:C8:29',
'port': 2156,
}]
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# for serializerdata in serializer_data:
serializer = SecmonDetailsSerializer(data=serializer_data[0])
if serializer.valid(self.uuid):
serializer.create(serializer.data)
else:
print("serializer is not valid in setup")
def setUp(self):
self.uuid = generate_uuid() # Generate an id except for POST
self.uuid1 = generate_uuid() # Generate id for update
self.data1 = [{'id': self.uuid1,
'name': 'collectorset1',
'collector_ids': "[{'id':'87a3f7c1-88bc-4a4e-ba12-b87bb6878fa0','weight':20}, {'id':'87a3f7c1-88bc-4a4e-ba12-b87bb6878fa0','weight':20}]",
'col_type': 'rawforward',
'lb_algo': 1,
}]
self.data = [{'id': self.uuid,
'name': 'collectorset2',
'collector_ids': "[{'id':'8aefba80-e99d-4d9c-8b99-6c1a7049135b','weight':30}, {'id':'a016ff9e-2e6f-4db9-8ba4-cd0529407e7b','weight':40}]",
'col_type': 'netflow',
'lb_algo': 2,
}]
self.data2 = [{'id': self.uuid,
'name': 'collectorset2',
'collector_ids': "[{'id':'87a3f7c1-88bc-4a4e-ba12-b87bb6878fa0','weight':20}, {'id':'87a3f7c1-88bc-4a4e-ba12-b87bb6878fa0','weight':20}]",
'col_type': 'rawforward',
'lb_algo': 0,
}]
print("inside setup function")
self.data3 = [{}]
serializer_data = json.loads(json.dumps(self.data))
# print("serializer_data:", serializer_data[0])
serializer = CollectorSetSerializer(data=serializer_data[0])
# print("serializer.data:", serializer.data)
if serializer.valid(self.uuid):
# print("serializer.data in setup:", serializer.data)
serializer.create(serializer.data)
else:
print("serializer data is not valid")
def test_put_collector_with_invalid_values(self):
"""Test case to update a Collector with invalid value of attributes"""
self.url = self.url_prefix + self.uuid + '/'
self._invalid_values = {
'id': generate_uuid(), # 'id' update not allowed
'name': 'new_collector1',
'ip_address': '10.42.0.12',
'udp_port': 70000,
'col_type': 'netflow',
'encapsulation_protocol': '',
}
response = self.client.put(self.url, self._invalid_values,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
LOG.debug(unicode_to_ascii_dict(response.data))
def setUp(self):
# Scope test record
self.data = {
'name': 'scope1',
'sflowstatus': 'enable',
'netflowstatus': 'disable',
'rawforwardstatus': 'disable',
}
self.url_prefix = '/v1.0/secmon/scope/name/'
# Store the test record in storage
if not self._testMethodName.startswith('test_post_'):
self.uuid = generate_uuid() # Generate an id except for POST
self.data.update({'id': self.uuid})
self.scope = Scope(**self.data)
self.scope.save()
def test_get_no_record(self):
"""Test case to fetch a RuleObject with invalid id."""
with self.assertRaises(ResourceNotFound):
RuleObject.get(generate_uuid())
def test_get_no_record(self):
"""Test case to fetch a NetFlowMonitor with invalid id."""
with self.assertRaises(ResourceNotFound):
NetFlowMonitor.get(generate_uuid())
def test_scope_get_with_invalid_sk(self):
"""test case to get none data for invalid get"""
self.uuid1 = generate_uuid()
self.url = self.url_prefix + 'scope2/'
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_invalid_get_record(self):
"""test case to test get for invalid id"""
with self.assertRaises(ResourceNotFound):
Collector.get(generate_uuid())
def test_get_no_record(self):
"""Test case to fetch a RawForwardAssociation with invalid id."""
with self.assertRaises(ResourceNotFound):
RawForwardAssociation.get(generate_uuid())
def test_get_no_record(self):
"""Test case to fetch a SecmonDetails with invalid id."""
with self.assertRaises(ResourceNotFound):
SecmonDetails.get(generate_uuid())
def test_get_no_record(self):
"""Test case to fetch a SlowConfig with invalid id."""
with self.assertRaises(ResourceNotFound):
SflowConfig.get(generate_uuid())
def test_get_no_record(self):
"""Test case to fetch a Notification with invalid id."""
with self.assertRaises(ResourceNotFound):
Notification.get(generate_uuid())
