def test_nominal(self):
"""
Nominal use-case from creation to deletion
"""
api = IkatsAPI()
delete_ts_if_exists("TEST_TS")
# Create a new TS
ts = api.ts.new()
ts.data = gen_random_ts(sd=1000000000000,
ed=1000000010000,
nb_points=10)
# Check
self.assertEqual(10, len(ts))
# No FID provided
with self.assertRaises(ValueError):
ts.save()
ts.fid = "TEST_TS"
ts.save(generate_metadata=True)
# TSUID has been set by the save action
self.assertIsNotNone(ts.tsuid)
# Minimum Metadata has been computed
self.assertEqual(ts.data[0][0], ts.metadata.get("ikats_start_date"))
self.assertEqual(ts.data[-1][0], ts.metadata.get("ikats_end_date"))
self.assertEqual(len(ts.data), ts.metadata.get("qual_nb_points"))
# Delete the TS
ts.delete()
def test_inherit(self):
"""
Test inheritance
"""
fid = "TEST_TS"
fid2 = "TEST_TS2"
api = IkatsAPI()
self.assertTrue(delete_ts_if_exists(fid=fid))
self.assertTrue(delete_ts_if_exists(fid=fid2))
# Save parent TS
parent_ts = api.ts.new(fid=fid,
data=gen_random_ts(sd=1000000000000,
ed=1000000010000,
period=1000))
parent_ts.metadata.set(name="my_meta", value=42, dtype=MDType.NUMBER)
parent_ts.save()
# Check inheritance
child_ts = api.ts.new(fid=fid2,
data=gen_random_ts(sd=1000000010000,
ed=1000000020000,
period=1000))
self.assertTrue(child_ts.save(parent=parent_ts))
child_ts.metadata.get("my_meta")
# cleanup
self.assertTrue(parent_ts.delete(raise_exception=False))
self.assertTrue(child_ts.delete(raise_exception=False))
def test_nominal(self):
"""
Nominal use case for Metadata from creation to deletion
"""
# Init
api = IkatsAPI()
delete_ts_if_exists(fid="MyTS")
ts_1 = api.ts.new(fid="MyTS")
# Create new MD
ts_1.metadata.set(name="myMD", value=42, dtype=MDType.STRING)
# Save it
self.assertTrue(ts_1.metadata.save())
# In a new object, get it
ts_2 = api.ts.get(fid="MyTS")
self.assertEqual("42", ts_2.metadata.get("myMD"))
# Mark deleted in first object
ts_1.metadata.delete(name="myMD")
# MD not present in first object
with self.assertRaises(IkatsNotFoundError):
ts_1.metadata.get("myMD")
# MD still present in second object (first not synced with database)
self.assertEqual("42", ts_2.metadata.get("myMD"))
# Save it
self.assertTrue(ts_1.metadata.save())
# MD still present in second object (first object synced with database)
self.assertEqual("42", ts_2.metadata.get("myMD"))
# Get last updates
ts_2.metadata.fetch()
# MD not present in second object
with self.assertRaises(IkatsNotFoundError):
ts_2.metadata.get("myMD")
# MD not present in just created object
ts_3 = api.ts.get(fid="MyTS")
with self.assertRaises(IkatsNotFoundError):
ts_3.metadata.get("myMD")
with self.assertRaises(IkatsNotFoundError):
ts_3.metadata.get_type("myMD")
md = ts_2.metadata
self.assertEqual(
"%s Metadata associated to TSUID %s" % (len(md.data), ts_2.tsuid),
repr(md))
self.assertEqual(len(md.data), len(md))
def test_types(self):
"""
Creation of a Metadata instance
"""
# Init
api = IkatsAPI()
delete_ts_if_exists("MyTS")
ts = api.ts.new(fid="MyTS")
# Provide a number, get a string
ts.metadata.set(name="myMD", value=42, dtype=MDType.STRING)
self.assertEqual("42", ts.metadata.get(name="myMD"))
self.assertEqual(str, type(ts.metadata.get(name="myMD")))
self.assertEqual(MDType.STRING, ts.metadata.get_type(name="myMD"))
# Provide a number, get a string (default to STRING if not provided)
ts.metadata.set(name="myMD", value=42)
self.assertEqual("42", ts.metadata.get(name="myMD"))
self.assertEqual(str, type(ts.metadata.get(name="myMD")))
self.assertEqual(MDType.STRING, ts.metadata.get_type(name="myMD"))
# Provide an int as string, get an int
ts.metadata.set(name="myMD", value="42", dtype=MDType.NUMBER)
self.assertEqual(int, type(ts.metadata.get(name="myMD")))
self.assertEqual(MDType.NUMBER, ts.metadata.get_type(name="myMD"))
# Provide a float as string, get a float
ts.metadata.set(name="myMD", value="42.5", dtype=MDType.NUMBER)
self.assertEqual(float, type(ts.metadata.get(name="myMD")))
self.assertEqual(MDType.NUMBER, ts.metadata.get_type(name="myMD"))
# Provide a date as string, get an int (corresponding to a date)
ts.metadata.set(name="myMD", value="42", dtype=MDType.DATE)
self.assertEqual(42, ts.metadata.get(name="myMD"))
self.assertEqual(MDType.DATE, ts.metadata.get_type(name="myMD"))
# Provide a date as int, get an int (corresponding to a date)
ts.metadata.set(name="myMD", value=1564856, dtype=MDType.DATE)
self.assertEqual(1564856, ts.metadata.get(name="myMD"))
self.assertEqual(MDType.DATE, ts.metadata.get_type(name="myMD"))
ts.delete()
def test_new_with_creation(self):
"""
Creation of a Timeseries instance with reservation of the FID
"""
fid = "TEST_TS"
api = IkatsAPI()
delete_ts_if_exists(fid=fid)
ts = api.ts.new(fid=fid)
# TSUID is filled
self.assertIsNotNone(ts.tsuid)
self.assertEqual(fid, ts.fid)
# No points are present
self.assertEqual(0, len(ts.data))
self.assertEqual(0, len(ts))
# Add points
ts.data = gen_random_ts(sd=1000000000000,
ed=1000000010000,
period=1000)
self.assertEqual(10, len(ts.data))
# Save TS (using the api method)
api.ts.save(ts)
# create a new instance of the same TS
ts2 = api.ts.get(fid=fid)
# Compare written data with read data
self.assertEqual(len(ts.data), len(ts2.data))
self.assertTrue(
np.allclose(np.array(ts.data, dtype=np.float64),
np.array(ts2.data, dtype=np.float64),
atol=1e-2))
# Delete TS using no exception raise
self.assertTrue(api.ts.delete(ts=ts2, raise_exception=False))
def test_create_delete(self):
"""
Complete use case from creation to deletion
"""
# Cleanup
api = IkatsAPI()
api.ds.delete(name="DS_TEST", deep=True, raise_exception=False)
for i in range(10):
delete_ts_if_exists(fid="FID_TEST_%s" % i)
# Setup
ts_list1 = [api.ts.new(fid="FID_TEST_%s" % i) for i in range(10)]
ds1 = api.ds.new(name="DS_TEST", desc="my description", ts=ts_list1)
# Test deletion with unknown dataset
with self.assertRaises(IkatsNotFoundError):
api.ds.delete(name=ds1)
self.assertFalse(ds1.delete(raise_exception=False))
# Check
if not ds1.save(raise_exception=False):
self.fail("Dataset should have been saved")
# Test deletion
self.assertTrue(ds1.delete(deep=True))
# Test empty TS list
ds1.ts = []
with self.assertRaises(ValueError):
ds1.save()
# No TSUID assigned to ts_list2 should produce an IkatsInputError when saving
ts_list2 = [api.ts.new() for _ in range(10)]
ds2 = api.ds.new(name="DS_TEST2", desc="my description", ts=ts_list2)
with self.assertRaises(IkatsInputError):
ds2.save()