test_tsio.py 20.6 KB
Newer Older
1
2
3
4
5
6
7
# coding: utf-8
from pathlib import Path
from datetime import datetime
from dateutil import parser

import pandas as pd
import numpy as np
8
import pytest
9

10
from tshistory.tsio import TimeSerie
11
12
13
14

DATADIR = Path(__file__).parent / 'data'


15
16
17
18
19
20
21
def assert_group_equals(g1, g2):
    for (n1, s1), (n2, s2) in zip(sorted(g1.items()),
                                  sorted(g2.items())):
        assert n1 == n2
        assert s1.equals(s2)


22
23
24
25
def assert_df(expected, df):
    assert expected.strip() == df.to_string().strip()


26
27
28
29
30
31
32
33
34
35
36
37
def genserie(start, freq, repeat, initval=None, tz=None, name=None):
    if initval is None:
        values = range(repeat)
    else:
        values = initval * repeat
    return pd.Series(values,
                     name=name,
                     index=pd.date_range(start=start,
                                         freq=freq,
                                         periods=repeat,
                                         tz=tz))

38
def test_changeset(engine):
39
40
41
42
    # instantiate one time serie handler object
    tso = TimeSerie()

    index = pd.date_range(start=datetime(2017, 1, 1), freq='D', periods=3)
43
    data = [1., 2., 3.]
44
45
46

    with engine.connect() as cnx:
        with tso.newchangeset(cnx, 'babar'):
47
            tso.insert(cnx, pd.Series(data, index=index), 'ts_values')
48
            tso.insert(cnx, pd.Series(['a', 'b', 'c'], index=index), 'ts_othervalues')
49

50
51
52
53
    g = tso.get_group(engine, 'ts_values')
    g2 = tso.get_group(engine, 'ts_othervalues')
    assert_group_equals(g, g2)

54
55
56
    with pytest.raises(AssertionError):
        tso.insert(engine, pd.Series([2,3,4], index=index), 'ts_values')

57
58
59
60
61
    with engine.connect() as cnx:
        data.append(data.pop(0))
        with tso.newchangeset(cnx, 'celeste'):
            tso.insert(cnx, pd.Series(data, index=index), 'ts_values')
            # below should be a noop
62
            tso.insert(cnx, pd.Series(['a', 'b', 'c'], index=index), 'ts_othervalues')
63

64
65
66
    g = tso.get_group(engine, 'ts_values')
    assert ['ts_values'] == list(g.keys())

67
    assert_df("""
68
69
70
2017-01-01    2.0
2017-01-02    3.0
2017-01-03    1.0
71
""", tso.get(engine, 'ts_values'))
72

73
    assert_df("""
74
75
76
2017-01-01    a
2017-01-02    b
2017-01-03    c
77
""", tso.get(engine, 'ts_othervalues'))
78

79

80
81
def test_tstamp_roundtrip(engine):
    tso = TimeSerie()
82
83
    ts = genserie(datetime(2017, 10, 28, 23),
                  'H', 4, tz='UTC')
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
    ts.index = ts.index.tz_convert('Europe/Paris')

    assert_df("""
2017-10-29 01:00:00+02:00    0
2017-10-29 02:00:00+02:00    1
2017-10-29 02:00:00+01:00    2
2017-10-29 03:00:00+01:00    3
Freq: H
    """, ts)

    tso.insert(engine, ts, 'tztest', 'Babar')
    back = tso.get(engine, 'tztest')

    # though un localized we understand it's been normalized to utc
    assert_df("""
2017-10-28 23:00:00    0.0
2017-10-29 00:00:00    1.0
2017-10-29 01:00:00    2.0
2017-10-29 02:00:00    3.0
""", back)

    back.index = back.index.tz_localize('UTC')
    assert (ts.index == back.index).all()


109
def test_differential(engine):
110
111
    # instantiate one time serie handler object
    tso = TimeSerie()
