gmaxfeed/test.py at master · TotalPerformanceData/gmaxfeed · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 15 11:35:05 2020

test the GmaxFeed functions

@author: George
"""
# TODO use unittest and do this properly with assertEqual etc
from gmaxfeed.feeds.postrace_feeds import GmaxFeed, RaceMetadata
from datetime import datetime, timezone, timedelta

from gmaxfeed import get_logger
logger = get_logger(name = __name__)

# set all paths here or make sure environ variable correctly set
gmax_feed = GmaxFeed()

def test_get_range(start_date = datetime(2020,10,1, tzinfo = timezone.utc),
                   end_date = datetime(2020,10,7, tzinfo = timezone.utc),
                   new: bool = False
                   ):
   sharecodes = gmax_feed.get_racelist_range(
       start_date = start_date,
       end_date = end_date,
       new = new
       )
   return sharecodes

def test_get_data(date: datetime = datetime(2020,10,5, tzinfo = timezone.utc),
                  request: set = {
                      'sectionals',
                      'sectionals-history',
                      'points',
                      'obstacles'
                      },
                  new: bool = False,
                  filter: RaceMetadata = None
                  ):
    sharecodes = gmax_feed.get_racelist(date = date, new = new)
    data = gmax_feed.get_data(
        sharecodes = sharecodes,
        request = request,
        new = new,
        filter = filter
        )
    return data

def test_filter(filter: RaceMetadata = None) -> filter:
    if filter is None:
        filter = RaceMetadata()
        filter.set_filter(
            countries = {'GB', 'CA'},
            start_date = datetime(2020,10,1, tzinfo = timezone.utc),
            end_date = datetime(2020,10,7, tzinfo = timezone.utc),
            published = True
            )
    gmax_feed.update(
        start_date = '2020-09-25',
        end_date = '2020-10-02',
        request = {'sectionals'},
        filter = filter
        )
    return filter

def test_get_race(sharecode: str = "58202010051755") -> dict:
    return gmax_feed.get_race(sharecode = sharecode, new = True)

def test_get_fixtures(date: str = '2019-05-01'):
    data = gmax_feed.get_fixtures(date = date)
    print(len(data))
    return data

def test_get_routes(course_codes = ["14", "3", "71", "30"]):
    routes = gmax_feed.get_routes(course_codes = course_codes)
    return routes

if __name__ == '__main__':
    try:
        # should return dict of racelist feed, sharecode->metadata
        racelist_range = test_get_range()
    except Exception:
        logger.exception('Error in racelist range generation')

    try:
        # should return a RaceMetadata object, if filter with some restrictions
        # are applied then len(filter._data) != len(filter._list)
        filter = test_filter()
        print("all_data length: {0}, filtered length: {1}".format(
            len(filter._data), len(filter._list))
            )
    except Exception:
        logger.exception('Error in racelist range generation')

    try:
        # returns data for all the given request types, if available and permitted
        daily_data = test_get_data()
    except Exception:
        logger.exception('Error in racelist range generation')

    single_record = test_get_race()

    fixtures = test_get_fixtures()
    fixtures_upcoming = gmax_feed.get_fixtures()

    routes = test_get_routes()

    update_return = gmax_feed.update(
        start_date = datetime.today() - timedelta(days = 6),
        end_date = datetime.today() - timedelta(days = 4),
        request = {'sectionals', 'points'},
        no_return = True
        )