test_collect.py 44.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
##############################################################################
#
# Copyright (c) 2014 Vifib SARL and Contributors. All Rights Reserved.
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsibility of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# guarantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

28
from slapos.util import mkdir_p
29
from datetime import datetime, timedelta
30 31 32 33 34
import csv
import six
import mock
import json
import time
35
import os
36
import glob
37 38
import unittest
import shutil
39
import tarfile
40 41 42
import tempfile
import slapos.slap
import psutil
43
import sqlite3
44
import subprocess
45 46
from time import strftime
from slapos.collect import entity, snapshot, db, reporter
47
from slapos.cli.entry import SlapOSApp
Bryton Lacquement's avatar
Bryton Lacquement committed
48
from six.moves.configparser import ConfigParser
49

50 51 52 53
from lxml import etree as ElementTree
import slapos.tests.data


54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
class FakeDatabase(object):
    def __init__(self):
      self.invoked_method_list = []

    def connect(self):
      self.invoked_method_list.append(("connect", ""))

    def close(self):
      self.invoked_method_list.append(("close", ""))

    def commit(self):
      self.invoked_method_list.append(("commit", ""))

    def insertUserSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertUserSnapshot", (args, kw)))

70 71 72
    def inserFolderSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("inserFolderSnapshot", (args, kw)))

73 74 75 76 77 78 79 80 81
    def insertSystemSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertSystemSnapshot", (args, kw)))

    def insertComputerSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertComputerSnapshot", (args, kw)))

    def insertDiskPartitionSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertDiskPartitionSnapshot", (args, kw)))

82 83 84 85 86 87 88 89 90 91 92
    def insertTemperatureSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertTemperatureSnapshot", (args, kw)))

    def insertHeatingSnapshot(self, *args, **kw):
      self.invoked_method_list.append(("insertHeatingSnapshot", (args, kw)))

class FakeDatabase2(FakeDatabase):
    def select(self, *args, **kw):
      self.invoked_method_list.append(("select", (args, kw)))
      return []

93 94 95 96 97 98 99 100 101 102 103 104
class TestCollectDatabase(unittest.TestCase):

    def setUp(self):
        self.instance_root = tempfile.mkdtemp()

    def tearDown(self):
        if os.path.exists(self.instance_root):
          shutil.rmtree(self.instance_root)

    def test_database_bootstrap(self):
        self.assertFalse(os.path.exists(
                  "%s/collector.db" % self.instance_root ))
105
        database = db.Database(self.instance_root, create=True)
106 107
        database.connect()
        try:
108
          self.assertEqual(
109
              [u'user', u'folder', u'computer', u'system', u'disk', u'temperature', u'heating'],
110
              database.getTableList())
111 112 113 114 115 116
        finally:
          database.close()

        self.assertTrue(os.path.exists(
                  "%s/collector.db" % self.instance_root ))

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
    def test_database_not_bootstrap(self):
        self.assertFalse(os.path.exists(
                  "%s/collector.db" % self.instance_root ))
        database = db.Database(self.instance_root)
        database.connect()
        try:
          self.assertNotEqual(
              [u'user', u'folder', u'computer', u'system', u'disk', u'temperature', u'heating'],
              database.getTableList())
        finally:
          database.close()

        self.assertTrue(os.path.exists(
                  "%s/collector.db" % self.instance_root ))

132 133 134
    def test_database_select(self):
      def _fake_execute(sql): return sql

135
      database = db.Database(self.instance_root, create=True)
136 137 138 139
      database.connect()
      original_execute = database._execute
      try:
        database._execute = _fake_execute
140 141
        self.assertEqual("SELECT * FROM user  ", database.select('user'))
        self.assertEqual("SELECT DATE FROM user  WHERE date = '0.1'  AND time=\"00:02\"  ",
142
                          database.select('user', 0.1, 'DATE', 'time="00:02"'))
143
        self.assertEqual("SELECT DATE FROM user  WHERE date = '0.1'   GROUP BY time ORDER BY date",
144
                          database.select('user', 0.1, 'DATE', order='date', group='time' ))
145
        self.assertEqual("SELECT DATE FROM user  WHERE date = '0.1'   limit 1",
146 147 148 149 150
                          database.select('user', 0.1, 'DATE', limit=1))
      finally:
        database._execute = original_execute
        database.close()

151 152
    def test_insert_user_snapshot(self):

153
        database = db.Database(self.instance_root, create=True)
154 155 156 157 158 159
        database.connect()
        try:
            database.insertUserSnapshot(
             'fakeuser0', 10, '10-12345', '0.1', '10.0', '1',
             '10.0', '10.0', '0.1', '0.1', 'DATE', 'TIME')
            database.commit()
160
            self.assertEqual([i for i in database.select('user')], 
161 162 163 164 165 166 167
                          [(u'fakeuser0', 10.0, u'10-12345', 0.1, 10.0, 
                          1.0, 10.0, 10.0, 0.1, 0.1, u'DATE', u'TIME', 0)])
        finally:
            database.close()

    def test_insert_folder_snapshot(self):

168
        database = db.Database(self.instance_root, create=True)
169 170 171 172 173
        database.connect()
        try:
            database.inserFolderSnapshot(
             'fakeuser0', '0.1', 'DATE', 'TIME')
            database.commit()
174
            self.assertEqual([i for i in database.select('folder')], 
175
                          [(u'fakeuser0', 0.1, u'DATE', u'TIME', 0)])
176 177 178 179 180
        finally:
            database.close()

    def test_insert_computer_snapshot(self):

181
        database = db.Database(self.instance_root, create=True)
182 183 184 185 186
        database.connect()
        try:
            database.insertComputerSnapshot(
              '1', '0', '0', '100', '0', '/dev/sdx1', 'DATE', 'TIME')
            database.commit()
187
            self.assertEqual([i for i in database.select('computer')], 
188 189 190 191 192 193
                    [(1.0, 0.0, u'0', 100.0, u'0', u'/dev/sdx1', u'DATE', u'TIME', 0)]) 
        finally:
          database.close()

    def test_insert_disk_partition_snapshot(self):

