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