Пример #1
0
def test_commons(teacher, student, meetup, dropoff):
    """add 3 lessons, 2 of them with same meetup
    and dropoff. check returns of common_meetup
    and common_dropoff"""
    for _ in range(2):
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=teacher.user,
            duration=40,
            date=datetime.utcnow(),
            meetup_place=meetup,
            dropoff_place=dropoff,
        )

    second_meetup = Place.create(description="other",
                                 used_as=PlaceType.meetup.value,
                                 student=student)
    second_dropoff = Place.create(description="other",
                                  used_as=PlaceType.dropoff.value,
                                  student=student)

    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow(),
        meetup_place=second_meetup,
        dropoff_place=second_dropoff,
    )
    assert student.common_meetup == meetup
    assert student.common_dropoff == dropoff
Пример #2
0
def test_total_lessons_price(teacher, student, meetup, dropoff):
    st = Student.query.filter(Student.total_lessons_price ==
                              0).first()  # no lesson has been done yet
    assert st == student
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow() - timedelta(hours=2),
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,
    )
    st = Student.query.filter(
        Student.total_lessons_price == teacher.price).first()
    assert st == student

    student.update(price=1000)
    # this is still true because lessons have a fixed price once scheduled
    assert student.total_lessons_price == teacher.price

    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow() - timedelta(hours=2),
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,
    )
    assert student.total_lessons_price == teacher.price + student.price
Пример #3
0
def test_teacher_available_hours_with_rules(
    teacher, student, requester, meetup, dropoff
):
    tomorrow = datetime.utcnow().replace(hour=7, minute=0) + timedelta(days=1)
    kwargs = {
        "teacher": teacher,
        "day": 1,
        "from_hour": tomorrow.hour,
        "from_minutes": tomorrow.minute,
        "to_hour": 23,
        "to_minutes": 59,
        "on_date": tomorrow,
    }
    WorkDay.create(**kwargs)

    for i in range(3):
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=teacher.user,
            duration=teacher.lesson_duration,
            date=tomorrow + timedelta(minutes=i),
            meetup_place=meetup,
            dropoff_place=dropoff,
            is_approved=True,
        )

    hours_with_rules = list(teacher.available_hours(tomorrow, student=student))
    hours_without_rules = list(teacher.available_hours(tomorrow))
    assert hours_with_rules != hours_without_rules
Пример #4
0
def test_topics_in_progress(teacher, student, topic, meetup, dropoff, lesson):
    lesson_topic = LessonTopic(is_finished=False, topic_id=topic.id)
    lesson.topics.append(lesson_topic)
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow(),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    lesson_topic = LessonTopic(is_finished=False, topic_id=topic.id)
    lesson.topics.append(lesson_topic)

    lt = student._lesson_topics(is_finished=False)
    in_progress = student._topics_in_progress(lt)
    assert topic in in_progress

    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow(),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    lesson_topic = LessonTopic(is_finished=True, topic_id=topic.id)
    lesson.topics.append(lesson_topic)
    lt = student._lesson_topics(is_finished=False)
    in_progress = student._topics_in_progress(lt)
    assert len(in_progress) == 0
Пример #5
0
def test_init_hours(student, teacher, meetup, dropoff):
    # TODO improve test logic
    initial_hours = LessonRule.hours
    date = datetime.utcnow().replace(hour=6, minute=0) + timedelta(days=2)
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=teacher.lesson_duration,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,
    )
    query = Appointment.query.filter(
        func.extract("day", Appointment.date) == date.day).filter(
            func.extract("month", Appointment.date) == date.month)
    new_hours = LessonRule.init_hours(
        date,
        student,
        teacher.work_hours_for_date(date),
        teacher.taken_appointments_tuples(query, only_approved=True),
    )
    assert initial_hours != new_hours
    # we want to fill the gap after 6, so hours 7 and 8 should be really cold
    hour_8 = new_hours[1].score
    hour_7 = new_hours[0].score
    old_hour_7 = initial_hours[0].score
    old_hour_8 = initial_hours[1].score
    assert hour_7 < old_hour_7
    assert hour_8 < old_hour_8