194
        database = db.Database(self.instance_root, create=True)
195 196 197 198 199
        database.connect()
        try:
            database.insertDiskPartitionSnapshot(
                 '/dev/sdx1', '10', '20', '/mnt', 'DATE', 'TIME')
            database.commit() 
200
            self.assertEqual([i for i in database.select('disk')], 
201 202 203 204 205 206
                            [(u'/dev/sdx1', u'10', u'20', u'/mnt', u'DATE', u'TIME', 0)])
        finally:
          database.close()

    def test_insert_system_snapshot(self):

207
        database = db.Database(self.instance_root, create=True)
208 209 210 211 212 213
        database.connect()
        try:
            database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                         '10.0', '1', '2', '12.0', '1', '1', 'DATE', 'TIME')
            database.commit()

214
            self.assertEqual([i for i in database.select('system')], 
215 216 217 218 219 220 221
                             [(0.1, 10.0, 100.0, 100.0, 10.0, 1.0, 
                               2.0, 12.0, 1.0, 1.0, u'DATE', u'TIME', 0)])
        finally:
          database.close()

    def test_date_scope(self):

222
        database = db.Database(self.instance_root, create=True)
223 224 225 226 227 228
        database.connect()
        try:
            database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                 '10.0', '1', '2', '12.0', '1', '1', 'EXPECTED-DATE', 'TIME')
            database.commit()

229
            self.assertEqual([i for i in database.getDateScopeList()], 
230 231
                             [('EXPECTED-DATE', 1)])

232
            self.assertEqual([i for i in \
233 234 235
               database.getDateScopeList(ignore_date='EXPECTED-DATE')], 
               [])

236
            self.assertEqual([i for i in \
237 238 239 240 241 242
               database.getDateScopeList(reported=1)], 
               [])

        finally:
          database.close()

243
    def test_garbage_collection_date_list(self):
244
        database = db.Database(self.instance_root, create=True)
245
        self.assertEqual(len(database._getGarbageCollectionDateList(3)), 3)
246 247
        self.assertEqual(len(database._getGarbageCollectionDateList(1)), 1)
        self.assertEqual(len(database._getGarbageCollectionDateList(0)), 0)
248

249
        self.assertEqual(database._getGarbageCollectionDateList(1), 
250 251 252 253
                           [strftime("%Y-%m-%d")])

    def test_garbage(self):

254
        database = db.Database(self.instance_root, create=True)
255 256 257 258 259 260 261
        database.connect()
        database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                         '10.0', '1', '2', '12.0', '1', '1', '1983-01-10', 'TIME')
        database.insertDiskPartitionSnapshot(
                 '/dev/sdx1', '10', '20', '/mnt', '1983-01-10', 'TIME')
        database.insertComputerSnapshot(
              '1', '0', '0', '100', '0', '/dev/sdx1', '1983-01-10', 'TIME')
262 263 264 265 266
        database.insertUserSnapshot(
             'fakeuser0', 10, '10-12345', '0.1', '10.0', '1',
             '10.0', '10.0', '0.1', '0.1', '1983-01-10', 'TIME')
        database.inserFolderSnapshot(
             'fakeuser0', '0.1', '1983-01-10', 'TIME')
267 268
        database.commit()
        database.markDayAsReported(date_scope="1983-01-10", 
269
                                       table_list=database.getTableList())
270
        database.commit()
271
        self.assertEqual(len([x for x in database.select('system')]), 1)
272 273 274 275
        self.assertEqual(len([x for x in database.select('folder')]), 1)
        self.assertEqual(len([x for x in database.select('user')]), 1)
        #self.assertEqual(len([x for x in database.select('heating')]), 1)
        #self.assertEqual(len([x for x in database.select('temperature')]), 1)
276 277
        self.assertEqual(len([x for x in database.select('computer')]), 1)
        self.assertEqual(len([x for x in database.select('disk')]), 1)
278 279 280 281
        database.close()

        database.garbageCollect()
        database.connect()
282 283 284 285
        self.assertEqual(len([x for x in database.select('folder')]), 0)
        self.assertEqual(len([x for x in database.select('user')]), 0)
        #self.assertEqual(len([x for x in database.select('heating')]), 0)
        #self.assertEqual(len([x for x in database.select('temperature')]), 0)
286 287 288
        self.assertEqual(len([x for x in database.select('system')]), 0)
        self.assertEqual(len([x for x in database.select('computer')]), 0)
        self.assertEqual(len([x for x in database.select('disk')]), 0)
289 290 291

    def test_mark_day_as_reported(self):

292
        database = db.Database(self.instance_root, create=True)
293 294 295 296 297 298 299 300
        database.connect()
        try:
            database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                 '10.0', '1', '2', '12.0', '1', '1', 'EXPECTED-DATE', 'TIME')
            database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                 '10.0', '1', '2', '12.0', '1', '1', 'NOT-EXPECTED-DATE', 'TIME')
            database.commit()

301
            self.assertEqual([i for i in database.select('system')], 
302 303 304 305 306 307 308 309 310
                             [(0.1, 10.0, 100.0, 100.0, 10.0, 1.0, 
                               2.0, 12.0, 1.0, 1.0, u'EXPECTED-DATE', u'TIME', 0),
                             (0.1, 10.0, 100.0, 100.0, 10.0, 1.0, 
                               2.0, 12.0, 1.0, 1.0, u'NOT-EXPECTED-DATE', u'TIME', 0)])

            database.markDayAsReported(date_scope="EXPECTED-DATE", 
                                       table_list=["system"])
            database.commit()

311
            self.assertEqual([i for i in database.select('system')], 
312 313 314 315 316 317 318 319
                             [(0.1, 10.0, 100.0, 100.0, 10.0, 1.0, 
                               2.0, 12.0, 1.0, 1.0, u'EXPECTED-DATE', u'TIME', 1),
                             (0.1, 10.0, 100.0, 100.0, 10.0, 1.0, 
                               2.0, 12.0, 1.0, 1.0, u'NOT-EXPECTED-DATE', u'TIME', 0)])

        finally:
          database.close()

