def testRemovingKeyFromMeta(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set('foo', 'bar').write().remove('foo').write()
self.assertEqual(dict(pake.config.node.Meta(test_node_root)), {})
# cleanup
helpers.rmnode(testdir)
def testNodeRegeneration(self):
reqs = [{'act': 'node.manager.init', 'path': testdir},
{'act': 'nest.manager.init', 'path': testdir},
{'act': 'nest.config.meta.set', 'key': 'name', 'value': 'test'},
{'act': 'node.config.nests.register', 'path': testdir},
{'act': 'node.config.meta.set', 'key': 'foo', 'value': 'bar'},
{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'},
{'act': 'node.config.aliens.set', 'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}, 'fetch': False},
{'act': 'node.manager.reinit', 'path': testdir}
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
ifstream = open('./env/node/required/directories.json')
directories = json.loads(ifstream.read())
ifstream.close()
configs = [ ('meta.json', {'foo': 'bar'}), # (filename, desired_content)
('pushers.json', [{'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}]),
('aliens.json', {'http://alien.example.com': {'mirrors': [], 'meta': {}}}),
('nests.json', {'test': os.path.abspath(os.path.join(testdir, '.pakenest'))}),
]
# test logic
runner.run()
self.assertIn('.pakenode', os.listdir(testdir))
for d in directories:
path = os.path.join(test_node_root, d)
self.assertEqual(True, os.path.isdir(path))
for f, desired in configs:
path = os.path.join(test_node_root, f)
print(path, os.path.isfile(path))
ifstream = open(path, 'r')
self.assertEqual(desired, json.loads(ifstream.read()))
ifstream.close()
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testListingAliens(self):
helpers.gennode(testdir)
reqs = [{
'act': 'node.config.aliens.set',
'url': 'http://alien.example.com',
'mirrors': [],
'meta': {}
}, {
'act': 'node.config.aliens.set',
'url': 'http://alien.example.net',
'mirrors': [],
'meta': {}
}, {
'act': 'node.config.aliens.set',
'url': 'http://alien.example.org',
'mirrors': [],
'meta': {}
}, {
'act': 'node.config.aliens.getall'
}]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
foo = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
bar = {'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}}
baz = {'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}}
# test logic
runner.run()
aliens = runner.getstack()[-1]
self.assertIn(foo, aliens)
self.assertIn(bar, aliens)
self.assertIn(baz, aliens)
# cleanup
helpers.rmnode(testdir)
def testSettingKeyInMeta(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set('foo', 'bar').write()
self.assertEqual(pake.config.node.Meta(test_node_root).get('foo'), 'bar')
# cleanup
helpers.rmnode(testdir)
def testGettingMetaKeys(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set('foo', 0).set('bar', 1).set('baz', 2).write()
self.assertEqual(['bar', 'baz', 'foo'], sorted(pake.config.node.Meta(test_node_root).keys()))
# cleanup
helpers.rmnode(testdir)
def testListingAlienURLs(self):
helpers.gennode(testdir)
reqs = [{
'act': 'node.config.aliens.set',
'url': 'http://alien.example.com',
'mirrors': [],
'meta': {}
}, {
'act': 'node.config.aliens.set',
'url': 'http://alien.example.net',
'mirrors': [],
'meta': {}
}, {
'act': 'node.config.aliens.set',
'url': 'http://alien.example.org',
'mirrors': [],
'meta': {}
}]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
urls = [
'http://alien.example.com', 'http://alien.example.net',
'http://alien.example.org'
]
self.assertEqual(
urls, sorted(pake.config.node.Aliens(test_node_root).urls()))
# cleanup
helpers.rmnode(testdir)
def testSettingKeyInMeta(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set('foo', 'bar').write()
self.assertEqual(
pake.config.node.Meta(test_node_root).get('foo'), 'bar')
# cleanup
helpers.rmnode(testdir)
def testCheckingForURLInPushers(self):
helpers.gennode(testdir)
# test logic
pusher = {'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}
pake.config.node.Pushers(test_node_root).set(**pusher).write()
self.assertEqual(True, pake.config.node.Pushers(test_node_root).hasurl('http://pake.example.com'))
# cleanup
helpers.rmnode(testdir)
def testSettingNest(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Nests(root=test_node_root).set('foo', './testdir/.pakenest').write()
self.assertEqual('./testdir/.pakenest', pake.config.node.Nests(test_node_root).get('foo'))
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testRemovingKeyFromMeta(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set(
'foo', 'bar').write().remove('foo').write()
self.assertEqual(dict(pake.config.node.Meta(test_node_root)), {})
# cleanup
helpers.rmnode(testdir)
def testSettingKeyInMeta(self):
reqs = [{'act': 'node.manager.init', 'path': testdir},
{'act': 'node.config.meta.set', 'key': 'foo', 'value': 'bar'}]
# test logic
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
self.assertEqual(pake.config.node.Meta(test_node_root).get('foo'), 'bar')
# cleanup
helpers.rmnode(testdir)
def testGettingPusher(self):
helpers.gennode(testdir)
# test logic
pusher = {'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}
pake.config.node.Pushers(test_node_root).set(**pusher).write()
self.assertEqual(pusher, pake.config.node.Pushers(test_node_root).get(url='http://pake.example.com'))
# cleanup
helpers.rmnode(testdir)
def testGettingAlien(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.aliens.set', 'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}, 'fetch': False},
{'act': 'node.config.aliens.get', 'url': 'http://alien.example.com'}
]
# test logic
self.assertEqual({'mirrors': [], 'meta': {}}, pake.transactions.runner.Runner(root=testdir, requests=reqs).run().getstack()[-1])
# cleanup
helpers.rmnode(testdir)
def testRemovingAlien(self):
helpers.gennode(testdir)
# test logic
alien = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**alien).write()
pake.config.node.Aliens(test_node_root).remove(alien['url']).write()
self.assertNotIn('http://alien.example.com', pake.config.node.Aliens(test_node_root))
# cleanup
helpers.rmnode(testdir)
def testAddingAlien(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.aliens.set', 'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}, 'fetch': False}]
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
# test logic
alien = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
self.assertIn('http://alien.example.com', list(pake.config.node.Aliens(test_node_root)))
# cleanup
helpers.rmnode(testdir)
def testRemovingKeyFromMeta(self):
reqs = [{'act': 'node.manager.init', 'path': testdir},
{'act': 'node.config.meta.set', 'key': 'foo', 'value': 'bar'},
{'act': 'node.config.meta.remove', 'key': 'foo'}]
# test logic
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
self.assertEqual(dict(pake.config.node.Meta(test_node_root)), {})
# cleanup
helpers.rmnode(testdir)
def testGettingAlien(self):
helpers.gennode(testdir)
# test logic
alien = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**alien).write()
del alien['url']
self.assertEqual(alien, pake.config.node.Aliens(test_node_root).get('http://alien.example.com'))
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testSettingNest(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Nests(root=test_node_root).set(
'foo', './testdir/.pakenest').write()
self.assertEqual('./testdir/.pakenest',
pake.config.node.Nests(test_node_root).get('foo'))
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testAddingPusher(self):
reqs = [{'act': 'node.manager.init', 'path': testdir},
{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}
]
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
# test logic
pusher = {'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}
self.assertIn(pusher, pake.config.node.Pushers(test_node_root))
# cleanup
helpers.rmnode(testdir)
def testRemovingAlien(self):
helpers.gennode(testdir)
# test logic
alien = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**alien).write()
pake.config.node.Aliens(test_node_root).remove(alien['url']).write()
self.assertNotIn('http://alien.example.com',
pake.config.node.Aliens(test_node_root))
# cleanup
helpers.rmnode(testdir)
def testMirrorlistGeneration(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Pushers(test_node_root).set(url='http://pake.example.com', host='example.com', cwd='').write()
pake.node.pusher.genmirrorlist(test_node_root)
ifstream = open(os.path.join(test_node_root, 'mirrors.json'))
self.assertEqual(['http://pake.example.com'], json.loads(ifstream.read()))
ifstream.close()
# cleanup
helpers.rmnode(testdir)
def testRemovingNest(self):
helpers.gennode(testdir)
# test logic
nest = {'name': 'foo', 'path': '~/Dev/foo'}
pake.config.node.Nests(test_node_root).set(**nest).write()
pake.config.node.Nests(test_node_root).remove('foo').write()
self.assertRaises(KeyError, pake.config.node.Nests(test_node_root).get, 'foo')
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testRemovingNest(self):
helpers.gennode(testdir)
# test logic
nest = {'name': 'foo', 'path': '~/Dev/foo'}
pake.config.node.Nests(test_node_root).set(**nest).write()
pake.config.node.Nests(test_node_root).remove('foo').write()
self.assertRaises(KeyError,
pake.config.node.Nests(test_node_root).get, 'foo')
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testGettingPathsOfAllNests(self):
helpers.gennode(testdir)
# test logic
foo = {'name': 'foo', 'path': '~/Dev/foo'}
bar = {'name': 'bar', 'path': '~/Dev/bar'}
baz = {'name': 'baz', 'path': '~/Dev/baz'}
pake.config.node.Nests(test_node_root).set(**foo).set(**bar).set(**baz).write()
self.assertEqual(['~/Dev/bar', '~/Dev/baz', '~/Dev/foo'], sorted(pake.config.node.Nests(test_node_root).paths()))
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testGettingMetaKeys(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Meta(test_node_root).set('foo',
0).set('bar',
1).set('baz',
2).write()
self.assertEqual(['bar', 'baz', 'foo'],
sorted(pake.config.node.Meta(test_node_root).keys()))
# cleanup
helpers.rmnode(testdir)
def testRegisteringNest(self):
helpers.gennode(testdir)
helpers.gennest(testdir)
reqs = [{'act': 'nest.config.meta.set', 'key': 'name', 'value': 'test'},
{'act': 'node.config.nests.register', 'path': testdir}]
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
# test logic
self.assertEqual(os.path.abspath(test_nest_root), pake.config.node.Nests(test_node_root).get('test'))
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testGettingValuesFromMeta(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.meta.set', 'key': 'foo', 'value': 'bar'},
{'act': 'node.config.meta.get', 'key': 'foo'}
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
self.assertEqual('bar', runner.getstack()[-1])
# cleanup
helpers.rmnode(testdir)
def testSettingPusher(self):
helpers.gennode(testdir)
# test logic
pusher = {
'url': 'http://pake.example.com',
'host': 'example.com',
'cwd': '/domains/example.com/public_html/pake'
}
pake.config.node.Pushers(test_node_root).set(**pusher).write()
self.assertIn(pusher, pake.config.node.Pushers(test_node_root))
# cleanup
helpers.rmnode(testdir)
def testRemovingNest(self):
helpers.gennode(testdir)
helpers.gennest(testdir)
reqs = [{'act': 'nest.config.meta.set', 'key': 'name', 'value': 'test'},
{'act': 'node.config.nests.register', 'path': testdir},
{'act': 'node.config.nests.remove', 'name': 'test'}]
pake.transactions.runner.Runner(root=testdir, requests=reqs).run()
# test logic
self.assertRaises(KeyError, pake.config.node.Nests(test_node_root).get, 'test')
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testMirrorlistGeneration(self):
helpers.gennode(testdir)
# test logic
pake.config.node.Pushers(test_node_root).set(
url='http://pake.example.com', host='example.com', cwd='').write()
pake.node.pusher.genmirrorlist(test_node_root)
ifstream = open(os.path.join(test_node_root, 'mirrors.json'))
self.assertEqual(['http://pake.example.com'],
json.loads(ifstream.read()))
ifstream.close()
# cleanup
helpers.rmnode(testdir)
def testListingAlienURLs(self):
helpers.gennode(testdir)
# test logic
foo = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
bar = {'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}}
baz = {'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**foo).set(**bar).set(**baz).write()
self.assertEqual(['http://alien.example.com', 'http://alien.example.net', 'http://alien.example.org'],
sorted(pake.config.node.Aliens(test_node_root).urls()))
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testListingAliens(self):
helpers.gennode(testdir)
# test logic
foo = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
bar = {'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}}
baz = {'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**foo).set(**bar).set(**baz).write()
aliens = pake.config.node.Aliens(test_node_root).all()
self.assertIn(foo, aliens)
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testGettingPusher(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'},
{'act': 'node.config.mirrors.get', 'url': 'http://pake.example.com'}
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
pusher = {'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'}
self.assertEqual(pusher, runner.getstack()[-1])
# cleanup
helpers.rmnode(testdir)
def testGettingPathOfOneNest(self):
helpers.gennode(testdir)
# test logic
foo = {'name': 'foo', 'path': '~/Dev/foo'}
bar = {'name': 'bar', 'path': '~/Dev/bar'}
baz = {'name': 'baz', 'path': '~/Dev/baz'}
pake.config.node.Nests(test_node_root).set(**foo).set(**bar).set(**baz).write()
self.assertEqual('~/Dev/foo', pake.config.node.Nests(test_node_root).get('foo'))
self.assertEqual('~/Dev/bar', pake.config.node.Nests(test_node_root).get('bar'))
self.assertEqual('~/Dev/baz', pake.config.node.Nests(test_node_root).get('baz'))
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testRegisteringNests(self):
helpers.gennode(testdir)
helpers.gennest(testdir)
# test logic
pake.config.nest.Meta(test_nest_root).set('name', 'foo').write()
pake.node.packages.register(root=test_node_root, path=testdir)
print('don\'t worry - this warning is supposed to appear in this test')
# paths must be absolute to ensure that they are reachable from every directory
self.assertEqual(os.path.abspath(test_nest_root), pake.config.node.Nests(test_node_root).get('foo'))
pake.node.packages.unregister(root=test_node_root, name='foo')
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testGettingAlien(self):
helpers.gennode(testdir)
# test logic
alien = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**alien).write()
del alien['url']
self.assertEqual(
alien,
pake.config.node.Aliens(test_node_root).get(
'http://alien.example.com'))
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testListingAlienURLs(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.aliens.set', 'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}, 'fetch': False},
{'act': 'node.config.aliens.set', 'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}, 'fetch': False},
{'act': 'node.config.aliens.set', 'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}, 'fetch': False}
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
urls = ['http://alien.example.com', 'http://alien.example.net', 'http://alien.example.org']
self.assertEqual(urls, sorted(pake.config.node.Aliens(test_node_root).urls()))
# cleanup
helpers.rmnode(testdir)
def testGettingPathsOfAllNests(self):
helpers.gennode(testdir)
helpers.gennest(testdir)
reqs = [{'act': 'nest.config.meta.set', 'key': 'name', 'value': 'test'},
{'act': 'node.config.nests.register', 'path': testdir},
{'act': 'node.config.nests.getpaths'}
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
self.assertEqual([os.path.abspath(test_nest_root)], runner.run().getstack()[-1])
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testListingAliens(self):
helpers.gennode(testdir)
# test logic
foo = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
bar = {'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}}
baz = {'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**foo).set(**bar).set(
**baz).write()
aliens = pake.config.node.Aliens(test_node_root).all()
self.assertIn(foo, aliens)
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testGettingPathsOfAllNests(self):
helpers.gennode(testdir)
# test logic
foo = {'name': 'foo', 'path': '~/Dev/foo'}
bar = {'name': 'bar', 'path': '~/Dev/bar'}
baz = {'name': 'baz', 'path': '~/Dev/baz'}
pake.config.node.Nests(test_node_root).set(**foo).set(**bar).set(
**baz).write()
self.assertEqual(['~/Dev/bar', '~/Dev/baz', '~/Dev/foo'],
sorted(
pake.config.node.Nests(test_node_root).paths()))
pake.config.node.Nests(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testRegisteringNests(self):
helpers.gennode(testdir)
helpers.gennest(testdir)
# test logic
pake.config.nest.Meta(test_nest_root).set('name', 'foo').write()
pake.node.packages.register(root=test_node_root, path=testdir)
print('don\'t worry - this warning is supposed to appear in this test')
# paths must be absolute to ensure that they are reachable from every directory
self.assertEqual(os.path.abspath(test_nest_root),
pake.config.node.Nests(test_node_root).get('foo'))
pake.node.packages.unregister(root=test_node_root, name='foo')
# cleanup
helpers.rmnode(testdir)
helpers.rmnest(testdir)
def testMirrorlistGeneration(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.com', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'},
{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.net', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'},
{'act': 'node.config.mirrors.set', 'url': 'http://pake.example.org', 'host': 'example.com', 'cwd': '/domains/example.com/public_html/pake'},
{'act': 'node.config.mirrors.genlist'},
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
ifstream = open(os.path.join(test_node_root, 'mirrors.json'))
self.assertEqual(['http://pake.example.com', 'http://pake.example.net', 'http://pake.example.org'], json.loads(ifstream.read()))
ifstream.close()
# cleanup
helpers.rmnode(testdir)
def testNodeManagerDirectoriesWriting(self):
"""This test checks for correct initialization of all required directories.
"""
runner = pake.transactions.runner.Runner(root=testdir, requests=[{'act': 'node.manager.init', 'path': testdir}])
ifstream = open('./env/node/required/directories.json')
directories = json.loads(ifstream.read())
ifstream.close()
# test logic
runner.run()
self.assertIn('.pakenode', os.listdir(testdir))
for d in directories:
path = os.path.join(test_node_root, d)
self.assertEqual(True, os.path.isdir(path))
# cleanup
helpers.rmnode(testdir)
def testListingAlienURLs(self):
helpers.gennode(testdir)
# test logic
foo = {'url': 'http://alien.example.com', 'mirrors': [], 'meta': {}}
bar = {'url': 'http://alien.example.net', 'mirrors': [], 'meta': {}}
baz = {'url': 'http://alien.example.org', 'mirrors': [], 'meta': {}}
pake.config.node.Aliens(test_node_root).set(**foo).set(**bar).set(
**baz).write()
self.assertEqual([
'http://alien.example.com', 'http://alien.example.net',
'http://alien.example.org'
], sorted(pake.config.node.Aliens(test_node_root).urls()))
pake.config.node.Aliens(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
def testNodeManagerDirectoriesWriting(self):
"""This test checks for correct initialization of all required directories.
"""
# preparation
helpers.gennode(testdir)
ifstream = open('./env/node/required/directories.json')
directories = json.loads(ifstream.read())
ifstream.close()
# test logic
self.assertIn('.pakenode', os.listdir(testdir))
for d in directories:
path = os.path.join(test_node_root, d)
self.assertEqual(True, os.path.isdir(path))
# cleanup
helpers.rmnode(testdir)
def testGettingMetaKeys(self):
helpers.gennode(testdir)
reqs = [{'act': 'node.config.meta.set', 'key': 'foo', 'value': 0},
{'act': 'node.config.meta.set', 'key': 'bar', 'value': 1},
{'act': 'node.config.meta.set', 'key': 'baz', 'value': 2},
{'act': 'node.config.meta.getkeys'},
]
runner = pake.transactions.runner.Runner(root=testdir, requests=reqs)
# test logic
runner.run()
self.assertEqual(['bar', 'baz', 'foo'], sorted(runner.getstack()[-1]))
self.assertEqual(['bar', 'baz', 'foo'], sorted(pake.config.node.Meta(test_node_root).keys()))
pake.config.node.Meta(test_node_root).reset().write()
# cleanup
helpers.rmnode(testdir)
