Jim Paris
0b631b7dea
simplejson was there for python <= 2.6 compatibility. It's not needed now, and installing it with pip can lead to segfaults because pip is dumb. (see e.g. https://github.com/simplejson/simplejson/issues/114)
785 lines
32 KiB
Python
785 lines
32 KiB
Python
# -*- coding: utf-8 -*-
|
||
|
||
import nilmdb.server
|
||
import nilmdb.client
|
||
|
||
from nilmdb.utils.printf import *
|
||
from nilmdb.utils import timestamper
|
||
from nilmdb.client import ClientError, ServerError, Error
|
||
from nilmdb.utils.sort import sort_human
|
||
import datetime_tz
|
||
|
||
from nose.plugins.skip import SkipTest
|
||
from nose.tools import *
|
||
from nose.tools import assert_raises
|
||
import itertools
|
||
import distutils.version
|
||
import os
|
||
import sys
|
||
import threading
|
||
import io
|
||
import json
|
||
import unittest
|
||
import warnings
|
||
import resource
|
||
import time
|
||
import re
|
||
import struct
|
||
|
||
from testutil.helpers import *
|
||
|
||
testdb = "tests/client-testdb"
|
||
testurl = "http://localhost:32180/"
|
||
|
||
def setup_module():
|
||
global test_server, test_db
|
||
# Clear out DB
|
||
recursive_unlink(testdb)
|
||
|
||
# Start web app on a custom port
|
||
test_db = nilmdb.utils.serializer_proxy(nilmdb.server.NilmDB)(testdb)
|
||
test_server = nilmdb.server.Server(test_db, host = "127.0.0.1",
|
||
port = 32180, stoppable = False,
|
||
fast_shutdown = True,
|
||
force_traceback = True)
|
||
test_server.start(blocking = False)
|
||
|
||
def teardown_module():
|
||
global test_server, test_db
|
||
# Close web app
|
||
test_server.stop()
|
||
test_db.close()
|
||
|
||
class TestClient(object):
|
||
|
||
def test_client_01_basic(self):
|
||
# Test a fake host
|
||
client = nilmdb.client.Client(url = "http://localhost:1/")
|
||
with assert_raises(nilmdb.client.ServerError):
|
||
client.version()
|
||
client.close()
|
||
|
||
# Then a fake URL on a real host
|
||
client = nilmdb.client.Client(url = "http://localhost:32180/fake/")
|
||
with assert_raises(nilmdb.client.ClientError):
|
||
client.version()
|
||
client.close()
|
||
|
||
# Now a real URL with no http:// prefix
|
||
client = nilmdb.client.Client(url = "localhost:32180")
|
||
version = client.version()
|
||
client.close()
|
||
|
||
# Now use the real URL
|
||
client = nilmdb.client.Client(url = testurl)
|
||
version = client.version()
|
||
eq_(distutils.version.LooseVersion(version),
|
||
distutils.version.LooseVersion(test_server.version))
|
||
|
||
# Bad URLs should give 404, not 500
|
||
with assert_raises(ClientError):
|
||
client.http.get("/stream/create")
|
||
|
||
# Test error handling
|
||
url = testurl
|
||
args = { "url": url,
|
||
"status": "400",
|
||
"message": "Something went wrong",
|
||
"traceback": None }
|
||
with assert_raises(ClientError):
|
||
client.http._handle_error(url, 400, json.dumps(args))
|
||
with assert_raises(ClientError):
|
||
client.http._handle_error(url, 400, "this is not JSON.. {")
|
||
args["status"] = "500"
|
||
with assert_raises(ServerError):
|
||
client.http._handle_error(url, 500, json.dumps(args))
|
||
args["message"] = None
|
||
with assert_raises(ServerError):
|
||
client.http._handle_error(url, 500, json.dumps(args))
|
||
args["status"] = "600"
|
||
with assert_raises(Error):
|
||
client.http._handle_error(url, 600, json.dumps(args))
|
||
|
||
# Use get_gen for an endpoint that doesn't have newlines,
|
||
# for better test coverage.
|
||
for line in client.http.get_gen("/version"):
|
||
pass
|
||
|
||
client.close()
|
||
|
||
def test_client_02_createlist(self):
|
||
# Basic stream tests, like those in test_nilmdb:test_stream
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
# Database starts empty
|
||
eq_(client.stream_list(), [])
|
||
|
||
# Bad path
|
||
with assert_raises(ClientError):
|
||
client.stream_create("foo/bar/baz", "float32_8")
|
||
with assert_raises(ClientError):
|
||
client.stream_create("/foo", "float32_8")
|
||
# Bad layout type
|
||
with assert_raises(ClientError):
|
||
client.stream_create("/newton/prep", "NoSuchLayout")
|
||
|
||
# Bad method types
|
||
with assert_raises(ClientError):
|
||
client.http.put("/stream/list",b"")
|
||
# Try a bunch of times to make sure the request body is getting consumed
|
||
for x in range(10):
|
||
with assert_raises(ClientError):
|
||
client.http.post("/stream/list")
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
# Create four streams
|
||
client.stream_create("/newton/prep", "float32_8")
|
||
client.stream_create("/newton/raw", "uint16_6")
|
||
client.stream_create("/newton/zzz/rawnotch2", "uint16_9")
|
||
client.stream_create("/newton/zzz/rawnotch11", "uint16_9")
|
||
|
||
# Test sort_human (used by stream_list)
|
||
eq_(sort_human(["/s/10", "/s/2"]), ["/s/2", "/s/10"])
|
||
|
||
# Verify we got 4 streams in the right order
|
||
eq_(client.stream_list(), [ ["/newton/prep", "float32_8"],
|
||
["/newton/raw", "uint16_6"],
|
||
["/newton/zzz/rawnotch2", "uint16_9"],
|
||
["/newton/zzz/rawnotch11", "uint16_9"]
|
||
])
|
||
|
||
# Match just one type or one path
|
||
eq_(client.stream_list(layout="uint16_6"),
|
||
[ ["/newton/raw", "uint16_6"] ])
|
||
eq_(client.stream_list(path="/newton/raw"),
|
||
[ ["/newton/raw", "uint16_6"] ])
|
||
|
||
# Try messing with resource limits to trigger errors and get
|
||
# more coverage. Here, make it so we can only create files 1
|
||
# byte in size, which will trigger an IOError in the server when
|
||
# we create a table.
|
||
limit = resource.getrlimit(resource.RLIMIT_FSIZE)
|
||
resource.setrlimit(resource.RLIMIT_FSIZE, (1, limit[1]))
|
||
|
||
# normal
|
||
with assert_raises(ServerError) as e:
|
||
client.stream_create("/newton/hello", "uint16_6")
|
||
|
||
# same but with force_traceback == False, to improve coverage
|
||
global test_server
|
||
test_server.force_traceback = False
|
||
with assert_raises(ServerError) as e:
|
||
client.stream_create("/newton/world", "uint16_6")
|
||
test_server.force_traceback = True
|
||
|
||
# Reset resource limit
|
||
resource.setrlimit(resource.RLIMIT_FSIZE, limit)
|
||
|
||
client.close()
|
||
|
||
def test_client_03_metadata(self):
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
# Set / get metadata
|
||
eq_(client.stream_get_metadata("/newton/prep"), {})
|
||
eq_(client.stream_get_metadata("/newton/raw"), {})
|
||
meta1 = { "description": "The Data",
|
||
"v_scale": "1.234" }
|
||
meta2 = { "description": "The Data" }
|
||
meta3 = { "v_scale": "1.234" }
|
||
client.stream_set_metadata("/newton/prep", meta1)
|
||
client.stream_update_metadata("/newton/prep", {})
|
||
client.stream_update_metadata("/newton/raw", meta2)
|
||
client.stream_update_metadata("/newton/raw", meta3)
|
||
eq_(client.stream_get_metadata("/newton/prep"), meta1)
|
||
eq_(client.stream_get_metadata("/newton/raw"), meta1)
|
||
eq_(client.stream_get_metadata("/newton/raw",
|
||
[ "description" ] ), meta2)
|
||
eq_(client.stream_get_metadata("/newton/raw",
|
||
[ "description", "v_scale" ] ), meta1)
|
||
|
||
# missing key
|
||
eq_(client.stream_get_metadata("/newton/raw", "descr"),
|
||
{ "descr": None })
|
||
eq_(client.stream_get_metadata("/newton/raw", [ "descr" ]),
|
||
{ "descr": None })
|
||
|
||
# test wrong types (list instead of dict)
|
||
with assert_raises(ClientError):
|
||
client.stream_set_metadata("/newton/prep", [1,2,3])
|
||
with assert_raises(ClientError):
|
||
client.stream_update_metadata("/newton/prep", [1,2,3])
|
||
|
||
# test wrong types (dict of non-strings)
|
||
# numbers are OK; they'll get converted to strings
|
||
client.stream_set_metadata("/newton/prep", { "hello": 1234 })
|
||
# anything else is not
|
||
with assert_raises(ClientError):
|
||
client.stream_set_metadata("/newton/prep", { "world": { 1: 2 } })
|
||
with assert_raises(ClientError):
|
||
client.stream_set_metadata("/newton/prep", { "world": [ 1, 2 ] })
|
||
|
||
client.close()
|
||
|
||
def test_client_04_insert(self):
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
# Limit _max_data to 1 MB, since our test file is 1.5 MB
|
||
old_max_data = nilmdb.client.client.StreamInserter._max_data
|
||
nilmdb.client.client.StreamInserter._max_data = 1 * 1024 * 1024
|
||
|
||
datetime_tz.localtz_set("America/New_York")
|
||
|
||
testfile = "tests/data/prep-20120323T1000"
|
||
start = nilmdb.utils.time.parse_time("20120323T1000")
|
||
rate = 120
|
||
|
||
# First try a nonexistent path
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
with assert_raises(ClientError) as e:
|
||
result = client.stream_insert("/newton/no-such-path", data)
|
||
in_("404 Not Found", repr(e.exception))
|
||
|
||
# Now try reversed timestamps
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
data = reversed(list(data))
|
||
with assert_raises(ClientError) as e:
|
||
result = client.stream_insert("/newton/prep", data)
|
||
in_("400 Bad Request", str(e.exception))
|
||
in2_("timestamp is not monotonically increasing",
|
||
"start must precede end", str(e.exception))
|
||
|
||
# Now try empty data (no server request made)
|
||
empty = io.StringIO("")
|
||
data = timestamper.TimestamperRate(empty, start, 120)
|
||
result = client.stream_insert("/newton/prep", data)
|
||
eq_(result, None)
|
||
|
||
# It's OK to insert an empty interval
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": 1, "end": 2 })
|
||
eq_(list(client.stream_intervals("/newton/prep")), [[1, 2]])
|
||
client.stream_remove("/newton/prep")
|
||
eq_(list(client.stream_intervals("/newton/prep")), [])
|
||
|
||
# Timestamps can be negative too
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": -2, "end": -1 })
|
||
eq_(list(client.stream_intervals("/newton/prep")), [[-2, -1]])
|
||
client.stream_remove("/newton/prep")
|
||
eq_(list(client.stream_intervals("/newton/prep")), [])
|
||
|
||
# Intervals that end at zero shouldn't be any different
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": -1, "end": 0 })
|
||
eq_(list(client.stream_intervals("/newton/prep")), [[-1, 0]])
|
||
client.stream_remove("/newton/prep")
|
||
eq_(list(client.stream_intervals("/newton/prep")), [])
|
||
|
||
# Try forcing a server request with equal start and end
|
||
with assert_raises(ClientError) as e:
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": 0, "end": 0 })
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("start must precede end", str(e.exception))
|
||
|
||
# Invalid times in HTTP request
|
||
with assert_raises(ClientError) as e:
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": "asdf", "end": 0 })
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("invalid start", str(e.exception))
|
||
|
||
with assert_raises(ClientError) as e:
|
||
client.http.put("stream/insert", b"", { "path": "/newton/prep",
|
||
"start": 0, "end": "asdf" })
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("invalid end", str(e.exception))
|
||
|
||
# Good content type
|
||
with assert_raises(ClientError) as e:
|
||
client.http.put("stream/insert", b"",
|
||
{ "path": "xxxx", "start": 0, "end": 1,
|
||
"binary": 1 })
|
||
in_("No such stream", str(e.exception))
|
||
|
||
# Bad content type
|
||
with assert_raises(ClientError) as e:
|
||
client.http.put("stream/insert", b"",
|
||
{ "path": "xxxx", "start": 0, "end": 1,
|
||
"binary": 1 },
|
||
content_type="text/plain; charset=utf-8")
|
||
in_("Content type must be application/octet-stream", str(e.exception))
|
||
|
||
# Specify start/end (starts too late)
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
with assert_raises(ClientError) as e:
|
||
result = client.stream_insert("/newton/prep", data,
|
||
start + 5000000, start + 120000000)
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("Data timestamp 1332511200000000 < start time 1332511205000000",
|
||
str(e.exception))
|
||
|
||
# Specify start/end (ends too early)
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
with assert_raises(ClientError) as e:
|
||
result = client.stream_insert("/newton/prep", data,
|
||
start, start + 1000000)
|
||
in_("400 Bad Request", str(e.exception))
|
||
# Client chunks the input, so the exact timestamp here might change
|
||
# if the chunk positions change.
|
||
assert(re.search("Data timestamp 13325[0-9]+ "
|
||
">= end time 1332511201000000", str(e.exception))
|
||
is not None)
|
||
|
||
def check_data():
|
||
# Verify the intervals. Should be just one, even if the data
|
||
# was inserted in chunks, due to nilmdb interval concatenation.
|
||
intervals = list(client.stream_intervals("/newton/prep"))
|
||
eq_(intervals, [[start, start + 119999777]])
|
||
|
||
# Try some overlapping data -- just insert it again
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
with assert_raises(ClientError) as e:
|
||
result = client.stream_insert("/newton/prep", data)
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("verlap", str(e.exception))
|
||
|
||
# Now do the real load
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
result = client.stream_insert("/newton/prep", data,
|
||
start, start + 119999777)
|
||
check_data()
|
||
|
||
# Try inserting directly-passed data
|
||
client.stream_remove("/newton/prep", start, start + 119999777)
|
||
data = timestamper.TimestamperRate(testfile, start, 120)
|
||
data_bytes = b''.join(data)
|
||
result = client.stream_insert("/newton/prep", data_bytes,
|
||
start, start + 119999777)
|
||
check_data()
|
||
|
||
nilmdb.client.client.StreamInserter._max_data = old_max_data
|
||
client.close()
|
||
|
||
def test_client_05_extractremove(self):
|
||
# Misc tests for extract and remove. Most of them are in test_cmdline.
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
for x in client.stream_extract("/newton/prep",
|
||
999123000000, 999124000000):
|
||
raise AssertionError("shouldn't be any data for this request")
|
||
|
||
with assert_raises(ClientError) as e:
|
||
client.stream_remove("/newton/prep", 123000000, 120000000)
|
||
|
||
# Test count
|
||
eq_(client.stream_count("/newton/prep"), 14400)
|
||
|
||
# Test binary output
|
||
with assert_raises(ClientError) as e:
|
||
list(client.stream_extract("/newton/prep",
|
||
markup = True, binary = True))
|
||
with assert_raises(ClientError) as e:
|
||
list(client.stream_extract("/newton/prep",
|
||
count = True, binary = True))
|
||
data = b"".join(client.stream_extract("/newton/prep", binary = True))
|
||
# Quick check using struct
|
||
unpacker = struct.Struct("<qffffffff")
|
||
out = []
|
||
for i in range(14400):
|
||
out.append(unpacker.unpack_from(data, i * unpacker.size))
|
||
eq_(out[0], (1332511200000000, 266568.0, 224029.0, 5161.39990234375,
|
||
2525.169921875, 8350.83984375, 3724.699951171875,
|
||
1355.3399658203125, 2039.0))
|
||
|
||
# Just get some coverage
|
||
with assert_raises(ClientError) as e:
|
||
client.http.post("/stream/remove", { "path": "/none" })
|
||
|
||
client.close()
|
||
|
||
def test_client_06_generators(self):
|
||
# A lot of the client functionality is already tested by test_cmdline,
|
||
# but this gets a bit more coverage that cmdline misses.
|
||
client = nilmdb.client.Client(url = testurl)
|
||
|
||
# Trigger a client error in generator
|
||
start = nilmdb.utils.time.parse_time("20120323T2000")
|
||
end = nilmdb.utils.time.parse_time("20120323T1000")
|
||
for function in [ client.stream_intervals, client.stream_extract ]:
|
||
with assert_raises(ClientError) as e:
|
||
next(function("/newton/prep", start, end))
|
||
in_("400 Bad Request", str(e.exception))
|
||
in_("start must precede end", str(e.exception))
|
||
|
||
# Trigger a curl error in generator
|
||
with assert_raises(ServerError) as e:
|
||
next(client.http.get_gen("http://nosuchurl.example.com./"))
|
||
|
||
# Check 404 for missing streams
|
||
for function in [ client.stream_intervals, client.stream_extract ]:
|
||
with assert_raises(ClientError) as e:
|
||
next(function("/no/such/stream"))
|
||
in_("404 Not Found", str(e.exception))
|
||
in_("No such stream", str(e.exception))
|
||
|
||
client.close()
|
||
|
||
def test_client_07_headers(self):
|
||
# Make sure that /stream/intervals and /stream/extract
|
||
# properly return streaming, chunked, text/plain response.
|
||
# Pokes around in client.http internals a bit to look at the
|
||
# response headers.
|
||
|
||
client = nilmdb.client.Client(url = testurl)
|
||
http = client.http
|
||
|
||
# Use a warning rather than returning a test failure for the
|
||
# transfer-encoding, so that we can still disable chunked
|
||
# responses for debugging.
|
||
|
||
def headers():
|
||
h = ""
|
||
for (k, v) in list(http._last_response.headers.items()):
|
||
h += k + ": " + v + "\n"
|
||
return h.lower()
|
||
|
||
# Intervals
|
||
x = http.get("stream/intervals", { "path": "/newton/prep" })
|
||
if "transfer-encoding: chunked" not in headers():
|
||
warnings.warn("Non-chunked HTTP response for /stream/intervals")
|
||
if "content-type: application/x-json-stream" not in headers():
|
||
raise AssertionError("/stream/intervals content type "
|
||
"is not application/x-json-stream:\n" +
|
||
headers())
|
||
|
||
# Extract
|
||
x = http.get("stream/extract", { "path": "/newton/prep",
|
||
"start": "123", "end": "124" })
|
||
if "transfer-encoding: chunked" not in headers():
|
||
warnings.warn("Non-chunked HTTP response for /stream/extract")
|
||
if "content-type: text/plain;charset=utf-8" not in headers():
|
||
raise AssertionError("/stream/extract is not text/plain:\n" +
|
||
headers())
|
||
|
||
x = http.get("stream/extract", { "path": "/newton/prep",
|
||
"start": "123", "end": "124",
|
||
"binary": "1" })
|
||
if "transfer-encoding: chunked" not in headers():
|
||
warnings.warn("Non-chunked HTTP response for /stream/extract")
|
||
if "content-type: application/octet-stream" not in headers():
|
||
raise AssertionError("/stream/extract is not binary:\n" +
|
||
headers())
|
||
|
||
# Make sure a binary of "0" is really off
|
||
x = http.get("stream/extract", { "path": "/newton/prep",
|
||
"start": "123", "end": "124",
|
||
"binary": "0" })
|
||
if "content-type: application/octet-stream" in headers():
|
||
raise AssertionError("/stream/extract is not text:\n" +
|
||
headers())
|
||
|
||
# Invalid parameters
|
||
with assert_raises(ClientError) as e:
|
||
x = http.get("stream/extract", { "path": "/newton/prep",
|
||
"start": "123", "end": "124",
|
||
"binary": "asdfasfd" })
|
||
in_("can't parse parameter", str(e.exception))
|
||
|
||
client.close()
|
||
|
||
def test_client_08_unicode(self):
|
||
# Try both with and without posting JSON
|
||
for post_json in (False, True):
|
||
# Basic Unicode tests
|
||
client = nilmdb.client.Client(url = testurl, post_json = post_json)
|
||
|
||
# Delete streams that exist
|
||
for stream in client.stream_list():
|
||
client.stream_remove(stream[0])
|
||
client.stream_destroy(stream[0])
|
||
|
||
# Database is empty
|
||
eq_(client.stream_list(), [])
|
||
|
||
# Create Unicode stream, match it
|
||
raw = [ "/düsseldorf/raw", "uint16_6" ]
|
||
prep = [ "/düsseldorf/prep", "uint16_6" ]
|
||
client.stream_create(*raw)
|
||
eq_(client.stream_list(), [raw])
|
||
eq_(client.stream_list(layout=raw[1]), [raw])
|
||
eq_(client.stream_list(path=raw[0]), [raw])
|
||
client.stream_create(*prep)
|
||
eq_(client.stream_list(), [prep, raw])
|
||
|
||
# Set / get metadata with Unicode keys and values
|
||
eq_(client.stream_get_metadata(raw[0]), {})
|
||
eq_(client.stream_get_metadata(prep[0]), {})
|
||
meta1 = { "alpha": "α",
|
||
"β": "beta" }
|
||
meta2 = { "alpha": "α" }
|
||
meta3 = { "β": "beta" }
|
||
client.stream_set_metadata(prep[0], meta1)
|
||
client.stream_update_metadata(prep[0], {})
|
||
client.stream_update_metadata(raw[0], meta2)
|
||
client.stream_update_metadata(raw[0], meta3)
|
||
eq_(client.stream_get_metadata(prep[0]), meta1)
|
||
eq_(client.stream_get_metadata(raw[0]), meta1)
|
||
eq_(client.stream_get_metadata(raw[0], [ "alpha" ]), meta2)
|
||
eq_(client.stream_get_metadata(raw[0], [ "alpha", "β" ]), meta1)
|
||
|
||
client.close()
|
||
|
||
def test_client_09_closing(self):
|
||
# Make sure we actually close sockets correctly. New
|
||
# connections will block for a while if they're not, since the
|
||
# server will stop accepting new connections.
|
||
for test in [1, 2]:
|
||
start = time.time()
|
||
for i in range(50):
|
||
if time.time() - start > 15:
|
||
raise AssertionError("Connections seem to be blocking... "
|
||
"probably not closing properly.")
|
||
if test == 1:
|
||
# explicit close
|
||
client = nilmdb.client.Client(url = testurl)
|
||
with assert_raises(ClientError) as e:
|
||
client.stream_remove("/newton/prep", 123, 120)
|
||
client.close() # remove this to see the failure
|
||
elif test == 2:
|
||
# use the context manager
|
||
with nilmdb.client.Client(url = testurl) as c:
|
||
with assert_raises(ClientError) as e:
|
||
c.stream_remove("/newton/prep", 123, 120)
|
||
|
||
def test_client_10_context(self):
|
||
# Test using the client's stream insertion context manager to
|
||
# insert data.
|
||
client = nilmdb.client.Client(testurl)
|
||
|
||
client.stream_create("/context/test", "uint16_1")
|
||
with client.stream_insert_context("/context/test") as ctx:
|
||
# override _max_data to trigger frequent server updates
|
||
ctx._max_data = 15
|
||
|
||
ctx.insert(b"1000 1\n")
|
||
|
||
ctx.insert(b"1010 ")
|
||
ctx.insert(b"1\n1020 1")
|
||
ctx.insert(b"")
|
||
ctx.insert(b"\n1030 1\n")
|
||
|
||
ctx.insert(b"1040 1\n")
|
||
ctx.insert(b"# hello\n")
|
||
ctx.insert(b" # hello\n")
|
||
ctx.insert(b" 1050 1\n")
|
||
ctx.finalize()
|
||
|
||
ctx.insert(b"1070 1\n")
|
||
ctx.update_end(1080)
|
||
ctx.finalize()
|
||
ctx.update_start(1090)
|
||
ctx.insert(b"1100 1\n")
|
||
ctx.insert(b"1110 1\n")
|
||
ctx.send()
|
||
ctx.insert(b"1120 1\n")
|
||
ctx.insert(b"1130 1\n")
|
||
ctx.insert(b"1140 1\n")
|
||
ctx.update_end(1160)
|
||
ctx.insert(b"1150 1\n")
|
||
ctx.update_end(1170)
|
||
ctx.insert(b"1160 1\n")
|
||
ctx.update_end(1180)
|
||
ctx.insert(b"1170 1" +
|
||
b" # this is super long" * 100 +
|
||
b"\n")
|
||
ctx.finalize()
|
||
ctx.insert(b"# this is super long" * 100)
|
||
|
||
# override _max_data_after_send to trigger ValueError on a
|
||
# long nonterminated line
|
||
ctx._max_data_after_send = 1000
|
||
with assert_raises(ValueError):
|
||
ctx.insert(b"# this is super long" * 100)
|
||
|
||
with assert_raises(ClientError):
|
||
with client.stream_insert_context("/context/test",
|
||
1000, 2000) as ctx:
|
||
ctx.insert(b"1180 1\n")
|
||
|
||
with assert_raises(ClientError):
|
||
with client.stream_insert_context("/context/test",
|
||
2000, 3000) as ctx:
|
||
ctx.insert(b"1180 1\n")
|
||
|
||
with assert_raises(ClientError):
|
||
with client.stream_insert_context("/context/test") as ctx:
|
||
ctx.insert(b"bogus data\n")
|
||
|
||
with client.stream_insert_context("/context/test", 2000, 3000) as ctx:
|
||
# make sure our override wasn't permanent
|
||
ne_(ctx._max_data, 15)
|
||
ctx.insert(b"2250 1\n")
|
||
ctx.finalize()
|
||
|
||
with assert_raises(ClientError):
|
||
with client.stream_insert_context("/context/test",
|
||
3000, 4000) as ctx:
|
||
ctx.insert(b"3010 1\n")
|
||
ctx.insert(b"3020 2\n")
|
||
ctx.insert(b"3030 3\n")
|
||
ctx.insert(b"3040 4\n")
|
||
ctx.insert(b"3040 4\n") # non-monotonic after a few lines
|
||
ctx.finalize()
|
||
|
||
eq_(list(client.stream_intervals("/context/test")),
|
||
[ [ 1000, 1051 ],
|
||
[ 1070, 1080 ],
|
||
[ 1090, 1180 ],
|
||
[ 2000, 3000 ] ])
|
||
|
||
# destroy stream (try without removing data first)
|
||
with assert_raises(ClientError):
|
||
client.stream_destroy("/context/test")
|
||
client.stream_remove("/context/test")
|
||
client.stream_destroy("/context/test")
|
||
client.close()
|
||
|
||
def test_client_11_emptyintervals(self):
|
||
# Empty intervals are ok! If recording detection events
|
||
# by inserting rows into the database, we want to be able to
|
||
# have an interval where no events occurred. Test them here.
|
||
client = nilmdb.client.Client(testurl)
|
||
client.stream_create("/empty/test", "uint16_1")
|
||
|
||
def info():
|
||
result = []
|
||
for interval in list(client.stream_intervals("/empty/test")):
|
||
result.append((client.stream_count("/empty/test", *interval),
|
||
interval))
|
||
return result
|
||
|
||
eq_(info(), [])
|
||
|
||
# Insert a region with just a few points
|
||
with client.stream_insert_context("/empty/test") as ctx:
|
||
ctx.update_start(100)
|
||
ctx.insert(b"140 1\n")
|
||
ctx.insert(b"150 1\n")
|
||
ctx.insert(b"160 1\n")
|
||
ctx.update_end(200)
|
||
ctx.finalize()
|
||
|
||
eq_(info(), [(3, [100, 200])])
|
||
|
||
# Delete chunk, which will leave one data point and two intervals
|
||
client.stream_remove("/empty/test", 145, 175)
|
||
eq_(info(), [(1, [100, 145]),
|
||
(0, [175, 200])])
|
||
|
||
# Try also creating a completely empty interval from scratch,
|
||
# in a few different ways.
|
||
client.stream_insert("/empty/test", b"", 300, 350)
|
||
client.stream_insert("/empty/test", [], 400, 450)
|
||
with client.stream_insert_context("/empty/test", 500, 550):
|
||
pass
|
||
|
||
# If enough timestamps aren't provided, empty streams won't be created.
|
||
client.stream_insert("/empty/test", [])
|
||
with client.stream_insert_context("/empty/test"):
|
||
pass
|
||
client.stream_insert("/empty/test", [], start = 600)
|
||
with client.stream_insert_context("/empty/test", start = 700):
|
||
pass
|
||
client.stream_insert("/empty/test", [], end = 850)
|
||
with client.stream_insert_context("/empty/test", end = 950):
|
||
pass
|
||
|
||
# Equal start and end is OK as long as there's no data
|
||
with client.stream_insert_context("/empty/test", start=9, end=9):
|
||
pass
|
||
|
||
# Try various things that might cause problems
|
||
with client.stream_insert_context("/empty/test", 1000, 1050) as ctx:
|
||
ctx.finalize() # inserts [1000, 1050]
|
||
ctx.finalize() # nothing
|
||
ctx.finalize() # nothing
|
||
ctx.insert(b"1100 1\n")
|
||
ctx.finalize() # inserts [1100, 1101]
|
||
ctx.update_start(1199)
|
||
ctx.insert(b"1200 1\n")
|
||
ctx.update_end(1250)
|
||
ctx.finalize() # inserts [1199, 1250]
|
||
ctx.update_start(1299)
|
||
ctx.finalize() # nothing
|
||
ctx.update_end(1350)
|
||
ctx.finalize() # nothing
|
||
ctx.update_start(1400)
|
||
ctx.insert(b"# nothing!\n")
|
||
ctx.update_end(1450)
|
||
ctx.finalize()
|
||
ctx.update_start(1500)
|
||
ctx.insert(b"# nothing!")
|
||
ctx.update_end(1550)
|
||
ctx.finalize()
|
||
ctx.insert(b"# nothing!\n" * 10)
|
||
ctx.finalize()
|
||
# implicit last finalize inserts [1400, 1450]
|
||
|
||
# Check everything
|
||
eq_(info(), [(1, [100, 145]),
|
||
(0, [175, 200]),
|
||
(0, [300, 350]),
|
||
(0, [400, 450]),
|
||
(0, [500, 550]),
|
||
(0, [1000, 1050]),
|
||
(1, [1100, 1101]),
|
||
(1, [1199, 1250]),
|
||
(0, [1400, 1450]),
|
||
(0, [1500, 1550]),
|
||
])
|
||
|
||
# Clean up
|
||
client.stream_remove("/empty/test")
|
||
client.stream_destroy("/empty/test")
|
||
client.close()
|
||
|
||
def test_client_12_persistent(self):
|
||
# Check that connections are NOT persistent. Rather than trying
|
||
# to verify this at the TCP level, just make sure that the response
|
||
# contained a "Connection: close" header.
|
||
with nilmdb.client.Client(url = testurl) as c:
|
||
c.stream_create("/persist/test", "uint16_1")
|
||
eq_(c.http._last_response.headers["Connection"], "close")
|
||
|
||
c.stream_destroy("/persist/test")
|
||
eq_(c.http._last_response.headers["Connection"], "close")
|
||
|
||
def test_client_13_timestamp_rounding(self):
|
||
# Test potentially bad timestamps (due to floating point
|
||
# roundoff etc). The server will round floating point values
|
||
# to the nearest int.
|
||
client = nilmdb.client.Client(testurl)
|
||
|
||
client.stream_create("/rounding/test", "uint16_1")
|
||
with client.stream_insert_context("/rounding/test",
|
||
100000000, 200000000.1) as ctx:
|
||
ctx.insert(b"100000000.1 1\n")
|
||
ctx.insert(b"150000000.00003 1\n")
|
||
ctx.insert(b"199999999.4 1\n")
|
||
eq_(list(client.stream_intervals("/rounding/test")),
|
||
[ [ 100000000, 200000000 ] ])
|
||
|
||
with assert_raises(ClientError):
|
||
with client.stream_insert_context("/rounding/test",
|
||
200000000, 300000000) as ctx:
|
||
ctx.insert(b"200000000 1\n")
|
||
ctx.insert(b"250000000 1\n")
|
||
# Server will round this and give an error on finalize()
|
||
ctx.insert(b"299999999.99 1\n")
|
||
|
||
client.stream_remove("/rounding/test")
|
||
client.stream_destroy("/rounding/test")
|
||
client.close()
|