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)
