forked from SplitTime/OpenSplitTime
-
Notifications
You must be signed in to change notification settings - Fork 0
/
data_status_spec.rb
149 lines (125 loc) · 5.71 KB
/
data_status_spec.rb
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
RSpec.describe DataStatus do
describe '.worst' do
it 'returns :bad when the array includes any :bad element' do
data_status_array = [:good, :questionable, nil, :bad, :good]
expect(DataStatus.worst(data_status_array)).to eq('bad')
end
it 'returns :questionable when the array includes any :questionable element but no :bad element' do
data_status_array = [:good, :questionable, nil, :good, :good]
expect(DataStatus.worst(data_status_array)).to eq('questionable')
end
it 'returns nil when the array includes any nil element but no :bad or :questionable elements' do
data_status_array = [:good, :good, nil, :good, :good]
expect(DataStatus.worst(data_status_array)).to be_nil
end
it 'returns :good when the array includes no :bad, :questionable, or nil elements' do
data_status_array = [:good, :good, :good, :good, :good]
expect(DataStatus.worst(data_status_array)).to eq('good')
end
it 'returns :good when the array includes only :good and :confirmed elements' do
data_status_array = [:good, :good, :confirmed, :good, :confirmed]
expect(DataStatus.worst(data_status_array)).to eq('good')
end
it 'returns :confirmed when the array includes only :confirmed elements' do
data_status_array = [:confirmed, :confirmed, :confirmed, :confirmed, :confirmed]
expect(DataStatus.worst(data_status_array)).to eq('confirmed')
end
it 'returns nil when the array is empty' do
data_status_array = []
expect(DataStatus.worst(data_status_array)).to be_nil
end
it 'returns nil when the provided argument is nil' do
data_status_array = nil
expect(DataStatus.worst(data_status_array)).to be_nil
end
it 'functions properly if the array consists of strings instead of symbols' do
data_status_array = %w(good confirmed questionable bad good)
expect(DataStatus.worst(data_status_array)).to eq('bad')
end
end
describe '.limits' do
let(:typical_time_in_aid) { DataStatus::TYPICAL_TIME_IN_AID }
let(:terrain_limit_factors) { DataStatus::LIMIT_FACTORS[:terrain].symbolize_keys }
let(:in_aid_limit_factors) { DataStatus::LIMIT_FACTORS[:in_aid].symbolize_keys }
it 'raises an error if type is not recognized' do
typical_time = 999
type = :random_type
expect { DataStatus.limits(typical_time, type) }.to raise_error(/not recognized/)
end
it 'returns nil if type is nil' do
typical_time = 999
type = nil
expect(DataStatus.limits(typical_time, type)).to be_nil
end
it 'returns nil if typical_time is nil' do
typical_time = nil
type = :in_aid
expect(DataStatus.limits(typical_time, type)).to be_nil
end
it 'returns a hash containing zero limits when type is :start' do
typical_time = 0
type = :zero_start
expected = {low_bad: 0, low_questionable: 0, high_questionable: 0, high_bad: 0}
expect(DataStatus.limits(typical_time, type)).to eq(expected)
end
it 'returns a hash containing zero lower limits and liberal upper limits when type is :in_aid' do
typical_time = 5.minutes
type = :in_aid
expected = in_aid_limit_factors.transform_values { |factor| (factor * (typical_time + typical_time_in_aid)).to_i }
expect(DataStatus.limits(typical_time, type)).to eq(expected)
end
it 'returns a hash containing calculated upper and lower limits when type is :terrain' do
typical_time = 60.minutes
type = :terrain
expected = terrain_limit_factors.transform_values { |factor| (factor * typical_time).to_i }
expect(DataStatus.limits(typical_time, type)).to eq(expected)
end
end
describe '.determine' do
it 'returns nil if limits is nil' do
limits = nil
seconds = 999
expect(DataStatus.determine(limits, seconds)).to be_nil
end
it 'returns nil if limits is an empty hash' do
limits = {}
seconds = 999
expect(DataStatus.determine(limits, seconds)).to be_nil
end
it 'returns nil if seconds is nil' do
limits = {low_bad: 0, low_questionable: 0, high_questionable: 0, high_bad: 0}
seconds = nil
expect(DataStatus.determine(limits, seconds)).to be_nil
end
it 'returns "good" if seconds is zero and all limits are zero' do
limits = {low_bad: 0, low_questionable: 0, high_questionable: 0, high_bad: 0}
seconds = 0
expect(DataStatus.determine(limits, seconds)).to eq('good')
end
it 'returns "good" if seconds is between low_questionable and high_questionable' do
limits = {low_bad: 100, low_questionable: 200, high_questionable: 300, high_bad: 400}
seconds = 250
expect(DataStatus.determine(limits, seconds)).to eq('good')
end
it 'returns "questionable" if seconds is between low_bad and low_questionable' do
limits = {low_bad: 100, low_questionable: 200, high_questionable: 300, high_bad: 400}
seconds = 150
expect(DataStatus.determine(limits, seconds)).to eq('questionable')
end
it 'returns "questionable" if seconds is between high_questionable and high_bad' do
limits = {low_bad: 100, low_questionable: 200, high_questionable: 300, high_bad: 400}
seconds = 350
expect(DataStatus.determine(limits, seconds)).to eq('questionable')
end
it 'returns "bad" if seconds is below low_bad' do
limits = {low_bad: 100, low_questionable: 200, high_questionable: 300, high_bad: 400}
seconds = 50
expect(DataStatus.determine(limits, seconds)).to eq('bad')
end
it 'returns "bad" if seconds is above high_bad' do
limits = {low_bad: 100, low_questionable: 200, high_questionable: 300, high_bad: 400}
seconds = 450
expect(DataStatus.determine(limits, seconds)).to eq('bad')
end
end
end