Пример #6
0
def test_lessons_done(teacher, student, meetup, dropoff):
    """create new lesson for student,
    check lessons_done updates"""
    old_lesson_number = student.lessons_done
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=60,
        date=datetime.utcnow(),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    assert student.lessons_done == old_lesson_number + 60 / teacher.lesson_duration
    assert student.lessons_done == lesson.lesson_number
    old_lesson_number = student.lessons_done
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow() + timedelta(hours=20),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    assert (student.lessons_done == old_lesson_number
            )  # because it's later than now, it hasn't changed

    st = Student.query.filter(
        Student.lessons_done == old_lesson_number).first()
    assert st.id == student.id
Пример #7
0
def test_student_blocked_hours_by_test(
    teacher, student, meetup, dropoff, auth, requester
):
    date = (datetime.utcnow() + timedelta(days=1)).replace(hour=13, minute=0)
    data = {
        "teacher": teacher,
        "from_hour": 13,
        "from_minutes": 0,
        "to_hour": 17,
        "to_minutes": 0,
        "on_date": date,
    }
    WorkDay.create(**data)
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=False,
        type=AppointmentType.TEST.value,
    )
    auth.login(email=student.user.email)
    resp = requester.post(
        f"/teacher/{teacher.id}/available_hours",
        json={"date": date.strftime(WORKDAY_DATE_FORMAT)},
    )
    hours = [hour[0] for hour in resp.json["data"]]
    assert all(date.strftime("%H:%M") not in hour for hour in hours)
Пример #8
0
def test_available_hours_route_with_places(
    teacher, student, meetup, dropoff, auth, requester, responses
):
    auth.login(email=student.user.email)
    tomorrow = datetime.utcnow() + timedelta(days=1)
    data = {
        "teacher": teacher,
        "from_hour": 7,
        "from_minutes": 0,
        "to_hour": 17,
        "to_minutes": 0,
        "on_date": tomorrow,
    }
    WorkDay.create(**data)

    date = tomorrow.replace(hour=16, minute=0)
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,  # only check places for approved lessons
    )
    ret = {
        "destination_addresses": ["HaNassi Blvd, Haifa, Israel"],
        "origin_addresses": ["Gruenbaum St 3, Haifa, Israel"],
        "rows": [
            {
                "elements": [
                    {
                        "distance": {"text": "4.8 mi", "value": 7742},
                        "duration": {"text": "17 mins", "value": 1037},
                        "status": "OK",
                    }
                ]
            }
        ],
        "status": "OK",
    }
    responses.add(
        responses.GET,
        "https://maps.googleapis.com/maps/api/distancematrix/json",
        body=json.dumps(ret),
        status=200,
        content_type="application/json",
    )
    resp = requester.post(
        f"/teacher/{teacher.id}/available_hours",
        json={
            "date": date.strftime(WORKDAY_DATE_FORMAT),
            "meetup_place_id": "test1",
            "dropoff_place_id": "test2",
        },
    )
    assert resp.json["data"]
Пример #9
0
def test_more_than_lessons_in_week(student, teacher, hours, meetup, dropoff):
    date = datetime.utcnow() + timedelta(days=2)
    rule = more_than_lessons_week.MoreThanLessonsWeek(date, student, hours)
    assert not rule.blacklisted()["start_hour"]
    for i in range(3):
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=teacher.user,
            duration=teacher.lesson_duration,
            date=date + timedelta(minutes=i * teacher.lesson_duration),
            meetup_place=meetup,
            dropoff_place=dropoff,
            is_approved=True,
        )
    assert rule.blacklisted()["start_hour"]
