mirror of https://github.com/buildinspace/peru.git
111 lines
4.3 KiB
Python
111 lines
4.3 KiB
Python
import os
|
|
|
|
from peru import cache
|
|
from peru import rule
|
|
|
|
import shared
|
|
from shared import COLON
|
|
|
|
|
|
class RuleTest(shared.PeruTest):
|
|
@shared.make_synchronous
|
|
async def setUp(self):
|
|
self.cache_dir = shared.create_dir()
|
|
self.cache = await cache.Cache(self.cache_dir)
|
|
# Include a leading colon to test that we prepend ./ to pathspecs.
|
|
self.content = {'a': 'foo', 'b/c': 'bar', COLON + 'd': 'baz'}
|
|
self.content_dir = shared.create_dir(self.content)
|
|
self.content_tree = await self.cache.import_tree(self.content_dir)
|
|
self.entries = await self.cache.ls_tree(
|
|
self.content_tree, recursive=True)
|
|
|
|
@shared.make_synchronous
|
|
async def test_copy(self):
|
|
# A file copied into a directory should be placed into that directory.
|
|
# A directory or file copied into a file should overwrite that file.
|
|
copies = {'a': ['x', 'b', 'b/c'], 'b': ['a', 'y']}
|
|
tree = await rule.copy_files(self.cache, self.content_tree, copies)
|
|
await shared.assert_tree_contents(
|
|
self.cache, tree, {
|
|
'a/c': 'bar',
|
|
'b/a': 'foo',
|
|
'b/c': 'foo',
|
|
'x': 'foo',
|
|
'y/c': 'bar',
|
|
COLON + 'd': 'baz',
|
|
})
|
|
|
|
@shared.make_synchronous
|
|
async def test_move(self):
|
|
# Same semantics as copy above. Also, make sure that move deletes move
|
|
# sources, but does not delete sources that were overwritten by the
|
|
# target of another move.
|
|
moves = {'a': 'b', 'b': 'a'}
|
|
tree = await rule.move_files(self.cache, self.content_tree, moves)
|
|
await shared.assert_tree_contents(self.cache, tree, {
|
|
'a/c': 'bar',
|
|
'b/a': 'foo',
|
|
COLON + 'd': 'baz',
|
|
})
|
|
|
|
@shared.make_synchronous
|
|
async def test_drop(self):
|
|
drop_dir = await rule.drop_files(self.cache, self.content_tree, ['b'])
|
|
await shared.assert_tree_contents(self.cache, drop_dir, {
|
|
'a': 'foo',
|
|
COLON + 'd': 'baz'
|
|
})
|
|
|
|
drop_file = await rule.drop_files(self.cache, self.content_tree, ['a'])
|
|
await shared.assert_tree_contents(self.cache, drop_file, {
|
|
'b/c': 'bar',
|
|
COLON + 'd': 'baz'
|
|
})
|
|
|
|
drop_colon = await rule.drop_files(self.cache, self.content_tree,
|
|
[COLON + 'd'])
|
|
await shared.assert_tree_contents(self.cache, drop_colon, {
|
|
'a': 'foo',
|
|
'b/c': 'bar'
|
|
})
|
|
|
|
globs = await rule.drop_files(self.cache, self.content_tree,
|
|
['**/c', '**/a'])
|
|
await shared.assert_tree_contents(self.cache, globs,
|
|
{COLON + 'd': 'baz'})
|
|
|
|
@shared.make_synchronous
|
|
async def test_pick(self):
|
|
pick_dir = await rule.pick_files(self.cache, self.content_tree, ['b'])
|
|
await shared.assert_tree_contents(self.cache, pick_dir, {'b/c': 'bar'})
|
|
|
|
pick_file = await rule.pick_files(self.cache, self.content_tree, ['a'])
|
|
await shared.assert_tree_contents(self.cache, pick_file, {'a': 'foo'})
|
|
|
|
pick_colon = await rule.pick_files(self.cache, self.content_tree,
|
|
[COLON + 'd'])
|
|
await shared.assert_tree_contents(self.cache, pick_colon,
|
|
{COLON + 'd': 'baz'})
|
|
|
|
globs = await rule.pick_files(self.cache, self.content_tree,
|
|
['**/c', '**/a'])
|
|
await shared.assert_tree_contents(self.cache, globs, {
|
|
'a': 'foo',
|
|
'b/c': 'bar'
|
|
})
|
|
|
|
@shared.make_synchronous
|
|
async def test_executable(self):
|
|
exe = await rule.make_files_executable(self.cache, self.content_tree,
|
|
['b/*'])
|
|
new_content_dir = shared.create_dir()
|
|
await self.cache.export_tree(exe, new_content_dir)
|
|
shared.assert_contents(new_content_dir, self.content)
|
|
shared.assert_not_executable(os.path.join(new_content_dir, 'a'))
|
|
shared.assert_executable(os.path.join(new_content_dir, 'b/c'))
|
|
|
|
@shared.make_synchronous
|
|
async def test_export(self):
|
|
b = await rule.get_export_tree(self.cache, self.content_tree, 'b')
|
|
await shared.assert_tree_contents(self.cache, b, {'c': 'bar'})
|