112

113
    ts_begin = genserie(datetime(2010, 1, 1), 'D', 10)
114
    tso.insert(engine, ts_begin, 'ts_test', 'test')
115

116
    assert_df("""
117
118
119
120
121
122
123
124
125
126
2010-01-01    0.0
2010-01-02    1.0
2010-01-03    2.0
2010-01-04    3.0
2010-01-05    4.0
2010-01-06    5.0
2010-01-07    6.0
2010-01-08    7.0
2010-01-09    8.0
2010-01-10    9.0
127
""", tso.get(engine, 'ts_test'))
128
129

    # we should detect the emission of a message
130
    tso.insert(engine, ts_begin, 'ts_test', 'babar')
131

132
    assert_df("""
133
134
135
136
137
138
139
140
141
142
2010-01-01    0.0
2010-01-02    1.0
2010-01-03    2.0
2010-01-04    3.0
2010-01-05    4.0
2010-01-06    5.0
2010-01-07    6.0
2010-01-08    7.0
2010-01-09    8.0
2010-01-10    9.0
143
""", tso.get(engine, 'ts_test'))
144
145
146
147

    ts_slight_variation = ts_begin.copy()
    ts_slight_variation.iloc[3] = 0
    ts_slight_variation.iloc[6] = 0
148
    tso.insert(engine, ts_slight_variation, 'ts_test', 'celeste')
149

150
    assert_df("""
151
152
153
154
155
156
157
158
159
160
2010-01-01    0.0
2010-01-02    1.0
2010-01-03    2.0
2010-01-04    0.0
2010-01-05    4.0
2010-01-06    5.0
2010-01-07    0.0
2010-01-08    7.0
2010-01-09    8.0
2010-01-10    9.0
161
""", tso.get(engine, 'ts_test'))
162

163
    ts_longer = genserie(datetime(2010, 1, 3), 'D', 15)
164
165
166
167
    ts_longer.iloc[1] = 2.48
    ts_longer.iloc[3] = 3.14
    ts_longer.iloc[5] = ts_begin.iloc[7]

168
    tso.insert(engine, ts_longer, 'ts_test', 'test')
169

170
    assert_df("""
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
2010-01-01     0.00
2010-01-02     1.00
2010-01-03     0.00
2010-01-04     2.48
2010-01-05     2.00
2010-01-06     3.14
2010-01-07     4.00
2010-01-08     7.00
2010-01-09     6.00
2010-01-10     7.00
2010-01-11     8.00
2010-01-12     9.00
2010-01-13    10.00
2010-01-14    11.00
2010-01-15    12.00
2010-01-16    13.00
2010-01-17    14.00
188
""", tso.get(engine, 'ts_test'))
189
190

    # start testing manual overrides
191
    ts_begin = genserie(datetime(2010, 1, 1), 'D', 5, initval=[2])
192
    ts_begin.loc['2010-01-04'] = -1
193
    tso.insert(engine, ts_begin, 'ts_mixte', 'test')
194
195

    # -1 represents bogus upstream data
196
    assert_df("""
197
198
199
200
201
2010-01-01    2.0
2010-01-02    2.0
2010-01-03    2.0
2010-01-04   -1.0
2010-01-05    2.0
202
""", tso.get(engine, 'ts_mixte'))
203
204

    # refresh all the period + 1 extra data point
205
    ts_more = genserie(datetime(2010, 1, 2), 'D', 5, [2])
206
    ts_more.loc['2010-01-04'] = -1
207
    tso.insert(engine, ts_more, 'ts_mixte', 'test')
208

209
    assert_df("""
210
211
212
213
214
215
2010-01-01    2.0
2010-01-02    2.0
2010-01-03    2.0
2010-01-04   -1.0
2010-01-05    2.0
2010-01-06    2.0
216
""", tso.get(engine, 'ts_mixte'))
217
218

    # just append an extra data point