Пример #10
0
def test_sort_data(teacher, student, meetup, dropoff):
    lessons = []
    for _ in range(3):
        lessons.append(
            Appointment.create(
                teacher=teacher,
                student=student,
                creator=student.user,
                duration=40,
                date=datetime.utcnow(),
                meetup_place=meetup,
                dropoff_place=dropoff,
            ))
    args = {"order_by": "created_at desc"}
    lessons_from_db = Appointment.query.order_by(
        Appointment._sort_data(args)).all()
    assert lessons_from_db[0] == lessons[-1]
    args = {"order_by": "does_not_exist desc"}
    lessons_from_db = Appointment.query.order_by(
        Appointment._sort_data(args)).all()
    assert lessons_from_db
    args = {"order_by": "created_at huh"}
    lessons_from_db = Appointment.query.order_by(
        Appointment._sort_data(args)).all()
    assert lessons_from_db
Пример #11
0
def test_regular_students(student, teacher, hours, meetup, dropoff):
    date = datetime.utcnow() - timedelta(days=2)
    rule = regular_students.RegularStudents(date, student, hours)
    assert not rule.blacklisted()["start_hour"]
    for i in range(10):
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=teacher.user,
            duration=teacher.lesson_duration,
            date=date + timedelta(minutes=i * teacher.lesson_duration),
            meetup_place=meetup,
            dropoff_place=dropoff,
            is_approved=True,
        )
    assert rule.blacklisted()["start_hour"]
Пример #12
0
def test_teacher_available_hours(teacher, student, requester, meetup, dropoff):
    tomorrow = datetime.utcnow().replace(hour=7, minute=0) + timedelta(days=1)
    kwargs = {
        "teacher": teacher,
        "day": 1,
        "from_hour": tomorrow.hour,
        "from_minutes": tomorrow.minute,
        "to_hour": 23,
        "to_minutes": 59,
        "on_date": tomorrow,
    }
    WorkDay.create(**kwargs)
    assert next(teacher.available_hours(tomorrow))[0] == tomorrow

    # we create a non approved lesson - available hours should still contain its date
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=teacher.lesson_duration,
        date=tomorrow,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=False,
    )

    assert next(teacher.available_hours(tomorrow, only_approved=True))[0] == tomorrow
    assert next(teacher.available_hours(tomorrow, only_approved=False))[0] != tomorrow
Пример #13
0
def test_filter_data(teacher, student, meetup, dropoff):
    date = datetime.utcnow() + timedelta(days=100)
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=student.user,
        duration=40,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    # date=ge:DATE
    date = datetime.strftime(date, DATE_FORMAT)
    lessons_from_db = Appointment.query.filter(
        Appointment._filter_data("date", f"ge:{date}")).all()
    assert lessons_from_db[0] == lesson
    # student_id=2
    lessons_from_db = Appointment.query.filter(
        Appointment._filter_data("student_id", 2)).all()
    assert not lessons_from_db
    # date=gggg:DATE
    lessons_from_db = Appointment.query.filter(
        Appointment._filter_data(
            "date", f"ggfggg:{date}")).all()  # supposed to translate to equal
    assert lessons_from_db[0] == lesson
    # date=DATE
    with pytest.raises(ValueError):
        lessons_from_db = Appointment.query.filter(
            Appointment._filter_data("date", f"{date}")).all()
Пример #14
0
def test_filter_and_sort(user, teacher, student, meetup, dropoff):
    """test that limit is maxed to 100, base query, custom date, non allowed filters"""
    date = datetime.utcnow() + timedelta(days=100)
    for x in range(101):
        user = User.create(email=f"{x}@test.com",
                           password="******",
                           name="teacher",
                           area="test")
        teacher = Teacher.create(user=user,
                                 price=100,
                                 lesson_duration=40,
                                 is_approved=True,
                                 crn=9)
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=student.user,
            duration=40,
            date=date,
            meetup_place=meetup,
            dropoff_place=dropoff,
        )

    args = MultiDict([("teacher_id", teacher.id)])  # not allowed
    query = None
    lessons_from_db = Appointment.filter_and_sort(args, query=query)
    assert len(lessons_from_db) == 102
    args = MultiDict([("date", date.strftime(WORKDAY_DATE_FORMAT))])
    lessons_from_db = Appointment.filter_and_sort(
        args,
        query=query,
        custom_date=lambda x: datetime.strptime(x, WORKDAY_DATE_FORMAT),
    )
    assert not lessons_from_db
    query = Appointment.query.filter_by(teacher_id=3)
    args = MultiDict()
    lessons_from_db = Appointment.filter_and_sort(args, query=query)
    assert len(lessons_from_db) == 1
    query = None
    args = MultiDict([("limit", 100_000_000_000_000)])
    lessons_from_db = Appointment.filter_and_sort(args,
                                                  query=query,
                                                  with_pagination=True)
    assert len(lessons_from_db.items) == 100
