示例#1
0
    def test_index(self):
        # init
        workingdir = get_tempdir()
        catalogpath = create_rnd_file(workingdir, 'catalog.json', content='')
        self.addCleanup(clean, workingdir)

        dirpath = get_tempdir()
        self.addCleanup(clean, dirpath)

        # create 3 files
        f1 = create_rnd_file(dirpath, get_rnd_string(5))
        f2 = create_rnd_file(dirpath, get_rnd_string(5))
        f3 = create_rnd_file(dirpath, get_rnd_string(5))

        # create 2 directories
        d1 = create_dir(dirpath, get_rnd_string(3))
        d2 = create_dir(dirpath, get_rnd_string(3))

        # fill directories with files
        _ = create_rnd_file(d1, get_rnd_string(4))
        _ = create_rnd_file(d1, get_rnd_string(4))
        _ = create_rnd_file(d2, get_rnd_string(6))

        noder = Noder()
        top = noder.new_top_node()
        catalog = Catalog(catalogpath, force=True, debug=False)

        # create fake args
        tmpdirname = 'tmpdir'
        args = {
            '<path>': dirpath,
            '<name>': tmpdirname,
            '--hash': True,
            '--meta': ['some meta'],
            '--no-subsize': False,
            '--verbose': True
        }

        # index the directory
        cmd_index(args, noder, catalog, top)
        self.assertTrue(os.stat(catalogpath).st_size != 0)

        # explore the top node to find all nodes
        self.assertTrue(len(top.children) == 1)
        storage = top.children[0]
        self.assertTrue(len(storage.children) == 5)

        # ensures files and directories are in
        names = [x.name for x in storage.children]
        self.assertTrue(os.path.basename(f1) in names)
        self.assertTrue(os.path.basename(f2) in names)
        self.assertTrue(os.path.basename(f3) in names)
        self.assertTrue(os.path.basename(d1) in names)
        self.assertTrue(os.path.basename(d2) in names)

        for node in storage.children:
            if node.name == os.path.basename(d1):
                self.assertTrue(len(node.children) == 2)
            elif node.name == os.path.basename(d2):
                self.assertTrue(len(node.children) == 1)
示例#2
0
    def test_find(self):
        # init
        catalog = Catalog('fake', force=True, debug=False)
        top = catalog._restore_json(get_fakecatalog())
        noder = Noder()

        # create fake args
        args = {
            '<term>': '7544G',
            '--script': True,
            '--verbose': True,
            '--parent': False,
            '--directory': False,
            '--path': None,
            '--format': 'native'
        }

        # try to find something
        found = cmd_find(args, noder, top)
        self.assertTrue(len(found) > 0)

        # try to find something that does not exist
        args['<term>'] = 'verynotfoundnote'
        found = cmd_find(args, noder, top)
        self.assertTrue(len(found) == 0)
示例#3
0
    def test_rm(self):
        # init
        path = 'fake'
        self.addCleanup(clean, path)
        catalog = Catalog(path, force=True, debug=False)
        top = catalog._restore_json(get_fakecatalog())
        noder = Noder()

        # create fake args dict
        args = {'<path>': '', '--recursive': False,
                '--verbose': True}

        # list files and make sure there are children
        args['<path>'] = ''
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) > 0)
        self.assertTrue(len(top.children) == 1)

        # rm a not existing storage
        args['<storage>'] = 'abc'
        top = cmd_rm(args, noder, catalog, top)

        # rm a storage
        args['<storage>'] = 'tmpdir'
        top = cmd_rm(args, noder, catalog, top)

        # ensure there no children anymore
        self.assertTrue(len(top.children) == 0)
示例#4
0
    def test_ls(self):
        # init
        path = 'fake'
        self.addCleanup(clean, path)
        catalog = Catalog(path, force=True, debug=False)
        top = catalog._restore_json(get_fakecatalog())
        noder = Noder()

        # create fake args
        args = {'<path>': '', '--recursive': False, '--verbose': True}

        # list root
        args['<path>'] = ''
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) > 0)

        # list tmpdir that should have 5 children
        args['<path>'] = '/tmpdir'
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) == 5)

        # list folder that should have 2 children
        args['<path>'] = '/tmpdir/P4C'
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) == 2)

        # list folder that should have 1 children
        args['<path>'] = '/tmpdir/VNN'
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) == 1)

        # test not existing path
        args['<path>'] = 'itdoesnotexist'
        found = cmd_ls(args, noder, top)
        self.assertTrue(len(found) == 0)