320
class TestCollectReport(unittest.TestCase):
321

322 323 324 325 326 327 328
    def setUp(self):
        self.instance_root = tempfile.mkdtemp()

    def tearDown(self):
        if os.path.exists(self.instance_root):
          shutil.rmtree(self.instance_root)

329
    def getPopulatedDB(self, day='1983-01-10', amount=1):
330
        database = db.Database(self.instance_root, create=True)
331
        database.connect()
332 333 334 335 336 337 338 339 340 341 342 343
        for i in range(0, amount):
          database.insertSystemSnapshot("0.1", '10.0', '100.0', '100.0', 
                           '10.0', '1', '2', '12.0', '1', '1', day, 'TIME')
          database.insertDiskPartitionSnapshot(
                   '/dev/sdx1', '10', '20', '/mnt', day, 'TIME')
          database.insertComputerSnapshot(
                '1', '0', '0', '100', '0', '/dev/sdx1', day, 'TIME')
          database.insertUserSnapshot(
               'fakeuser0', 10, '10-12345', '0.1', '10.0', '1',
               '10.0', '10.0', '0.1', '0.1', day, 'TIME')
          database.inserFolderSnapshot(
               'fakeuser0', '0.1', day, 'TIME')
344 345
        database.commit()
        database.close()
346 347 348 349 350 351 352 353 354
        return database

    def _get_file_content(self, f_path):
        with open(f_path, "r") as f:
          return f.readlines()

    def test_raw_csv_report(self):

        database = self.getPopulatedDB(amount=1)
355 356 357
        reporter.RawCSVDumper(database).dump(self.instance_root)
        self.assertTrue(os.path.exists("%s/1983-01-10" % self.instance_root))

358 359 360 361 362 363 364 365 366 367 368 369 370
        csv_path_dict = {
          '%s/1983-01-10/dump_disk.csv' % self.instance_root : 
            [['/dev/sdx1','10','20','/mnt','1983-01-10','TIME','0']],
          '%s/1983-01-10/dump_computer.csv' % self.instance_root :
            [['1.0','0.0','0','100.0','0','/dev/sdx1','1983-01-10','TIME','0']],
          '%s/1983-01-10/dump_user.csv' % self.instance_root :
            [['fakeuser0','10.0','10-12345','0.1','10.0','1.0','10.0','10.0','0.1','0.1','1983-01-10','TIME','0']],
          '%s/1983-01-10/dump_folder.csv' % self.instance_root :
            [['fakeuser0','0.1','1983-01-10','TIME','0']],
          '%s/1983-01-10/dump_heating.csv' % self.instance_root : [],
          '%s/1983-01-10/dump_temperature.csv' % self.instance_root : [],
          '%s/1983-01-10/dump_system.csv' % self.instance_root :
            [['0.1','10.0','100.0','100.0','10.0','1.0','2.0','12.0','1.0','1.0','1983-01-10','TIME','0']]}
371

372
        self.assertEqual(set(glob.glob("%s/1983-01-10/*.csv" % self.instance_root)),
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
                          set(csv_path_dict.keys()))

        
        for f_path in list(set(glob.glob("%s/1983-01-10/*.csv" % self.instance_root))):
          with open(f_path, "r") as csv_file:
            self.assertEqual([i for i in csv.reader(csv_file)], csv_path_dict[f_path])

    def test_system_json_report(self):
        database = self.getPopulatedDB(strftime("%Y-%m-%d"), amount=2)
        reporter.SystemJSONReporterDumper(database).dump(self.instance_root)
        date_to_test = strftime("%Y-%m-%d")
        json_path_dict = {
          '%s/system_memory_used.json' % self.instance_root: 
            '[  {    "entry": 0.09765625,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_cpu_percent.json' % self.instance_root: 
            '[  {    "entry": 10.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_net_out_bytes.json' % self.instance_root:
            '[  {    "entry": 0.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_net_in_bytes.json' % self.instance_root: 
            '[  {    "entry": 0.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_disk_memory_free__dev_sdx1.json' % self.instance_root:
            '[  {    "entry": 0.01953125,     "time": "%s TIME"  }, '\
             '  {    "entry": 0.01953125,     "time": "%s TIME"  }]' % (date_to_test, date_to_test),
          '%s/system_net_out_errors.json' % self.instance_root: 
            '[  {    "entry": 1.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_disk_memory_used__dev_sdx1.json' % self.instance_root: 
            '[  {    "entry": 0.009765625,     "time": "%s TIME"  },'\
            '   {    "entry": 0.009765625,     "time": "%s TIME"  }]' % (date_to_test, date_to_test),
          '%s/system_net_out_dropped.json' % self.instance_root: 
            '[  {    "entry": 1.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_memory_free.json' % self.instance_root:
            '[  {    "entry": 0.09765625,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_net_in_errors.json' % self.instance_root: 
            '[  {    "entry": 1.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_net_in_dropped.json' % self.instance_root: 
            '[  {    "entry": 2.0,     "time": "%s TIME"  }]' % date_to_test,
          '%s/system_loadavg.json' % self.instance_root: 
            '[  {    "entry": 0.1,     "time": "%s TIME"  }]' % date_to_test}

        self.assertEqual(set(glob.glob("%s/*.json" % self.instance_root)),
                         set(json_path_dict)) 

        for f_path in set(glob.glob("%s/*.json" % self.instance_root)):
          with open(f_path, "r") as value:
            self.assertEqual(json.load(value), json.loads(json_path_dict[f_path]))
418 419


420 421
    def test_system_csv_report(self):
        database = self.getPopulatedDB(strftime("%Y-%m-%d"), amount=2)