Пример #15
0
def test_filter_multiple_params(teacher, student, meetup, dropoff):
    date = datetime.utcnow() + timedelta(days=100)
    month_start = date.replace(day=1,
                               hour=0,
                               minute=0,
                               second=0,
                               microsecond=0)
    month_range = calendar.monthrange(month_start.year, month_start.month)
    month_end = date.replace(
        month=month_start.month,
        day=month_range[1],
        hour=0,
        minute=0,
        second=0,
        microsecond=0,
    )
    duration = 1200
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=student.user,
        duration=duration,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=student.user,
        duration=duration,
        date=date + timedelta(days=100),  # so it won't be the same month
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    month_end = datetime.strftime(month_end, DATE_FORMAT)
    month_start = datetime.strftime(month_start, DATE_FORMAT)
    lessons_from_db = (Appointment.query.filter(
        Appointment._filter_data("date", f"ge:{month_start}")).filter(
            Appointment._filter_data("date", f"le:{month_end}")).all())
    assert len(lessons_from_db) == 1
    assert lessons_from_db[0] == lesson
Пример #16
0
def test_taken_appointments_tuples(teacher, student, meetup, dropoff, lesson):
    taken_lessons = teacher.taken_appointments_tuples(
        Appointment.query, only_approved=False
    )
    assert len(taken_lessons) == 1
    assert isinstance(taken_lessons[0], tuple)
    Appointment.create(
        teacher=teacher,
        student=student,
        # schedule to 5 days from now to it won't bother with no test
        creator=teacher.user,
        duration=40,
        date=(datetime.utcnow() + timedelta(days=5)),
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=False,
    )
    taken_lessons = teacher.taken_appointments_tuples(
        Appointment.query, only_approved=True
    )
    assert len(taken_lessons) == 1
Пример #17
0
def test_lesson_topics(teacher, student, topic, meetup, dropoff):
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow(),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    lesson_topic = LessonTopic(is_finished=False, topic_id=topic.id)
    lesson.topics.append(lesson_topic)
    lt = student._lesson_topics(is_finished=False)
    assert lesson_topic in lt
    assert isinstance(lt, BaseQuery)
Пример #18
0
def test_total_lessons_price_with_different_prices(teacher, student, meetup,
                                                   dropoff):
    st = Student.query.filter(Student.total_lessons_price ==
                              0).first()  # no lesson has been done yet
    assert st == student
    price = 100
    prices = price
    for x in range(3):
        Appointment.create(
            teacher=teacher,
            student=student,
            creator=teacher.user,
            duration=40,
            date=datetime.utcnow() - timedelta(hours=x),
            meetup_place=meetup,
            dropoff_place=dropoff,
            is_approved=True,
            price=price * x,
        )
        prices += price * x

    assert student.total_lessons_price == prices
    st = Student.query.filter(Student.total_lessons_price == prices).first()
    assert st == student
