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): 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 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, )