422
        reporter.SystemCSVReporterDumper(database).dump(self.instance_root)
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
        date_for_test = strftime("%Y-%m-%d")
        csv_path_dict = {'%s/system_memory_used.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'0.09765625']],
                         '%s/system_cpu_percent.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'10.0']],
                         '%s/system_net_out_bytes.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'0.0']],
                         '%s/system_net_in_bytes.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'0.0']],
                         '%s/system_disk_memory_free__dev_sdx1.csv' % self.instance_root: 
                           [['time','entry'], ['%s TIME' % date_for_test,'0.01953125'], 
                            ['%s TIME' % date_for_test,'0.01953125']],
                         '%s/system_net_out_errors.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'1.0']],
                         '%s/system_disk_memory_used__dev_sdx1.csv' % self.instance_root: 
                           [['time','entry'], ['%s TIME' % date_for_test,'0.009765625'], 
                             ['%s TIME' % date_for_test,'0.009765625']],
                         '%s/system_net_out_dropped.csv' % self.instance_root: 
                           [['time','entry'], ['%s TIME' % date_for_test,'1.0']],
                         '%s/system_memory_free.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'0.09765625']],
                         '%s/system_net_in_errors.csv' % self.instance_root:
                           [['time','entry'], ['%s TIME' % date_for_test,'1.0']],
                         '%s/system_net_in_dropped.csv' % self.instance_root: 
                           [['time','entry'], ['%s TIME' % date_for_test,'2.0']],
                         '%s/system_loadavg.csv' % self.instance_root:
                            [['time','entry'], ['%s TIME' % date_for_test,'0.1']]}

        self.assertEqual(set(glob.glob("%s/*.csv" % self.instance_root)),
                    set(csv_path_dict.keys())) 

        for f_path in list(set(glob.glob("%s/*.csv" % self.instance_root))):
          with open(f_path, "r") as csv_file:
            self.assertEqual([i for i in csv.reader(csv_file)], csv_path_dict[f_path])

458

459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
    def test_compress_log_directory(self):
        log_directory = "%s/test_compress" % self.instance_root
        dump_folder = "%s/1990-01-01" % log_directory

        if not os.path.exists(log_directory):
            os.mkdir(log_directory)

        if os.path.exists(dump_folder):
            shutil.rmtree(dump_folder)

        os.mkdir("%s/1990-01-01" % log_directory)
        with open("%s/test.txt" % dump_folder, "w") as dump_file:
            dump_file.write("hi")
            dump_file.close()

        reporter.compressLogFolder(log_directory)

        self.assertFalse(os.path.exists(dump_folder))

        self.assertTrue(os.path.exists("%s.tar.gz" % dump_folder))

        with tarfile.open("%s.tar.gz" % dump_folder) as tf:
481 482
            self.assertEqual(tf.getmembers()[0].name, "1990-01-01")
            self.assertEqual(tf.getmembers()[1].name, "1990-01-01/test.txt")
Bryton Lacquement's avatar
Bryton Lacquement committed
483
            self.assertEqual(tf.extractfile(tf.getmembers()[1]).read(), b'hi')
484

485 486 487



488 489 490 491 492 493 494 495 496 497 498 499
class TestCollectSnapshot(unittest.TestCase):

    def setUp(self):
        self.slap = slapos.slap.slap()
        self.app = SlapOSApp()
        self.temp_dir = tempfile.mkdtemp()
        os.environ["HOME"] = self.temp_dir
        self.instance_root = tempfile.mkdtemp()
        self.software_root = tempfile.mkdtemp()
        if os.path.exists(self.temp_dir):
          shutil.rmtree(self.temp_dir)

500 501 502 503 504
    def getFakeUser(self, disk_snapshot_params={}):
       os.mkdir("%s/fakeuser0" % self.instance_root)
       return entity.User("fakeuser0", 
                    "%s/fakeuser0" % self.instance_root, disk_snapshot_params ) 

505 506 507 508
    def test_process_snapshot(self):
        process = psutil.Process(os.getpid())
        process_snapshot = snapshot.ProcessSnapshot(process)

509
        self.assertNotEqual(process_snapshot.username, None)  
510 511
        self.assertEqual(int(process_snapshot.pid), os.getpid())
        self.assertEqual(int(process_snapshot.process.split("-")[0]),
512 513
                          os.getpid())

514 515 516 517 518 519 520
        self.assertNotEqual(process_snapshot.cpu_percent , None)
        self.assertNotEqual(process_snapshot.cpu_time , None)
        self.assertNotEqual(process_snapshot.cpu_num_threads, None)
        self.assertNotEqual(process_snapshot.memory_percent , None)
        self.assertNotEqual(process_snapshot.memory_rss, None)
        self.assertNotEqual(process_snapshot.io_rw_counter, None)
        self.assertNotEqual(process_snapshot.io_cycles_counter, None)
521

522 523 524 525 526 527 528 529 530 531
    def test_folder_size_snapshot(self):
        disk_snapshot = snapshot.FolderSizeSnapshot(self.instance_root)
        self.assertEqual(disk_snapshot.disk_usage, 0)
        for i in range(0, 10):
          folder = 'folder%s' % i
          os.mkdir(os.path.join(self.instance_root, folder))
          with open(os.path.join(self.instance_root, folder, 'toto'), 'w') as f:
            f.write('toto text')

        disk_snapshot.update_folder_size()
532
        self.assertNotEqual(disk_snapshot.disk_usage, 0)
533 534 535 536

        pid_file = os.path.join(self.instance_root, 'disk_snap.pid')
        disk_snapshot = snapshot.FolderSizeSnapshot(self.instance_root, pid_file)
        disk_snapshot.update_folder_size()
537
        self.assertNotEqual(disk_snapshot.disk_usage, 0)
538 539 540 541 542

        pid_file = os.path.join(self.instance_root, 'disk_snap.pid')
        disk_snapshot = snapshot.FolderSizeSnapshot(self.instance_root, pid_file,
                                           use_quota=True)
        disk_snapshot.update_folder_size()