Пример #19
0
def test_available_hours_route(teacher, student, meetup, dropoff, auth, requester):
    auth.login(email=teacher.user.email)
    tomorrow = datetime.utcnow() + timedelta(days=1)
    date = tomorrow.strftime(WORKDAY_DATE_FORMAT)
    time_and_date = date + "T13:30:20.123123Z"
    data = {
        "teacher": teacher,
        "from_hour": 13,
        "from_minutes": 0,
        "to_hour": 17,
        "to_minutes": 0,
        "on_date": tomorrow,
    }
    WorkDay.create(**data)

    # now let's add a lesson
    lesson_date = datetime.strptime(time_and_date, DATE_FORMAT)
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=lesson_date,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=False,
    )
    resp = requester.post(f"/teacher/{teacher.id}/available_hours", json={"date": date})

    assert len(resp.json["data"]) == 6
    lesson.update(is_approved=True)
    resp = requester.post(
        f"/teacher/{teacher.id}/available_hours", json={"date": date, "duration": "120"}
    )
    assert len(resp.json["data"]) == 1
    auth.logout()
    # if we login as student, we shouldn't this non approved lesson date
    auth.login(email=student.user.email)
    lesson.update(is_approved=False)
    resp = requester.post(f"/teacher/{teacher.id}/available_hours", json={"date": date})
    hours = [hour[0] for hour in resp.json["data"]]
    assert all(lesson_date.strftime("%H:%M") not in hour for hour in hours)
Пример #20
0
def test_balance(teacher, student, meetup, dropoff):
    # we have one lesson currently and 0 payments, but the lesson hasn't yet happened
    assert student.balance == 0
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow() - timedelta(hours=2),
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,
    )
    assert student.balance == -teacher.price
    lesson.update(is_approved=False)
    assert student.balance == 0

    st = Student.query.filter(Student.balance == 0).first()
    assert st == student
    Payment.create(amount=teacher.price, teacher=teacher, student=student)
    assert student.balance == teacher.price
Пример #21
0
def new_appointment():
    data = flask.request.get_json()
    if not data.get("date"):
        raise RouteError("Please insert the date of the appointment.")
    appointment = Appointment.create(**get_data(data, current_user))

    # send fcm to the user who wasn't the one creating the lesson
    user_to_send_to = appointment.teacher.user
    body_text = gettext(
        "%(student)s wants to schedule a new lesson at %(date)s. Click here to check it out.",
        student=appointment.student.user.name,
        date=format_datetime(
            appointment.date, locale=LOCALE, format="short", tzinfo=timezone(TIMEZONE)
        ),
    )
    if appointment.creator == appointment.teacher.user and appointment.student:
        user_to_send_to = appointment.student.user
        body_text = gettext(
            "%(teacher)s scheduled a new lesson at %(value)s. Click here to check it out.",
            teacher=appointment.teacher.user.name,
            value=format_datetime(
                appointment.date,
                locale=LOCALE,
                format="short",
                tzinfo=timezone(TIMEZONE),
            ),
        )
    if user_to_send_to.firebase_token:
        logger.debug(f"sending fcm to {user_to_send_to} for new appointment")
        try:
            FCM.notify(
                token=user_to_send_to.firebase_token,
                title=gettext("New Lesson!"),
                body=body_text,
            )
        except NotificationError:
            pass
    return {"data": appointment.to_dict()}, 201
Пример #22
0
def create_lesson(
    teacher,
    student,
    meetup,
    dropoff,
    date,
    duration=40,
    deleted=False,
    is_approved=True,
    **kwargs,
):
    return Appointment.create(
        teacher=teacher,
        student=student,
        creator=student.user if student else teacher.user,
        duration=duration,
        date=date.replace(second=0, microsecond=0),
        meetup_place=meetup,
        dropoff_place=dropoff,
        deleted=deleted,
        is_approved=is_approved,
        **kwargs,
    )
Пример #23
0
def test_filter_topics(teacher, student, meetup, dropoff, topic, lesson):
    """make topic in-progress and check. then make it finished
    and check again"""
    topic2 = Topic.create(title="aa", min_lesson_number=3, max_lesson_number=5)
    lesson_topic = LessonTopic(is_finished=False, topic_id=topic.id)
    lesson.topics.append(lesson_topic)
    assert topic in student.topics(is_finished=False)

    # let's create another lesson with same topic
    lesson = Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=40,
        date=datetime.utcnow(),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
    lesson_topic = LessonTopic(is_finished=True, topic_id=topic.id)
    lesson.topics.append(lesson_topic)
    lesson_topic2 = LessonTopic(is_finished=False, topic_id=topic2.id)
    lesson.topics.append(lesson_topic2)
    assert topic in student.topics(is_finished=True)
    assert topic2 in student.topics(is_finished=False)