示例#5
0
    def test_tree(self):
        # init
        path = 'fake'
        self.addCleanup(clean, path)
        catalog = Catalog(path, force=True, verbose=False)
        top = catalog._restore_json(get_fakecatalog())
        noder = Noder()

        # create fake args dict
        args = {'<path>': path, '--verbose': True}

        # print tree and wait for any errors
        cmd_tree(args, noder, top)
示例#6
0
    def test_graph(self):
        # init
        path = 'fake'
        gpath = tempfile.gettempdir() + os.sep + 'graph.dot'
        self.addCleanup(clean, path)
        self.addCleanup(clean, gpath)
        catalog = Catalog(path, force=True, verbose=False)
        top = catalog._restore_json(get_fakecatalog())
        noder = Noder()

        # create fake args dict
        args = {'<path>': gpath, '--verbose': True}

        # create the graph
        cmd_graph(args, noder, top)

        # ensure file exists
        self.assertTrue(os.path.exists(gpath))
示例#7
0
    def test_index(self):
        # init
        workingdir = get_tempdir()
        catalogpath = create_rnd_file(workingdir, 'catalog.json', content='')
        self.addCleanup(clean, workingdir)

        dirpath = get_tempdir()
        self.addCleanup(clean, dirpath)

        # create 3 files
        f1 = create_rnd_file(dirpath, 'file1')
        f2 = create_rnd_file(dirpath, 'file2')
        f3 = create_rnd_file(dirpath, 'file3')
        f4 = create_rnd_file(dirpath, 'file4')

        # create 2 directories
        d1 = create_dir(dirpath, 'dir1')
        d2 = create_dir(dirpath, 'dir2')

        # fill directories with files
        d1f1 = create_rnd_file(d1, 'dir1file1')
        d1f2 = create_rnd_file(d1, 'dir1file2')
        d2f1 = create_rnd_file(d2, 'dir2file1')
        d2f2 = create_rnd_file(d2, 'dir2file2')

        noder = Noder(debug=True)
        noder.set_hashing(True)
        top = noder.new_top_node()
        catalog = Catalog(catalogpath, force=True, debug=False)

        # get checksums
        f4_md5 = md5sum(f4)
        self.assertTrue(f4_md5)
        d1f1_md5 = md5sum(d1f1)
        self.assertTrue(d1f1_md5)
        d2f2_md5 = md5sum(d2f2)
        self.assertTrue(d2f2_md5)

        # create fake args
        tmpdirname = 'tmpdir'
        args = {
            '<path>': dirpath,
            '<name>': tmpdirname,
            '--hash': True,
            '--meta': ['some meta'],
            '--no-subsize': False,
            '--verbose': True,
            '--lpath': None
        }

        # index the directory
        unix_tree(dirpath)
        cmd_index(args, noder, catalog, top)
        self.assertTrue(os.stat(catalogpath).st_size != 0)

        # ensure md5 sum are in
        nods = noder.find_name(top, os.path.basename(f4))
        self.assertTrue(len(nods) == 1)
        nod = nods[0]
        self.assertTrue(nod)
        self.assertTrue(nod.md5 == f4_md5)

        # print catalog
        noder.print_tree(top)

        # add some files and directories
        new1 = create_rnd_file(d1, 'newf1')
        new2 = create_rnd_file(dirpath, 'newf2')
        new3 = create_dir(dirpath, 'newd3')
        new4 = create_dir(d2, 'newd4')
        new5 = create_rnd_file(new4, 'newf5')
        unix_tree(dirpath)

        # modify files
        EDIT = 'edited'
        edit_file(d1f1, EDIT)
        d1f1_md5_new = md5sum(d1f1)
        self.assertTrue(d1f1_md5_new)
        self.assertTrue(d1f1_md5_new != d1f1_md5)

        # change file without mtime
        maccess = os.path.getmtime(f4)
        EDIT = 'edited'
        edit_file(f4, EDIT)
        # reset edit time
        os.utime(f4, (maccess, maccess))
        f4_md5_new = md5sum(d1f1)
        self.assertTrue(f4_md5_new)
        self.assertTrue(f4_md5_new != f4_md5)

        # change file without mtime
        maccess = os.path.getmtime(d2f2)
        EDIT = 'edited'
        edit_file(d2f2, EDIT)
        # reset edit time
        os.utime(d2f2, (maccess, maccess))
        d2f2_md5_new = md5sum(d2f2)
        self.assertTrue(d2f2_md5_new)
        self.assertTrue(d2f2_md5_new != d2f2_md5)

        # update storage
        cmd_update(args, noder, catalog, top)

        # print catalog
        # print(read_from_file(catalogpath))
        noder.print_tree(top)

        # explore the top node to find all nodes
        self.assertTrue(len(top.children) == 1)
        storage = top.children[0]
        self.assertTrue(len(storage.children) == 8)

        # ensure d1f1 md5 sum has changed in catalog
        nods = noder.find_name(top, os.path.basename(d1f1))
        self.assertTrue(len(nods) == 1)
        nod = nods[0]
        self.assertTrue(nod)
        self.assertTrue(nod.md5 != d1f1_md5)
        self.assertTrue(nod.md5 == d1f1_md5_new)

        # ensure f4 md5 sum has changed in catalog
        nods = noder.find_name(top, os.path.basename(f4))
        self.assertTrue(len(nods) == 1)
        nod = nods[0]
        self.assertTrue(nod)
        self.assertTrue(nod.md5 != f4_md5)
        self.assertTrue(nod.md5 == f4_md5_new)

        # ensure d2f2 md5 sum has changed in catalog
        nods = noder.find_name(top, os.path.basename(d2f2))
        self.assertTrue(len(nods) == 1)
        nod = nods[0]
        self.assertTrue(nod)
        self.assertTrue(nod.md5 != d2f2_md5)
        self.assertTrue(nod.md5 == d2f2_md5_new)

        # ensures files and directories are in
        names = [node.name for node in anytree.PreOrderIter(storage)]
        print(names)
        self.assertTrue(os.path.basename(f1) in names)
        self.assertTrue(os.path.basename(f2) in names)
        self.assertTrue(os.path.basename(f3) in names)
        self.assertTrue(os.path.basename(f4) in names)
        self.assertTrue(os.path.basename(d1) in names)
        self.assertTrue(os.path.basename(d1f1) in names)
        self.assertTrue(os.path.basename(d1f2) in names)
        self.assertTrue(os.path.basename(d2) in names)
        self.assertTrue(os.path.basename(d2f1) in names)
        self.assertTrue(os.path.basename(new1) in names)
        self.assertTrue(os.path.basename(new2) in names)
        self.assertTrue(os.path.basename(new3) in names)
        self.assertTrue(os.path.basename(new4) in names)
        self.assertTrue(os.path.basename(new5) in names)

        for node in storage.children:
            if node.name == os.path.basename(d1):
                self.assertTrue(len(node.children) == 3)
            elif node.name == os.path.basename(d2):
                self.assertTrue(len(node.children) == 3)
            elif node.name == os.path.basename(new3):
                self.assertTrue(len(node.children) == 0)
            elif node.name == os.path.basename(new4):
                self.assertTrue(len(node.children) == 1)
        self.assertTrue(read_from_file(d1f1) == EDIT)

        # remove some files
        clean(d1f1)
        clean(d2)
        clean(new2)
        clean(new4)

        # update storage
        cmd_update(args, noder, catalog, top)

        # ensures files and directories are (not) in
        names = [node.name for node in anytree.PreOrderIter(storage)]
        print(names)
        self.assertTrue(os.path.basename(f1) in names)
        self.assertTrue(os.path.basename(f2) in names)
        self.assertTrue(os.path.basename(f3) in names)
        self.assertTrue(os.path.basename(f4) in names)
        self.assertTrue(os.path.basename(d1) in names)
        self.assertTrue(os.path.basename(d1f1) not in names)
        self.assertTrue(os.path.basename(d1f2) in names)
        self.assertTrue(os.path.basename(d2) not in names)
        self.assertTrue(os.path.basename(d2f1) not in names)
        self.assertTrue(os.path.basename(d2f1) not in names)
        self.assertTrue(os.path.basename(new1) in names)
        self.assertTrue(os.path.basename(new2) not in names)
        self.assertTrue(os.path.basename(new3) in names)
        self.assertTrue(os.path.basename(new4) not in names)
        self.assertTrue(os.path.basename(new5) not in names)
        for node in storage.children:
            if node.name == os.path.basename(d1):
                self.assertTrue(len(node.children) == 2)
            elif node.name == os.path.basename(new3):
                self.assertTrue(len(node.children) == 0)