543
        self.assertNotEqual(disk_snapshot.disk_usage, 0)
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

    def test_process_in_progress_disk_usage(self):
        pid_file = os.path.join(self.instance_root, 'sleep.pid')
        disk_snapshot = snapshot.FolderSizeSnapshot(self.instance_root, pid_file)

        command = 'sleep 1h'
        process = subprocess.Popen(command, stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE, shell=True)
        
        with open(pid_file, 'w') as fpid:
          pid = fpid.write(str(process.pid))
        self.assertTrue(os.path.isfile(pid_file))

        self.assertEqual(disk_snapshot.update_folder_size(), None)

        disk_snapshot = snapshot.FolderSizeSnapshot(self.instance_root, pid_file,
                                           use_quota=True)
        self.assertEqual(disk_snapshot.update_folder_size(), None)

        process.terminate()

    def test_time_cycle(self):
        disk_snapshot_params = {'enable': True, 'time_cycle': 3600, 'testing': True}
        user = self.getFakeUser(disk_snapshot_params)
        database = db.Database(self.instance_root, create=True)

        date = datetime.utcnow().date()
        time = datetime.utcnow().time().strftime("%H:%M:%S")
        time_earlier = (datetime.utcnow() - \
          timedelta(hours=3)).time().strftime("%H:%M:%S")

        database.connect()
        database.inserFolderSnapshot('fakeuser0', '1.0', date, time_earlier)
        database.commit()
        database.close()

        # check that _insertDiskSnapShot called update_folder_size
        with mock.patch('slapos.collect.snapshot.FolderSizeSnapshot.update_folder_size'
                        ) as update_folder_size_call:
          user._insertDiskSnapShot(database, date, time)
          update_folder_size_call.assert_called_once()

        time_earlier = (datetime.utcnow() - \
          timedelta(minutes=10)).time().strftime("%H:%M:%S")
588
        
589 590 591 592 593 594 595 596 597 598 599
        database.connect()
        database.inserFolderSnapshot('fakeuser0', '1.0', date, time_earlier)
        database.commit()
        database.close()

        # check that _insertDiskSnapShot stop before calling update_folder_size
        with mock.patch('slapos.collect.snapshot.FolderSizeSnapshot.update_folder_size'
                        ) as update_folder_size_call:
          user._insertDiskSnapShot(database, date, time)
          update_folder_size_call.assert_not_called()

600

601 602 603 604 605 606
    def test_process_snapshot_broken_process(self):
        self.assertRaises(AssertionError, 
                 snapshot.ProcessSnapshot, None)

    def test_computer_snapshot(self):
        computer_snapshot = snapshot.ComputerSnapshot()
607 608 609 610 611
        self.assertNotEqual(computer_snapshot.cpu_num_core , None)
        self.assertNotEqual(computer_snapshot.cpu_frequency , None)
        self.assertNotEqual(computer_snapshot.cpu_type , None)
        self.assertNotEqual(computer_snapshot.memory_size , None)
        self.assertNotEqual(computer_snapshot.memory_type , None)
612
        
613
        self.assertEqual(type(computer_snapshot.system_snapshot),  
614 615
                               snapshot.SystemSnapshot)

616 617
        self.assertNotEqual(computer_snapshot.disk_snapshot_list, [])
        self.assertNotEqual(computer_snapshot.partition_list, []) 
618

619
        self.assertEqual(type(computer_snapshot.disk_snapshot_list[0]), 
620 621 622 623
                snapshot.DiskPartitionSnapshot)

    def test_system_snapshot(self):
        system_snapshot = snapshot.SystemSnapshot()       
624 625 626 627 628 629 630 631 632 633 634
        self.assertNotEqual(system_snapshot.memory_used , None)
        self.assertNotEqual(system_snapshot.memory_free , None)
        self.assertNotEqual(system_snapshot.memory_percent , None)
        self.assertNotEqual(system_snapshot.cpu_percent , None)
        self.assertNotEqual(system_snapshot.load , None)
        self.assertNotEqual(system_snapshot.net_in_bytes , None)
        self.assertNotEqual(system_snapshot.net_in_errors, None)
        self.assertNotEqual(system_snapshot.net_in_dropped , None)
        self.assertNotEqual(system_snapshot.net_out_bytes , None)
        self.assertNotEqual(system_snapshot.net_out_errors, None)
        self.assertNotEqual(system_snapshot.net_out_dropped , None)
635 636 637 638 639 640 641 642 643 644 645 646 647 648
 
class TestCollectEntity(unittest.TestCase):

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        os.environ["HOME"] = self.temp_dir
        self.instance_root = tempfile.mkdtemp()
        self.software_root = tempfile.mkdtemp()
        if os.path.exists(self.temp_dir):
          shutil.rmtree(self.temp_dir)

    def tearDown(self):
        pass

649 650
    def getFakeUser(self, disk_snapshot_params={}):
       os.mkdir("%s/fakeuser0" % self.instance_root)
651
       return entity.User("fakeuser0", 
652
                    "%s/fakeuser0" % self.instance_root, disk_snapshot_params ) 
653 654 655 656 657 658 659 660 661 662 663

    def test_get_user_list(self):
        config = ConfigParser()
        config.add_section('slapformat')
        config.set('slapformat', 'partition_amount', '3')
        config.set('slapformat', 'user_base_name', 'slapuser')
        config.set('slapformat', 'partition_base_name', 'slappart')
        config.add_section('slapos')
        config.set('slapos', 'instance_root', self.instance_root)
 
        user_dict = entity.get_user_list(config)
Bryton Lacquement's avatar
Bryton Lacquement committed
664
        username_set = {'slapuser0', 'slapuser1', 'slapuser2'} 
665
        self.assertEqual(username_set, set(user_dict))
666
       
Bryton Lacquement's avatar
Bryton Lacquement committed
667
        for name in username_set:
668 669
          self.assertEqual(user_dict[name].name, name)
          self.assertEqual(user_dict[name].snapshot_list, [])
670
          expected_path = "%s/slappart%s" % (self.instance_root, name.strip("slapuser")) 
