def test_and(self): req = HttpRequest() req.user = AnonymousUser() self.assertTrue(AlwaysAndAlways(request=req).is_authorized()) self.assertFalse(AlwaysAndNever(request=req).is_authorized()) self.assertFalse(NeverAndAlways(request=req).is_authorized()) self.assertFalse(NeverAndNever(request=req).is_authorized())
def test_upload_file(self): VARIANT_SET_NAME = 'newVariant' self.assertEqual(0, VariantSet.objects.count()) refGenome = self.common_entities['reference_genome'] request = HttpRequest() request.POST = { 'refGenomeUid': refGenome.uid, 'variantSetName': VARIANT_SET_NAME, 'createSetType': 'from-file' } request.method = 'POST' request.user = self.common_entities['user'] authenticate(username=TEST_USERNAME, password=TEST_PASSWORD) self.assertTrue(request.user.is_authenticated()) #random test file selected variant_set_file = os.path.join(GD_ROOT, 'test_data', 'recoli_321UAG_variant_set_upload.vcf') mock_uploaded_file = UploadedFile( file=StringIO.StringIO(), name=variant_set_file) request.FILES['vcfFile'] = mock_uploaded_file response = create_variant_set(request) self.assertEqual(STATUS_CODE__SUCCESS, response.status_code) variantsets = VariantSet.objects.all() self.assertEqual(1, len(variantsets)) self.assertEqual(VARIANT_SET_NAME, VariantSet.objects.get().label) self.assertEqual(refGenome, VariantSet.objects.get().reference_genome)
def handle(self, *args, **options): # Check params if len(args) != 4: raise CommandError('Invalid number of parameters!') # Get translation object translation = self.get_translation(args) # Get user try: user = User.objects.get(email=options['author']) except User.DoesNotExist: raise CommandError('Import user does not exist!') # Create fake request object request = HttpRequest() request.user = user # Process import try: with open(args[3], 'rb') as handle: translation.merge_upload( request, handle, False, method='suggest', author=get_author_name(user), ) except IOError: raise CommandError('Failed to import translation file!')
def test_mixed(self): req = HttpRequest() req.user = AnonymousUser() AAAAndAON = And(AlwaysAndAlways, AlwaysOrNever) AOAAndAAN = And(AlwaysOrAlways, AlwaysAndNever) self.assertTrue(AAAAndAON(request=req).is_authorized()) self.assertFalse(AOAAndAAN(request=req).is_authorized())
def handle(self, *args, **options): # Check params if len(args) != 4: raise CommandError('Invalid number of parameters!') # Get translation object try: translation = Translation.objects.get( subproject__project__slug=args[0], subproject__slug=args[1], language__code=args[2], ) except Translation.DoesNotExist: raise CommandError('No matching translation project found!') # Get user try: user = User.objects.get(email=options['author']) except User.DoesNotExist: raise CommandError('Import user does not exist!') # Create fake request object request = HttpRequest() request.user = user # Process import try: with open(args[3], 'r') as handle: translation.merge_upload( request, handle, False, method='suggest', author=get_author_name(user), ) except IOError: raise CommandError('Failed to import translation file!')
def test_list_owner_is_saved_if_user_is_authenticated(self): request = HttpRequest() request.user = User.objects.create(email='*****@*****.**') request.POST['text'] = 'new list item' new_list(request) list_ = List.objects.first() self.assertEqual(list_.owner, request.user)
def test_with_server_name(self): request = HttpRequest() request.META = { 'SERVER_NAME': 'example.com', 'SERVER_PORT': 80 } self.assertEqual(Site.find_for_request(request), self.site)
def test_get_ip(self): request = HttpRequest() request.META['REMOTE_ADDR'] = '1.2.3.4' self.assertEqual( get_ip_address(request), '1.2.3.4' )
def test_agent(self): request = HttpRequest() request.META['HTTP_USER_AGENT'] = 'agent' self.assertEqual( get_user_agent(request), 'Other / Other / Other' )
def test_movie_no_add_during_get_request(self): request = HttpRequest() request.method = 'GET' home_page(request) self.assertEqual(Movie.objects.count(), 0)
def test_agent_long(self): request = HttpRequest() request.META['HTTP_USER_AGENT'] = 'agent ' * 200 self.assertLess( len(get_user_agent(request)), 200 )
def test_not(self): req = HttpRequest() req.user = AnonymousUser() self.assertFalse(NotAlways(request=req).is_authorized()) self.assertTrue(NotNever(request=req).is_authorized()) self.assertFalse(NotNeverAlways(request=req).is_authorized()) self.assertFalse(NotAlwaysNever(request=req).is_authorized()) self.assertTrue(NotNeverNever(request=req).is_authorized())
def test_vocabulary_render_one(self): request = HttpRequest() request.course = self.sample_course vocabulary = Vocabulary.objects.get(name="shapes") detail = VocabularyResource().render_one(request, vocabulary) self.assertEquals(detail['display_name'], "Shapes") self.assertEquals(len(detail['term_set']), 2)
def test_calls_auth_login_if_authenticate_returns_a_user(self, mock_login, mock_authenticate): request = HttpRequest() request.POST['assertion'] = 'asserted' mock_user = mock_authenticate.return_value login(request) mock_login.assert_called_once_with(request, mock_user)
def test_movie_save_post_content_and_return(self): request = HttpRequest() request.method = 'POST' request.POST['movie_name'] = 'Troy' home_page(request) self.assertEqual(Movie.objects.count(), 1) self.assertEqual(Movie.objects.first().name, "Troy")
def test_movie_save_post_content_and_redirect(self): request = HttpRequest() request.method = 'POST' request.POST['movie_name'] = 'Troy' response = home_page(request) self.assertEqual(response.status_code, 302) self.assertEqual(response['location'], "/")
def test_home_page_redirects_after_POST(self): request = HttpRequest() request.method = "POST" request.POST["item_text"] = 'A new list item' response = home_page(request) self.assertEqual(response.status_code, 302) self.assertEqual(response['location'], '/')
def test_object_permitted(self): tmpl = """ {% if "editable" in perm.permitter_test.CanEditObject %} success! {% endif %} """ req = HttpRequest() req.user = AnonymousUser() resp = Template(tmpl).render(RequestContext(req)) self.assertTrue('success!' in resp)
def test_home_page_can_save_a_POST_request(self): request = HttpRequest() request.method = 'POST' request.POST['item_text'] = 'A new list item' response = home_page(request) self.assertEqual(Item.objects.all().count(), 1) new_item = Item.objects.all()[0] self.assertEqual(new_item.text, 'A new list item')
def test_missing_required_perm_arguments(self): tmpl = """ {% if perm.permitter_test.CanEditObject %} fail {% endif %} """ req = HttpRequest() req.user = User() tmpl, ctx = Template(tmpl), RequestContext(req) self.assertRaises(KeyError, lambda: tmpl.render(ctx))
def test_simple_not_permitted(self): tmpl = """ {% if not perm.permitter_test.NeverAuthorized %} success! {% endif %} """ req = HttpRequest() req.user = AnonymousUser() resp = Template(tmpl).render(RequestContext(req)) self.assertTrue('success!' in resp)
def test_home_page_can_save_a_POST_requeste(self): request = HttpRequest() request.method = "POST" request.POST["item_text"] = 'A new list item' response = home_page(request) self.assertEqual(Item.objects.count(), 1) newItem = Item.objects.first() self.assertEqual(newItem.text, 'A new list item')
def test_movie_list_in_table(self): Movie.objects.create(name = "Troy") Movie.objects.create(name = "Terminator") request = HttpRequest() request.method = 'GET' response = home_page(request) self.assertIn("Troy", response.content) self.assertIn("Terminator", response.content)
def test_get_from_request(self): request = HttpRequest() request.POST = {'param1': 'str1'} self.assertEqual('str1', DjangoAppUtils.get_from_request(request, 'param1')) self.assertIsNone(DjangoAppUtils.get_from_request(request, 'param2')) self.assertEqual('default', DjangoAppUtils.get_from_request( request, 'param2', 'default') )
def _get_list_response_internal(self, **kwargs): logger.info('kwargs: %r', kwargs) request = HttpRequest() class User: is_superuser = True # @staticmethod # def is_superuser(): # return true request.user = User result = self._get_list_response(request, **kwargs) return result
def test_EmailConfirmationMiddleware(self): request = HttpRequest() request.user = self.u from django.contrib.messages.storage.fallback import FallbackStorage setattr(request, "session", "session") messages = FallbackStorage(request) setattr(request, "_messages", messages) mid = EmailConfirmationMiddleware() mid.process_request(request)
def test_add_online_course_save_given_course(self): request = HttpRequest() request.method = 'POST' request.POST['course_name'] = 'Apache Spark' request.POST['course_url'] = 'www.coursera.com/apache_spark' request.POST['course_description'] = 'Introduction to Apache Spark' add_online_course(request) courses = Course.objects.all() self.assertEqual("Apache Spark",courses[0].name) self.assertEqual('Introduction to Apache Spark',courses[0].description)
def test_vocabulary_render_list(self): request = HttpRequest() request.course = self.sample_course lst = VocabularyResource().render_list( request, Vocabulary.objects.get_for_object(request.course)) self.assertEquals(len(lst), 2) self.assertEquals(lst[0]['display_name'], "Colors") self.assertEquals(len(lst[0]['term_set']), 3) self.assertEquals(lst[1]['display_name'], "Shapes") self.assertEquals(len(lst[1]['term_set']), 2)
def test_user_login(user_data, user): from django.contrib.auth import authenticate, login from django.http.request import HttpRequest from django.contrib.sessions.backends.cache import SessionStore assert user.activate('516bb9061d58280acd0c3900e18feaf5166f02ff') request = HttpRequest() request.session = SessionStore() user = authenticate( username=user_data['username'], password=user_data['password']) login(request, user) assert user.is_authenticated()
def test_email_confirmation_required_w_redirect(self): request = HttpRequest() request.user = self.u # Set the required properties of your request function = lambda x: x decorator = email_confirmation_required(function) response = decorator(request) rurl = reverse("gogonzo_email_confirmation:alert", kwargs={"email": self.u.email}) # Testing that it redirects, since the user is not confirmed self.assertTrue(rurl == response.url)
def test_periodic_table_module_render_data_returns_the_chosen_element_if_given( self, render_template): # Arrange request = HttpRequest() element = "AC" my_module = PeriodicTableModule() my_module.data = element # Act result = my_module._render_data(request) self.assertEqual(True, result == "Chosen element: " + element)
def test_parse_kakao_user_id(self): request = HttpRequest() data = {'userRequest': {'user': {'id': 'test123'}}} setattr(request, 'data', data) kakao = Kakao() kakao.preprocess(request) kakao.parse_kakao_user_id() self.assertEqual(kakao.kakao_user_id, 'test123') self.assertEqual(kakao.kakao_user_id_parsed, True)
def _render_form_error(self, err_message): if type(err_message) not in [str, unicode]: raise TypeError('Error message should be string or unicode (' + str(type(err_message)) + ' given)') context = RequestContext(HttpRequest()) data = {'message': err_message} context.update(data) return self.templates['form_error'].render(context)
def test_get_object_by_kakao_user_id_fail(self): request = HttpRequest() data = {'userRequest': {'user': {'id': 'test123'}}} setattr(request, 'data', data) kakao = KakaoResponseAPI() kakao.preprocess(request) kakao.request = request self.assertRaises(Http404, kakao.get_object_by_kakao_user_id)
def items(self, obj): search_view = SearchView(request=HttpRequest()) Query_Q = search_view.parse_q_object( members_ids=[], parties_ids=[], tags_ids=[], phrases=[x.keyword for x in obj.words_in_rss_feed.all()]) return Facebook_Status.objects.filter(Query_Q).order_by( '-published')[:MAX_STATUSES_IN_RSS_FEED]
def setUp(self): self.request = HttpRequest() self.request.session = {} address = Address.objects.create( street="Matematicka 47", town="Algebrovo", postal_code="420 47", country=Country("SK") ) self.school = School.objects.create( abbreviation="GJH", verbose_name="Gymnázium Janka Hraška", pk=2, street="Hronca 42", city="Bratislava", zip_code="123 45", ) self.user = User.objects.create( username="******", first_name="Janko", last_name="Hrasko", password="******", gender="M", birth_date=datetime.date(1999, 9, 19), email="*****@*****.**", mail_to_school=True, school=self.school, graduation=2018, home_address=address, ) self.form_data = { "username": "******", "password1": "heslo", "password2": "heslo", "first_name": "Jožko", "last_name": "Mrkvička", "gender": "M", "mailing_option": constants.MAILING_OPTION_SCHOOL, "school": 2, "graduation": 2017, "street": "Pekná 47", "town": "Bratislava", "postal_code": "420 47", "country": Country("SK"), "birth_date": datetime.date(2016, 8, 19), "email": "*****@*****.**", } self.form_data_corr = self.form_data.copy() self.form_data_corr.update( { "username": "******", "corr_street": "Pekna 47", "corr_town": "Krasno", "corr_postal_code": "842 47", "corr_country": Country("SK"), } ) self.full_name = "Jožko Mrkvička"
def test_accept_proposal(self): self.client.login(request=HttpRequest(), username=self.professional.user.email, password='******') response = self.client.put( f'/proposals/{self.proposal.uuid}/accept.json') self.assertEqual(response.status_code, 200, response.content) self.assertIn('accepted', response.json()) self.assertEqual(response.json()['accepted'], True) self.assertIn('job', response.json()) self.assertEqual(response.json()['job'], str(self.proposal.job.uuid))
def setUp(self): # call parent setUp super(ComposerTestSuite, self).setUp() # create the request self.request = HttpRequest() # create the session engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) # init the session self.request.session['includedTypesCompose'] = []
def get_tenant_for_request(request: HttpRequest) -> Tenant: """Get tenant object for current request""" db_tenants = ( Tenant.objects.annotate(host_domain=V(request.get_host())) .filter(Q(host_domain__iendswith=F("domain")) | _q_default) .order_by("default") ) tenants = list(db_tenants.all()) if len(tenants) < 1: return DEFAULT_TENANT return tenants[0]
def setUp(self): schema_data = join('utils', 'XSDParser', 'tests', 'data', 'parser') self.schema_data_handler = DataHandler(schema_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['curateFormData'] = self.form_id
def handle(self, *args, **options): # Get translation object translation = self.get_translation(**options) # Create fake request object request = HttpRequest() request.user = None # Process import try: translation.merge_upload(request, options['file'], False, method='suggest', author_email=options['author']) except IOError as err: raise CommandError( 'Failed to import translation file: {}'.format(err)) finally: options['file'].close()
def send_mail( self, subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name=None): reset_url = HttpRequest.build_absolute_uri( reverse( 'account_reset_password_confirm', kwargs={'uidb64': context['uid'], 'token': context['token']})) context['reset_url'] = reset_url send_templated_mail( 'account/password_set', from_email=from_email, recipient_list=[to_email], context=context)
def test_custo_read_404(self): """ Tests the NOT_FOUND case of the reading of resource: ID=9999999 """ http_response = get_custom_algo(http_request=HttpRequest(), customized_algo_id=9999999, query_dict=None) self.assertTrue(http_response.status_code == HttpResponseFactory.NOT_FOUND_HTTP_STATUS)
def is_module_managing_occurencies(module): request = HttpRequest() request.method = 'GET' request.GET = { 'url': module.url, 'module_id': module.id, 'managing_occurences': True } module_view = get_module_view(module.url) response = module_view(request).content.decode("utf-8") if response == 'false': return False elif response == 'true': return True else: raise ValueError("Unexpected value (expected 'true'|'false', got {})".format(response))
def line_login(self): response_type = "code" client_id = os.environ.get("LINE_CHANNEL") redirect_uri = HttpRequest.build_absolute_uri( self, reverse("users:line-callback")) state = "asjdklqlkfj" # todo unique state scope = "openid%20profile" return redirect( f"https://access.line.me/oauth2/v2.1/authorize?response_type={response_type}&client_id={client_id}&state={state}&scope={scope}&nonce=asdasd&redirect_uri={redirect_uri}" )
def test_login_not_active(monkeypatch): user = User() user.is_active = False authenticate_mock = mock.MagicMock(return_value=user) login_mock = mock.Mock() monkeypatch.setattr(views, 'authenticate', authenticate_mock) monkeypatch.setattr(views, 'login', login_mock) method = 'POST' request = HttpRequest() request.method = method result = views.login_user(request=request) authenticate_mock.assert_called_once() login_mock.assert_not_called() assert result.status_code == 200
def verify_bitcoin_signature(address: str, challenge: str, signature: str, request: HttpRequest) -> bool: """Verifies if the provided bitcoin signature is valid.""" network = getattr(settings, "DJCL_BITCOIN_NETWORK", None) if not network: warnings.warn( _("Please configure the bitcoin network in the settings file")) is_testnet = True if network == "testnet" else False callback_uri = request.build_absolute_uri() return bitid.challenge_valid(address, signature, challenge, callback_uri, is_testnet)
def store_workflow_nrows_in_session(request: HttpRequest, wflow: Workflow): """Store the workflow id and name in the request.session dictionary. :param request: Request object :param wflow: Workflow object :return: Nothing. Store the id and the name in the session """ request.session['ontask_workflow_rows'] = wflow.nrows request.session.save()
def test_commit_groupping(self): component = self.create_component() translation = component.translation_set.get(language_code='cs') request = HttpRequest() request.user = create_test_user() start_rev = component.repository.last_revision # Initial translation for unit in translation.unit_set.all(): unit.translate(request, 'test2', STATE_TRANSLATED) # Translation completed, no commit forced self.assertEqual(start_rev, component.repository.last_revision) # Translation from same author should not trigger commit for unit in translation.unit_set.all(): unit.translate(request, 'test3', STATE_TRANSLATED) for unit in translation.unit_set.all(): unit.translate(request, 'test4', STATE_TRANSLATED) self.assertEqual(start_rev, component.repository.last_revision) # Translation from other author should trigger commmit for i, unit in enumerate(translation.unit_set.all()): request.user = User.objects.create( full_name='User {}'.format(unit.pk), username='******'.format(unit.pk), email='{}@example.com'.format(unit.pk) ) # Fetch current pending state, it might have been # updated by background commit unit.pending = Unit.objects.get(pk=unit.pk).pending unit.translate(request, 'test', STATE_TRANSLATED) if i == 0: # First edit should trigger commit self.assertNotEqual( start_rev, component.repository.last_revision ) start_rev = component.repository.last_revision # No further commit now self.assertEqual(start_rev, component.repository.last_revision) # Commit pending changes translation.commit_pending('test', None) self.assertNotEqual(start_rev, component.repository.last_revision)
def _generate_test_instance(self, rg_files, rg_names=None): if rg_names is None: rg_names = [str(i) for i in range(len(rg_files))] project = self.common_entities['project'] ref_genomes = [] for i, rg_file in enumerate(rg_files): file_type = 'fasta' if rg_file.endswith('.fa') else 'genbank' ref_genomes.append( import_reference_genome_from_local_file(project, rg_names[i], rg_file, file_type, move=False)) test_label = 'concat_test' request_data = { 'newGenomeLabel': test_label, 'refGenomeUidList': [rg.uid for rg in ref_genomes] } request = HttpRequest() request.POST = {'data': json.dumps(request_data)} request.method = 'POST' request.user = self.common_entities['user'] authenticate(username=TEST_USERNAME, password=TEST_PASSWORD) self.assertTrue(request.user.is_authenticated()) ref_genomes_concatenate(request) concat_ref = ReferenceGenome.objects.get(label=test_label) # Assert correct number of chromosomes self.assertEqual(concat_ref.num_chromosomes, sum([rg.num_chromosomes for rg in ref_genomes])) # Assert correct number of bases self.assertEqual(concat_ref.num_bases, sum([rg.num_bases for rg in ref_genomes]))
def generate_qr_code(instance: Coach, request: HttpRequest) -> str: save_path = os.path.join(settings.MEDIA_ROOT, 'coaches', 'qr') os.makedirs(save_path, exist_ok=True) svg_filename = 'id{}.svg'.format(instance.pk) if not os.path.isfile(os.path.join(save_path, svg_filename)): full_url = request.build_absolute_uri( reverse('yoyo:detail', kwargs={'pk': instance.pk})) qr = pyqrcode.create(full_url) qr.svg(os.path.join(save_path, svg_filename), scale=4) return '/'.join([settings.MEDIA_URL, 'coaches', 'qr', svg_filename])
def test_tenth_of_twenty_pages(self): paginator = Paginator(range(20), per_page=1) ctx = {"page_obj": paginator.page(10), "request": HttpRequest()} result = self.template.render(ctx) assert ( '<a name="Previous" title="Previous" class="prev" rel="prev" href="?page=9">' in result) assert '<a title="page 10" class="pagelink" aria-current="page"' in result assert '<a title="page 11" class="pagelink" href="?page=11">' in result assert ( '<a name="Next" title="Next" class="next" rel="next" href="?page=11">' in result)
def test_update_counter_proposal(self): self.client.login(request=HttpRequest(), username=self.professional.user.email, password='******') data = {'value': 310, 'description': 'NaN'} response = self.client.put( f'/proposals/{self.proposal.uuid}/counter.json', data=data, content_type='application/json') self.assertEqual(response.status_code, 200, response.content) self.assertIn('uuid', response.json()) self.assertEqual(data['value'], response.json()['value'])
def test_login(monkeypatch): user = User() user.is_active = True authenticate_mock = mock.MagicMock(return_value=user) login_mock = mock.Mock() monkeypatch.setattr(views, 'authenticate', authenticate_mock) monkeypatch.setattr(views, 'login', login_mock) method = 'POST' request = HttpRequest() request.method = method result = views.login_user(request=request) authenticate_mock.assert_called_once() login_mock.assert_called_once() assert isinstance(result, HttpResponseRedirect) assert result.url == reverse('mypage:main_page', kwargs={'path': ''})
def test_reject_counter(self): self.client.login(request=HttpRequest(), username=self.user.email, password='******') data = {'accept': False} response = self.client.patch( f'/proposals/{self.proposal.uuid}/counter.json', data=data, content_type='application/json') self.assertEqual(response.status_code, 200, response.content) self.assertIn('uuid', response.json()) self.assertFalse(response.json()['accepted'], msg=response.content)
def test_rate_job(self): self.client.login(request=HttpRequest(), username=self.user.email, password='******') data = {'grade': 3} response = self.client.post( f'/jobs/{self.proposal.job.uuid}/rate.json', data=data, content_type='application/json') self.assertEqual(response.status_code, 200, msg=response.content) self.assertIn('uuid', response.json()) self.assertEqual(3, response.json()['rate'])
def test_admin_synchronize_action(self): layer = Layer.objects.external()[0] layer.new_nodes_allowed = False layer.save() layer = Layer.objects.get(pk=layer.pk) url = '%s/geojson1.json' % MOCK_URL_PREFIX responses.add(responses.GET, url, body=self._load('geojson1.json'), content_type='application/json') external = LayerExternal(layer=layer) external.synchronizer_path = 'nodeshot.interop.sync.synchronizers.GeoJson' external._reload_schema() external.url = url external.full_clean() external.save() from django.http.request import HttpRequest from django.contrib.admin.sites import AdminSite from nodeshot.interop.sync.admin import LayerAdmin admin = LayerAdmin(Layer, AdminSite()) request = HttpRequest() # expect no output because trying to synchronize non-external layers output = capture_output( admin.synchronize_action, [request, Layer.objects.filter(is_external=False)]) self.assertEqual(output, '') # expect no output because trying to synchronize a single non-external layer output = capture_output( admin.synchronize_action, [request, Layer.objects.filter(is_external=False)[0:1]]) self.assertEqual(output, '') # expects output output = capture_output( admin.synchronize_action, [request, Layer.objects.filter(pk=layer.pk)]) # ensure following text is in output self.assertIn('2 nodes added', output) self.assertIn('0 nodes changed', output) self.assertIn('2 total external', output) self.assertIn('2 total local', output) # ensure all nodes have been imported self.assertEqual(layer.node_set.count(), 2)
def tests_test_app_length_3(self): request = HttpRequest() mock = CURRENT_MOCK.delay mock.call_args_list = [] models = [self.generate_models(application=True) for _ in range(0, 3)] result = check_app(None, request, Application.objects.all()) self.assertEqual(result, None) self.assertEqual(mock.call_args_list, [call(model['application'].id) for model in models])
def handle(self, *args, **options): # Get translation object translation = self.get_translation(**options) # Create fake request object request = HttpRequest() request.user = None # Process import try: translation.merge_upload( request, options["file"], False, method="suggest", author_email=options["author"], ) except OSError as err: raise CommandError(f"Failed to import translation file: {err}") finally: options["file"].close()
def paginate_queryset(self, queryset): if self.paginator is None: return None if not hasattr(self, '_validated_data'): self.is_valid(True) v_data: dict = self.validated_data request: Request = Request(HttpRequest()) request.query_params.setlist('page', [v_data['page']]) request.query_params.setlist('page_size', [v_data['page_size']]) return self.paginator.paginate_queryset(queryset, request)