219
220
    # with no intersection with the previous ts
    ts_one_more = genserie(datetime(2010, 1, 7), 'D', 1, [3])
221
    tso.insert(engine, ts_one_more, 'ts_mixte', 'test')
222

223
    assert_df("""
224
225
226
227
228
229
230
2010-01-01    2.0
2010-01-02    2.0
2010-01-03    2.0
2010-01-04   -1.0
2010-01-05    2.0
2010-01-06    2.0
2010-01-07    3.0
231
""", tso.get(engine, 'ts_mixte'))
232

233
    hist = pd.read_sql('select id, parent from timeserie.ts_test order by id',
234
                        engine)
235
    assert_df("""
236
237
238
239
   id  parent
0   1     NaN
1   2     1.0
2   3     2.0
240
""", hist)
241

242
    hist = pd.read_sql('select id, parent from timeserie.ts_mixte order by id',
243
                        engine)
244
    assert_df("""
245
246
247
248
   id  parent
0   1     NaN
1   2     1.0
2   3     2.0
249
""", hist)
250

251
    allts = pd.read_sql("select name, table_name from registry "
252
                        "where name in ('ts_test', 'ts_mixte')",
253
254
                        engine)

255
    assert_df("""
256
257
258
       name          table_name
0   ts_test   timeserie.ts_test
1  ts_mixte  timeserie.ts_mixte
259
""", allts)
260

261
    assert_df("""
262
263
264
265
266
267
268
2010-01-01    2.0
2010-01-02    2.0
2010-01-03    2.0
2010-01-04   -1.0
2010-01-05    2.0
2010-01-06    2.0
2010-01-07    3.0
269
270
""", tso.get(engine, 'ts_mixte',
             revision_date=datetime.now()))
271
272
273


def test_bad_import(engine):
274
275
276
    # instantiate one time serie handler object
    tso = TimeSerie()

277
278
279
280
281
    # the data were parsed as date by pd.read_json()
    df_result = pd.read_csv(DATADIR / 'test_data.csv')
    df_result['Gas Day'] = df_result['Gas Day'].apply(parser.parse, dayfirst=True, yearfirst=False)
    df_result.set_index('Gas Day', inplace=True)
    ts = df_result['SC']
282
283
284

    tso.insert(engine, ts, 'SND_SC', 'test')
    result = tso.get(engine, 'SND_SC')
285
    assert result.dtype == 'float64'
286
287
288

    # insertion of empty ts
    ts = pd.Series(name='truc', dtype='object')
289
290
    tso.insert(engine, ts, 'empty_ts', 'test')
    assert tso.get(engine, 'empty_ts') is None
291
292
293

    # nan in ts
    # all na
294
    ts = genserie(datetime(2010, 1, 10), 'D', 10, [np.nan], name='truc')
295
296
    tso.insert(engine, ts, 'test_nan', 'test')
    assert tso.get(engine, 'test_nan') is None
297
298
299
300
301

    # mixe na
    ts = pd.Series([np.nan] * 5 + [3] * 5,
                   index=pd.date_range(start=datetime(2010, 1, 10),
                                       freq='D', periods=10), name='truc')
302
303
    tso.insert(engine, ts, 'test_nan', 'test')
    result = tso.get(engine, 'test_nan')
304

305
306
    tso.insert(engine, ts, 'test_nan', 'test')
    result = tso.get(engine, 'test_nan')
307
    assert_df("""
308
309
310
311
312
2010-01-15    3.0
2010-01-16    3.0
2010-01-17    3.0
2010-01-18    3.0
2010-01-19    3.0
313
""", result)
314
315
316

    # get_ts with name not in database

317
    tso.get(engine, 'inexisting_name', 'test')
318
319
320


def test_revision_date(engine):
321
322
323
    # instantiate one time serie handler object
    tso = TimeSerie()

