def test_process_path(self):
b = BluefloodClient("host", "tenant", False, None)
step = 100
big_step = step * 1000
val_step = 12
first_time = 1385074800000
first_val = 48
second_time = first_time + big_step
second_val = first_val + val_step
third_time = second_time + big_step
third_val = second_val + val_step
data_key = NonNestedDataKey(u'average')
values = [{
u'timestamp': first_time,
u'average': first_val,
u'numPoints': 97
}, {
u'timestamp': second_time,
u'average': second_val,
u'numPoints': 3
}, {
u'timestamp': third_time,
u'average': third_val,
u'numPoints': 3
}]
enum_values = [{
u'timestamp': first_time,
u'enum_values': {
u'v1': first_val
},
u'numPoints': 97
}, {
u'timestamp': second_time,
u'enum_values': {
u'v1': second_val
},
u'numPoints': 3
}, {
u'timestamp': third_time,
u'enum_values': {
u'v1': third_val
},
u'numPoints': 3
}]
enum_data_key = NestedDataKey('enum_values', 'v1')
start_time = first_time / 1000
end_time = third_time / 1000 + 1
#test that start and end time exactly match the datapoints
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
#test end time past end of data
end_time += 2 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(
ret, (first_val, second_val, third_val, None, None))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(
ret, (first_val, second_val, third_val, None, None))
#test start time before beginning of data
end_time -= 2 * step
start_time -= 2 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(
ret, (None, None, first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(
ret, (None, None, first_val, second_val, third_val))
#test end time before beginning of data
end_time -= 3 * step
start_time -= 3 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (None, None, None, None, None))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(ret, (None, None, None, None, None))
#test start and end outside of data and interpolation in the middle
second_time = first_time + (3 * big_step)
third_time = second_time + (3 * big_step)
start_time = first_time - (2 * big_step)
start_time /= 1000
end_time = third_time + (2 * big_step)
end_time = (end_time / 1000) + 1
values = [{
u'timestamp': first_time,
u'average': first_val,
u'numPoints': 97
}, {
u'timestamp': second_time,
u'average': second_val,
u'numPoints': 3
}, {
u'timestamp': third_time,
u'average': third_val,
u'numPoints': 3
}]
enum_values = [{
u'timestamp': first_time,
u'enum_values': {
u'v1': first_val
},
u'numPoints': 97
}, {
u'timestamp': second_time,
u'enum_values': {
u'v1': second_val
},
u'numPoints': 3
}, {
u'timestamp': third_time,
u'enum_values': {
u'v1': third_val
},
u'numPoints': 3
}]
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(
ret,
(None, None, first_val, first_val + 4, first_val + 8, second_val,
second_val + 4, second_val + 8, third_val, None, None))
ret = b.process_path(enum_values, start_time, end_time, step,
enum_data_key)
self.assertSequenceEqual(
ret,
(None, None, first_val, first_val + 4, first_val + 8, second_val,
second_val + 4, second_val + 8, third_val, None, None))
def test_process_path(self):
b = BluefloodClient("host", "tenant", False, None)
step = 100
big_step = step * 1000
val_step = 12
first_time = 1385074800000
first_val = 48
second_time = first_time + big_step
second_val = first_val + val_step
third_time = second_time + big_step
third_val = second_val + val_step
data_key = NonNestedDataKey(u'average')
values = [{u'timestamp': first_time, u'average': first_val, u'numPoints': 97},
{u'timestamp': second_time, u'average': second_val, u'numPoints': 3},
{u'timestamp': third_time, u'average': third_val, u'numPoints': 3}]
enum_values = [{u'timestamp': first_time, u'enum_values': {u'v1': first_val}, u'numPoints': 97},
{u'timestamp': second_time, u'enum_values': {u'v1': second_val}, u'numPoints': 3},
{u'timestamp': third_time, u'enum_values': {u'v1': third_val}, u'numPoints': 3}]
enum_data_key = NestedDataKey('enum_values', 'v1')
start_time = first_time/1000
end_time = third_time/1000 + 1
#test that start and end time exactly match the datapoints
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val))
#test end time past end of data
end_time += 2 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val, None, None))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (first_val, second_val, third_val, None, None))
#test start time before beginning of data
end_time -= 2 * step
start_time -= 2 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (None, None, first_val, second_val, third_val))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (None, None, first_val, second_val, third_val))
#test end time before beginning of data
end_time -= 3 * step
start_time -= 3 * step
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (None, None, None, None, None))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (None, None, None, None, None))
#test start and end outside of data and interpolation in the middle
second_time = first_time + (3 * big_step)
third_time = second_time + (3 * big_step)
start_time = first_time - (2 * big_step)
start_time /= 1000
end_time = third_time + (2 * big_step)
end_time = (end_time/1000) + 1
values = [{u'timestamp': first_time, u'average': first_val, u'numPoints': 97},
{u'timestamp': second_time, u'average': second_val, u'numPoints': 3},
{u'timestamp': third_time, u'average': third_val, u'numPoints': 3}]
enum_values = [{u'timestamp': first_time, u'enum_values': {u'v1': first_val}, u'numPoints': 97},
{u'timestamp': second_time, u'enum_values': {u'v1': second_val}, u'numPoints': 3},
{u'timestamp': third_time, u'enum_values': {u'v1': third_val}, u'numPoints': 3}]
ret = b.process_path(values, start_time, end_time, step, data_key)
self.assertSequenceEqual(ret, (None, None, first_val, first_val + 4, first_val + 8, second_val,
second_val + 4, second_val + 8, third_val , None, None))
ret = b.process_path(enum_values, start_time, end_time, step, enum_data_key)
self.assertSequenceEqual(ret, (None, None, first_val, first_val + 4, first_val + 8, second_val,
second_val + 4, second_val + 8, third_val , None, None))