Пример #24
0
def setup_db(app):
    User.create(email="*****@*****.**",
                password="******",
                name="test",
                area="test",
                phone="044444444")
    User.create(
        email="*****@*****.**",
        password="******",
        name="admin",
        area="test",
        is_admin=True,
        phone="055555555",
    )
    teacher_user = User.create(email="*****@*****.**",
                               password="******",
                               name="teacher",
                               area="test")
    teacher = Teacher.create(
        user=teacher_user,
        price=100,
        lesson_duration=40,
        is_approved=True,
        crn=999999999,
        invoice_api_key=DEMO_API_KEY,
    )
    Car.create(teacher=teacher, number=1111111111)
    student_user = User.create(email="*****@*****.**",
                               password="******",
                               name="student",
                               area="test")
    student = Student.create(user=student_user,
                             teacher=teacher,
                             creator=teacher.user,
                             is_approved=True)
    meetup = Place.create(
        description="test",
        used_as=PlaceType.meetup.value,
        student=student,
        google_id="ID1",
    )
    dropoff = Place.create(
        description="test",
        used_as=PlaceType.dropoff.value,
        student=student,
        google_id="ID2",
    )
    WorkDay.create(
        teacher=teacher,
        day=1,
        from_hour=0,
        to_hour=23,
        to_minutes=59,
        on_date=(datetime.utcnow() + timedelta(days=2)).date(),
    )  # 2 days from now
    Topic.create(title="topic test", min_lesson_number=1, max_lesson_number=5)
    Appointment.create(
        teacher=teacher,
        student=student,
        # schedule to 5 days from now to it won't bother with no test
        creator=teacher.user,
        duration=40,
        date=(datetime.utcnow() + timedelta(days=5)),
        meetup_place=meetup,
        dropoff_place=dropoff,
    )
Пример #25
0
def test_place_distances(student, teacher, meetup, dropoff, hours, responses):
    date = datetime.utcnow().replace(hour=16, minute=0)
    Appointment.create(
        teacher=teacher,
        student=student,
        creator=teacher.user,
        duration=teacher.lesson_duration,
        date=date,
        meetup_place=meetup,
        dropoff_place=dropoff,
        is_approved=True,
    )
    ret = {
        "destination_addresses": ["HaNassi Blvd, Haifa, Israel"],
        "origin_addresses": ["Gruenbaum St 3, Haifa, Israel"],
        "rows": [{
            "elements": [{
                "distance": {
                    "text": "4.8 mi",
                    "value": 7742
                },
                "duration": {
                    "text": "17 mins",
                    "value": 1037
                },
                "status": "OK",
            }]
        }],
        "status":
        "OK",
    }
    responses.add(
        responses.GET,
        "https://maps.googleapis.com/maps/api/distancematrix/json",
        body=json.dumps(ret),
        status=200,
        content_type="application/json",
    )
    rule = place_distance.PlaceDistances(date, student, hours,
                                         ("test1", "test2"))
    assert not rule.blacklisted()["start_hour"]
    ret = {
        "destination_addresses": ["Arlozorov St, Tel Aviv-Yafo, Israel"],
        "origin_addresses": ["Gruenbaum St 3, Haifa, Israel"],
        "rows": [{
            "elements": [{
                "distance": {
                    "text": "59.4 mi",
                    "value": 95649
                },
                "duration": {
                    "text": "1 hour 16 mins",
                    "value": 4539
                },
                "status": "OK",
            }]
        }],
        "status":
        "OK",
    }
    responses.replace(
        responses.GET,
        "https://maps.googleapis.com/maps/api/distancematrix/json",
        body=json.dumps(ret),
        status=200,
        content_type="application/json",
    )
    rule = place_distance.PlaceDistances(date, student, hours,
                                         ("test2", "test3"))
    blacklist = rule.blacklisted()
    assert blacklist["start_hour"]
    assert blacklist["end_hour"]