def test_rfs_update(self): fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',)))) fieldset_b = rfs(('a__i', 'l')) fieldset_a.update(fieldset_b) assert_equal(str(fieldset_a), 'a(i),b(c,g),d(e(f)),l') assert_equal(str(fieldset_b), 'a(i),l')
def test_rfs_add_list(self): fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',)))) fieldset_b = ('a__i', 'l') fieldset_c = fieldset_a + fieldset_b assert_equal(str(fieldset_a), 'a,b(c,g),d(e(f))') assert_equal(str(fieldset_c), 'a(i),b(c,g),d(e(f)),l')
def test_processing_sms_is_timeouted(self): sms1 = OutputSMSFactory(state=ATS_STATES.PROCESSING, changed_at=timezone.now()) call_command('clean_processing_sms', stdout=StringIO(), stderr=StringIO()) assert_equal(OutputSMS.objects.get(pk=sms1.pk).state, ATS_STATES.PROCESSING) sms2 = OutputSMSFactory(state=ATS_STATES.PROCESSING, changed_at=timezone.now() - timedelta(seconds=11)) call_command('clean_processing_sms', stdout=StringIO(), stderr=StringIO()) assert_equal(OutputSMS.objects.get(pk=sms2.pk).state, ATS_STATES.TIMEOUT)
def test_change_and_save_with_update_only_changed_fields_should_change_only_defined_fields(self): obj = DiffModel.objects.create(name='test', datetime=timezone.now(), number=2) DiffModel.objects.filter(pk=obj.pk).update(name='test2') obj.change_and_save(number=3, update_only_changed_fields=True) obj.refresh_from_db() assert_equal(obj.name, 'test2') assert_equal(obj.number, 3)
def test_smart_model_pre_save(self): obj = TestPreProxySmartModel.objects.create() assert_equal(obj.name, 'test pre save') obj.name = 10 * 'a' obj.save() assert_equal(obj.name, 'test pre save') assert_true(TestPreProxySmartModel.objects.filter(name='test pre save').exists())
def test_get_domain_choices(self): choices = get_domain_choices() assert_equal(len(choices), 2) assert_equal(choices[0][1], 'backend') assert_equal(choices[1][1], 'frontend') assert_equal(choices[0][0], 1) assert_equal(choices[1][0], 2)
def test_num_enum(self): enum = NumEnum( 'A', 'B' ) assert_equal(enum.A, 1) assert_equal(enum.B, 2) with assert_raises(AttributeError): enum.C
def test_output_logged_requests_with_atomic_block_should_not_be_logged_if_exception_is_raised(self): responses.add(responses.GET, 'http://test.cz', body='test') with assert_raises(TestException): with transaction.atomic(): requests.get('http://test.cz') assert_equal(OutputLoggedRequest.objects.count(), 1) raise TestException assert_equal(OutputLoggedRequest.objects.count(), 0)
def test_smart_model_clean_pre_save(self): assert_raises(PersistenceException, TestProxySmartModel.objects.create, name=10 * 'a') obj = TestProxySmartModel.objects.create(name=9 * 'a') obj.name = 11 * 'a' assert_raises(PersistenceException, obj.save) assert_equal(len(TestProxySmartModel.objects.get(pk=obj.pk).name), 9) obj.save(is_cleaned_pre_save=False) assert_equal(len(TestProxySmartModel.objects.get(pk=obj.pk).name), 11)
def test_enum(self): enum = Enum( 'A', 'B' ) assert_equal(enum.A, 'A') assert_equal(enum.B, 'B') with assert_raises(AttributeError): enum.C # pylint: disable=W0104
def test_sms_template_for_unavailable_service_should_create_message_with_state_local_to_send(self): def raise_exception(request): raise requests.exceptions.HTTPError() responses.add_callback(responses.POST, settings.ATS_URL, content_type='text/xml', callback=raise_exception) assert_raises(SMSSendingError, send_template, '+420777111222', slug='test', context={'variable': 'context works'}, pk=245) assert_equal(OutputSMS.objects.get(pk=245).state, ATS_STATES.LOCAL_TO_SEND)
def test_user_may_edit_itself(self): user = self.logged_user.user resp = self.get('%s%s/' % (self.USER_UI_URL, user.pk)) assert_http_ok(resp) CHANGED_USERNAME = '******' self.post('%s%s/' % (self.USER_UI_URL, user.pk), data={'edit-is-user-username': CHANGED_USERNAME}) assert_http_ok(resp) assert_equal(User.objects.get(pk=user.pk).username, CHANGED_USERNAME)
def test_json_request_should_be_truncated_with_another_method(self): self.c.post('/admin/login/', data=json.dumps({'a': 50 * 'a', 'b': 50 * 'b'}), content_type='application/json') input_logged_request = InputLoggedRequest.objects.get() assert_equal( json.loads(input_logged_request.request_body), json.loads('{"a": "aaaaaaa...", "b": "bbbbbbb..."}') ) assert_false(input_logged_request.request_body.endswith('...'))
def test_return_json_snippet_content_without_snippet(self): resp = self.get(self.JSON_SNIPPET_URL) assert_equal( force_text(resp.content), '<div class="snippet snippet-1" data-snippet="test-snippet-1" data-snippet-type="replace">' 'test-snippet-1-content</div><div class="snippet snippet-2" data-snippet="test-snippet-2" ' 'data-snippet-type="replace">test-snippet-2-content</div>' ) assert_equal(resp['content-type'], 'text/html; charset=utf-8')
def test_ats_invalid_request_should_return_24_code(self): sms_count = InputSMS.objects.count() response = self.post(self.API_URL, self.ATS_SMS_POST_PAYLOAD.format(self.INVALID_MESSAGES)) self.assert_http_ok(response) # ATS requires to return 200 in every situation assert_equal(sms_count + 1, InputSMS.objects.count()) assert_equal(response.content.replace('\n', ' ').replace('\r', ''), '<?xml version="1.0" encoding="UTF-8" ?> <status> <code uniq="">24</code> ' '<code uniq="invalid">24</code> <code uniq="4">24</code> ' '<code uniq="5">23</code> </status>')
def test_translation_activate_block(self): @translation_activate_block(language='en') def en_block(): assert_equal(get_language(), 'en') assert_equal(get_language(), 'cs') en_block() assert_equal(get_language(), 'cs')
def test_subchoices_field_value_should_be_empty(self): self.inst.state = 4 # setting an invalid value try: TestFieldsModel._meta.get_field('state_reason').validate( # pylint: disable=W0212 TestFieldsModel.STATE_REASON.SUB_NOT_OK_2, self.inst) # pylint: disable=W0212 assert_true(False, 'Field validation should raise an error') except ValidationError as ex: assert_equal(['Value must be empty'], ex.messages) assert_is_none(TestFieldsModel._meta.get_field('state_reason').clean( # pylint: disable=W0212 TestFieldsModel.STATE_REASON.SUB_NOT_OK_2, self.inst)) # pylint: disable=W0212
def test_decimal_field(self): change_and_save(self.inst, decimal=3) assert_equal(self.inst.decimal, 3) assert_raises(PersistenceException, change_and_save, self.inst, decimal='2.99') assert_raises(PersistenceException, change_and_save, self.inst, decimal='10.00001') try: change_and_save(self.inst, decimal='11.1') assert_true(False, 'Previous `change_and_save` suppose to raise an exception') except PersistenceException as ex: assert_true('decimal: ' in str(ex), 'Exception message was supposed to contain a field name.')
def test_sms_template_should_be_immediately_send(self): responses.add(responses.POST, settings.ATS_URL, content_type='text/xml', body=self.ATS_SINGLE_SMS_REQUEST_RESPONSE_SENT.format(245), status=200) sms1 = send_template('+420777111222', slug='test', context={'variable': 'context works'}, pk=245) sms1 = OutputSMS.objects.get(pk=sms1.pk) assert_equal(sms1.state, ATS_STATES.OK) assert_true('context works' in sms1.content) assert_is_not_none(sms1.sent_at)
def test_decimal_field_should_return_correct_widget_attrs(self): kwargs = { 'step': 0.5, 'min': 1.0, 'max': 10.0, } field = DecimalField(**kwargs) widget_attrs = field.widget_attrs(TextInput()) assert_true(len(widget_attrs.keys()) > 0) for attr, value in kwargs.items(): assert_equal(value, widget_attrs[attr])
def test_get_object_or_404(self): obj = ShortcutsModel.objects.create(name='test1', datetime=timezone.now(), number=1) ShortcutsModel.objects.create(name='test2', datetime=timezone.now(), number=2) ShortcutsModel.objects.create(name='test2', datetime=timezone.now(), number=3) assert_equal(get_object_or_404(ShortcutsModel, name='test1'), obj) assert_raises(Http404, get_object_or_404, ShortcutsModel, name='test3') assert_raises(Http404, get_object_or_404, ShortcutsModel, number='test3') assert_raises(Http404, get_object_or_404, ShortcutsModel, datetime='test3') assert_raises(FieldError, get_object_or_none, ShortcutsModel, non_field='test2') assert_raises(MultipleObjectsReturned, get_object_or_none, ShortcutsModel, name='test2')
def test_smart_model_post_save(self): assert_raises(PersistenceException, TestPostProxySmartModel.objects.create) obj = TestPostProxySmartModel.objects.create(name=10 * 'a') assert_equal(obj.name, 'test post save') assert_false(TestPreProxySmartModel.objects.filter(name='test post save').exists()) assert_true(TestPreProxySmartModel.objects.filter(name=10 * 'a').exists()) obj.save() assert_true(TestPreProxySmartModel.objects.filter(name='test post save').exists()) obj.name = 10 * 'a' obj.save() assert_equal(obj.name, 'test post save') assert_false(TestPreProxySmartModel.objects.filter(name='test post save').exists())
def test_records_should_be_imported_from_csv(self): assert_equal(CSVRecord.objects.count(), 0) BulkCSVRecordImporter().import_csv() assert_equal(CSVRecord.objects.count(), 7) assert_equal(CSVRecord.objects.last().name, 'Geordi LaForge') # Ensure correct value is stored assert_equal(CSVRecord.objects.last().number, 888) # Ensure clean methods work
def test_serialization(self): for i in range(10): User.objects.create(is_superuser=True, email='test{}@test.cz'.format(i)) assert_true(isinstance(json.loads((serialize(User.objects.all()))), list)) assert_true(isinstance(json.loads((serialize(User.objects.first()))), dict)) assert_equal( set(json.loads((serialize(User.objects.first()))).keys()), {'_obj_name', 'id', 'created_at', 'contract', 'email'} ) assert_equal( set(json.loads((serialize(User.objects.first(), ('id',)))).keys()), {'id'} ) xml.dom.minidom.parseString(serialize(User.objects.first(), converter_name='xml'))
def test_enum_should_contain_only_defined_values(self): enum = Enum( 'A', 'B' ) assert_equal(enum.A, 'A') assert_equal(enum.B, 'B') assert_equal(list(enum), ['A', 'B']) assert_equal(enum.all, ('A', 'B')) assert_equal(enum.get_name('A'), 'A') with assert_raises(AttributeError): enum.C # pylint: disable=W0104 assert_is_none(enum.get_name('C')) assert_in('A', enum) assert_in(enum.A, enum) assert_not_in('C', enum)
def test_enum_with_distinct_key_and_value_should_contain_only_defined_values(self): enum = Enum( ('A', 'c'), ('B', 'd') ) assert_equal(enum.A, 'c') assert_equal(enum.B, 'd') assert_equal(list(enum), ['c', 'd']) assert_equal(enum.all, ('c', 'd')) assert_equal(enum.get_name('c'), 'A') with assert_raises(AttributeError): enum.C # pylint: disable=W0104 assert_is_none(enum.get_name('f')) assert_in('c', enum) assert_in(enum.A, enum) assert_not_in('A', enum)
def test_auto_gemerated_num_enum_should_contain_only_defined_values(self): enum = NumEnum( 'A', 'B' ) assert_equal(enum.A, 1) assert_equal(enum.B, 2) assert_equal(list(enum), [1, 2]) assert_equal(enum.all, (1, 2)) assert_equal(enum.get_name(1), 'A') with assert_raises(AttributeError): enum.C # pylint: disable=W0104 assert_is_none(enum.get_name(3)) assert_in(1, enum) assert_in(enum.A, enum) assert_not_in('A', enum)
def test_num_enum_with_defined_ids_should_return_valid_values(self): enum = NumEnum( ('A', 4), ('B', 2), 'C' ) assert_equal(enum.A, 4) assert_equal(enum.B, 2) assert_equal(enum.C, 3) assert_equal(list(enum), [4, 2, 3])
def test_output_logged_request_should_be_related_with_object(self, user): assert_http_redirect(self.post('/admin/login/', data={'username': '******', 'password': '******'})) responses.add(responses.GET, 'http://test.cz', body='test') assert_equal(self.get('/proxy/?url=http://test.cz').content, b'test') assert_equal(InputLoggedRequest.objects.count(), 2) assert_equal(OutputLoggedRequest.objects.count(), 1) output_logged_request = OutputLoggedRequest.objects.get() assert_equal(output_logged_request.related_objects.get().content_object, user)
def test_bulk_change_and_save(self): obj1 = ShortcutsModel.objects.create(name='test1', datetime=timezone.now(), number=1) obj2 = ShortcutsModel.objects.create(name='test2', datetime=timezone.now(), number=2) bulk_change_and_save([obj1, obj2], name='modified') assert_equal(obj1.name, 'modified') assert_equal(obj2.name, 'modified') assert_equal(ShortcutsModel.objects.first().name, 'modified') # instance is changed but NOT saved to DB assert_equal(ShortcutsModel.objects.last().name, 'modified') # instance is changed but NOT saved to DB
def test_decimal_field(self): change_and_save(self.inst, decimal=3) assert_equal(self.inst.decimal, 3) assert_raises(PersistenceException, change_and_save, self.inst, decimal='2.99') assert_raises(PersistenceException, change_and_save, self.inst, decimal='10.00001') try: change_and_save(self.inst, decimal='11.1') assert_true( False, 'Previous `change_and_save` suppose to raise an exception') except PersistenceException as ex: assert_true( 'decimal: ' in str(ex), 'Exception message was supposed to contain a field name.')
def test_on_success_inheritance(self): numbers_list = [] with transaction_signals(): with transaction_signals(): on_success(lambda: add_number(numbers_list, 0)) assert_equal(len(numbers_list), 0) assert_equal(len(numbers_list), 0) try: with transaction_signals(): on_success(lambda: add_number(numbers_list, 1)) assert_equal(len(numbers_list), 0) raise Exception() except Exception: pass on_success(lambda: add_number(numbers_list, 2)) assert_equal(len(numbers_list), 0) assert_equal(numbers_list, [0, 2])
def test_file_field(self): customer = Customer(**CUSTOMER__KWARGS) customer.save() avatar = Avatar() avatar.customer = customer avatar.image.save('test_file_secret_data', ContentFile('Super secret data'), save=False) avatar.save() avatar_2: Avatar = Avatar.objects.last() assert_equal(avatar_2.image.read(), b'Super secret data') avatar_2._anonymize_obj(base_encryption_key='LoremIpsumDolorSitAmet') avatar_3: Avatar = Avatar.objects.last() assert_not_equal(avatar_3.image.read(), b'Super secret data') # Cleanup avatar_3.image.delete() avatar_3.delete()
def test_file_field_real_file(self): anonymizer = anonymizer_register[Avatar] anonymizer.image.replacement_file = 'test_file' customer = Customer(**CUSTOMER__KWARGS) customer.save() avatar = Avatar() avatar.customer = customer avatar.image.save('test_file_real', ContentFile('Super secret data')) avatar_2: Avatar = Avatar.objects.last() assert_equal(avatar_2.image.read(), b'Super secret data') avatar_2._anonymize_obj(base_encryption_key='LoremIpsumDolorSitAmet') avatar_3: Avatar = Avatar.objects.last() assert_not_equal(avatar_3.image.read(), b'Super secret data') anonymizer.image.replacement_file = None # Cleanup avatar_3.image.delete() avatar_3.delete()
def test_clean_tokens_remove_only_old_tokens(self, user): expired_tokens = [ Token.objects.create(user=user, ip='127.0.0.1') for _ in range(10) ] not_expired_tokens = [ Token.objects.create(user=user, ip='127.0.0.1') for _ in range(settings.COUNT_USER_PRESERVED_TOKENS - 5) ] Token.objects.filter( pk__in=[token.pk for token in expired_tokens]).update( last_access=timezone.now() - timedelta(seconds=settings.MAX_TOKEN_AGE)) call_command('clean_tokens', stdout=StringIO(), stderr=StringIO()) assert_equal( Token.objects.filter( pk__in=[token.pk for token in not_expired_tokens]).count(), settings.COUNT_USER_PRESERVED_TOKENS - 5) assert_equal( Token.objects.filter(pk__in=[token.pk for token in expired_tokens]).count(), 5)
def test_should_correctly_handle_unknown_ats_state(self): responses.add(responses.POST, settings.ATS_URL, content_type='text/xml', body=self.ATS_UNKNOW_STATE_RESPONSE, status=200) sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[0], **self.ATS_OUTPUT_SMS1) sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[1], **self.ATS_OUTPUT_SMS2) response = send_ats_requests(sms1, sms2) with open('./var/log/ats_sms.log') as ats_log: log_lines_count = sum(1 for _ in ats_log) response_codes = parse_response_codes(response.text) ats_log.seek(0) log_lines = ats_log.readlines() assert_equal(log_lines_count + 1, len(log_lines)) assert_true('999' in log_lines[-1]) assert_false(response_codes)
def test_verification_token_should_be_found_by_model_class_or_instance( self, user): # 2 users of the same content type with tokens created user2 = User.objects._create_user('user2', '*****@*****.**', 'test2') token = VerificationToken.objects.deactivate_and_create(user) VerificationToken.objects.deactivate_and_create( user2, deactivate_old_tokens=False) # another content type object with token created group = Group.objects.create(name='authorized_group') token_from_group = VerificationToken.objects.deactivate_and_create( group, deactivate_old_tokens=False) tokens_by_class = VerificationToken.objects.filter_active_tokens(User) assert_equal(tokens_by_class.count(), 2) tokens_by_object = VerificationToken.objects.filter_active_tokens(user) assert_equal(tokens_by_object.count(), 1) assert_token_is_same_active_and_valid(tokens_by_object.first(), token) tokens_by_object = VerificationToken.objects.filter_active_tokens( Group) assert_equal(tokens_by_object.count(), 1) assert_token_is_same_active_and_valid(tokens_by_object.first(), token_from_group)
def test_output_logged_request_should_be_related_with_object(self, user): with capture_security_logs() as logged_data: assert_http_redirect(self.post('/admin/login/', data={'username': '******', 'password': '******'})) responses.add(responses.GET, 'http://localhost', body='test') assert_equal(self.get('/proxy/?url=http://localhost').content, b'test') assert_equal(len(logged_data.output_request[0].related_objects), 1) assert_equal(list(logged_data.output_request[0].related_objects)[0], get_object_triple(user))
def test_input_logged_request_should_have_set_data(self, user): with capture_security_logs() as logged_data: assert_http_redirect(self.post('/admin/login/', data={'username': '******', 'password': '******'})) assert_http_ok(self.get('/home/')) assert_equal(len(logged_data.input_request[1].related_objects), 1) assert_equal(list(logged_data.input_request[1].related_objects)[0], get_object_triple(user)) assert_equal(logged_data.input_request_finished[1].slug, 'user-home')
def create_and_upldate_test_on_dispatcher_model(): model = TestDispatchersModel.objects.create() assert_equal(TestOnDispatchModel.objects.count(), 0) model.change_and_save(state=2) assert_equal(TestOnDispatchModel.objects.count(), 0) model.change_and_save(state=1) assert_equal(TestOnDispatchModel.objects.count(), 0)
def test_more_test_on_dispatch_instances_should_be_created_if_transaction_signals_is_not_activated(self): model = TestDispatchersModel.objects.create() assert_equal(TestOnDispatchModel.objects.count(), 1) model.change_and_save(state=2) assert_equal(TestOnDispatchModel.objects.count(), 2) model.change_and_save(state=1) assert_equal(TestOnDispatchModel.objects.count(), 3)
def test_celery_task_should_have_rightly_set_expires_time_if_stale_time_limit_is_set_in_task_call( self): sum_task.apply_async(args=(5, 8), stale_time_limit=100) celery_task_log = CeleryTaskLog.objects.get() assert_equal(celery_task_log.estimated_time_of_first_arrival, now()) assert_equal(celery_task_log.stale, now() + timedelta(seconds=100)) assert_equal(celery_task_log.expires, now() + timedelta(seconds=90))
def test_model_diff(self): obj = DiffModel.objects.create(name='test', datetime=timezone.now(), number=2) assert_false(obj.has_changed) obj.name = 'test2' assert_true(obj.has_changed) assert_equal(set(obj.changed_fields.keys()), {'name'}) assert_equal((obj.changed_fields['name'].initial, obj.changed_fields['name'].current), ('test', 'test2')) obj.name = 'test' assert_false(obj.has_changed) assert_false(obj.changed_fields) obj.name = 'test2' obj.number = 3 obj.datetime = obj.datetime + timedelta(days=2) assert_true(obj.has_changed) assert_equal(set(obj.changed_fields.keys()), {'name', 'number', 'datetime'}) obj.save() assert_false(obj.has_changed) assert_false(obj.changed_fields)
def test_apply_task_with_related_objects_should_be_stored(self, user): sum_task.apply_async(args=(5, 8), related_objects=[user]) assert_equal(CeleryTaskLog.objects.count(), 1) assert_equal(CeleryTaskLog.objects.get().state, CeleryTaskLogState.SUCCEEDED) assert_equal(CeleryTaskLog.objects.get().related_objects.get().object, user)
def test_expirement_legal_reason_related(self): related_email: Email = Email(customer=self.customer, email=CUSTOMER__EMAIL) related_email.save() related_email2: Email = Email(customer=self.customer, email=CUSTOMER__EMAIL2) related_email2.save() related_email3: Email = Email(customer=self.customer, email=CUSTOMER__EMAIL3) related_email3.save() legal = LegalReason.objects.create_consent(EMAIL_SLUG, self.customer) legal.expire() anon_customer = Customer.objects.get(pk=self.customer.pk) assert_equal(anon_customer.primary_email_address, CUSTOMER__EMAIL) self.assertAnonymizedDataNotExists(anon_customer, "primary_email_address") # make sure only data we want were anonymized assert_equal(anon_customer.first_name, CUSTOMER__FIRST_NAME) self.assertAnonymizedDataNotExists(anon_customer, "first_name") anon_related_email: Email = Email.objects.get(pk=related_email.pk) assert_not_equal(anon_related_email.email, CUSTOMER__EMAIL) self.assertAnonymizedDataExists(anon_related_email, "email") anon_related_email2: Email = Email.objects.get(pk=related_email2.pk) assert_not_equal(anon_related_email2.email, CUSTOMER__EMAIL2) self.assertAnonymizedDataExists(anon_related_email2, "email") anon_related_email3: Email = Email.objects.get(pk=related_email3.pk) assert_not_equal(anon_related_email3.email, CUSTOMER__EMAIL3) self.assertAnonymizedDataExists(anon_related_email3, "email")
def test_sequence_choices_num_enum(self): # Only the first state is valid when field is null because it is the initial state assert_is_none(self.inst.state_graph) assert_raises(PersistenceException, change_and_save, self.inst, state_graph=TestFieldsModel.GRAPH.SECOND) assert_raises(PersistenceException, change_and_save, self.inst, state_graph=TestFieldsModel.GRAPH.THIRD) change_and_save(self.inst, state_graph=TestFieldsModel.GRAPH.FIRST) assert_equal(self.inst.state_graph, TestFieldsModel.GRAPH.FIRST) # Than one can switch only to second state assert_raises(PersistenceException, change_and_save, self.inst, state_graph=TestFieldsModel.GRAPH.THIRD) change_and_save(self.inst, state_graph=TestFieldsModel.GRAPH.SECOND) assert_equal(self.inst.state_graph, TestFieldsModel.GRAPH.SECOND) # We cannot go back to first but we can go to the third state assert_raises(PersistenceException, change_and_save, self.inst, state_graph=TestFieldsModel.GRAPH.FIRST) change_and_save(self.inst, state_graph=TestFieldsModel.GRAPH.THIRD) assert_equal(self.inst.state_graph, TestFieldsModel.GRAPH.THIRD)
def test_output_logged_request_should_be_related_with_object(self, user): assert_http_redirect( self.post('/admin/login/', data={ 'username': '******', 'password': '******' })) responses.add(responses.GET, 'http://test.cz', body='test') assert_equal(self.get('/proxy/?url=http://test.cz').content, b'test') assert_equal(InputLoggedRequest.objects.count(), 2) assert_equal(OutputLoggedRequest.objects.count(), 1) output_logged_request = OutputLoggedRequest.objects.get() assert_equal( output_logged_request.related_objects.get().content_object, user)
def test_command_should_check_delivery_status(self): responses.add( responses.POST, settings.ATS_URL, content_type='text/xml', body=self.ATS_SMS_DELIVERY_RESPONSE.format(*self.ATS_TEST_UNIQ), status=200) sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[1], sent_at=timezone.now(), state=ATS_STATES.OK, **self.ATS_OUTPUT_SMS2) sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[0], sent_at=timezone.now(), state=ATS_STATES.OK, **self.ATS_OUTPUT_SMS1) CheckDeliveryCommand().handle() sms1 = OutputSMS.objects.get(pk=sms1.pk) sms2 = OutputSMS.objects.get(pk=sms2.pk) assert_equal( strip_all(responses.calls[0].request.body), strip_all( self.ATS_SMS_DELIVERY_REQUEST.format( first_id=self.ATS_TEST_UNIQ[0], second_id=self.ATS_TEST_UNIQ[1]))) assert_equal(sms1.state, ATS_STATES.SENT) assert_equal(sms2.state, ATS_STATES.DELIVERED)
def test_error_command_should_be_logged_in_elasticsearch_backend(self, user): with capture_security_logs() as logged_data: with log_with_data(related_objects=[user]): with assert_raises(RuntimeError): test_call_command('test_error_command') elasticsearch_command_log = ElasticsearchCommandLog.get( id=logged_data.command[0].id ) assert_equal_model_fields( elasticsearch_command_log, name='test_error_command', input='', is_executed_from_command_line=False, time=(elasticsearch_command_log.stop - elasticsearch_command_log.start).total_seconds(), state=CommandState.FAILED, output=None, ) assert_is_not_none(elasticsearch_command_log.error_message) assert_equal( [rel_obj for rel_obj in elasticsearch_command_log.related_objects], ['default|3|{}'.format(user.id)] )
def test_serialization(self): for i in range(10): User.objects.create(is_superuser=True, email='test{}@test.cz'.format(i)) assert_true( isinstance(json.loads((serialize(User.objects.all()))), list)) assert_true( isinstance(json.loads((serialize(User.objects.first()))), dict)) assert_equal( set(json.loads((serialize(User.objects.first()))).keys()), { 'id', 'created_at', '_obj_name', 'email', 'contract', 'solving_issue', 'first_name', 'last_name', 'manual_created_date' }) assert_equal( set( json.loads((serialize(User.objects.first(), ('id', )))).keys()), {'id'}) xml.dom.minidom.parseString( serialize(User.objects.first(), converter_name='xml'))
def test_command_should_send_and_update_sms(self): responses.add(responses.POST, settings.ATS_URL, content_type='text/xml', body=self.ATS_SMS_REQUEST_RESPONSE_SENT.format( *self.ATS_TEST_UNIQ), status=200) sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[0], **self.ATS_OUTPUT_SMS1) sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[1], **self.ATS_OUTPUT_SMS2) SendCommand().handle() sms1 = OutputSMS.objects.get(pk=sms1.pk) sms2 = OutputSMS.objects.get(pk=sms2.pk) assert_equal(sms1.state, ATS_STATES.OK) assert_is_not_none(sms1.sent_at) assert_equal(sms2.state, ATS_STATES.LOCAL_UNKNOWN_ATS_STATE) assert_is_not_none(sms2.sent_at)
def test_should_send_ats_request_and_parse_response_codes(self, prefix): responses.add(responses.POST, settings.ATS_SMS_URL, content_type='text/xml', status=200, body=self.ATS_SMS_REQUEST_RESPONSE_SENT.format(prefix=prefix, **self.ATS_TEST_UNIQ)) sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ['uniq1'], **self.ATS_OUTPUT_SMS1) sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ['uniq2'], **self.ATS_OUTPUT_SMS2) response = send_ats_requests(sms1, sms2) assert_equal(response.request.url, 'http://fik.atspraha.cz/gwfcgi/XMLServerWrapper.fcgi') assert_equal(response.request.headers['content-type'], 'text/xml') response_codes = parse_response_codes(response.text) assert_equal(response_codes[self.ATS_TEST_UNIQ['uniq1']], 0) assert_equal(response_codes[self.ATS_TEST_UNIQ['uniq2']], 123456)
def test_celery_task_should_have_rightly_set_expires_time_according_to_default_task_stale_limit_value( self): error_task.apply_async() celery_task_log = CeleryTaskLog.objects.get() assert_equal(celery_task_log.estimated_time_of_first_arrival, now()) assert_equal(celery_task_log.stale, now() + timedelta(seconds=60 * 60)) assert_equal(celery_task_log.expires, now() + timedelta(seconds=60 * 60 - 10))
def test_rfs_add(self): fieldset_a = rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f', )))) fieldset_b = rfs(('a__i', 'l')) fieldset_c = fieldset_a + fieldset_b assert_equal(str(fieldset_a), 'a,b(c,g),d(e(f))') assert_equal(str(fieldset_b), 'a(i),l') assert_equal(str(fieldset_c), 'a(i),b(c,g),d(e(f)),l')
def test_command_should_be_logged_in_elasticsearch_backend(self, user): with capture_security_logs() as logged_data: with log_with_data(related_objects=[user]): test_call_command('test_command', verbosity=0) elasticsearch_command_log = ElasticsearchCommandLog.get( id=logged_data.command[0].id ) assert_equal_model_fields( elasticsearch_command_log, name='test_command', input='verbosity=0', is_executed_from_command_line=False, time=(elasticsearch_command_log.stop - elasticsearch_command_log.start).total_seconds(), state=CommandState.SUCCEEDED, error_message=None, ) assert_is_not_none(elasticsearch_command_log.output) assert_equal( [rel_obj for rel_obj in elasticsearch_command_log.related_objects], ['default|3|{}'.format(user.id)] ) ElasticsearchCommandLog._index.refresh() assert_equal(get_logs_related_with_object(LoggerName.COMMAND, user), [elasticsearch_command_log])
def test_stale_succeded_celery_task_should_not_be_set_as_succeeded_with_command( self): sum_task.apply_async(args=(5, 8)) celery_task_log = CeleryTaskLog.objects.create( celery_task_id='random id', name='error_task', queue_name='default', input='', task_args=[], task_kwargs={}, estimated_time_of_first_arrival=now() - timedelta(minutes=5), expires=now() - timedelta(minutes=4), stale=now() - timedelta(minutes=3)) CeleryTaskRunLog.objects.create(celery_task_id='random id', name='error_task', state=CeleryTaskRunLogState.SUCCEEDED, task_args=[], task_kwargs={}, retries=0) test_call_command('set_celery_task_log_state') assert_equal(celery_task_log.refresh_from_db().state, CeleryTaskLogState.SUCCEEDED)
def test_state_dispatcher(self): m = TestDispatchersModel.objects.create() # Moving TestDispatcher model to SECOND state should create new TestSmartModel instance assert_equal(TestSmartModel.objects.count(), 0) change_and_save(m, state=TestDispatchersModel.STATE.SECOND) assert_equal(TestSmartModel.objects.count(), 1) # But subsequent saves should not create more instances change_and_save(m, state=TestDispatchersModel.STATE.SECOND) assert_equal(TestSmartModel.objects.count(), 1) # Moving back and forth between the states creates another instance change_and_save(m, state=TestDispatchersModel.STATE.FIRST) change_and_save(m, state=TestDispatchersModel.STATE.SECOND) assert_equal(TestSmartModel.objects.count(), 2)
def test_smart_queryset_fast_distinct(self): t = TestSmartModel.objects.create(name='name') RelatedSmartModel.objects.create(test_smart_model=t) RelatedSmartModel.objects.create(test_smart_model=t) qs = TestSmartModel.objects.filter( test_smart_models__test_smart_model=t) assert_equal(qs.count(), 2) assert_equal(tuple(qs.values_list('pk', flat=True)), (t.pk, t.pk)) assert_equal(qs.fast_distinct().count(), 1)
def test_get_object_or_none(self): obj = ShortcutsModel.objects.create(name='test1', datetime=timezone.now(), number=1) ShortcutsModel.objects.create(name='test2', datetime=timezone.now(), number=2) ShortcutsModel.objects.create(name='test2', datetime=timezone.now(), number=3) assert_equal(get_object_or_none(ShortcutsModel, name='test1'), obj) assert_is_none(get_object_or_none(ShortcutsModel, name='test3')) assert_is_none(get_object_or_none(ShortcutsModel, number='test3')) assert_is_none(get_object_or_none(ShortcutsModel, datetime='test3')) assert_raises(FieldError, get_object_or_none, ShortcutsModel, non_field='test2') assert_raises(MultipleObjectsReturned, get_object_or_none, ShortcutsModel, name='test2')