示例#8
0
    def test_index(self):
        # init
        workingdir = get_tempdir()
        catalogpath = create_rnd_file(workingdir, 'catalog.json', content='')
        self.addCleanup(clean, workingdir)

        dirpath = get_tempdir()
        self.addCleanup(clean, dirpath)

        # create 3 files
        f1 = create_rnd_file(dirpath, 'file1')
        f2 = create_rnd_file(dirpath, 'file2')
        f3 = create_rnd_file(dirpath, 'file3')

        # create 2 directories
        d1 = create_dir(dirpath, 'dir1')
        d2 = create_dir(dirpath, 'dir2')

        # fill directories with files
        d1f1 = create_rnd_file(d1, 'dir1file1')
        d1f2 = create_rnd_file(d1, 'dir1file2')
        d2f1 = create_rnd_file(d2, 'dir2file1')

        noder = Noder()
        top = noder.new_top_node()
        catalog = Catalog(catalogpath, force=True, verbose=False)

        # create fake args
        tmpdirname = 'tmpdir'
        args = {
            '<path>': dirpath,
            '<name>': tmpdirname,
            '--hash': True,
            '--meta': ['some meta'],
            '--no-subsize': False,
            '--verbose': True
        }

        # index the directory
        unix_tree(dirpath)
        cmd_index(args, noder, catalog, top, debug=True)
        self.assertTrue(os.stat(catalogpath).st_size != 0)

        # print catalog
        noder.print_tree(top)

        # add some files and directories
        new1 = create_rnd_file(d1, 'newf1')
        new2 = create_rnd_file(dirpath, 'newf2')
        new3 = create_dir(dirpath, 'newd3')
        new4 = create_dir(d2, 'newd4')
        new5 = create_rnd_file(new4, 'newf5')
        unix_tree(dirpath)

        # modify files
        EDIT = 'edited'
        edit_file(d1f1, EDIT)

        # update storage
        cmd_update(args, noder, catalog, top, debug=True)

        # print catalog
        # print(read_from_file(catalogpath))
        noder.print_tree(top)

        # explore the top node to find all nodes
        self.assertTrue(len(top.children) == 1)
        storage = top.children[0]
        self.assertTrue(len(storage.children) == 7)

        # ensures files and directories are in
        names = [node.name for node in anytree.PreOrderIter(storage)]
        print(names)
        self.assertTrue(os.path.basename(f1) in names)
        self.assertTrue(os.path.basename(f2) in names)
        self.assertTrue(os.path.basename(f3) in names)
        self.assertTrue(os.path.basename(d1) in names)
        self.assertTrue(os.path.basename(d1f1) in names)
        self.assertTrue(os.path.basename(d1f2) in names)
        self.assertTrue(os.path.basename(d2) in names)
        self.assertTrue(os.path.basename(d2f1) in names)
        self.assertTrue(os.path.basename(new1) in names)
        self.assertTrue(os.path.basename(new2) in names)
        self.assertTrue(os.path.basename(new3) in names)
        self.assertTrue(os.path.basename(new4) in names)
        self.assertTrue(os.path.basename(new5) in names)

        for node in storage.children:
            if node.name == os.path.basename(d1):
                self.assertTrue(len(node.children) == 3)
            elif node.name == os.path.basename(d2):
                self.assertTrue(len(node.children) == 2)
            elif node.name == os.path.basename(new3):
                self.assertTrue(len(node.children) == 0)
            elif node.name == os.path.basename(new4):
                self.assertTrue(len(node.children) == 1)
        self.assertTrue(read_from_file(d1f1) == EDIT)

        # remove some files
        clean(d1f1)
        clean(d2)
        clean(new2)
        clean(new4)

        # update storage
        cmd_update(args, noder, catalog, top, debug=True)

        # ensures files and directories are (not) in
        names = [node.name for node in anytree.PreOrderIter(storage)]
        print(names)
        self.assertTrue(os.path.basename(f1) in names)
        self.assertTrue(os.path.basename(f2) in names)
        self.assertTrue(os.path.basename(f3) in names)
        self.assertTrue(os.path.basename(d1) in names)
        self.assertTrue(os.path.basename(d1f1) not in names)
        self.assertTrue(os.path.basename(d1f2) in names)
        self.assertTrue(os.path.basename(d2) not in names)
        self.assertTrue(os.path.basename(d2f1) not in names)
        self.assertTrue(os.path.basename(new1) in names)
        self.assertTrue(os.path.basename(new2) not in names)
        self.assertTrue(os.path.basename(new3) in names)
        self.assertTrue(os.path.basename(new4) not in names)
        self.assertTrue(os.path.basename(new5) not in names)
        for node in storage.children:
            if node.name == os.path.basename(d1):
                self.assertTrue(len(node.children) == 2)
            elif node.name == os.path.basename(new3):
                self.assertTrue(len(node.children) == 0)