Ejemplo n.º 1
0
    def test_endpoint(self):
        # This line is duplicated on purpose. Currency will have always 1+N number of queries
        # because of the exchange rate
        factory.build_batch(PublicsCurrencyFactory, 4)

        # Create one of each model to check if all serializers are working fine
        PublicsAirlineCompanyFactory()
        country = PublicsCountryFactory(currency=None)
        PublicsDSARegionFactory(country=country)
        PublicsBusinessAreaFactory()
        PublicsWBSFactory(business_area=None)
        PublicsGrantFactory()
        PublicsFundFactory()
        PublicsTravelExpenseTypeFactory()

        with self.assertNumQueries(10):
            response = self.forced_auth_req('get',
                                            reverse('public:static'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)
        self.assertKeysIn([
            'currencies', 'travel_types', 'countries', 'airlines',
            'travel_modes', 'expense_types', 'business_areas'
        ],
                          response_json,
                          exact=True)
def records(class_type="model", size=1, max_patient_count=30):
    doctor_class = dict
    record_class = dict

    if class_type == "model":
        doctor_class = models.Doctor
        record_class = models.Record

    doctors = factory.build_batch(doctor_class,
                                  size=size,
                                  FACTORY_CLASS=factories.DoctorFactory)

    records = []
    for doctor in doctors:
        patient_count = randint(0, max_patient_count)

        doctor_values = doctor
        if type(doctor) != dict:
            doctor_values = doctor.__dict__
        records.extend(
            factory.build_batch(
                record_class,
                size=patient_count,
                FACTORY_CLASS=factories.RecordFactory,
                **doctor_values,
            ))

    if size > 1:
        return records
    else:
        return records[0]
Ejemplo n.º 3
0
    def test_endpoint(self):
        # This line is duplicated on purpose. Currency will have always 1+N number of queries
        # because of the exchange rate
        factory.build_batch(PublicsCurrencyFactory, 4)

        # Create one of each model to check if all serializers are working fine
        PublicsAirlineCompanyFactory()
        country = PublicsCountryFactory(currency=None)
        PublicsDSARegionFactory(country=country)
        PublicsBusinessAreaFactory()
        PublicsTravelExpenseTypeFactory()

        with self.assertNumQueries(11):
            response = self.forced_auth_req('get', reverse('publics:static'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)
        self.assertKeysIn(['currencies',
                           'travel_types',
                           'countries',
                           'airlines',
                           'travel_modes',
                           'expense_types',
                           'business_areas'],
                          response_json,
                          exact=True)
Ejemplo n.º 4
0
    def test_airlines_view(self):
        factory.build_batch(PublicsAirlineCompanyFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get', reverse('publics:airlines'),
                                            user=self.unicef_staff)
        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['id', 'name', 'code']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 5
0
    def test_business_areas_view(self):
        factory.build_batch(PublicsBusinessAreaFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get', reverse('publics:business_areas'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['region', 'code', 'id', 'name', 'default_currency']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 6
0
    def test_expense_types_view(self):
        factory.build_batch(PublicsTravelExpenseTypeFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get', reverse('publics:expense_types'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['vendor_number', 'unique', 'id', 'name']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 7
0
    def test_airlines_view(self):
        factory.build_batch(PublicsAirlineCompanyFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get',
                                            reverse('public:airlines'),
                                            user=self.unicef_staff)
        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['id', 'name', 'code']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 8
0
    def test_business_areas_view(self):
        factory.build_batch(PublicsBusinessAreaFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get',
                                            reverse('public:business_areas'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['region', 'code', 'id', 'name', 'default_currency']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 9
0
    def test_expense_types_view(self):
        factory.build_batch(PublicsTravelExpenseTypeFactory, 3)

        with self.assertNumQueries(1):
            response = self.forced_auth_req('get',
                                            reverse('public:expense_types'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = ['vendor_number', 'unique', 'id', 'name']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 10
0
    def test_currencies_view(self):

        self.assertEqual(Currency.objects.count(), 1)
        factory.build_batch(PublicsCurrencyFactory, 3)

        with self.assertNumQueries(5):
            response = self.forced_auth_req('get', reverse('publics:currencies'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 4)

        expected_keys = ['iso_4217', 'code', 'exchange_to_dollar', 'id', 'name']
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 11
0
class SchoolFactory(factory.Factory):
    class Meta:
        model = School

    schoolName = factory.sequence(
        lambda n: 'school%04d' % n)  #factory.sequence
    home = factory.List(factory.build_batch(HomeFactory, 4))
Ejemplo n.º 12
0
    def test_currencies_view(self):
        factory.build_batch(PublicsCurrencyFactory, 3)

        with self.assertNumQueries(4):
            response = self.forced_auth_req('get',
                                            reverse('public:currencies'),
                                            user=self.unicef_staff)

        response_json = json.loads(response.rendered_content)

        self.assertEqual(len(response_json), 3)

        expected_keys = [
            'iso_4217', 'code', 'exchange_to_dollar', 'id', 'name'
        ]
        self.assertKeysIn(expected_keys, response_json[0], exact=True)
Ejemplo n.º 13
0
    def test_counting_applications_for_app_info_without_interviews(self):
        course1, course2 = factory.build_batch(size=2, klass=CourseFactory)
        cd1 = CourseDescriptionFactory(course=course1)
        cd2 = CourseDescriptionFactory(course=course2)
        app_info1 = ApplicationInfoFactory(course=cd1)
        app_info2 = ApplicationInfoFactory(course=cd2)

        self.assertEquals(
            0,
            Application.objects.without_interviews_for(app_info1).count())
        self.assertEquals(
            0,
            Application.objects.without_interviews_for(app_info2).count())

        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info2)
        ApplicationFactory(application_info=app_info2)

        self.assertEquals(
            4,
            Application.objects.without_interviews_for(app_info1).count())
        self.assertEquals(
            2,
            Application.objects.without_interviews_for(app_info2).count())
        self.assertEquals(6, Application.objects.without_interviews().count())
Ejemplo n.º 14
0
    def test_not_generate_interviews_when_have_not_enough_free_slots_for_app_info(
            self):
        course1, course2 = factory.build_batch(size=2, klass=CourseFactory)
        cd1 = CourseDescriptionFactory(course=course1)
        cd2 = CourseDescriptionFactory(course=course2)
        app_info1 = ApplicationInfoFactory(course=cd1)
        app_info2 = ApplicationInfoFactory(course=cd2)

        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info1)
        ApplicationFactory(application_info=app_info2)
        ApplicationFactory(application_info=app_info2)
        interviewer1, interviewer2 = factory.build_batch(
            size=2, klass=InterviewerFactory)

        interviewer1.courses_to_interview.add(app_info1)
        interviewer2.courses_to_interview.add(app_info2)

        InterviewerFreeTime.objects.create(interviewer=interviewer1,
                                           date=datetime.now().date(),
                                           start_time='11:00',
                                           end_time='12:00')
        InterviewerFreeTime.objects.create(interviewer=interviewer2,
                                           date=datetime.now().date(),
                                           start_time='12:00',
                                           end_time='15:00')

        self.assertEquals(
            3,
            Application.objects.without_interviews_for(app_info1).count())
        self.assertEquals(
            2,
            Application.objects.without_interviews_for(app_info2).count())

        call_command('generate_interview_slots')
        self.assertEquals(
            3,
            Application.objects.without_interviews_for(app_info1).count())
        self.assertEquals(2,
                          Interview.objects.free_slots_for(app_info1).count())
        self.assertEquals(
            0,
            Application.objects.without_interviews_for(app_info2).count())
        self.assertEquals(4,
                          Interview.objects.free_slots_for(app_info2).count())
Ejemplo n.º 15
0
 def books(self, created, extracted, **kwargs):
     if created:
         books = factory.build_batch(BookFactory,
                                     size=random.randint(1, 10))
         for book in books:
             self.books.add(book)
     if extracted:
         for book in extracted:
             self.books.add(book)
Ejemplo n.º 16
0
    def test_build_batch(self):
        objs = factory.build_batch(TestObject, 4, two=2,
            three=factory.LazyAttribute(lambda o: o.two + 1))

        self.assertEqual(4, len(objs))
        self.assertEqual(4, len(set(objs)))

        for obj in objs:
            self.assertEqual(obj.one, None)
            self.assertEqual(obj.two, 2)
            self.assertEqual(obj.three, 3)
            self.assertEqual(obj.four, None)
Ejemplo n.º 17
0
 def test_list_pagination(self):
     build_batch(PostFactory, 21, rubric=self.category)
     response = client.get('/' + self.parent.slug + '/')
     self.assertEqual(response.status_code, 200)
     self.assertTemplateUsed(response, 'posts/list.html')
     self.assertTemplateUsed(response, 'helpers/pagination.html')
     self.assertTrue(response.context['page_obj'].has_next())
     self.assertFalse(response.context['page_obj'].has_previous())
     self.assertEqual(response.context['page_obj'].next_page_number(), 2)
     self.assertEqual(response.context['page_obj'].number, 1)
     self.assertEqual(response.context['paginator'].num_pages, 2)
     self.assertIn(b'pagination', response.content)
     response = client.get('/' + self.parent.slug + '/?page=2')
     self.assertEqual(response.status_code, 200)
     self.assertTemplateUsed(response, 'posts/list.html')
     self.assertTemplateUsed(response, 'helpers/pagination.html')
     self.assertFalse(response.context['page_obj'].has_next())
     self.assertTrue(response.context['page_obj'].has_previous())
     self.assertEqual(response.context['page_obj'].previous_page_number(), 1)
     self.assertEqual(response.context['page_obj'].number, 2)
     self.assertIn(b'pagination', response.content)
 def test_create_related_with_expanded_serializer(self):
     todos_dict = factory.build_batch(dict,
                                      FACTORY_CLASS=TodoFactory,
                                      size=3)
     for todo in todos_dict:
         todo.pop('assignee')
     person = factory.build(dict,
                            FACTORY_CLASS=PersonWithForeignFactory,
                            todos=todos_dict)
     serializer = PersonExpandForeignSerializer(data=person)
     assert serializer.is_valid()
     created_person = serializer.save()
     for todo in todos_dict:
         assert created_person.todos.filter(id=todo['id']).exists()
Ejemplo n.º 19
0
    def test_build_batch(self):
        objs = factory.build_batch(
            TestObject,
            4,
            two=2,
            three=factory.LazyAttribute(lambda o: o.two + 1))

        self.assertEqual(4, len(objs))
        self.assertEqual(4, len(set(objs)))

        for obj in objs:
            self.assertEqual(obj.one, None)
            self.assertEqual(obj.two, 2)
            self.assertEqual(obj.three, 3)
            self.assertEqual(obj.four, None)
Ejemplo n.º 20
0
 def test_create_related_with_expanded_serializer(self):
     comments_dict = factory.build_batch(dict,
                                         FACTORY_CLASS=CommentFactory,
                                         size=3)
     for comment in comments_dict:
         comment.pop('todo')
     assignee_for_todos = PersonFactory.create()
     todo = factory.build(dict,
                          FACTORY_CLASS=TodoWithForeignFactory,
                          comments=comments_dict,
                          assignee=assignee_for_todos.pk)
     serializer = TodoExpandForeignSerializer(data=todo)
     assert serializer.is_valid()
     created_todo = serializer.save()
     for comment in comments_dict:
         assert created_todo.comments.filter(id=comment['id']).exists()
Ejemplo n.º 21
0
    def test_save_replaces_schedule(self):
        """Check that existing schedule items are removed when posting a new schedule"""
        plan = factories.CustomPaymentPlanFactory()
        url = reverse('invoice:save-payment-schedule',
                      kwargs={'plan_id': plan.id})
        old_payment = factories.ScheduledPaymentFactory(payment_plan=plan)

        # A simple way of producing dicts from a factory_boy class.  See:
        # https://factoryboy.readthedocs.io/en/stable/recipes.html#converting-a-factory-s-output-to-a-dict
        data = factory.build_batch(
            dict, FACTORY_CLASS=factories.ScheduledPaymentFactory, size=2)
        response = self.client.post(url, data=data, format='json')

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(plan.scheduled_payments.count(), 2)
        with self.assertRaises(models.ScheduledPayment.DoesNotExist):
            old_payment.refresh_from_db()
Ejemplo n.º 22
0
    def test_not_generate_interview_for_past_days(self):
        app_info = ApplicationInfoFactory()
        interviewer1, interviewer2 = factory.build_batch(
            size=2, klass=InterviewerFactory)

        interviewer1.courses_to_interview.add(app_info)
        interviewer2.courses_to_interview.add(app_info)

        InterviewerFreeTime.objects.create(interviewer=interviewer1,
                                           date=datetime.now().date() -
                                           timedelta(days=1),
                                           start_time='11:00',
                                           end_time='14:00')

        InterviewerFreeTime.objects.create(interviewer=interviewer2,
                                           date=datetime.now().date(),
                                           start_time='11:00',
                                           end_time='14:00')

        call_command('generate_interview_slots')
        self.assertEquals(6, Interview.objects.get_free_slots().count())
Ejemplo n.º 23
0
    def test_generate_interviews_for_more_interviewers(self):
        app_info = ApplicationInfoFactory()
        application1 = ApplicationFactory(application_info=app_info)
        application2 = ApplicationFactory(application_info=app_info)
        application3 = ApplicationFactory(application_info=app_info)
        interviewer1, interviewer2 = factory.build_batch(
            size=2, klass=InterviewerFactory)

        interviewer1.courses_to_interview.add(app_info)
        interviewer2.courses_to_interview.add(app_info)

        InterviewerFreeTime.objects.create(interviewer=interviewer1,
                                           date=datetime.now().date(),
                                           start_time='11:00',
                                           end_time='14:00')

        InterviewerFreeTime.objects.create(interviewer=interviewer2,
                                           date=datetime.now().date(),
                                           start_time='12:00',
                                           end_time='15:00')

        self.assertEquals(
            3,
            Application.objects.without_interviews_for(app_info).count())

        call_command('generate_interview_slots')
        self.assertEquals(9,
                          Interview.objects.free_slots_for(app_info).count())
        interviewer_for_app1 = Interview.objects.get(
            application=application1).interviewer
        interviewer_for_app2 = Interview.objects.get(
            application=application2).interviewer
        interviewer_for_app3 = Interview.objects.get(
            application=application3).interviewer
        self.assertNotEqual(interviewer_for_app1, interviewer_for_app2)
        self.assertEqual(interviewer_for_app1, interviewer_for_app3)
        self.assertEquals(
            0,
            Application.objects.without_interviews_for(app_info).count())
Ejemplo n.º 24
0
 def mock(self, model, factory, count, chunksize=10, bulk=True, **kwargs):
     """
     The mock function has two modes of operation, bulk or not.
     Djangos bulk_create method is fast but does not call the .save()
     method, and does not trigger signals. Use bulk if possible, it
     is much faster.
     """
     logger.info(
         "Creating %s instances of model %s using factory %s and kwargs %s"
         % (count, model, factory, kwargs))
     if bulk:
         for i in range(0, count, chunksize):
             chunk_items = factory.build_batch(
                 count - i if count - i < chunksize else chunksize,
                 **kwargs)
             model.objects.bulk_create(chunk_items)
             if i:
                 logger.debug("Mocked %s objects in %s" % (i, model))
     else:
         for i in range(0, count):
             item = factory.build(**kwargs)
             item.save()
Ejemplo n.º 25
0
class UserFactory(factory.Factory):
    class Meta:
        model = User

    name = factory.Faker("name", locale="zh_CN")  #factory.Faker
    num = factory.Faker("num")
    #age = factory.fuzzy.FuzzyInteger(42)#factory.fuzzy.FuzzyInteger
    age = factory.Faker("random_int", min=18, max=30, step=1)
    city = factory.Faker("address", locale="zh_CN")
    phone = factory.fuzzy.FuzzyText("138", 7, "1",
                                    "1234567890")  #factory.fuzzy.FuzzyText
    school = factory.SubFactory(SchoolFactory)  #factory.SubFactory

    #info=factory.List([SchoolFactory])
    info = factory.List(factory.build_batch(SchoolFactory, 4))
    #dictmap=factory.Dict([("one",SchoolFactory),("two",SchoolFactory)])
    dictmap = factory.Dict({"one": SchoolFactory, "two": SchoolFactory})

    #dictmap = factory.Dict(dict(one=1, two=2))

    class Params:
        shipped = factory.Trait(name=None)
Ejemplo n.º 26
0
class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = User
        sqlalchemy_session = DBSession  # the SQLAlchemy session object
        sqlalchemy_session_persistence = "commit"  #"commit"--perform a session commit() #'flush'-- perform a session flush()

    id = factory.Sequence(lambda n: n)
    #id = 9
    name = factory.Sequence(lambda n: u'User %d' % n)


#清除表内容
DBSession.query(User).delete()
#DBSession.query(User).filter(User.id==0).delete()
DBSession.commit()

# users=DBSession.query(User).all()
# for usr in users:
#     print(usr.__dict__)

#创建一条记录
UserFactory()
# UserFactory()
#创建100条记录
factory.build_batch(UserFactory, 100)
#DBSession.commit()
users = DBSession.query(User).all()
for usr in users:
    print(usr.__dict__)
print(len(users))
DBSession.remove()
Ejemplo n.º 27
0
    def test_counting_interview_slots_for_app_info_without_applications(self):
        course1, course2 = factory.build_batch(size=2, klass=CourseFactory)
        cd1 = CourseDescriptionFactory(course=course1)
        cd2 = CourseDescriptionFactory(course=course2)
        app_info1 = ApplicationInfoFactory(course=cd1)
        app_info2 = ApplicationInfoFactory(course=cd2)

        interviewer1 = InterviewerFactory()
        interviewer1.courses_to_interview.add(app_info1)
        interviewer2 = InterviewerFactory()
        interviewer2.courses_to_interview.add(app_info2)

        free_time1 = InterviewerFreeTime.objects.create(
            interviewer=interviewer1,
            date=datetime.now().date(),
            start_time='11:00',
            end_time='14:00')
        free_time2 = InterviewerFreeTime.objects.create(
            interviewer=interviewer1,
            date=datetime.now().date(),
            start_time='10:00',
            end_time='14:00')

        Interview.objects.create(interviewer=interviewer2,
                                 date=datetime.now().date(),
                                 start_time='12:00',
                                 end_time='12:30',
                                 interviewer_time_slot=free_time2)

        Interview.objects.create(interviewer=interviewer2,
                                 date=datetime.now().date(),
                                 start_time='12:00',
                                 end_time='12:30',
                                 interviewer_time_slot=free_time2)

        interview = Interview.objects.create(interviewer=interviewer1,
                                             date=datetime.now().date(),
                                             start_time='11:00',
                                             end_time='11:30',
                                             interviewer_time_slot=free_time1)

        Interview.objects.create(interviewer=interviewer1,
                                 date=datetime.now().date(),
                                 start_time='12:00',
                                 end_time='12:30',
                                 interviewer_time_slot=free_time1)

        self.assertEquals(2,
                          Interview.objects.free_slots_for(app_info1).count())
        self.assertEquals(2,
                          Interview.objects.free_slots_for(app_info2).count())
        self.assertEquals(4, Interview.objects.get_free_slots().count())

        application = ApplicationFactory(application_info=app_info1)
        interview.application = application
        interview.save()

        self.assertEquals(1,
                          Interview.objects.free_slots_for(app_info1).count())
        self.assertEquals(2,
                          Interview.objects.free_slots_for(app_info2).count())
        self.assertEquals(3, Interview.objects.get_free_slots().count())
Ejemplo n.º 28
0
# -*- coding: utf-8 -*-
# @Time    : 2019/8/12 0012 23:40
# @Author  : Vincent
# @Email   : [email protected]
# @File    : use.py
# @Software: PyCharm
from django.forms.models import model_to_dict
import factory
from fbtest.userfc import UserFactory
from fbtest.school import School

seq = []
uf = UserFactory()
print(uf.__dict__)
seq.append(uf.__dict__)
seq.append(UserFactory().__dict__)
print(seq)

list = []
fss = factory.build_batch(UserFactory, 4)
for fs in fss:
    list.append(fs.__dict__)
print(list)

uff = UserFactory(shipped=True)
print(uff.__dict__)

# uffs=UserFactory(city="1245")
# print(model_to_dict(UserFactory(city="1245")))
Ejemplo n.º 29
0
 def test_num_queries_bo(self):
     factory.build_batch(LicenceWithUserAndBaseObjectsFactory, 100)
     licence_relation = LicenceRelationsReport()
     with self.assertNumQueries(3):
         list(licence_relation.prepare(BackOfficeAsset))
Ejemplo n.º 30
0
 def json_batch(cls, num, **kwargs):
     return factory.build_batch(dict, num, FACTORY_CLASS=cls, **kwargs)
Ejemplo n.º 31
0
    client.credentials(HTTP_AUTHORIZATION=f"Bearer {jwt}")
    return client


@pytest.fixture
def register_form() -> Dict[str, str]:
    user = f.UserFactory.build()

    return {
        "password": data.DEFAULT_PASSWORD,
        "email": user.email,
        "firstName": user.first_name,
        "lastName": user.last_name,
        "zipcode": user.profile.zipcode,
    }


@pytest.fixture(params={**data.UpdateProfileForm.__members__})
def update_profile_params(request):
    return data.UpdateProfileForm[request.param].value


@pytest.fixture(params=factory.build_batch(dict,
                                           5,
                                           FACTORY_CLASS=f.ProfileFactory))
def random_profile_dict(request):
    profile = request.param
    if "user" in profile:
        del profile["user"]
    return request.param
Ejemplo n.º 32
0
def build_social_persons(count):
    return factory.build_batch(dict, FACTORY_CLASS=SocialPersonFactory, size=count)
Ejemplo n.º 33
0
 def existing_instructors(self, group_info):
     group_info.instructors = factory.build_batch(
         dict, 3, FACTORY_CLASS=factories.HUser)
     return group_info.instructors
Ejemplo n.º 34
0
    def test_generate_interviews_for_different_courses_with_different_interviewers(
            self):
        course1, course2 = factory.build_batch(size=2, klass=CourseFactory)
        cd1 = CourseDescriptionFactory(course=course1)
        cd2 = CourseDescriptionFactory(course=course2)
        app_info1 = ApplicationInfoFactory(course=cd1)
        app_info2 = ApplicationInfoFactory(course=cd2)

        application1 = ApplicationFactory(application_info=app_info1)
        application2 = ApplicationFactory(application_info=app_info2)
        application3 = ApplicationFactory(application_info=app_info1)
        application4 = ApplicationFactory(application_info=app_info2)
        application5 = ApplicationFactory(application_info=app_info1)
        interviewer1, interviewer2, interviewer3 = factory.build_batch(
            size=3, klass=InterviewerFactory)

        interviewer1.courses_to_interview.add(app_info1)
        interviewer2.courses_to_interview.add(app_info2)
        interviewer3.courses_to_interview.add(app_info1)

        InterviewerFreeTime.objects.create(interviewer=interviewer1,
                                           date=datetime.now().date(),
                                           start_time='11:00',
                                           end_time='14:00')
        InterviewerFreeTime.objects.create(interviewer=interviewer2,
                                           date=datetime.now().date(),
                                           start_time='12:00',
                                           end_time='15:00')
        InterviewerFreeTime.objects.create(interviewer=interviewer3,
                                           date=datetime.now().date(),
                                           start_time='13:00',
                                           end_time='15:00')

        self.assertEquals(
            3,
            Application.objects.without_interviews_for(app_info1).count())
        self.assertEquals(
            2,
            Application.objects.without_interviews_for(app_info2).count())
        self.assertEquals(5, Application.objects.without_interviews().count())

        call_command('generate_interview_slots')
        self.assertEquals(7,
                          Interview.objects.free_slots_for(app_info1).count())
        self.assertEquals(4,
                          Interview.objects.free_slots_for(app_info2).count())
        self.assertEquals(11, Interview.objects.get_free_slots().count())

        interviewer_for_app1 = Interview.objects.get(
            application=application1).interviewer
        interviewer_for_app2 = Interview.objects.get(
            application=application2).interviewer
        interviewer_for_app3 = Interview.objects.get(
            application=application3).interviewer
        interviewer_for_app4 = Interview.objects.get(
            application=application4).interviewer
        interviewer_for_app5 = Interview.objects.get(
            application=application5).interviewer

        self.assertEqual(interviewer1, interviewer_for_app1)
        self.assertEqual(interviewer1, interviewer_for_app5)
        self.assertEqual(interviewer2, interviewer_for_app2)
        self.assertEqual(interviewer2, interviewer_for_app4)
        self.assertEqual(interviewer3, interviewer_for_app3)

        self.assertTrue(application1 in interviewer1.interviews.all())
        self.assertTrue(application5 in interviewer1.interviews.all())
        self.assertTrue(application2 in interviewer2.interviews.all())
        self.assertTrue(application4 in interviewer2.interviews.all())
        self.assertTrue(application3 in interviewer3.interviews.all())
Ejemplo n.º 35
0
 def handle(self, *args, **options):
     factory.build_batch(ActivityPeriodFactory, size = options['num'])
     self.stdout.write(self.style.SUCCESS('Successfully generated fields'))
Ejemplo n.º 36
0
def build_social_persons(count):
    return factory.build_batch(dict,
                               FACTORY_CLASS=SocialPersonFactory,
                               size=count)