671
          self.assertEqual(user_dict[name].path, expected_path) 
672 673 674
       
    def test_user_add_snapshot(self):
        user = self.getFakeUser() 
675
        self.assertEqual(user.snapshot_list, [])
676
        user.append("SNAPSHOT")
677
        self.assertEqual(user.snapshot_list, ["SNAPSHOT"])
678 679

    def test_user_save(self):
680 681
        disk_snapshot_params = {'enable': False}
        user = self.getFakeUser(disk_snapshot_params)
682 683 684 685
        process = psutil.Process(os.getpid())
        user.append(snapshot.ProcessSnapshot(process))
        database = FakeDatabase()
        user.save(database, "DATE", "TIME")
686
        self.assertEqual(database.invoked_method_list[0], ("connect", ""))
687

688 689
        self.assertEqual(database.invoked_method_list[1][0], "insertUserSnapshot")
        self.assertEqual(database.invoked_method_list[1][1][0], ("fakeuser0",))
Bryton Lacquement's avatar
Bryton Lacquement committed
690 691
        self.assertEqual(set(database.invoked_method_list[1][1][1]), 
                   {'cpu_time', 'cpu_percent', 'process',
692 693
                    'memory_rss', 'pid', 'memory_percent',
                    'io_rw_counter', 'insertion_date', 'insertion_time',
Bryton Lacquement's avatar
Bryton Lacquement committed
694
                    'io_cycles_counter', 'cpu_num_threads'})
695 696
        self.assertEqual(database.invoked_method_list[2], ("commit", ""))
        self.assertEqual(database.invoked_method_list[3], ("close", ""))
697

698 699 700 701 702 703 704
    def test_user_save_disk_snapshot(self):
        disk_snapshot_params = {'enable': True, 'testing': True}
        user = self.getFakeUser(disk_snapshot_params)
        process = psutil.Process(os.getpid())
        user.append(snapshot.ProcessSnapshot(process))
        database = FakeDatabase2()
        user.save(database, "DATE", "TIME")
705
        self.assertEqual(database.invoked_method_list[0], ("connect", ""))
706

707 708
        self.assertEqual(database.invoked_method_list[1][0], "insertUserSnapshot")
        self.assertEqual(database.invoked_method_list[1][1][0], ("fakeuser0",))
Bryton Lacquement's avatar
Bryton Lacquement committed
709 710
        self.assertEqual(set(database.invoked_method_list[1][1][1]), 
                   {'cpu_time', 'cpu_percent', 'process',
711 712
                    'memory_rss', 'pid', 'memory_percent',
                    'io_rw_counter', 'insertion_date', 'insertion_time',
Bryton Lacquement's avatar
Bryton Lacquement committed
713
                    'io_cycles_counter', 'cpu_num_threads'})
714 715
        self.assertEqual(database.invoked_method_list[2], ("commit", ""))
        self.assertEqual(database.invoked_method_list[3], ("close", ""))
716

717 718 719
        self.assertEqual(database.invoked_method_list[4], ("connect", ""))
        self.assertEqual(database.invoked_method_list[5][0], "inserFolderSnapshot")
        self.assertEqual(database.invoked_method_list[5][1][0], ("fakeuser0",))
Bryton Lacquement's avatar
Bryton Lacquement committed
720 721
        self.assertEqual(set(database.invoked_method_list[5][1][1]), 
                   {'insertion_date', 'disk_usage', 'insertion_time'})
722 723
        self.assertEqual(database.invoked_method_list[6], ("commit", ""))
        self.assertEqual(database.invoked_method_list[7], ("close", ""))
724 725 726 727 728 729 730 731

    def test_user_save_disk_snapshot_cycle(self):
        disk_snapshot_params = {'enable': True, 'time_cycle': 3600, 'testing': True}
        user = self.getFakeUser(disk_snapshot_params)
        process = psutil.Process(os.getpid())
        user.append(snapshot.ProcessSnapshot(process))
        database = FakeDatabase2()
        user.save(database, "DATE", "TIME")
732
        self.assertEqual(database.invoked_method_list[0], ("connect", ""))
733

734 735
        self.assertEqual(database.invoked_method_list[1][0], "insertUserSnapshot")
        self.assertEqual(database.invoked_method_list[1][1][0], ("fakeuser0",))
Bryton Lacquement's avatar
Bryton Lacquement committed
736 737
        self.assertEqual(set(database.invoked_method_list[1][1][1]), 
                   {'cpu_time', 'cpu_percent', 'process',
738 739
                    'memory_rss', 'pid', 'memory_percent',
                    'io_rw_counter', 'insertion_date', 'insertion_time',
Bryton Lacquement's avatar
Bryton Lacquement committed
740
                    'io_cycles_counter', 'cpu_num_threads'})
741 742
        self.assertEqual(database.invoked_method_list[2], ("commit", ""))
        self.assertEqual(database.invoked_method_list[3], ("close", ""))
743

744 745 746
        self.assertEqual(database.invoked_method_list[4], ("connect", ""))
        self.assertEqual(database.invoked_method_list[5][0], "select")
        self.assertEqual(database.invoked_method_list[5][1][0], ())
Bryton Lacquement's avatar
Bryton Lacquement committed
747 748
        self.assertEqual(set(database.invoked_method_list[5][1][1]),
                                {'table', 'where', 'limit', 'order', 'columns'})
749 750
        self.assertEqual(database.invoked_method_list[6][0], "inserFolderSnapshot")
        self.assertEqual(database.invoked_method_list[6][1][0], ("fakeuser0",))
Bryton Lacquement's avatar
Bryton Lacquement committed
751 752
        self.assertEqual(set(database.invoked_method_list[6][1][1]), 
                   {'insertion_date', 'disk_usage', 'insertion_time'})
753 754
        self.assertEqual(database.invoked_method_list[7], ("commit", ""))
        self.assertEqual(database.invoked_method_list[8], ("close", ""))
755