324
325
    idate1 = datetime(2015, 1, 1, 15, 43, 23)
    with tso.newchangeset(engine, 'test', _insertion_date=idate1):
326

327
        ts = genserie(datetime(2010, 1, 4), 'D', 4, [1], name='truc')
328
329
        tso.insert(engine, ts, 'ts_through_time')
        assert idate1 == tso.latest_insertion_date(engine, 'ts_through_time')
330

331
332
    idate2 = datetime(2015, 1, 2, 15, 43, 23)
    with tso.newchangeset(engine, 'test', _insertion_date=idate2):
333

334
        ts = genserie(datetime(2010, 1, 4), 'D', 4, [2], name='truc')
335
336
        tso.insert(engine, ts, 'ts_through_time')
        assert idate2 == tso.latest_insertion_date(engine, 'ts_through_time')
337

338
339
    idate3 = datetime(2015, 1, 3, 15, 43, 23)
    with tso.newchangeset(engine, 'test', _insertion_date=idate3):
340

341
        ts = genserie(datetime(2010, 1, 4), 'D', 4, [3], name='truc')
342
343
        tso.insert(engine, ts, 'ts_through_time')
        assert idate3 == tso.latest_insertion_date(engine, 'ts_through_time')
344

345
    ts = tso.get(engine, 'ts_through_time')
346

347
    assert_df("""
348
349
350
351
2010-01-04    3.0
2010-01-05    3.0
2010-01-06    3.0
2010-01-07    3.0
352
""", ts)
353

354
355
    ts = tso.get(engine, 'ts_through_time',
                 revision_date=datetime(2015, 1, 2, 18, 43, 23) )
356

357
    assert_df("""
358
359
360
361
2010-01-04    2.0
2010-01-05    2.0
2010-01-06    2.0
2010-01-07    2.0
362
""", ts)
363

364
365
    ts = tso.get(engine, 'ts_through_time',
                 revision_date=datetime(2015, 1, 1, 18, 43, 23))
366

367
    assert_df("""
368
369
370
371
2010-01-04    1.0
2010-01-05    1.0
2010-01-06    1.0
2010-01-07    1.0
372
""", ts)
373

374
375
    ts = tso.get(engine, 'ts_through_time',
                 revision_date=datetime(2014, 1, 1, 18, 43, 23))
376
377
378

    assert ts is None

379
380
381

def test_snapshots(engine):
    tso = TimeSerie()
382
    tso._snapshot_interval = 4
383
384

    with engine.connect() as cnx:
385
        for tscount in range(1, 11):
386
            ts = genserie(datetime(2015, 1, 1), 'D', tscount, [1])
387
388
389
390
391
            diff = tso.insert(cnx, ts, 'growing', 'babar')
            assert diff.index[0] == diff.index[-1] == ts.index[-1]

    diff = tso.insert(engine, ts, 'growing', 'babar')
    assert diff is None
392

393
394
    df = pd.read_sql("select id from timeserie.growing where snapshot is not null",
                     engine)
395
    assert_df("""
396
397
   id
0   1
398
399
400
1   4
2   8
3  10
401
""", df)
402
403

    ts = tso.get(engine, 'growing')
404
    assert_df("""
405
406
407
408
409
410
411
412
413
414
2015-01-01    1.0
2015-01-02    1.0
2015-01-03    1.0
2015-01-04    1.0
2015-01-05    1.0
2015-01-06    1.0
2015-01-07    1.0
2015-01-08    1.0
2015-01-09    1.0
2015-01-10    1.0
415
""", ts)
416

417
    df = pd.read_sql("select id, diff, snapshot from timeserie.growing order by id", engine)
418
419
420
    for attr in ('diff', 'snapshot'):
        df[attr] = df[attr].apply(lambda x: 0 if x is None else len(x))

