def test_fill_type_valid(self):
singleRun = single.SingleRun()
config_dict = {blockNames.FileParams.type: blockNames.RunTypes.E}
singleRun.fill_type(config_dict)
self.assertEqual(
singleRun.type,
types.RUN_TYPES_ENUM.E)
def build_run(self, run_desc):
"""Builds the run(s) in dictionary
Builds the run (or runs if there is more than one) in the
input dictionary
Args:
run_desc(dict): Dictionary used as single run input
Returns:
list: list of single runs
Note:
It accepts a run_desc in dict format with either one or
a list of single runs. In the latter, the list is
defined with the key in `blockNames.FileParams.list`
"""
if not isinstance(run_desc, dict):
error = f"Input must be a dict"
logging.exception(error)
raise Exception(error)
try:
run_dicts = run_desc[blockNames.FileParams.list]
except KeyError:
run_dicts = [run_desc]
single_runs = []
for run_dict in run_dicts:
single_run = single.SingleRun()
single_run.load(run_dict)
single_runs.append(single_run)
return single_runs
def test_compute_vspeed(self):
singleRun = single.SingleRun()
config_dict = {'climb': 10}
singleRun.climb = 600
singleRun.time = 60
singleRun.compute_vspeed()
self.assertEqual(singleRun.vspeed, 600)
def test_assign_to_easy_regardless_of_activity_type_if_no_struct(self):
# The spare time and basic type is assigned to the easy type in
# running activities
singleRun = single.SingleRun()
singleRun.type = types.RUN_TYPES_ENUM.M
singleRun.distance = 10
singleRun.time = 60
#Note that by default basic_dist and basic_time are empty
singleRun.fill_basic_volume_dict_with_unassigned_volume()
golden_basic_dist = {}
golden_basic_time = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 10
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 60 * 60
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_compute_vspeed_time_is_0(self):
singleRun = single.SingleRun()
config_dict = {'climb': 10}
singleRun.climb = 600
singleRun.time = 0
singleRun.compute_vspeed()
self.assertTrue(math.isnan(singleRun.vspeed))
def test_parse_structure(self):
singleRun = single.SingleRun()
input_dict = [{
"type": "E",
"distance": 2.36
}, {
"type": "T",
"distance": 5.84,
"pace": "3:56"
}, {
"type": "E",
"distance": 2.2
}]
singleRun.parse_structure(input_dict)
self.assertEqual(len(singleRun.structure), 3)
for i, sgmnt in enumerate(singleRun.structure):
if i == 0:
self.assertAlmostEqual(sgmnt.distance, 2.36, 2)
elif i == 1:
self.assertAlmostEqual(sgmnt.distance, 5.84, 2)
self.assertAlmostEqual(sgmnt.pace, 236, 2)
elif i == 2:
self.assertAlmostEqual(sgmnt.distance, 2.2, 2)
def test_fill_activity_type(self):
singleRun = single.SingleRun()
config_dict = {
blockNames.FileParams.activity:
blockNames.Activities.mountaineering
}
singleRun.fill_activity(config_dict)
self.assertEqual(singleRun.activity, types.ACTIVITIES.MOUNTAINEERING)
def test_build_run2(self):
# Testing that the run is properly loaded, creating
# corresponding structures
#allRuns = all_runs.AllRuns()
#datafile = os.path.join(os.path.split(__file__)[0], 'data', 'test_3.json')
#singleRun = allRuns.read_run_in_file(datafile, verbose=False)
run_desc = {
"type": "E",
"date": "27-11-2018",
"time": "1h",
"distance": 12.2,
"climb": 100,
"where":"Park2"
}
allRuns = all_runs.AllRuns()
singleRun = allRuns.build_run(run_desc)
self.assertEqual(len(singleRun),1)
singleRun = singleRun[0]
goldenSingleRun = single.SingleRun()
goldenSingleRun.type = types.RUN_TYPES_ENUM.E
goldenSingleRun.time = 60
goldenSingleRun.distance = 12.2
goldenSingleRun.climb = 100
goldenSingleRun.inclination = 0.81967
goldenSingleRun.vspeed = 100
goldenSingleRun.pace = 295.081967213
goldenSingleRun.trail_running = False
goldenSingleRun.where = "Park2"
goldenSingleRun.route = ""
goldenSingleRun.date = datetime.strptime("27/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 12.2
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3600
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 295.081967213
goldenSingleRun.basic_dist = golden_basic_dist
goldenSingleRun.basic_time = golden_basic_time
goldenSingleRun.basic_pace = golden_basic_pace
self.assertEqual(singleRun, goldenSingleRun)
def test_load_json_cross_training_with_struct(self):
# We can assign data to any basic type with an X activity.
# In the case of cross training activities, the remaining
# is assigned to the cross training activity type
singleRun = single.SingleRun()
parsed_json = {
"activity": "mountaineering",
"type": "X",
"date": "26-11-2018",
"time": "1h 15m",
"distance": 16,
"structure": [{
"type": "M",
"distance": 12,
"time": "1h"
}]
}
singleRun.load(parsed_json)
self.assertEqual(singleRun.activity, types.ACTIVITIES.MOUNTAINEERING)
self.assertEqual(singleRun.time, 75)
self.assertEqual(singleRun.climb, 0)
self.assertEqual(singleRun.where, "")
self.assertEqual(singleRun.route, "")
self.assertEqual(singleRun.feeling, None)
self.assertEqual(singleRun.is_trail_running, False)
dateObj = datetime.datetime.strptime("26/11/2018", "%d/%m/%Y").date()
self.assertEqual(singleRun.date, dateObj)
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.M] = 12
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.X] = 4
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.M] = 60 * 60
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.X] = 15 * 60
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.M] = 300
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.X] = 225
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_pace[i],
golden_basic_pace[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_load_json_assign_to_E_if_no_struct(self):
# If no structure is defined, time and distance are assigned
# to easy type regardless of type
singleRun = single.SingleRun()
parsed_json = {
"type": "T",
"date": "01-01-2020",
"time": "1h",
"distance": 14
}
singleRun.load(parsed_json)
self.assertEqual(singleRun.time, 60)
self.assertEqual(singleRun.distance, 14)
self.assertEqual(singleRun.climb, 0)
self.assertEqual(singleRun.where, "")
self.assertEqual(singleRun.route, "")
self.assertEqual(singleRun.feeling, None)
self.assertEqual(singleRun.is_trail_running, False)
dateObj = datetime.datetime.strptime("01/01/2020", "%d/%m/%Y").date()
self.assertEqual(singleRun.date, dateObj)
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 14
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.T] = 257.1428
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 60 * 60
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_pace[i],
golden_basic_pace[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_load_json_cross_training(self):
# All dist/time/pace are assigned to key X in dictionary
singleRun = single.SingleRun()
parsed_json = {
"activity": "mountaineering",
"type": "X",
"date": "26-11-2018",
"time": "1h15min",
"distance": 15,
}
singleRun.load(parsed_json)
self.assertEqual(singleRun.activity, types.ACTIVITIES.MOUNTAINEERING)
self.assertEqual(singleRun.time, 75)
self.assertEqual(singleRun.climb, 0)
self.assertEqual(singleRun.where, "")
self.assertEqual(singleRun.route, "")
self.assertEqual(singleRun.feeling, None)
self.assertEqual(singleRun.is_trail_running, False)
dateObj = datetime.datetime.strptime("26/11/2018", "%d/%m/%Y").date()
self.assertEqual(singleRun.date, dateObj)
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.X] = 15
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.X] = 75 * 60
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.X] = 300
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_pace[i],
golden_basic_pace[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_load_json_no_struct(self):
singleRun = single.SingleRun()
parsed_json = {
"activity": "running",
"type": "E",
"trail": True,
"date": "26-11-2018",
"time": "1h15min",
"distance": 15,
}
singleRun.load(parsed_json)
self.assertEqual(singleRun.activity, types.ACTIVITIES.RUNNING)
self.assertEqual(singleRun.time, 75)
self.assertEqual(singleRun.climb, 0)
self.assertEqual(singleRun.where, "")
self.assertEqual(singleRun.route, "")
self.assertEqual(singleRun.feeling, None)
self.assertEqual(singleRun.is_trail_running, True)
dateObj = datetime.datetime.strptime("26/11/2018", "%d/%m/%Y").date()
self.assertEqual(singleRun.date, dateObj)
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 15
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 75 * 60
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 300
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_pace[i],
golden_basic_pace[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_fill_dist_and_time_dictionaries(self):
#Single run type is not passed to the structure
singleRun = single.SingleRun()
input_dict = [{
"type": "E",
"distance": 2.36
}, {
"type": "T",
"distance": 5.84,
"pace": "3:56"
}, {
"type": "E",
"distance": 2.2
}]
#Segments are needed to be set in singleRun
singleRun.parse_structure(input_dict)
singleRun.fill_basic_volume_dict_with_structure_volume()
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 4.56
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5.84
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 1378.24
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_pace[i],
golden_basic_pace[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_parse_structure_pass_activity_attributes(self):
# is_trail_running_activity, date, and feeling are
# passed from singleRun
singleRun = single.SingleRun()
singleRun.is_trail_running = True
date = datetime.datetime.strptime('15/05/2020', "%d/%m/%Y")
singleRun.date = date
singleRun.feeling = 3
input_dict = [{
"type": "E",
"distance": 2.38
}, {
"type": "T",
"distance": 5.84,
"pace": "3:56"
}, {
"type": "E",
"distance": 2.2
}]
singleRun.parse_structure(input_dict)
self.assertEqual(len(singleRun.structure), 3)
for i, sgmnt in enumerate(singleRun.structure):
if i == 0:
self.assertAlmostEqual(sgmnt.distance, 2.38, 2)
elif i == 1:
self.assertAlmostEqual(sgmnt.distance, 5.84, 2)
self.assertAlmostEqual(sgmnt.pace, 236, 2)
elif i == 2:
self.assertAlmostEqual(sgmnt.distance, 2.2, 2)
self.assertEqual(sgmnt.is_trail_running, True)
self.assertEqual(sgmnt.date, date)
self.assertEqual(sgmnt.feeling, 3)
def test_parse_structure_invalid_segment(self):
# Goal: assert that an exception is raised when an
# invalid segment type is passed. This is already
# tested in the segment's tests, but explicitly added
# here as a remark
singleRun = single.SingleRun()
# First segment has an invalid type
input_dict = [{
"type": "AAA",
"distance": 2.2
}, {
"type": "T",
"distance": 5.84,
"pace": "3:56"
}, {
"type": "E",
"distance": 2.2
}]
with self.assertRaises(Exception):
singleRun.parse_structure(input_dict)
def test_fill_basic_volume_dict_with_unassigned_volume(self):
singleRun = single.SingleRun()
#Equivalent distance and time distributions to structure:
#[
# {"type":"M", "distance":10.0, "time":"40min"},
# {"type":"T", "distance":5.0, "time":"17min"}
#]
singleRun.basic_dist[types.BASIC_RUN_TYPES_ENUM.M] = 10
singleRun.basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5
singleRun.basic_time[types.BASIC_RUN_TYPES_ENUM.M] = 40 * 60
singleRun.basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 17 * 60
singleRun.type = types.RUN_TYPES_ENUM.E
singleRun.distance = 20
singleRun.time = 82
singleRun.fill_basic_volume_dict_with_unassigned_volume()
golden_basic_dist = {}
golden_basic_time = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.M] = 10
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.M] = 40 * 60
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 17 * 60
#See singleRun distance and time
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 5
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 25 * 60
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
self.assertAlmostEqual(singleRun.basic_dist[i],
golden_basic_dist[i], 2)
self.assertAlmostEqual(singleRun.basic_time[i],
golden_basic_time[i], 2)
def test_parse_structure_empty_segment(self):
# Goal: assert that empty segments are not added
singleRun = single.SingleRun()
# First segment does not match a known type
input_dict = [{}, {
"type": "T",
"distance": 5.84,
"pace": "3:56"
}, {
"type": "E",
"distance": 2.2
}]
singleRun.parse_structure(input_dict)
self.assertEqual(len(singleRun.structure), 2)
for i, sgmnt in enumerate(singleRun.structure):
if i == 0:
self.assertAlmostEqual(sgmnt.distance, 5.84, 2)
self.assertAlmostEqual(sgmnt.pace, 236, 2)
elif i == 1:
self.assertAlmostEqual(sgmnt.distance, 2.2, 2)
def test_build_run_3(self):
# Input is a list of runs in a single dict
#allRuns = all_runs.AllRuns()
#datafile = os.path.join(os.path.split(__file__)[0], 'data', 'test_1.json')
#singleRuns = allRuns.read_run_in_file(datafile, verbose=False)
run_desc = {
"list": [
{
"type": "T",
"trail": True,
"date": "26-11-2018",
"time": "1h15min",
"distance": 13.8,
"climb": 110,
"where":"Park",
"route":"Lap 1",
"feeling": 4,
"structure":[
{"type":"E", "distance" : 2.36},
{"type":"T", "distance": 5.84, "pace":"3:56"},
{"type":"E", "distance" : 2.2}
]
},
{
"type": "E",
"date": "27-11-2018",
"time": "1h",
"distance": 12.2,
"climb": 100,
"where":"Park2"
}
]
}
allRuns = all_runs.AllRuns()
singleRun = allRuns.build_run(run_desc)
self.assertEqual(len(singleRun),2)
# First run
goldenSingleRun = single.SingleRun()
goldenSingleRun.type = types.RUN_TYPES_ENUM.T
goldenSingleRun.time = 75
goldenSingleRun.distance = 13.80
goldenSingleRun.climb = 110
goldenSingleRun.inclination = 0.7971
goldenSingleRun.vspeed = 88
goldenSingleRun.pace = 326.087
goldenSingleRun.where = "Park"
goldenSingleRun.route = "Lap 1"
goldenSingleRun.is_trail_running = True
goldenSingleRun.feeling = 4
goldenSingleRun.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 7.96
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5.84
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3121.76
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 1378.24
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 392.1809
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.T] = 236
goldenSingleRun.basic_dist = golden_basic_dist
goldenSingleRun.basic_time = golden_basic_time
goldenSingleRun.basic_pace = golden_basic_pace
# Build segments
segment1 = segment.Segment()
segment1.type = types.BASIC_RUN_TYPES_ENUM.E
segment1.distance = 2.36
segment1.repetition = 0
segment1.feeling = 4
segment1.is_trail_running = True
segment1.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment2 = segment.Segment()
segment2.type = types.BASIC_RUN_TYPES_ENUM.T
segment2.distance = 5.84
segment2.pace = 236
segment2.time = 1378.24
segment2.repetition = 1
segment2.is_trail_running = True
segment2.feeling = 4
segment2.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment3 = segment.Segment()
segment3.type = types.BASIC_RUN_TYPES_ENUM.E
segment3.distance = 2.2
segment3.repetition = 2
segment3.is_trail_running = True
segment3.feeling = 4
segment3.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
goldenSingleRun.structure = [
segment1,
segment2,
segment3
]
# Second run
goldenSingleRun2 = single.SingleRun()
goldenSingleRun2.type = types.RUN_TYPES_ENUM.E
goldenSingleRun2.time = 60
goldenSingleRun2.distance = 12.2
goldenSingleRun2.climb = 100
goldenSingleRun2.inclination = 0.81967
goldenSingleRun2.vspeed = 100
goldenSingleRun2.pace = 295.081967213
goldenSingleRun2.trail_running = False
goldenSingleRun2.where = "Park2"
goldenSingleRun2.route = ""
goldenSingleRun2.date = datetime.strptime("27/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 12.2
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3600
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 295.081967213
goldenSingleRun2.basic_dist = golden_basic_dist
goldenSingleRun2.basic_time = golden_basic_time
goldenSingleRun2.basic_pace = golden_basic_pace
self.assertEqual(singleRun[0], goldenSingleRun)
self.assertEqual(singleRun[1], goldenSingleRun2)
def test_missing_date_raise_exception(self):
singleRun = single.SingleRun()
config_dict = {'invalid_key' : '01/05/2020'}
with self.assertRaises(Exception):
singleRun.fill_date(config_dict)
def test_fill_date_valid(self):
singleRun = single.SingleRun()
config_dict = {'date': '01/05/2020'}
singleRun.fill_date(config_dict)
dateObj = datetime.datetime.strptime("01/05/2020", "%d/%m/%Y").date()
self.assertEqual(singleRun.date, dateObj)
def test_missing_distance_raise_exception(self):
singleRun = single.SingleRun()
config_dict = {'invalid_key' : 10}
with self.assertRaises(Exception):
singleRun.fill_distance(config_dict)
def test_fill_distance_valid(self):
singleRun = single.SingleRun()
config_dict = {'distance': 10}
singleRun.fill_distance(config_dict)
self.assertEqual(singleRun.distance, 10)
def test_fill_time_valid(self):
singleRun = single.SingleRun()
config_dict = {'time': '1h'}
singleRun.fill_time(config_dict)
self.assertEqual(singleRun.time, 60)
def test_fill_activity_invalid(self):
singleRun = single.SingleRun()
config_dict = {blockNames.FileParams.activity: 'aaa'}
with self.assertRaises(Exception):
singleRun.fill_activity(config_dict)
def test_fill_activity_missing(self):
singleRun = single.SingleRun()
config_dict = {}
singleRun.fill_activity(config_dict)
self.assertEqual(singleRun.activity, types.ACTIVITIES.RUNNING)
def test_fill_type_missing(self):
singleRun = single.SingleRun()
config_dict = {}
singleRun.fill_type(config_dict)
self.assertEqual(singleRun.type, types.RUN_TYPES_ENUM.E)
def test_build_run(self):
# Testing that the run is properly loaded, creating
# corresponding structures
run_desc = {
"type": "T",
"trail": True,
"date": "26-11-2018",
"time": "1h15min",
"distance": 13.8,
"climb": 110,
"where":"Park",
"route":"Lap 1",
"feeling": 4,
"structure":[
{"type":"E", "distance" : 2.36},
{"type":"T", "distance": 5.84, "pace":"3:56"},
{"type":"E", "distance" : 2.2}
]
}
allRuns = all_runs.AllRuns()
singleRun = allRuns.build_run(run_desc)
self.assertEqual(len(singleRun),1)
singleRun = singleRun[0]
goldenSingleRun = single.SingleRun()
goldenSingleRun.type = types.RUN_TYPES_ENUM.T
goldenSingleRun.time = 75
goldenSingleRun.distance = 13.80
goldenSingleRun.climb = 110
goldenSingleRun.inclination = 0.7971
goldenSingleRun.vspeed = 88
goldenSingleRun.pace = 326.087
goldenSingleRun.where = "Park"
goldenSingleRun.route = "Lap 1"
goldenSingleRun.is_trail_running = True
goldenSingleRun.feeling = 4
goldenSingleRun.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 7.96
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5.84
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3121.76
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 1378.24
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 392.1809
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.T] = 236
goldenSingleRun.basic_dist = golden_basic_dist
goldenSingleRun.basic_time = golden_basic_time
goldenSingleRun.basic_pace = golden_basic_pace
# Build segments
segment1 = segment.Segment()
segment1.type = types.BASIC_RUN_TYPES_ENUM.E
segment1.distance = 2.36
segment1.repetition = 0
segment1.is_trail_running = True
segment1.feeling = 4
segment1.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment2 = segment.Segment()
segment2.type = types.BASIC_RUN_TYPES_ENUM.T
segment2.distance = 5.84
segment2.pace = 236
segment2.time = 1378.24
segment2.repetition = 1
segment2.is_trail_running = True
segment2.feeling = 4
segment2.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment3 = segment.Segment()
segment3.type = types.BASIC_RUN_TYPES_ENUM.E
segment3.distance = 2.2
segment3.repetition = 2
segment3.is_trail_running = True
segment3.feeling = 4
segment3.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
goldenSingleRun.structure = [
segment1,
segment2,
segment3
]
self.assertEqual(singleRun, goldenSingleRun)
def test_fill_notes(self):
singleRun = single.SingleRun()
config_dict = {'notes': 'Nice run!'}
singleRun.fill_notes(config_dict)
self.assertEqual(singleRun.notes, 'Nice run!')
def test_load_runs(self):
# Tests load_runs
# run 1: with struct
# run 2: repeating run 1
# run 3: second run
run_descs = [
{
"type": "T",
"date": "26-11-2018",
"time": "1h15min",
"distance": 13.8,
"climb": 110,
"where":"Park",
"route":"Lap 1",
"feeling": 4,
"trail": True,
"structure":[
{"type":"E", "distance" : 2.36},
{"type":"T", "distance": 5.84, "pace":"3:56"},
{"type":"E", "distance" : 2.2}
]
},
{
"type": "T",
"date": "26-11-2018",
"time": "1h15min",
"distance": 13.8,
"climb": 110,
"where":"Park",
"route":"Lap 1",
"feeling": 4,
"trail": True,
"structure":[
{"type":"E", "distance" : 2.36},
{"type":"T", "distance": 5.84, "pace":"3:56"},
{"type":"E", "distance" : 2.2}
]
},
{
"type": "E",
"date": "27-11-2018",
"time": "1h",
"distance": 12.2,
"climb": 100,
"where":"Park2"
}
]
allRuns = all_runs.AllRuns()
added_single_runs = allRuns.load_runs(run_descs, verbose=False)
# First run
goldenSingleRun = single.SingleRun()
goldenSingleRun.type = types.RUN_TYPES_ENUM.T
goldenSingleRun.time = 75
goldenSingleRun.distance = 13.80
goldenSingleRun.climb = 110
goldenSingleRun.inclination = 0.7971
goldenSingleRun.vspeed = 88
goldenSingleRun.pace = 326.087
goldenSingleRun.where = "Park"
goldenSingleRun.route = "Lap 1"
goldenSingleRun.is_trail_running = True
goldenSingleRun.feeling = 4
goldenSingleRun.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 7.96
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.T] = 5.84
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3121.76
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.T] = 1378.24
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 392.1809
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.T] = 236
goldenSingleRun.basic_dist = golden_basic_dist
goldenSingleRun.basic_time = golden_basic_time
goldenSingleRun.basic_pace = golden_basic_pace
# Build segments
segment1 = segment.Segment()
segment1.type = types.BASIC_RUN_TYPES_ENUM.E
segment1.distance = 2.36
segment1.repetition = 0
segment1.feeling = 4
segment1.is_trail_running = True
segment1.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment2 = segment.Segment()
segment2.type = types.BASIC_RUN_TYPES_ENUM.T
segment2.distance = 5.84
segment2.pace = 236
segment2.time = 1378.24
segment2.repetition = 1
segment2.is_trail_running = True
segment2.feeling = 4
segment2.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
segment3 = segment.Segment()
segment3.type = types.BASIC_RUN_TYPES_ENUM.E
segment3.distance = 2.2
segment3.repetition = 2
segment3.is_trail_running = True
segment3.feeling = 4
segment3.date = datetime.strptime("26/11/2018", "%d/%m/%Y").date()
goldenSingleRun.structure = [
segment1,
segment2,
segment3
]
# Second run
goldenSingleRun2 = single.SingleRun()
goldenSingleRun2.type = types.RUN_TYPES_ENUM.E
goldenSingleRun2.time = 60
goldenSingleRun2.distance = 12.2
goldenSingleRun2.climb = 100
goldenSingleRun2.inclination = 0.81967
goldenSingleRun2.vspeed = 100
goldenSingleRun2.pace = 295.081967213
goldenSingleRun2.trail_running = False
goldenSingleRun2.where = "Park2"
goldenSingleRun2.route = ""
goldenSingleRun2.date = datetime.strptime("27/11/2018", "%d/%m/%Y").date()
# Build basic dictionaries
golden_basic_dist = {}
golden_basic_time = {}
golden_basic_pace = {}
for i in types.BASIC_RUN_TYPES_DICTIONARY.keys():
golden_basic_dist[i] = 0
golden_basic_time[i] = 0
golden_basic_pace[i] = None
golden_basic_dist[types.BASIC_RUN_TYPES_ENUM.E] = 12.2
golden_basic_time[types.BASIC_RUN_TYPES_ENUM.E] = 3600
golden_basic_pace[types.BASIC_RUN_TYPES_ENUM.E] = 295.081967213
goldenSingleRun2.basic_dist = golden_basic_dist
goldenSingleRun2.basic_time = golden_basic_time
goldenSingleRun2.basic_pace = golden_basic_pace
self.assertEqual(len(allRuns.runs), 2)
self.assertEqual(allRuns.runs[0], goldenSingleRun)
self.assertEqual(allRuns.runs[1], goldenSingleRun2)
def test_fill_notes_missing(self):
singleRun = single.SingleRun()
config_dict = {}
singleRun.fill_notes(config_dict)
self.assertEqual(singleRun.notes, '')
