def test_importing_result_line_protocol():
_make_many_lines = influx.InfluxDB._make_many_lines
client = influx.client(_get_url())
result = fixtures.json.result
columns, values = client.unpack(result)
# Sanity check
eq_(columns[0], 'time')
eq_(values[0][0], 1487275118000000)
columns = columns[:3]
values = [row[:3] for row in values[:3]]
measurement = 'lines'
fields = columns
tags = {'mytag': 'mine'}
lines = _make_many_lines(measurement, fields, values, tags)
expected = ('lines,mytag=mine blding.cmpA=34.45272,blding.cmpB=48.43736,'
'time=1487275118000000\n'
'lines,mytag=mine blding.cmpA=34.223846,blding.cmpB=48.417927,'
'time=1487275133000000\n'
'lines,mytag=mine blding.cmpA=23.646818,blding.cmpB=48.378204,'
'time=1487275148000000\n')
eq_(lines, expected)
def test_select_where():
client = influx.client(_get_url())
# Replace microseconds race conditions at the nanosecond level
test_time = pytool.time.utcnow().replace(microsecond=0)
expected_time = pytool.time.toutctimestamp(test_time) * 1e6
measurement = _get_unique_measurement()
db = 'test_select_where'
tags = {'my_tag': 'workplz'}
resp = client.write(db, measurement, {'value': 1}, tags, time=test_time)
# Sleep for 10ms to guarantee write persistence
time.sleep(0.01)
# Make our query
resp = client.select_where(db,
measurement,
tags=tags,
where='time > now() - 1s')
eq_(
resp, {
'results': [{
'statement_id':
0,
'series': [{
'name': measurement,
'columns': ['time', 'my_tag', 'value'],
'values': [[expected_time, 'workplz', 1]]
}]
}]
})
def test_select_all():
client = influx.client(_get_url())
# Replace microseconds race conditions at the nanosecond level
test_time = pytool.time.utcnow().replace(microsecond=0)
expected_time = pytool.time.toutctimestamp(test_time) * 1e6
measurement = _get_unique_measurement()
resp = client.write('test_select_all',
measurement, {'value': 1},
time=test_time)
# Sleep for 50ms to guarantee write persistence
time.sleep(0.05)
resp = client.select_recent('test_select_all', measurement)
eq_(
resp, {
'results': [{
'statement_id':
0,
'series': [{
'name': measurement,
'columns': ['time', 'value'],
'values': [[expected_time, 1]]
}]
}]
})
def test_missing_tags():
client = influx.client(_get_url())
# Field and tag schema shared between orig/new
fields = ['time', 'alpha', 'beta', 'class']
# site_id tag missing from fields
tags = {'class': 'VALUE', 'site_id': 'VALUE'}
# Orig values
values = [
[1521241703.092, 1, 1.1, 'test'],
[1521241705.092, 2, 1.2, 'test'],
[1521241707.092, 3, 1.3, 'test'],
[1521241709.092, 4, 1.4, 'test'],
[1521241711.092, 5, 1.5, 'test'],
[1521241703.092, 1, 1.1, 'fixed'],
[1521241705.092, 2, 1.2, 'fixed'],
[1521241707.092, 3, 1.3, 'fixed'],
[1521241709.092, 4, 1.4, 'fixed'],
[1521241711.092, 5, 1.5, 'fixed'],
]
# Write orig values to DB
measurement = _get_unique_measurement()
client.write_many('test',
measurement,
fields,
values,
tags,
time_field='time')
# Query back data for checking
resp = client.select_where('test', measurement, where="time > 0")
_, orig_values = client.unpack(resp)
eq_(len(values), len(orig_values))
def test_select_where_in_the_past():
client = influx.client(_get_url())
# Replace microseconds race conditions at the nanosecond level
test_time = pytool.time.utcnow().replace(microsecond=0)
test_time -= datetime.timedelta(hours=1)
expected_time = pytool.time.toutctimestamp(test_time) * 1e6
measurement = _get_unique_measurement()
db = 'test_select_where'
tags = {'my_tag': 'huzzah'}
# Write one data point an hour ago
resp = client.write(db, measurement, {'value': 1}, tags, time=test_time)
# Sleep for 10ms to guarantee write persistence
time.sleep(0.01)
# Make our query
where = 'time > now() - 61m AND time < now() - 59m'
resp = client.select_where(db, measurement, tags=tags, where=where)
# We should find our hour old data point
expected = {
'results': [{
'statement_id':
0,
'series': [{
'name': measurement,
'columns': ['time', 'my_tag', 'value'],
'values': [[expected_time, 'huzzah', 1]]
}]
}]
}
eq_(resp, expected)
# Query for 1h10m ago
where = 'time > now() - 71m AND time < now() - 69m'
resp = client.select_where(db, measurement, tags=tags, where=where)
# We shouldn't find anything
eq_(resp, {'results': [{'statement_id': 0}]})
# Query an hour ago again, but with timestamps
earlier = test_time - datetime.timedelta(minutes=1)
later = test_time + datetime.timedelta(minutes=1)
earlier = earlier.replace(tzinfo=None).isoformat('T') + 'Z'
later = later.replace(tzinfo=None).isoformat('T') + 'Z'
where = "time > '{}' AND time < '{}'".format(earlier, later)
resp = client.select_where(db, measurement, tags=tags, where=where)
# We should find our data point again
eq_(resp, expected)
def test_write_without_time():
client = influx.client(_get_url())
measurement = _get_unique_measurement()
err = client.write('test', measurement, {
'field1': 1.0,
'field2': 2
}, {'tag1': 'test_tag'})
# If there is no error, there will be no response JSON, and we're good
eq_(err, None)
def test_show_fields():
client = influx.client(_get_url())
measurement = _get_unique_measurement()
err = client.write('test', measurement, {
'field1': 1.0,
'field2': 2
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241703.092)
eq_(err, None)
fields = client.show_fields('test', measurement)
eq_(fields, ['field1', 'field2'])
def test_write_many():
client = influx.client(_get_url())
db = 'test_write_many'
measurement = _get_unique_measurement()
fields = ['alpha', 'beta']
values = [
[1.1, 100],
[1.2, 200],
[2.1, 300],
[3.0, 400],
[5.0, 500],
]
tags = {'tag_write_many': "unittest"}
err = client.write_many(db, measurement, fields, values, tags)
eq_(err, None)
def test_write_many_with_ts():
client = influx.client(_get_url())
now = pytool.time.utcnow()
now = pytool.time.toutctimestamp(now)
now = math.floor(now) * 1.0 # Strip ms to prevent rounding differences
db = 'test_write_many'
measurement = _get_unique_measurement()
fields = ['alpha', 'beta', 'ts']
values = [
[1.1, 100, now - 4],
[1.2, 200, now - 3],
[2.1, 300, now - 2],
[3.0, 400, now - 1],
[5.0, 500, now],
]
tags = {'tag_write_many_ts': "unittest"}
err = client.write_many(db, measurement, fields, values, tags, 'ts')
eq_(err, None)
resp = client.select_recent(db, measurement)
# Precision multiplier (ms)
exp = 1000000
now = math.floor(now * exp)
expected = {
'results': [{
'series': [{
'name':
measurement,
'columns': ['time', 'alpha', 'beta', 'tag_write_many_ts'],
'values': [[now - (4 * exp), 1.1, 100, 'unittest'],
[now - (3 * exp), 1.2, 200, 'unittest'],
[now - (2 * exp), 2.1, 300, 'unittest'],
[now - (1 * exp), 3, 400, 'unittest'],
[now, 5, 500, 'unittest']]
}],
'statement_id':
0
}]
}
# resp = resp['results'][0]['series'][0]['values']
# expected = expected['results'][0]['series'][0]['values']
eq_(resp, expected)
def test_write_float_returns_float():
client = influx.client(_get_url())
db = 'test_write_float'
measurement = _get_unique_measurement()
fields = {'float_value': 0.5}
tags = {'tested': 1}
err = client.write(db, measurement, fields, tags)
eq_(err, None)
resp = client.select_recent(db, measurement)
fields, vals = client.unpack(resp)
eq_(fields, ['time', 'float_value', 'tested'])
eq_(vals[0][1:], [0.5, '1'])
eq_(type(vals[0][1:][0]), float)
def test_select_into_cross_database_no_default():
client = influx.client(_get_url())
client.create_database('test2')
measurement = _get_unique_measurement()
err = client.write('test', measurement, {
'field1': 1.0,
'field2': 2
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241703.092)
eq_(err, None)
resp = client.select_where('test',
measurement,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_field1', 'count_field2'])
eq_(count[0][1], 1)
eq_(count[0][2], 1)
measurement = 'test.autogen.' + measurement
measurement2 = 'test2.autogen.' + _get_unique_measurement()
count = client.select_into(measurement2, measurement)
eq_(count, 1)
resp = client.select_where('test',
measurement2,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_field1', 'count_field2'])
eq_(count[0][1], 1)
eq_(count[0][2], 1)
def test_importing_result_write_and_retrieve():
client = influx.client(_get_url())
result = fixtures.json.result
columns, values = client.unpack(result)
columns = columns[:3]
values = [row[:3] for row in values[:3]]
db = 'test_write_result'
measurement = _get_unique_measurement()
fields = columns
tags = {'imported': 'yes'}
err = client.write_many(db, measurement, fields, values, tags, 'time')
eq_(err, None)
resp = client.select_recent(db, measurement, relative_time='100000d')
fields, vals = client.unpack(resp)
eq_(fields, columns + ['imported'])
eq_(vals, [v + ['yes'] for v in values])
def test_select_into():
client = influx.client(_get_url())
measurement = _get_unique_measurement()
err = client.write('test', measurement, {
'field1': 1.0,
'field2': 2
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241703.092)
eq_(err, None)
resp = client.select_where('test',
measurement,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_field1', 'count_field2'])
eq_(count[0][1], 1)
eq_(count[0][2], 1)
measurement2 = _get_unique_measurement()
count = client.select_into('test', measurement2, measurement)
eq_(count, 1)
resp = client.select_where('test',
measurement2,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_field1', 'count_field2'])
eq_(count[0][1], 1)
eq_(count[0][2], 1)
def test_safe_request():
# _make_request.return_value.status_code = 200
# _make_request.return_value.json = 'error'
# create_database.return_value = {'results': [{'statement_id': 0}]}
client = influx.client(_get_url())
missing_db = mock.MagicMock()
created_db = mock.MagicMock()
select = mock.MagicMock()
missing_db.status_code = 404
missing_db.json.return_value = {
'results': [{
'statement_id': 0,
'error': 'database not found'
}]
}
created_db.status_code = 200
created_db.json.return_value = {'results': [{'statement_id': 0}]}
select.status_code = 200
select.json.return_value = '200 OK'
with mock.patch.object(client.session, 'request') as request:
request.side_effect = [missing_db, created_db, select]
resp = client._safe_request(influx.IQL_SELECT,
database='database',
measurement='measurement',
fields='fields',
where='where')
eq_(len(request.call_args_list), 3)
ok_(resp.json() == '200 OK')
def test_select_into_existing():
client = influx.client(_get_url())
# Field and tag schema shared between orig/new
fields = ['time', 'alpha', 'beta', 'class']
tags = {'class': 'VALUE'}
# Orig values
values = [
[1521241703.092, 1, 1.1, 'test'],
[1521241705.092, 2, 1.2, 'test'],
[1521241707.092, 3, 1.3, 'test'],
[1521241709.092, 4, 1.4, 'test'],
[1521241711.092, 5, 1.5, 'test'],
[1521241703.092, 1, 1.1, 'fixed'],
[1521241705.092, 2, 1.2, 'fixed'],
[1521241707.092, 3, 1.3, 'fixed'],
[1521241709.092, 4, 1.4, 'fixed'],
[1521241711.092, 5, 1.5, 'fixed'],
]
# Write orig values to DB
measurement = _get_unique_measurement()
client.write_many('test',
measurement,
fields,
values,
tags,
time_field='time')
# Query back data for checking
resp = client.select_where('test', measurement, where="time > 0")
_, orig_values = client.unpack(resp)
# New values
new_values = [
[1521241705.092, 20, 1.2, 'test'],
[1521241707.092, 30, 1.3, 'test'],
[1521241708.092, 1, 1.35, 'new'],
[1521241711.092, 50, 1.5, 'test'],
]
# Write new values to DB
new_measurement = _get_unique_measurement()
client.write_many('test',
new_measurement,
fields,
new_values,
tags,
time_field='time')
# Check field schema matches
found_fields = client.show_fields('test', measurement)
new_fields = client.show_fields('test', new_measurement)
eq_(found_fields, new_fields)
# Check tag schema matches
found_tags = client.show_tags('test', measurement)
new_tags = client.show_tags('test', new_measurement)
eq_(found_tags, new_tags)
# Merge new data into orig
count = client.select_into('test', measurement, new_measurement)
eq_(count, len(new_values))
# Query back data for checking
resp = client.select_where('test', measurement, where="time > 0")
columns, values = client.unpack(resp)
# Make sure we have the same columns as the original schema
eq_(columns, fields)
# Modify timesetamps to be floats
values = sorted(values)
for i in range(len(values)):
# They come out with default precision 'u' so divide by 1M
values[i][0] = 1.0 * values[i][0] / 10.0**6
# We expect the 'test' values to be overwritten with the new values (except
# the first one). We also expect the 'new' value to be included. Lastly we
# expect the 'fixed' values to be unchanged.
expected = [
[1521241703.092, 1, 1.1, 'fixed'],
[1521241703.092, 1, 1.1, 'test'],
[1521241705.092, 2, 1.2, 'fixed'],
[1521241705.092, 20, 1.2, 'test'],
[1521241707.092, 3, 1.3, 'fixed'],
[1521241707.092, 30, 1.3, 'test'],
[1521241708.092, 1, 1.35, 'new'],
[1521241709.092, 4, 1.4, 'fixed'],
[1521241709.092, 4, 1.4, 'test'],
[1521241711.092, 5, 1.5, 'fixed'],
[1521241711.092, 50, 1.5, 'test'],
]
eq_(values, expected)
def test_select_into_group_by():
client = influx.client(_get_url())
measurement = _get_unique_measurement()
err = client.write('test', measurement, {
'field1': 1.0,
'field2': 2
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241703.092)
eq_(err, None)
err = client.write('test', measurement, {
'field1': 2.0,
'field2': 4
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241705.092)
eq_(err, None)
err = client.write('test', measurement, {
'field1': 3.0,
'field2': 6
}, {
'tag1': 'test_tag',
'tag2': 'foo'
}, 1521241707.092)
eq_(err, None)
resp = client.select_where('test',
measurement,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_field1', 'count_field2'])
eq_(count[0][1], 3)
eq_(count[0][2], 3)
measurement = 'test.autogen.' + measurement
measurement2 = 'test.autogen.' + _get_unique_measurement()
count = client.select_into(measurement2,
measurement,
fields='mean(*)',
group_by="time(15m)")
eq_(count, 1)
resp = client.select_where('test',
measurement2,
"count(*)",
where="time > 0")
columns, count = client.unpack(resp)
eq_(columns, ['time', 'count_mean_field1', 'count_mean_field2'])
eq_(count[0][1], 1)
eq_(count[0][2], 1)
resp = client.select_where('test', measurement2, "*", where="time > 0")
columns, values = client.unpack(resp)
eq_(columns, ['time', 'mean_field1', 'mean_field2'])
eq_(values[0][1], 2.0)
eq_(values[0][2], 4)
def test_create_database():
client = influx.client(_get_url())
resp = client.create_database('test')
eq_(resp, {'results': [{'statement_id': 0}]})
def test_select_into_four_args():
client = influx.client(_get_url())
client.select_into('test', 'test', 'test', 'test')
def test_select_into_one_arg():
client = influx.client(_get_url())
client.select_into('test')
def test_select_into_no_args():
client = influx.client(_get_url())
client.select_into()
def test_select_where_limits_and_order():
client = influx.client(_get_url())
# Replace microseconds race conditions at the nanosecond level
test_time = pytool.time.utcnow().replace(microsecond=0)
expected_time = pytool.time.toutctimestamp(test_time) * 1e6
measurement = _get_unique_measurement()
db = 'test_select_where'
tags = {'my_tag': 'workplz'}
resp = client.write(db,
measurement, {'value': 1},
tags,
time=test_time - datetime.timedelta(seconds=2))
eq_(resp, None)
resp = client.write(db,
measurement, {'value': 2},
tags,
time=test_time - datetime.timedelta(seconds=1))
eq_(resp, None)
resp = client.write(db, measurement, {'value': 3}, tags, time=test_time)
eq_(resp, None)
# Sleep for 10ms to guarantee write persistence
time.sleep(0.01)
# Make our query
fields = 'my_tag, last(value)'
resp = client.select_where(db,
measurement,
fields=fields,
tags=tags,
where='time > now() - 10s',
limit=1)
columns, values = client.unpack(resp)
eq_(values, [[expected_time, 'workplz', 3]])
# Test reverse ordering
resp = client.select_where(db, measurement, tags=tags, desc=True, limit=3)
columns, values = client.unpack(resp)
eq_(len(values), 3)
eq_(values[0], [expected_time, 'workplz', 3])
# Test starting timestamp with reverse ordering
fields = 'my_tag, first(value)'
resp = client.select_where(db, measurement, tags=tags, desc=True, limit=1)
columns, values = client.unpack(resp)
eq_(values, [[expected_time, 'workplz', 3]])
# Subtract two seconds from the expected time to match first result
expected_time -= 2000000
resp = client.select_where(db, measurement, tags=tags, desc=False, limit=3)
columns, values = client.unpack(resp)
eq_(len(values), 3)
eq_(values[0], [expected_time, 'workplz', 1])
# Test starting timestamp
fields = 'my_tag, first(value)'
resp = client.select_where(db, measurement, tags=tags, desc=False, limit=1)
columns, values = client.unpack(resp)
eq_(values, [[expected_time, 'workplz', 1]])
# Test regular ordering
resp = client.select_where(db, measurement, tags=tags, desc=False, limit=1)
columns, values = client.unpack(resp)
eq_(values, [[expected_time, 'workplz', 1]])
# Generic ordering
resp = client.select_where(db,
measurement,
tags=tags,
where='time > now() - 10s',
limit=1)
columns, values = client.unpack(resp)
eq_(values, [[expected_time, 'workplz', 1]])