421
    assert_df("""
422
   id  diff  snapshot
Arnaud Campeas's avatar
Arnaud Campeas committed
423
424
425
426
427
428
429
430
431
432
0   1     0        32
1   2    32         0
2   3    32         0
3   4    32       125
4   5    32         0
5   6    32         0
6   7    32         0
7   8    32       249
8   9    32         0
9  10    32       311
433
""", df)
434
435
436
437
438

    table = tso._get_ts_table(engine, 'growing')
    snapid, snap = tso._find_snapshot(engine, table, ())
    assert snapid == 10
    assert (ts == snap).all()
439
440
441
442
443


def test_deletion(engine):
    tso = TimeSerie()

444
445
    ts_begin = genserie(datetime(2010, 1, 1), 'D', 11)
    ts_begin.iloc[-1] = np.nan
446
447
    tso.insert(engine, ts_begin, 'ts_del', 'test')

448
    ts = tso._build_snapshot_upto(engine, tso._get_ts_table(engine, 'ts_del'))
449
    assert ts.iloc[-1] == 9.0
450

451
    ts_begin.iloc[0] = np.nan
452
    ts_begin.iloc[3] = np.nan
453
454
455

    tso.insert(engine, ts_begin, 'ts_del', 'test')

456
    assert_df("""
457
458
459
460
461
462
463
2010-01-02    1.0
2010-01-03    2.0
2010-01-05    4.0
2010-01-06    5.0
2010-01-07    6.0
2010-01-08    7.0
2010-01-09    8.0
464
465
2010-01-10    9.0
""", tso.get(engine, 'ts_del'))
466

467
468
469
470
471
    ts2 = tso.get(engine, 'ts_del',
                 # force snapshot reconstruction feature
                 revision_date=datetime(2038, 1, 1))
    assert (tso.get(engine, 'ts_del') == ts2).all()

472
473
474
475
476
    ts_begin.iloc[0] = 42
    ts_begin.iloc[3] = 23

    tso.insert(engine, ts_begin, 'ts_del', 'test')

477
    assert_df("""
478
479
480
481
482
483
484
485
486
2010-01-01    42.0
2010-01-02     1.0
2010-01-03     2.0
2010-01-04    23.0
2010-01-05     4.0
2010-01-06     5.0
2010-01-07     6.0
2010-01-08     7.0
2010-01-09     8.0
487
488
2010-01-10     9.0
""", tso.get(engine, 'ts_del'))
489
490
491

    # now with string!

492
    ts_string = genserie(datetime(2010, 1, 1), 'D', 10, ['machin'])
493
494
495
496
497
498
    tso.insert(engine, ts_string, 'ts_string_del', 'test')

    ts_string[4] = None
    ts_string[5] = None

    tso.insert(engine, ts_string, 'ts_string_del', 'test')
499
    assert_df("""
500
501
502
503
504
505
506
507
2010-01-01    machin
2010-01-02    machin
2010-01-03    machin
2010-01-04    machin
2010-01-07    machin
2010-01-08    machin
2010-01-09    machin
2010-01-10    machin
508
""", tso.get(engine, 'ts_string_del'))
509
510
511
512
513

    ts_string[4] = 'truc'
    ts_string[6] = 'truc'

    tso.insert(engine, ts_string, 'ts_string_del', 'test')
514
    assert_df("""
515
516
517
518
519
520
521
522
2010-01-01    machin
2010-01-02    machin
2010-01-03    machin
2010-01-04    machin
2010-01-05      truc
2010-01-07      truc
2010-01-08    machin
2010-01-09    machin
523
524
2010-01-10    machin
""", tso.get(engine, 'ts_string_del'))
525
526
527

    # first insertion with only nan

528
    ts_begin = genserie(datetime(2010, 1, 1), 'D', 10, [np.nan])
529
530
531
    tso.insert(engine, ts_begin, 'ts_null', 'test')

    assert tso.get(engine, 'ts_null') is None
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670