756 757 758 759 760
    def test_computer_entity(self):
        computer = entity.Computer(snapshot.ComputerSnapshot())
        database = FakeDatabase()
        computer.save(database, "DATE", "TIME")

761
        self.assertEqual(database.invoked_method_list[0], ("connect", ""))
762

763 764
        self.assertEqual(database.invoked_method_list[1][0], "insertComputerSnapshot")
        self.assertEqual(database.invoked_method_list[1][1][0], ())
Bryton Lacquement's avatar
Bryton Lacquement committed
765 766
        self.assertEqual(set(database.invoked_method_list[1][1][1]), 
                 {'insertion_time', 'insertion_date', 'cpu_num_core',
767
                  'partition_list', 'cpu_frequency', 'memory_size', 
Bryton Lacquement's avatar
Bryton Lacquement committed
768
                  'cpu_type', 'memory_type'})
769
 
770 771
        self.assertEqual(database.invoked_method_list[2][0], "insertSystemSnapshot")
        self.assertEqual(database.invoked_method_list[2][1][0], ())
Bryton Lacquement's avatar
Bryton Lacquement committed
772
        self.assertEqual(set(database.invoked_method_list[2][1][1]), 
773 774 775 776 777
          set([ 'memory_used', 'cpu_percent', 'insertion_date', 'insertion_time',
                'loadavg', 'memory_free', 'net_in_bytes', 'net_in_dropped', 
                'net_in_errors', 'net_out_bytes', 'net_out_dropped', 
                'net_out_errors']))

778 779
        self.assertEqual(database.invoked_method_list[3][0], "insertDiskPartitionSnapshot")
        self.assertEqual(database.invoked_method_list[3][1][0], ())
Bryton Lacquement's avatar
Bryton Lacquement committed
780
        self.assertEqual(set(database.invoked_method_list[3][1][1]), 
781 782 783
          set([ 'used', 'insertion_date', 'partition', 'free', 
                'mountpoint', 'insertion_time' ]))

784 785
        self.assertEqual(database.invoked_method_list[-2], ("commit", ""))
        self.assertEqual(database.invoked_method_list[-1], ("close", ""))
786

787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
class TestJournal(unittest.TestCase):

  def test_journal(self):
    journal = reporter.Journal()

    self.assertEqual(journal.getXML(),
      b"<?xml version='1.0' encoding='utf-8'?><journal/>")

    transaction = journal.newTransaction()
    journal.setProperty(transaction, "title", "TestJournal")
    journal.setProperty(transaction, "reference", "reference-of-testjournal")

    arrow = ElementTree.SubElement(transaction, "arrow")
    arrow.set("type", "Destination")

    journal.newMovement(transaction,
                        resource="ee",
                        title="ZZ",
                        quantity="10",
                        reference="BB",
                        category="")


    self.assertEqual(journal.getXML(),
      b'<?xml version=\'1.0\' encoding=\'utf-8\'?><journal><transaction type="Sale Packing List"><title>TestJournal</title><reference>reference-of-testjournal</reference><arrow type="Destination"/><movement><resource>ee</resource><title>ZZ</title><reference>BB</reference><quantity>10</quantity><price>0.0</price><VAT></VAT><category></category></movement></transaction></journal>')


class TestConsumptionReportBase(unittest.TestCase):

  base_path, = slapos.tests.data.__path__
  maxDiff = None

  def _get_file_content(self, f_path):
    with open(f_path, "r") as f:
      return f.readlines()

  def loadPredefinedDB(self):
    # populate db
    conn = sqlite3.connect(
      os.path.join(self.instance_root, 'collector.db'))
    with open(os.path.join(self.base_path, "monitor_collect.sql")) as f:
      sql = f.read()
    conn.executescript(sql)
    conn.close() 

  def get_fake_user_list(self, partition_amount=3):
    config = ConfigParser()
    config.add_section('slapformat')
    config.set('slapformat', 'partition_amount', str(partition_amount))
    config.set('slapformat', 'user_base_name', 'slapuser')
    config.set('slapformat', 'partition_base_name', 'slappart')
    config.add_section('slapos')
    config.set('slapos', 'instance_root', self.instance_root)
    
    return entity.get_user_list(config)

  def _getReport(self):
    return reporter.ConsumptionReportBase(self.database)

  def setUp(self):
    self.instance_root = tempfile.mkdtemp()
    # inititalise
    self.loadPredefinedDB()
850
    self.database = db.Database(self.instance_root, create=True)
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
    self.temp_dir = tempfile.mkdtemp()
    os.environ["HOME"] = self.temp_dir
    self.software_root = tempfile.mkdtemp()

    self.report = self._getReport() 

  def test_getPartitionUsedMemoryAverage(self):
    self.assertEqual(None,
      self.report.getPartitionUsedMemoryAverage('slapuser19', '2019-10-04'))
    self.assertEqual(None,
      self.report.getPartitionUsedMemoryAverage('slapuser15', '2019-10-05'))
    self.assertEqual(3868924121.87234,
      self.report.getPartitionUsedMemoryAverage('slapuser19', '2019-10-05'))

  def test_getPartitionCPULoadAverage(self):
    self.assertEqual(7.08297872340419,
      self.report.getPartitionCPULoadAverage('slapuser19', '2019-10-05'))
    self.assertEqual(None,
      self.report.getPartitionCPULoadAverage('slapuser15', '2019-10-05'))
    self.assertEqual(None,
      self.report.getPartitionCPULoadAverage('slapuser19', '2019-10-04'))


  def test_getPartitionDiskUsedAverage(self):
    self.assertEqual(7693240.0,
      self.report.getPartitionDiskUsedAverage('slapuser19', '2019-10-05'))
    self.assertEqual(None,
      self.report.getPartitionDiskUsedAverage('slapuser99', '2019-10-05'))

  def test_getPartitionProcessConsumptionList(self):
    data = self.report.getPartitionProcessConsumptionList(
            'slapuser19', date_scope='2019-10-05', 
            min_time='00:01:00', max_time='00:13:00')
