def test_insert_invalid_var_1(self):
"""
Corner case: giving a Variable instance with the same name as the one
of the table, but a different type. The input value corresponds to
this wrong type as well.
This should still raise an error! (a RuntimeError)
"""
invalid_value = 13.5
fake_var = Variable(float, "test_var")
with self.assertRaises(RuntimeError):
insert_new_var_value(self.conn, fake_var, invalid_value)
def test_timestamp_correct(self):
"""
In the database, the timestamp of the moment that the Variable
was created should be stored.
It needs to be an epoch time in seconds.
"""
var = Variable(int, "some_var")
add_var(self.conn, var)
df = get_all_rows_variables(self.conn)
timestamp_now = time.time()
self.assertLess(timestamp_now - df.loc[0, "timestamp"], 2)
def test_get_rows_of_vars_input_variables(self):
"""
Test get_rows_of_vars(),
given as input a sequence of Variable instances.
"""
var_foo = Variable(int, "foo")
var_bar = Variable(float, "bar")
self.db.create_new_var(var_foo)
self.db.create_new_var(var_bar)
self.db.insert_new_value_of_var(var_foo, 10)
self.db.insert_new_value_of_var(var_bar, 10.5)
# Pretend this happens a second later!
self.db.insert_new_value_of_var(var_foo, 12, int(time.time()) + 1)
self.db.insert_new_value_of_var(var_bar, 12.5, int(time.time()) + 1)
result = self.db.get_rows_of_vars((var_foo, var_bar))
expected = {"foo": (10, 12), "bar": (10.5, 12.5)}
for key in expected.keys():
np.testing.assert_allclose(expected[key], result[key])
def test_insert_valid_with_timestamp(self):
var = Variable(int, "test_var")
self.db.create_new_var(var)
new_value = 13
timestamp = 12345
self.db.insert_new_value_of_var(var, new_value, timestamp)
df = self.db.get_rows_of_var(var)
self.assertEqual(df.loc[0, "value"], new_value)
self.assertEqual(df.loc[0, "timestamp"], timestamp)
def setUp(self):
remove_database(TEST_DB_NAME)
self.db = DatabaseWriter(TEST_DB_NAME)
self.var_1 = Variable(int, "foo")
self.db.create_new_var(self.var_1)
self.db.insert_new_value_of_var(self.var_1, 10, 1)
self.db.insert_new_value_of_var(self.var_1, 11, 2)
self.db.insert_new_value_of_var(self.var_1, 12, 3)
self.db.insert_new_value_of_var(self.var_1, 13, 4)
self.db.insert_new_value_of_var(self.var_1, 14, 5)
self.var_2 = Variable(float, "bar")
self.db.create_new_var(self.var_2)
self.db.insert_new_value_of_var(self.var_2, 10.1, 1)
self.db.insert_new_value_of_var(self.var_2, 11.1, 2)
self.db.insert_new_value_of_var(self.var_2, 12.1, 3)
self.db.insert_new_value_of_var(self.var_2, 13.1, 4)
self.db.insert_new_value_of_var(self.var_2, 14.1, 5)
# Rule #1 is fireable.
trig_1 = TriggerExpression(
"mean(vars_dict['foo'][-2:]) > mean(vars_dict['bar'][-3:])",
{"foo", "bar"})
mess_1 = MessageExpression("vars_dict['bar'][-1:]", {"foo"})
eval_1 = EvaluationExpression(
"tanh(vars_dict['bar'][-1:] - vars_dict['foo'][-1:])",
{"foo", "bar"})
self.rule_1 = Rule(trig_1, mess_1, eval_1)
# Rule #2 is not fireable.
trig_2 = TriggerExpression(
"vars_dict['foo'][:1] > mean(vars_dict['bar'][:2])",
{"foo", "bar"})
mess_2 = MessageExpression("vars_dict['foo'][-1:]", {"bar"})
eval_2 = EvaluationExpression(
"tanh(vars_dict['bar'][:1] - vars_dict['foo'][-1:])",
{"foo", "bar"})
self.rule_2 = Rule(trig_2, mess_2, eval_2)
def read_vars_form_file(filename: str, db: DatabaseWriter):
"""
Read all Variable definitions from a file,
and store any new Variables in the database.
All cases are converted to lowercase.
"""
var_lines = extract_lines_with_prefix_from_file(filename, "VAR")
existing_var_names = tuple(map(lambda x: x.name, db.variables))
for var_line in var_lines:
var_line = var_line.lower().split()
new_var = Variable(eval(var_line[2]), var_line[1])
if new_var.name not in existing_var_names:
db.create_new_var(new_var)
def test_execute(self):
var = Variable(int, "meh")
timestamp = 123
new_value = 321
id = 999
db_writer = MockDatabaseWriter()
command = InsertCommand(db_writer, id, var, new_value, timestamp)
command.execute()
observation = db_writer.input
self.assertEqual(observation[0], var)
self.assertEqual(observation[1], new_value)
self.assertEqual(observation[2], timestamp)
def test_get_rows_of_var(self):
"""
Test insert_new_value_of_var() and get_rows_of_var().
"""
some_var = Variable(int, "some_var")
self.db.create_new_var(some_var)
self.db.insert_new_value_of_var(some_var, 10)
# Pretend this happens a second later!
self.db.insert_new_value_of_var(some_var, 12, int(time.time()) + 1)
df = self.db.get_rows_of_var(some_var)
timestamp = time.time()
self.assertEqual(df.loc[0, "value"], 10)
self.assertEqual(df.loc[1, "value"], 12)
self.assertLess(timestamp - df.loc[0, "timestamp"], 2)
self.assertLess(timestamp + 1 - df.loc[1, "timestamp"], 2)
self.assertEqual(len(df), 2)
def test_empty_table_for_var(self):
"""
A new, empty, table should be created, with the name of the variable.
The columns should be 'value' and 'timestamp'.
"""
var = Variable(int, "some_var")
add_var(self.conn, var)
expected_cols = ("value", "timestamp")
query = """
SELECT *
FROM some_var;
"""
df = pd.read_sql(query, self.conn)
self.assertTupleEqual(tuple(df.columns), expected_cols)
self.assertEqual(len(df), 0, "Table should be empty")
def setUp(self):
remove_database(TEST_DB_NAME)
self.db = DatabaseWriter(TEST_DB_NAME)
self.var_foo = Variable(int, "foo")
self.db.create_new_var(self.var_foo)
def test_repr(self):
occurrence = QuestionOccurrence(
Question("TestQuestion", Variable(str, "TestVar")), 0)
expected = "0: 'TestQuestion'"
result = str(occurrence)
self.assertEqual(result, expected)
def setUp(self):
remove_database(TEST_DB_NAME)
self.conn = connect_to_db(TEST_DB_NAME)
self.var = Variable(int, "test_var")
add_var(self.conn, self.var)