def test_multi_index(engine):
    tso = TimeSerie()

    appdate_0 = pd.DatetimeIndex(start=datetime(2015, 1, 1),
                                 end=datetime(2015, 1, 2),
                                 freq='D').values
    pubdate_0 = [pd.datetime(2015, 1, 11, 12, 0, 0)] * 2
    insertion_date_0 = [pd.datetime(2015, 1, 11, 12, 30, 0)] * 2

    multi = [
        appdate_0,
        np.array(pubdate_0),
        np.array(insertion_date_0)
    ]

    ts_multi = pd.Series(range(2), index=multi)
    ts_multi.index.rename(['b', 'c', 'a'], inplace=True)

    tso.insert(engine, ts_multi, 'ts_multi_simple', 'test')

    ts = tso.get(engine, 'ts_multi_simple')
    assert_df("""
                                                    ts_multi_simple
a                   b          c                                   
2015-01-11 12:30:00 2015-01-01 2015-01-11 12:00:00                0
                    2015-01-02 2015-01-11 12:00:00                1
""", pd.DataFrame(ts))

    diff = tso.insert(engine, ts_multi, 'ts_multi_simple', 'test')
    assert diff is None

    ts_multi_2 = pd.Series([0, 2], index=multi)
    ts_multi_2.index.rename(['b', 'c', 'a'], inplace=True)

    tso.insert(engine, ts_multi_2, 'ts_multi_simple', 'test')
    ts = tso.get(engine, 'ts_multi_simple')

    assert_df("""
                                                    ts_multi_simple
a                   b          c                                   
2015-01-11 12:30:00 2015-01-01 2015-01-11 12:00:00                0
                    2015-01-02 2015-01-11 12:00:00                2
""", pd.DataFrame(ts))

    # bigger ts
    appdate_0 = pd.DatetimeIndex(start=datetime(2015, 1, 1),
                                 end=datetime(2015, 1, 4),
                                 freq='D').values
    pubdate_0 = [pd.datetime(2015, 1, 11, 12, 0, 0)] * 4
    insertion_date_0 = [pd.datetime(2015, 1, 11, 12, 30, 0)] * 4

    appdate_1 = pd.DatetimeIndex(start=datetime(2015, 1, 1),
                                 end=datetime(2015, 1, 4),
                                 freq='D').values

    pubdate_1 = [pd.datetime(2015, 1, 21, 12, 0, 0)] * 4
    insertion_date_1 = [pd.datetime(2015, 1, 21, 12, 30, 0)] * 4

    multi = [
        np.concatenate([appdate_0, appdate_1]),
        np.array(pubdate_0 + pubdate_1),
        np.array(insertion_date_0 + insertion_date_1)
    ]

    ts_multi = pd.Series(range(8), index=multi)
    ts_multi.index.rename(['a', 'c', 'b'], inplace=True)

    tso.insert(engine, ts_multi, 'ts_multi', 'test')
    ts = tso.get(engine, 'ts_multi')

    assert_df("""
                                                    ts_multi
a          b                   c                            
2015-01-01 2015-01-11 12:30:00 2015-01-11 12:00:00         0
           2015-01-21 12:30:00 2015-01-21 12:00:00         4
2015-01-02 2015-01-11 12:30:00 2015-01-11 12:00:00         1
           2015-01-21 12:30:00 2015-01-21 12:00:00         5
2015-01-03 2015-01-11 12:30:00 2015-01-11 12:00:00         2
           2015-01-21 12:30:00 2015-01-21 12:00:00         6
2015-01-04 2015-01-11 12:30:00 2015-01-11 12:00:00         3
           2015-01-21 12:30:00 2015-01-21 12:00:00         7
    """, pd.DataFrame(ts.sort_index()))
    # Note: the columnns are returned according to the alphabetic order

    appdate_2 = pd.DatetimeIndex(start=datetime(2015, 1, 1),
                                 end=datetime(2015, 1, 4),
                                 freq='D').values
    pubdate_2 = [pd.datetime(2015, 1, 31, 12, 0, 0)] * 4
    insertion_date_2 = [pd.datetime(2015, 1, 31, 12, 30, 0)] * 4

    multi_2 = [
        np.concatenate([appdate_1, appdate_2]),
        np.array(pubdate_1 + pubdate_2),
        np.array(insertion_date_1 + insertion_date_2)
    ]

    ts_multi_2 = pd.Series([4] * 8, index=multi_2)
    ts_multi_2.index.rename(['a', 'c', 'b'], inplace=True)

    # A second ts is inserted with some index in common with the first
    # one: appdate_1, pubdate_1,and insertion_date_1. The value is set
    # at 4, which matches the previous value of the "2015-01-01" point.

    diff = tso.insert(engine, ts_multi_2, 'ts_multi', 'test')
    assert_df("""
                                                    ts_multi
a          b                   c                            
2015-01-01 2015-01-31 12:30:00 2015-01-31 12:00:00       4.0
2015-01-02 2015-01-21 12:30:00 2015-01-21 12:00:00       4.0
           2015-01-31 12:30:00 2015-01-31 12:00:00       4.0
2015-01-03 2015-01-21 12:30:00 2015-01-21 12:00:00       4.0
           2015-01-31 12:30:00 2015-01-31 12:00:00       4.0
2015-01-04 2015-01-21 12:30:00 2015-01-21 12:00:00       4.0
           2015-01-31 12:30:00 2015-01-31 12:00:00       4.0
        """, pd.DataFrame(diff.sort_index()))
    # the differential skips a value for "2015-01-01"
    # which does not change from the previous ts

    ts = tso.get(engine, 'ts_multi')
    assert_df("""
                                                    ts_multi
a          b                   c                            
2015-01-01 2015-01-11 12:30:00 2015-01-11 12:00:00         0
           2015-01-21 12:30:00 2015-01-21 12:00:00         4
           2015-01-31 12:30:00 2015-01-31 12:00:00         4
2015-01-02 2015-01-11 12:30:00 2015-01-11 12:00:00         1
           2015-01-21 12:30:00 2015-01-21 12:00:00         4
           2015-01-31 12:30:00 2015-01-31 12:00:00         4
2015-01-03 2015-01-11 12:30:00 2015-01-11 12:00:00         2
           2015-01-21 12:30:00 2015-01-21 12:00:00         4
           2015-01-31 12:30:00 2015-01-31 12:00:00         4
2015-01-04 2015-01-11 12:30:00 2015-01-11 12:00:00         3
           2015-01-21 12:30:00 2015-01-21 12:00:00         4
           2015-01-31 12:30:00 2015-01-31 12:00:00         4
        """, pd.DataFrame(ts.sort_index()))

    # the result ts have now 3 values for each point in 'a'
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698


def test_add_na(engine):
    tso = TimeSerie()

    # a serie of NaNs won't be insert in base
    # in case of first insertion
    ts_nan = genserie(datetime(2010, 1, 1), 'D', 5)
    ts_nan[[True] * len(ts_nan)] = np.nan

    diff = tso.insert(engine, ts_nan, 'ts_add_na', 'test')
    assert diff is None
    result = tso.get(engine, 'ts_add_na')
    assert result is None

    # in case of insertion in existing data
    ts_begin = genserie(datetime(2010, 1, 1), 'D', 5)
    tso.insert(engine, ts_begin, 'ts_add_na', 'test')

    ts_nan = genserie(datetime(2010, 1, 6), 'D', 5)
    ts_nan[[True] * len(ts_nan)] = np.nan
    ts_nan = pd.concat([ts_begin, ts_nan])

    diff = tso.insert(engine, ts_nan, 'ts_add_na', 'test')
    assert diff is None

    result = tso.get(engine, 'ts_add_na')
    assert len(result) == 5