Exemplo n.º 1
0
def test_api_for_create_file():

    path = fs.mkdir('root')
    fs.mkdir('root/code')
    fs.mkfile('root/code/main.c', contents = u'int main() { return 0; }')

    tree = ipe.load_tree(path)

    # We might want to create files and directories that are not in
    # the disk. To do that we use 'create_file' and 'create_dir', that
    # are provided by the Dir class.

    tree.create_file('.emacs')

    # The file is now available for us

    dotemacs = tree.get('.emacs')

    # Files that we create are called "artificial". Files that exist
    # are called "natural."
    
    assert dotemacs.is_artificial
    assert tree.get('code/main.c').is_natural

    # Initially, artificial files have no content.

    assert dotemacs.contents is None

    # No problem. We can set it ourselves.

    lisp = u'(setq tab-width 4)'
    dotemacs.contents = lisp
    assert dotemacs.contents == lisp

    # We cannot create a file or a directory if its name would
    # conflict with that of an existing file.

    try:
        tree.create_dir('.emacs')
    except ipe.DuplicateChild:
        pass

    # If we're tired of an artificial file, we can remove it.

    tree.remove(dotemacs)
    assert not tree.contains(dotemacs)

    # And now we can proceed creating the directory again. It will not
    # conflict.

    d = tree.create_dir('.emacs')
Exemplo n.º 2
0
def test_creating_dir_fails_if_there_is_a_file_in_the_way():
    
    # Let's first create a place where to store our stuff.

    out = fs.mkdir()
    rock = fs.mkfile(join(os.path.basename(out), 'rock'))
    assert isdir(out)
    assert os.path.isfile(rock)

    # Now let's create a tree that has a directory with the same
    # name as the file we created previously. They will conflict.

    root = ipe.Dir('root')
    root.create_dir('rock')

    # We'll store these with the CreateMissingDirectories tool. 

    tool = ipe.storage.CreateMissingDirectories(out)

    # It must not succeed because there is a file in the way.

    try: 
        ipe.top_down(root, tool)
        assert False, 'There is a file in the way!'
    except RuntimeError:
        pass
Exemplo n.º 3
0
def test_store_different_types_of_contents():

    # Let's first create a place where to store our stuff.

    out = fs.mkdir()
    assert isdir(out)

    # Files can have all sorts of contents. Unicode strings...

    txt_contents = u'O ipê amarelo é a árvore nacional do Brasil.'

    # ...iterables...

    lst_contents = [ txt_contents ]

    # ...generator functions...

    def gen_contents():
        for line in lst_contents:
            yield line

    # ...callables...

    def def_contents():
        return gen_contents

    # ...and files.

    fil_contents = open(fs.mkfile('tempfile', contents = txt_contents))

    # So, let's create the files. Each with a different kind of content

    root = ipe.Dir('root')
    f1 = root.create_file('f1', contents = txt_contents)
    f2 = root.create_file('f2', contents = lst_contents)
    f3 = root.create_file('f3', contents = gen_contents)
    f4 = root.create_file('f4', contents = def_contents)
    f5 = root.create_file('f5', contents = fil_contents)

    # Before creating files, let's first create the directories. We
    # know it works because we've tested it before!
    
    tool = ipe.storage.CreateMissingDirectories(out)
    ipe.top_down(root, tool)

    # Now that we know the directories are in place, we'll use
    # the StoreFiles tool to write the files down.

    tool = ipe.storage.StoreFiles(out)
    ipe.top_down(root, tool)

    # Now, let's check what's in those files

    assert codecs.open(join(out, f1.path), encoding='utf-8').read() == txt_contents
    assert codecs.open(join(out, f2.path), encoding='utf-8').read() == txt_contents
    assert codecs.open(join(out, f3.path), encoding='utf-8').read() == txt_contents
    assert codecs.open(join(out, f4.path), encoding='utf-8').read() == txt_contents
    assert codecs.open(join(out, f5.path), encoding='utf-8').read() == txt_contents    
Exemplo n.º 4
0
def test_invalid_dir():
    r = fs.mkfile('i/am/not/a/dir.txt')

    try:
        t = ipe.load_tree(r)
        assert False, 'IO Error'
    except IOError:
        pass

    try:
        t = ipe.load_tree(fs.abspath('not/created/yet'))
        assert False, 'IO Error'
    except IOError:
        pass

    t = ipe.load_tree(os.path.dirname(r))
    eq_(t.get('dir.txt').parent, t)
Exemplo n.º 5
0
def test_natural_file():

    dn = fs.mkdir('natural-files')
    fn = fs.mkfile('natural-files/file.txt', contents = u'test')
    root = ipe.load_tree(dn)

    # This is a natural file.

    f = root.get('file.txt')

    # By default, it has contents. The standard value is a file-like
    # object

    with f.contents as stream:

        # It is a read only stream

        try:
            stream.write('anything')
            assert False, 'The file should be read only.'
        except IOError:
            pass

        # And it must represent the contents of the file on disk.

        text = stream.read().decode('utf-8')
        assert text == u'test'

    # Replacing it with an UTF-8 string is OK.

    f.contents = u'replaced'
    assert f.contents == u'replaced'
    
    # It should not overwrite the contents of the file, though.

    with open(fn, 'rb') as stream:
        text = stream.read().decode('utf-8')
        assert text == u'test'
    
    # Setting to None should not reset the file to the original state.

    f.contents = None
    assert f.contents == None
Exemplo n.º 6
0
def test_create_some_files():
    d = fs.mkdir('hello/world')
    f = fs.mkfile('hello/world/again.txt')
Exemplo n.º 7
0
def test_load_dir():
    r = fs.mkdir('root')

    fs.mkdir('root/vanilla')
    fs.mkdir('root/foo/bar')

    fs.mkfile('root/a.txt')
    fs.mkfile('root/b.txt', contents = u'André')
    fs.mkfile('root/vanilla/c.txt')
    fs.mkfile('root/vanilla/d.txt')
    fs.mkfile('root/foo/e.txt')
    fs.mkfile('root/foo/bar/f.txt')
    fs.mkfile('root/foo/bar/g.txt')

    t = ipe.load_tree(r)

    eq_(t.get('vanilla/c.txt').name, 'c.txt')
    eq_(t.get('foo/bar/g.txt').parent.get('f.txt').abspath,
        t.get('foo/bar/f.txt').abspath)