def setUp(self):
self.list_categories_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'get_signals_v1_public_terms_categories.json'
)
)
self.retrieve_category_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'get_signals_v1_public_terms_categories_{slug}.json'
)
)
self.retrieve_sub_category_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'get_signals_v1_public_terms_categories_{slug}_sub_categories_{sub_slug}.json'
)
)
self.parent_category = ParentCategoryFactory.create()
CategoryFactory.create_batch(5, parent=self.parent_category)
self.parent_category.refresh_from_db()
super(TestCategoryTermsEndpoints, self).setUp()
def setUp(self):
self.test_parentcategory_overig = Category.objects.get(
slug='overig', parent__isnull=True)
self.test_subcategory_overig = Category.objects.get(
parent=self.test_parentcategory_overig,
slug='overig',
parent__isnull=False)
self.link_test_subcategory_overig = f'{self.test_host}/signals/v1/public/terms/categories/' \
f'{self.test_subcategory_overig.parent.slug}/sub_categories/' \
f'{self.test_subcategory_overig.slug,}'
self.test_subcategory = CategoryFactory.create()
self.link_test_subcategory = f'{self.test_host}/signals/v1/public/terms/categories/' \
f'{self.test_subcategory.parent.slug}/sub_categories/{self.test_subcategory.slug}'
self.test_subcategory_translated = CategoryFactory.create(
is_active=False)
self.link_test_subcategory_translated = f'{self.test_host}/signals/v1/public/terms/categories/' \
f'{self.test_subcategory_translated.parent.slug}/sub_categories/' \
f'{self.test_subcategory_translated.slug}'
self.link_test_subcategory_translation = CategoryTranslation.objects.create(
old_category=self.test_subcategory_translated,
new_category=self.test_subcategory,
text='For testing purposes we translate this category',
created_by='*****@*****.**',
)
def setUp(self):
SourceFactory.create(name='online', is_active=True)
SourceFactory.create(name='Telefoon – ASC', is_active=True)
self.main_category = ParentCategoryFactory.create(name='main',
slug='main')
self.link_main_category = '/signals/v1/public/terms/categories/main'
self.sub_category_1 = CategoryFactory.create(name='sub1',
slug='sub1',
parent=self.main_category)
self.link_sub_category_1 = f'{self.link_main_category}/sub_categories/sub1'
self.sub_category_2 = CategoryFactory.create(name='sub2',
slug='sub2',
parent=self.main_category)
self.link_sub_category_2 = f'{self.link_main_category}/sub_categories/sub2'
self.sia_read_write_user.user_permissions.add(
Permission.objects.get(codename='sia_can_view_all_categories'))
self.client.force_authenticate(user=self.sia_read_write_user)
self.initial_data_base = dict(
text='Mensen in het cafe maken erg veel herrie',
location=dict(geometrie=dict(
type='point', coordinates=[4.90022563, 52.36768424])),
category=dict(category_url=self.link_sub_category_1),
reporter=dict(email='*****@*****.**'),
incident_date_start=timezone.now().strftime('%Y-%m-%dT%H:%M'),
source='Telefoon – ASC',
)
self.retrieve_signal_schema = self.load_json_schema(
os.path.join(THIS_DIR, 'json_schema',
'get_signals_v1_private_signals_{pk}.json'))
def test_only_category_filter(self):
"""
unit test to only filter items with the category
create 3 signals and only 2 signals with the category 'plastic_trash"
"""
cat1 = ParentCategoryFactory.create(name='trash')
plastic = CategoryFactory.create(parent=cat1,
public_name='plastic_trash',
is_public_accessible=True)
compost = CategoryFactory.create(parent=cat1,
public_name='compost_trash',
is_public_accessible=True)
SignalFactoryValidLocation.create(
category_assignment__category=plastic)
SignalFactoryValidLocation.create(
category_assignment__category=plastic)
SignalFactoryValidLocation.create(
category_assignment__category=compost)
response = self.client.get(
f'{self.geography_endpoint}/?bbox=4.700000,52.200000,5.000000,52.500000&'
f'category_slug={plastic.slug}')
data = response.json()
self.assertEqual(2, len(data['features']))
def handle(self, *args, **options):
parent_slug = options.get('parent_slug', False)
if parent_slug:
parents_to_create = 1
parent_options = {
'slug': parent_slug,
}
else:
parents_to_create = int(options['parents_to_create']
or self.default_to_create)
parent_options = {}
children_to_create = int(options['children_to_create']
or self.default_to_create)
if not self.min_to_create <= parents_to_create <= self.max_to_create:
self.stderr.write(
f'The parents to create option must be an integer from {self.min_to_create} to '
f'{self.max_to_create}, {parents_to_create} given')
return
if not self.min_to_create <= children_to_create <= self.max_to_create:
self.stderr.write(
f'The children to create option must be an integer from {self.min_to_create} to '
f'{self.max_to_create}, {children_to_create} given')
return
parents = ParentCategoryFactory.create_batch(parents_to_create,
**parent_options)
for parent in parents:
CategoryFactory.create_batch(children_to_create, parent=parent)
def setUp(self):
user_model = get_user_model()
self.superuser, _ = user_model.objects.get_or_create(
email='*****@*****.**',
is_superuser=True,
defaults={
'first_name': 'John',
'last_name': 'Doe',
'is_staff': True
})
self.department = DepartmentFactory.create()
parent_category = ParentCategoryFactory.create()
self.category_1 = CategoryFactory.create(parent=parent_category,
departments=[self.department])
ServiceLevelObjectiveFactory.create(category=self.category_1,
n_days=2,
use_calendar_days=True)
self.category_2 = CategoryFactory.create(parent=parent_category,
departments=[self.department])
ServiceLevelObjectiveFactory.create(category=self.category_2,
n_days=3,
use_calendar_days=False)
self.category_3 = CategoryFactory.create(parent=parent_category,
departments=[self.department])
ServiceLevelObjectiveFactory.create(category=self.category_3,
n_days=4,
use_calendar_days=False)
def test_make_email_context_for_category_with_or_without_public_name(self):
# Check categories with public names.
main_cat_with_public_name = ParentCategoryFactory.create(
parent=None, name='PRIVATE_MAIN_I', public_name='PUBLIC_MAIN_I')
sub_cat_with_public_name = CategoryFactory.create(
parent=main_cat_with_public_name,
name='PRIVATE_SUB',
public_name='PUBLIC_SUB_I')
signal_with_public_name = SignalFactory.create(
category_assignment__category=sub_cat_with_public_name)
context_with = make_email_context(signal=signal_with_public_name)
self.assertEqual(context_with['main_category_public_name'],
'PUBLIC_MAIN_I')
self.assertEqual(context_with['sub_category_public_name'],
'PUBLIC_SUB_I')
# Check categories without public names.
main_cat_no_public_name = ParentCategoryFactory.create(
parent=None, name='PRIVATE_MAIN_II', public_name=None)
sub_cat_no_public_name = CategoryFactory.create(
parent=main_cat_no_public_name,
name='PRIVATE_SUB_II',
public_name=None)
signal_no_public_name = SignalFactory.create(
category_assignment__category=sub_cat_no_public_name)
context_without = make_email_context(signal=signal_no_public_name)
self.assertEqual(context_without['main_category_public_name'],
'PRIVATE_MAIN_II')
self.assertEqual(context_without['sub_category_public_name'],
'PRIVATE_SUB_II')
def test_only_main_category_filter(self):
"""
unit test to only filter items with the main category
create 5 signals and only 3 under the main category 'trash' that should be returned
"""
parent_cat = ParentCategoryFactory.create(name='trash')
child_category = CategoryFactory.create(parent=parent_cat,
public_name='',
is_public_accessible=True)
child_category_2 = CategoryFactory.create(parent=parent_cat,
public_name='',
is_public_accessible=True)
SignalFactoryValidLocation.create(
category_assignment__category=child_category)
SignalFactoryValidLocation.create(
category_assignment__category=child_category)
SignalFactoryValidLocation.create(
category_assignment__category=child_category_2)
parent_cat_2 = ParentCategoryFactory.create(name='animal')
child_animal = CategoryFactory.create(parent=parent_cat_2,
public_name='',
is_public_accessible=True)
SignalFactoryValidLocation.create(
category_assignment__category=child_animal)
SignalFactoryValidLocation.create(
category_assignment__category=child_animal)
response = self.client.get(
f'{self.geography_endpoint}/?bbox=4.700000,52.200000,5.000000,52.500000&'
f'maincategory_slug={parent_cat.slug}')
data = response.json()
self.assertEqual(3, len(data['features']))
def test_command_with_parameters(self):
CategoryFactory.create()
db_cnt = Signal.objects.count()
out = StringIO()
err = StringIO()
call_command('dummy_signals', to_create=5, stdout=out, stderr=err)
self.assertEqual(Signal.objects.count(), db_cnt + 5)
def setUp(self):
sia_category_write_permission = Permission.objects.get(codename='sia_category_write')
self.sia_read_write_user.user_permissions.add(sia_category_write_permission)
self.parent_category = ParentCategoryFactory.create()
CategoryFactory.create_batch(5, parent=self.parent_category)
self.parent_category.refresh_from_db()
super().setUp()
def setUp(self):
email = '*****@*****.**'
self.department_yes = DepartmentFactory.create(name='department_yes')
self.department_no = DepartmentFactory.create(name='department_no')
self.category_yes = CategoryFactory.create(departments=[self.department_yes])
self.category_no = CategoryFactory.create(departments=[self.department_no])
self.signal_yes = SignalFactory.create(category_assignment__category=self.category_yes, reporter__email=email)
self.signal_no = SignalFactory.create(category_assignment__category=self.category_no, reporter__email=email)
self.sia_read_write_user.profile.departments.add(self.department_yes)
def test_handling_message_in_history_is_constant(self):
# SIG-3555 because history is not tracked for the Category model and its
# handling_message. Changing the handling_message will also change the
# history of every Signal that has that Category associated with.
# This test demonstrates the problem.
message_1 = 'MESSAGE 1'
message_2 = 'MESSAGE 2'
cat1 = CategoryFactory.create(name='cat1', handling_message=message_1)
cat2 = CategoryFactory.create(name='cat2')
signal = SignalFactoryValidLocation(category_assignment__category=cat1)
self.sia_read_write_user.user_permissions.add(
Permission.objects.get(codename='sia_can_view_all_categories'))
self.client.force_authenticate(user=self.sia_read_write_user)
# Retrieve signal history before changing the Category handling message.
response = self.client.get(
f'/signals/v1/private/signals/{signal.id}/history' +
'?what=UPDATE_SLA')
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(len(response_json), 1)
self.assertEqual(response_json[0]['description'], message_1)
# Change handling message on category
cat1.handling_message = message_2
cat1.save()
cat1.refresh_from_db()
# Assign different category and then the same again, check handling messages.
Signal.actions.update_category_assignment({'category': cat2}, signal)
signal.refresh_from_db()
Signal.actions.update_category_assignment({'category': cat1}, signal)
response = self.client.get(
f'/signals/v1/private/signals/{signal.id}/history' +
'?what=UPDATE_SLA')
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(len(response_json), 1)
self.assertEqual(response_json[0]['description'], message_1)
# check that the correct handling messages are stored:
category_assignments = list(
CategoryAssignment.objects.filter(
_signal_id=signal.id).order_by('id'))
self.assertEqual(category_assignments[0].stored_handling_message,
message_1)
self.assertEqual(category_assignments[2].stored_handling_message,
message_2)
def setUp(self):
self.retrieve_sub_category_question_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'get_signals_v1_public_questions_categories_{slug}_sub_categories_{sub_slug}.json'
)
)
question = QuestionFactory.create_batch(1)
question2 = QuestionFactory.create_batch(1)
self.parent_category = ParentCategoryFactory.create(questions=question2)
CategoryFactory.create_batch(1, parent=self.parent_category, questions=question)
self.parent_category.refresh_from_db()
super().setUp()
def test_get_group_by(self):
"""
Return the GEOJson containing the first created_at in a BBOX grouped by a category
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(
parent=parent_category,
public_name='Public category for testing',
is_public_accessible=True)
now = timezone.now()
for x in range(5):
with (freeze_time(now - timedelta(days=x))):
# Should appear in the response
SignalFactory.create(
location__geometrie=Point(STADHUIS['lon'],
STADHUIS['lat']),
location__buurt_code=STADHUIS['buurt_code'],
category_assignment__category=child_category)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&bbox=4.875759,52.360656,4.921221,52.37942'
'&group_by=category')
self.assertEqual(200, response.status_code)
self.assertEqual(1, int(response.headers['X-Total-Count']))
data = response.json()
self.assertEqual(1, len(data['features']))
self.assertEqual(data['features'][0]['properties']['category']['name'],
child_category.public_name)
def test_get_geojson(self):
"""
Return the GEOJson containing all signals in the child category
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(
parent=parent_category,
public_name='Public category for testing',
is_public_accessible=True)
now = timezone.now()
for x in range(5):
with (freeze_time(now - timedelta(days=x))):
SignalFactoryValidLocation.create(
category_assignment__category=child_category)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&bbox=4.700000,52.200000,5.000000,52.500000'
)
self.assertEqual(200, response.status_code)
self.assertEqual(5, int(response.headers['X-Total-Count']))
data = response.json()
self.assertEqual(5, len(data['features']))
for feature in data['features']:
self.assertEqual(feature['properties']['category']['name'],
child_category.public_name)
def test_lon_lat_parameters(self):
"""
Return the GEOJson containing all signals in the child category
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(
parent=parent_category,
public_name='Public category for testing',
is_public_accessible=True)
signal = SignalFactoryValidLocation.create(
category_assignment__category=child_category)
lon = signal.location.geometrie.x
lat = signal.location.geometrie.y
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&lon={lon}&lat={lat}')
self.assertEqual(200, response.status_code)
self.assertEqual(1, int(response.headers['X-Total-Count']))
data = response.json()
self.assertEqual(1, len(data['features']))
for feature in data['features']:
self.assertEqual(feature['properties']['category']['name'],
child_category.public_name)
def test_public_name_isset(self):
"""
An empty public_name (None) must fallback to the name
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(parent=parent_category,
public_name='test',
is_public_accessible=True)
SignalFactoryValidLocation.create(
category_assignment__category=child_category)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&bbox=4.700000,52.200000,5.000000,52.500000'
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, int(response.headers['X-Total-Count']))
data = response.json()
self.assertEqual(1, len(data['features']))
self.assertEqual(child_category.public_name,
data['features'][0]['properties']['category']['name'])
self.assertNotEqual(
child_category.name,
data['features'][0]['properties']['category']['name'])
def setUp(self):
# We use a category without no deadlines to create signals/complaints that
# will have deadline set to None.
test_cat = CategoryFactory.create(name='testcategory')
with freeze_time(self.NOW - datetime.timedelta(days=4 * 7)):
self.signal_late_open = SignalFactory.create(
status__state=workflow.GEMELD,
category_assignment__category=test_cat)
self.signal_late_closed = SignalFactory.create(
status__state=workflow.AFGEHANDELD,
category_assignment__category=test_cat)
# We now set a Service Level Objective for the category, so that we can
# create some signals/complaints with a deadline set to some value other
# than None.
ServiceLevelObjectiveFactory.create(
category=test_cat,
n_days=5,
use_calendar_days=False,
)
with freeze_time(self.NOW - datetime.timedelta(hours=1)):
self.signal_punctual_open = SignalFactory.create(
status__state=workflow.GEMELD,
category_assignment__category=test_cat)
self.signal_punctual_closed = SignalFactory.create(
status__state=workflow.AFGEHANDELD,
category_assignment__category=test_cat)
def setUp(self):
with open(self.fixture_file, 'r') as f:
self.create_initial_data = json.load(f)
self.subcategory = CategoryFactory.create()
self.link_test_cat_sub = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format(
self.subcategory.parent.slug, self.subcategory.slug
)
self.create_initial_data['category'] = {'sub_category': self.link_test_cat_sub}
self.retrieve_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'get_signals_v1_public_signals_{uuid}.json'
)
)
self.create_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'post_signals_v1_public_signals.json'
)
)
self.create_attachment_schema = self.load_json_schema(
os.path.join(
THIS_DIR,
'json_schema',
'post_signals_v1_public_signals_attachment.json'
)
)
def setUp(self):
self.parent_category = ParentCategoryFactory.create(
name='PARENT-CATEGORY')
self.child_category = CategoryFactory.create(
name='CHILD-CATEGORY', parent=self.parent_category)
self.signal = SignalFactoryWithImage.create(
text='BLAH BLAH BLAH',
incident_date_start=timezone.now(),
category_assignment__category=self.child_category,
reporter__email='*****@*****.**',
reporter__phone='0612345678')
StatusFactory.create(_signal=self.signal,
state=workflow.AFWACHTING,
text='waiting')
StatusFactory.create(_signal=self.signal,
state=workflow.ON_HOLD,
text='please hold')
status = StatusFactory.create(_signal=self.signal,
state=workflow.AFGEHANDELD,
text='Consider it done')
self.signal.status = status
self.signal.save()
self.user = SuperUserFactory.create()
def setUp(self):
self.test_parentcategory_overig = Category.objects.get(slug='overig', parent__isnull=True)
self.test_subcategory_overig = Category.objects.get(parent=self.test_parentcategory_overig, slug='overig',
parent__isnull=False)
self.link_test_subcategory_overig = f'{self.test_host}/signals/v1/public/terms/categories/' \
f'{self.test_subcategory_overig.parent.slug}/sub_categories/' \
f'{self.test_subcategory_overig.slug,}'
self.test_subcategory = CategoryFactory.create()
self.link_test_subcategory = f'{self.test_host}/signals/v1/public/terms/categories/' \
f'{self.test_subcategory.parent.slug}/sub_categories/{self.test_subcategory.slug}'
def test_category_question_list(self):
question = QuestionFactory.create_batch(1)
question2 = QuestionFactory.create_batch(1)
self.parent_category = ParentCategoryFactory.create(
questions=question2)
CategoryFactory.create_batch(1,
parent=self.parent_category,
questions=question)
self.parent_category.refresh_from_db()
endpoint_url = '/signals/v1/public/questions/'
response = self.client.get(endpoint_url)
self.assertEqual(response.status_code, 200)
data = response.json()
# JSONSchema validation
self.assertJsonSchema(self.retrieve_sub_category_question_schema, data)
self.assertEqual(data['count'], 2)
# filter on main
sub_category = self.parent_category.children.first()
url = '{endp}?main_slug={slug}'.format(endp=endpoint_url,
slug=sub_category.parent.slug)
response = self.client.get(url)
self.assertEqual(response.status_code, 200, msg=url)
data = response.json()
# JSONSchema validation
self.assertJsonSchema(self.retrieve_sub_category_question_schema, data)
self.assertEqual(data['count'], 1)
# filter on main and sub
sub_category = self.parent_category.children.first()
url = '{endp}?main_slug={slug}&sub_slug={sub_slug}'.format(
endp=endpoint_url,
slug=sub_category.parent.slug,
sub_slug=sub_category.slug)
response = self.client.get(url)
self.assertEqual(response.status_code, 200, msg=url)
data = response.json()
# JSONSchema validation
self.assertJsonSchema(self.retrieve_sub_category_question_schema, data)
self.assertEqual(data['count'], 2)
def setUp(self):
self.department_read = Permission.objects.get(
codename='sia_department_read')
self.department_write = Permission.objects.get(
codename='sia_department_write')
self.sia_read_write_user.user_permissions.add(self.department_read)
self.sia_read_write_user.user_permissions.add(self.department_write)
self.department = DepartmentFactory.create()
self.maincategory = ParentCategoryFactory.create()
self.subcategory = CategoryFactory.create(parent=self.maincategory)
def setUp(self):
statusmessagetemplate_write_permission = Permission.objects.get(
codename='sia_statusmessagetemplate_write')
self.sia_read_write_user.user_permissions.add(
statusmessagetemplate_write_permission)
self.sia_read_write_user.save()
self.client.force_authenticate(user=self.sia_read_write_user)
self.subcategory = CategoryFactory.create()
self.link_cat_sub_templates = '/signals/v1/private/terms/categories/{}/sub_categories/{}/status-message-templates'.format( # noqa
self.subcategory.parent.slug, self.subcategory.slug)
self.link_cat_parent_templates = '/signals/v1/private/terms/categories/{}/status-message-templates'.format( # noqa
self.subcategory.parent.slug)
def test_missing_bbox_and_lonlat(self):
"""
Validate that when neither bbox or lon/lat is filled in to return a non_field_error
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(parent=parent_category,
is_public_accessible=False)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}')
data = response.json()
self.assertEqual(400, response.status_code)
self.assertIn('non_field_errors', data.keys())
self.assertEqual(1, len(data['non_field_errors']))
self.assertEqual('Either bbox or lon/lat must be filled in',
data['non_field_errors'][0])
def test_missing_lon(self):
"""
Validate that both lat /lon parameters have to be filled in if lons parameter is missing
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(parent=parent_category,
is_public_accessible=False)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&lat=5')
data = response.json()
self.assertEqual(400, response.status_code)
self.assertIn('non_field_errors', data.keys())
self.assertEqual(1, len(data['non_field_errors']))
self.assertEqual('Either bbox or lon/lat must be filled in',
data['non_field_errors'][0])
def test_sub_category_detail_questionnaire(self):
questionnaire = QuestionnaireFactory.create()
parent_category = ParentCategoryFactory.create()
sub_category = CategoryFactory.create(parent=parent_category,
questionnaire=questionnaire)
url = f'/signals/v1/public/terms/categories/{sub_category.parent.slug}/sub_categories/{sub_category.slug}'
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
data = response.json()
# JSONSchema validation
self.assertJsonSchema(self.retrieve_sub_category_schema, data)
self.assertIsNotNone(data['_links']['sia:questionnaire'])
self.assertEqual(data['questionnaire'],
str(sub_category.questionnaire.uuid))
def setUp(self):
self.signal = SignalFactory()
self.category = CategoryFactory()
self.category_assignment = CategoryAssignment.objects.create(
category=self.category, _signal_id=self.signal.id)
self.link_category = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format(
self.category.parent.slug, self.category.slug)
geometry = MultiPolygon(
[Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])],
srid=4326)
self.pt_in_center = Point(4.88, 52.36)
self.pt_out_center = Point(6, 53)
self.area = AreaFactory.create(geometry=geometry,
name='Centrum',
code='centrum',
_type__code='district')
def test_filter_maincategory_and_category_slugs_not_a_unique_slug(self):
parent_category = ParentCategoryFactory.create(name='not_unique')
category = CategoryFactory.create(name='not_unique',
parent=parent_category)
SignalFactory.create(category_assignment__category=category)
params = {
'maincategory_slug': [
parent_category.slug,
],
'category_slug': [
category.slug,
]
}
result_ids = self._request_filter_signals(params)
self.assertEqual(1, len(result_ids))
def setUp(self):
self.department = DepartmentFactory.create()
self.category = CategoryFactory.create(departments=[self.department])
self.signal = SignalFactory.create(
category_assignment__category=self.category)
self.attachment = ImageAttachmentFactory.create(
_signal=self.signal, created_by='*****@*****.**')
# Various Attachment delete permissions
self.permission_delete_other = Permission.objects.get(
codename='sia_delete_attachment_of_other_user')
self.permission_delete_anonymous_user = Permission.objects.get(
codename='sia_delete_attachment_of_anonymous_user')
self.permission_delete_normal = Permission.objects.get(
codename='sia_delete_attachment_of_normal_signal')
self.permission_delete_parent = Permission.objects.get(
codename='sia_delete_attachment_of_parent_signal')
self.permission_delete_child = Permission.objects.get(
codename='sia_delete_attachment_of_child_signal')