884 885 886 887 888
    self.assertEqual(0.02, data[-1]['cpu_time'])
    self.assertEqual(1363.0, data[-1]['pid'])
    self.assertEqual(193206.0, data[-1]['io_cycles_counter'])
    self.assertEqual(5.16, data[-1]['memory_rss'])
    self.assertEqual(2916352.0, data[-1]['io_rw_counter'])
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999

  def test_getPartitionConsumptionStatusList(self):
    data = self.report.getPartitionConsumptionStatusList('slapuser19', date_scope='2019-10-05',
                                         min_time='00:01:00', max_time='00:13:00')
    self.assertEqual(14.6, data[0]['cpu_percent'])
    self.assertEqual(2773721862147.0, data[2]['io_rw_counter'])

class TestConsumptionReport(TestConsumptionReportBase):

  def _getReport(self):
    return reporter.ConsumptionReport(database=self.database,
                                      computer_id="COMP-192938",
                                      location=self.temp_dir,
                                      user_list=self.get_fake_user_list(15))

  def test_getCpuLoadAverageConsumption(self):
    self.assertEqual(self.report._getCpuLoadAverageConsumption('2019-10-05'), 74.44468085106385)
    self.assertEqual(self.report._getCpuLoadAverageConsumption('2019-10-06'), 74.99183673469388)
    self.assertEqual(self.report._getCpuLoadAverageConsumption('2019-10-07'), 76.43714285714287)
    self.assertEqual(self.report._getCpuLoadAverageConsumption('2019-10-08'), None)
    self.assertEqual(self.report._getCpuLoadAverageConsumption('2019-NO(d'), None)

  def test_getMemoryAverageConsumption(self):
    self.assertEqual(self.report._getMemoryAverageConsumption('2019-10-05'), 14185032159.319149)
    self.assertEqual(self.report._getMemoryAverageConsumption('2019-10-06'), 14149247895.510204)
    self.assertEqual(self.report._getMemoryAverageConsumption('2019-10-07'), 14211174517.028572)
    self.assertEqual(self.report._getMemoryAverageConsumption('2019-10-08'), None)
    self.assertEqual(self.report._getMemoryAverageConsumption('2019-NO(d'), None)


  def test_buildXMLReport(self):
    with open(os.path.join(self.temp_dir, "2019-10-07.xml.uploaded"), "w+") as f:
      f.write("")
    report_path = self.report.buildXMLReport('2019-10-07')
    self.assertEqual(report_path, None)
    os.unlink(os.path.join(self.temp_dir, "2019-10-07.xml.uploaded"))

    report_path = self.report.buildXMLReport('2019-10-07')
    self.assertEqual(report_path, os.path.join(self.temp_dir, "2019-10-07.xml"))
    expected_file_path = "%s/%s" % (self.base_path, "2019-10-07.xml")
    with open(report_path, "r") as report_file:
      with open(expected_file_path, "r") as expected_file: 
        self.assertEqual(slapos.util.xml2dict(report_file.read()),
                         slapos.util.xml2dict(expected_file.read()))



class TestPartitionReport(TestConsumptionReportBase):
  def _getReport(self):
    return reporter.PartitionReport(self.database,
                                    user_list=self.get_fake_user_list(20))

  def test_initDataFile(self):
    now = time.time()
    time.sleep(.1)
    self.report._initDataFile(
      os.path.join(self.temp_dir, "testfile.json"), ["my", "colums", "goes", "here"])
    time.sleep(.1)
    with open(os.path.join(self.temp_dir, "testfile.json")) as f:
      _json = json.load(f)

    self.assertLessEqual(_json["date"], time.time())
    self.assertLessEqual(now , _json["date"])
    self.assertEqual(["my", "colums", "goes", "here"], _json["data"])
    self.assertEqual(["data", "date"], sorted(_json))

  def test_buildJSONMonitorReport(self):
    with mock.patch('time.time', return_value=1570495649.5):
      self.report.buildJSONMonitorReport()
      
      for user in self.report.user_list.values():
        location = os.path.join(user.path, ".slapgrid")
        self.assertFalse(set(glob.glob("%s/*.json" % location))) 
  
      for user in self.report.user_list.values():
        location = os.path.join(user.path, ".slapgrid")
        if not os.path.exists(location):
          if user.name in ["slapuser19", "slapuser12"]: 
            mkdir_p(location, 0o755)
        else:
          if user.name not in ["slapuser19", "slapuser12"]: 
            shutil.rmtree(location)
      self.report.buildJSONMonitorReport(date_scope="2019-10-06",
                                         min_time="00:00:00",
                                         max_time="00:10:00")

      for user in self.report.user_list.values():
        if user.name not in ["slapuser19", "slapuser12"]:
          continue
        csv_path_list = [
          '%s/.slapgrid/monitor/monitor_resource.status.json' % user.path, 
          '%s/.slapgrid/monitor/monitor_resource_memory.data.json' % user.path,
          '%s/.slapgrid/monitor/monitor_process_resource.status.json' % user.path,
          '%s/.slapgrid/monitor/monitor_resource_process.data.json' % user.path,
          '%s/.slapgrid/monitor/monitor_resource_io.data.json' % user.path] 
  
        self.assertEqual(set(glob.glob("%s/.slapgrid/monitor/*.json" % user.path)),
                         set(csv_path_list)) 
     
        for f_path in set(glob.glob("%s/.slapgrid/monitor/*.json" % user.path)):
          expected_file_path = os.path.join(self.base_path, user.name, os.path.basename(f_path))
          #if six.PY2:
          #  mkdir_p("%s/%s" % (self.base_path, user.name))
          #  with open(f_path) as f:
          #    with open(expected_file_path, "w") as z:
          #      z.write(f.read())
          with open(f_path, "r") as value:
            with open(expected_file_path, "r") as expected:
              json_value = json.load(value)
              json_expected = json.load(expected)
              self.assertEqual(json_value, json_expected)