def setUp(self):
super(PollingReportTestPhoneActivated, self).setUp()
self.center = RegistrationCenterFactory()
# Activate the phone to the center:
StaffPhone.objects.create(phone_number=self.NUMBER, registration_center=self.center)
# Create some registrations so that reports don't arrive for a center with no registrations.
create_batch(RegistrationFactory, 11, registration_center=self.center, archive_time=None)
def test_notification_emails_sent_to_moderators(self):
# Setup moderators to receive emails
factory.create_batch(
factories.ModeratorFactory,
3,
moderator=self.moderator
)
self.post_data()
expected_subject = 'New account request at {}'.format(self.site.name)
expected_intro = 'Hi {},'.format('Moderator')
expected_content = (
'new account application has be registered at {}'
).format(self.site.name)
expected_url = (
'href="http://testserver/moderation/review-applications/"'
)
email = mail.outbox[0]
# 3 created as batch, plus original.
self.assertEqual(len(mail.outbox), 4)
self.assertEqual(email.subject, expected_subject)
self.assertIn(expected_intro, email.body)
self.assertIn(expected_content, email.body)
self.assertIn(expected_url, email.alternatives[0][0])
def test_register_custom_factory(self):
## registering GA4GH variant factory
GenericFactoryAvro.register_factory(Variant,
GA4GHVariantFactory,
version="4.0.0")
factory = GenericFactoryAvro.get_factory_avro(Variant, "4.0.0")
instances = factory.create_batch(5)
for instance in instances:
self.assertTrue(instance.validate(instance.toJsonDict()))
self.assertTrue(instance.referenceBases in ["A", "C", "G", "T"])
## register CancerReportedVariantsFactory
GenericFactoryAvro.register_factory(
protocols.reports_3_0_0.ReportedVariantCancer,
CancerReportedVariantsFactory,
version="3.0.0")
factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_3_0_0.CancerInterpretationRequest, "3.0.0")
instances = factory.create_batch(5)
for instance in instances:
self.assertTrue(instance.validate(instance.toJsonDict()))
for tiered_variant in instance.TieredVariants:
self.assertTrue(tiered_variant.reportedVariantCancer.reference
in ["A", "C", "G", "T"])
self.assertTrue(tiered_variant.reportedVariantCancer.alternate
in ["A", "C", "G", "T"])
def test_retrieve_patient_list(self, apiclient):
factory.create_batch(Patient, 12, FACTORY_CLASS=FacPatient)
resp = apiclient.get(reverse('patient-list'))
patients = Patient.objects.all()
req = APIRequestFactory().get(reverse('patient-list'))
ser = PatientSerializer(patients, many=True, context={'request': req})
assert resp.data == ser.data
def test_view_resources(self):
records = randint(2, 102)
create_batch(ResourceFactory, records)
url = '/api/v1/resources/'
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], records)
def test_max_copies_per_center_limit(self):
"""test that register.models.N_MAX_COPY_CENTERS is respected"""
original_center = RegistrationCenterFactory()
create_batch(RegistrationCenterFactory, settings.N_MAX_COPY_CENTERS,
copy_of=original_center)
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
msg = 'Copy centre already has the maximum number of copies ({n_max}).'
self.assertEqual(cm.exception.message, msg.format(n_max=settings.N_MAX_COPY_CENTERS))
def setUp(self):
super(PollingReportTestPhoneActivated, self).setUp()
self.center = RegistrationCenterFactory()
# Activate the phone to the center:
StaffPhone.objects.create(phone_number=self.NUMBER,
registration_center=self.center)
# Create some registrations so that reports don't arrive for a center with no registrations.
create_batch(RegistrationFactory,
11,
registration_center=self.center,
archive_time=None)
def setUp(self):
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.reporting_user = UserFactory()
self.accused_user = UserFactory()
self.moderator = ModeratorFactory()
factory.create_batch(
ModeratorFactory,
10,
moderator=self.moderator,
)
def test_max_copies_per_center_limit(self):
"""test that register.models.N_MAX_COPY_CENTERS is respected"""
original_center = RegistrationCenterFactory()
create_batch(RegistrationCenterFactory,
settings.N_MAX_COPY_CENTERS,
copy_of=original_center)
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
msg = 'Copy centre already has the maximum number of copies ({n_max}).'
self.assertEqual(cm.exception.message,
msg.format(n_max=settings.N_MAX_COPY_CENTERS))
def setUp(self):
self.editor = EditorFactory()
factory.create_batch(
Article,
5,
FACTORY_CLASS=ArticleFactory,
status=Article.STATUS_APPROVED,
edited_by=self.editor,
)
factory.create_batch(
Article,
10,
FACTORY_CLASS=ArticleFactory,
)
def formset_base(field,
total,
delete,
factory,
same=False,
form_stage_info=None):
base_data = {
f'{field}-TOTAL_FORMS': total + delete,
f'{field}-INITIAL_FORMS': 0,
}
required_forms = total + delete
if not same:
application_forms = factory.create_batch(required_forms)
else:
application_forms = [factory()] * required_forms
deleted = 0
for i, form in enumerate(application_forms):
should_delete = deleted < delete
base_data.update({
f'{field}-{i}-form': form.id,
f'{field}-{i}-ORDER': i,
f'{field}-{i}-DELETE': should_delete,
})
if form_stage_info:
# form_stage_info contains stage number for selected application forms
stage = form_stage_info[i]
base_data[f'{field}-{i}-stage'] = stage
deleted += 1
return base_data
def handle(self, *args, **options):
factory.create_batch(
ArtistFactory,
5,
photos__n=3,
exhibitions__n=1,
exhibitions__photos__n=3,
press__n=2,
press__content='content_in_press'
)
PressFactory(artist__n=1, content_file__make=True)
ExhibitionFactory(press__n=3, press__content_file__make=True, photos__n=4)
factory.create_batch(
UpdateFactory,
5,
photos__n=3,
description=' update description!'
)
def test_create_batch(self):
objs = factory.create_batch(FakeModel, 4, foo='bar')
self.assertEqual(4, len(objs))
self.assertEqual(4, len(set(objs)))
for obj in objs:
self.assertEqual(obj.id, 2)
self.assertEqual(obj.foo, 'bar')
def test_create_batch(self):
objs = factory.create_batch(FakeDjangoModel, 4, foo='bar')
self.assertEqual(4, len(objs))
self.assertEqual(4, len(set(objs)))
for obj in objs:
self.assertEqual(obj.id, 1)
self.assertEqual(obj.foo, 'bar')
def test_create_batch_custom_base(self):
objs = factory.create_batch(FakeModel, 4, foo='bar',
FACTORY_CLASS=factory.DjangoModelFactory)
self.assertEqual(4, len(objs))
self.assertEqual(4, len(set(objs)))
for obj in objs:
self.assertEqual(obj.id, 2)
self.assertEqual(obj.foo, 'bar')
def test_pending_users_show_in_list(self):
pending = factory.create_batch(
InvitedPendingFactory,
10,
moderator=self.moderator,
)
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:moderators'))
context_pending = list(response.context['pending'])
self.assertCountEqual(context_pending, pending)
def test_notification_emails_sent_to_moderators(self):
# Setup moderators to receive emails
factory.create_batch(factories.ModeratorFactory,
3,
moderator=self.moderator)
self.post_data()
expected_subject = 'New account request at {}'.format(self.site.name)
expected_intro = 'Hi {},'.format('Moderator')
expected_content = (
'new account application has be registered at {}').format(
self.site.name)
expected_url = (
'href="http://testserver/moderation/review-applications/"')
email = mail.outbox[0]
# 3 created as batch, plus original.
self.assertEqual(len(mail.outbox), 4)
self.assertEqual(email.subject, expected_subject)
self.assertIn(expected_intro, email.body)
self.assertIn(expected_content, email.body)
self.assertIn(expected_url, email.alternatives[0][0])
def test_delete_one_resource(self):
records = create_batch(ResourceFactory, 10)
new_resource = create(ResourceFactory)
url = f'/api/v1/resources/{new_resource.guid}/'
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
subsequent_response = self.client.get(url)
self.assertEqual(subsequent_response.status_code,
status.HTTP_404_NOT_FOUND)
count_check = self.client.get('/api/v1/resources/')
self.assertEqual(count_check.data['count'], 10)
def test_pending_users_are_not_invited_by_other_moderators(self):
"""
Test that we only see users who this particular moderator has invited.
"""
other_moderator = ModeratorFactory()
pending = factory.create_batch(
InvitedPendingFactory,
10,
moderator=other_moderator,
)
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:moderators'))
# Should be empty...
context_pending = list(response.context['pending'])
self.assertFalse(context_pending)
def formset_base(field, total, delete, factory, same=False):
base_data = {
f'{field}-TOTAL_FORMS': total + delete,
f'{field}-INITIAL_FORMS': 0,
}
required_forms = total + delete
if not same:
application_forms = factory.create_batch(required_forms)
else:
application_forms = [factory()] * required_forms
deleted = 0
for i, form in enumerate(application_forms):
should_delete = deleted < delete
base_data.update({
f'{field}-{i}-form': form.id,
f'{field}-{i}-ORDER': i,
f'{field}-{i}-DELETE': should_delete,
})
deleted += 1
return base_data
def setUp(self):
self.cars = factory.create_batch(CarFactory, 5, has_ejector_seat=True)
def sub_task_create_batch(task_instance):
return factory.create_batch(klass=SubTaskFactory,
size=5,
task=task_instance)
def impl(context):
factory.create_batch(UserFactory, 5)
def prepare_user(number_of_users: int, **kwargs):
return factory.create_batch(UserFactory, number_of_users, **kwargs)
def create_resources(self, num):
return create_batch(ResourceFactory,
num,
user=random.choice(self.users))
def task_instance_create_batch(priority_instance, project_instance):
return factory.create_batch(klass=TaskFactory,
size=5,
priority=priority_instance,
project=project_instance)
def setUp(self):
self.cars = factory.create_batch(CarFactory, 5, has_ejector_seat=True)
self.control = CarFactory(fuel_efficiency_rating=Car.EFFICIENCY_C)
def removed_project_create_batch(active_user):
return factory.create_batch(klass=ProjectFactory,
size=5,
user=active_user,
is_removed=True)
def date_frame_create_batch(task_instance):
return factory.create_batch(klass=InnerDateFrameFactory,
size=5,
task=task_instance)
def setUpClass(cls):
super().setUpClass()
factory.create_batch(SecurityFactory, 2)
PortfolioFactory()
def active_user_batch():
return factory.create_batch(klass=UserFactory, size=5, is_active=True)
def date_frame_create_batch_for_second_project(
task_instance_in_second_project):
return factory.create_batch(klass=InnerDateFrameFactory,
size=5,
task=task_instance_in_second_project)
def create_list(factory, number: int):
model = factory._meta.get_model_class()
factory.reset_sequence(get_next_id(model))
factory.create_batch(number)
session.commit()
return session.query(model).all()
def project_create_batch(active_user):
return factory.create_batch(klass=ProjectFactory, size=5, user=active_user)
def setUp(self):
self.users = factory.create_batch(factories.UserFactory, size=5)
self.shows = factory.create_batch(factories.ShowFactory, size=25)
def priority_create_batch(active_user):
return factory.create_batch(klass=PriorityFactory,
size=5,
user=active_user)
def setUp(self):
self.resource_1, self.resource_2 = create_batch(ResourceFactory, 2)
def test_dashboard_writers(self):
writer_1 = WriterFactory()
writer_2 = WriterFactory()
writer_3 = WriterFactory()
with mock.patch('core.utils.timezone.now',
return_value=datetime(2020, 3, 1, tzinfo=pytz.UTC)):
factory.create_batch(
Article,
1,
FACTORY_CLASS=ArticleFactory,
written_by=writer_1,
)
factory.create_batch(
Article,
2,
FACTORY_CLASS=ArticleFactory,
written_by=writer_2,
)
factory.create_batch(
Article,
3,
FACTORY_CLASS=ArticleFactory,
written_by=writer_3,
)
with mock.patch('core.utils.timezone.now',
return_value=datetime(2020, 3, 1, tzinfo=pytz.UTC)):
factory.create_batch(
Article,
4,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_1,
)
factory.create_batch(
Article,
5,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_2,
)
factory.create_batch(
Article,
6,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_3,
)
with mock.patch('core.utils.timezone.now',
return_value=datetime(2020, 1, 1, tzinfo=pytz.UTC)):
factory.create_batch(
Article,
7,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_1,
)
factory.create_batch(
Article,
8,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_2,
)
factory.create_batch(
Article,
9,
FACTORY_CLASS=ApprovedArticleFactory,
written_by=writer_3,
)
with \
mock.patch(
'core.utils.timezone.now',
return_value=datetime(2020, 3, 1, tzinfo=pytz.UTC),
), \
self.assertNumQueries(1):
writers = Writer.objects.with_articles_count()
self.assertEqual(sum(w.total_articles for w in writers), 39)
self.assertEqual(
sum(w.total_articles_in_last_month for w in writers),
15,
)
