def _changes():
changes = Changes()
changes.deleted['deleted'] = Resource(None, 'old_content')
changes.deleted['renamed'] = Resource(
SimpleCell('usr/block/renamed'),
Content(ID((1234, )), load=Blob('old_content2')))
changes.created['created'] = Resource(
SimpleCell('usr/block/created'),
Content(id_=None, load=Blob('created')))
changes.created['renamed2'] = Resource(
SimpleCell('usr/block/renamed2'),
Content(id_=None, load=Blob('old_content2')))
changes.modified['modified_cont'] = Modification(
Resource(SimpleCell('usr/block/modified_cont'),
Content(id_=None, load=Blob('mod_content'))),
Resource(SimpleCell('usr/block/modified_cont'),
Content(id_=None, load=Blob('mod_content2'))))
changes.modified['modified_cell'] = Modification(
Resource(SimpleCell('usr/block/modified_cell'),
Content(id_=None, load=Blob('mod_cell'))),
Resource(SimpleCell('usr/block/modified_cell', CPP),
Content(id_=None, load=Blob('mod_cell'))))
changes.modified['modified_both'] = Modification(
Resource(SimpleCell('usr/block/modified_both'),
Content(id_=None, load='mod_both')),
Resource(SimpleCell('usr/block/modified_both', CPP),
Content(id_=None, load=Blob('mod_both2'))))
changes.renames = Renames({'renamed': 'renamed2'})
return changes
def setUp(self):
self.folder = self.new_tmp_folder()
brl_block = BRLBlock('dummy/dummy/block/master')
self.block_version = BlockVersion(brl_block, 0)
alf = Resource(SimpleCell("dummy/block/alf.c"),
Content(ID((0, 1, 2)), Blob("Hello Alf")))
alf.cell.ID = ID((0, 1, 2))
willy = Resource(SimpleCell("dummy/block/willy.c"),
Content(ID((0, 1, 3)), Blob("Hello Willy")))
willy.cell.ID = ID((0, 1, 45))
self.referenced_resources = ReferencedResources()
self.referenced_resources[self.block_version].update({
CellName("alf.c"):
alf,
CellName("willy.c"):
willy
})
self.cells_snapshot = [CellName("alf.c"), CellName("willy.c")]
self.dep_table = BlockVersionTable()
self.restapi = Mock(BiiAPI)
self.restapi.get_published_resources.return_value = self.referenced_resources
self.restapi.get_cells_snapshot.return_value = self.cells_snapshot
self.restapi.get_dep_table.return_value = self.dep_table
self.restapi.get_version_delta_info.return_value = BlockDelta(
'', DEV, None)
self.localdb = LocalDB(os.path.join(self.folder, 'bii.db'))
self.proxy = BiiAPIProxy(self.localdb, self.restapi, Mock())
def test_delete_main(self):
r1 = SimpleCell('user/block/r1.h', CPP)
r2 = SimpleCell('user/block/r2.cpp', CPP)
r3 = SimpleCell('user/block/r3.cpp', CPP)
r4 = SimpleCell('user/block/' + BIICODE_FILE)
res = {
r1.name: Resource(r1, Content(None, Blob(''))),
r2.name: Resource(r2, Content(None, Blob(''))),
r3.name: Resource(r3, Content(None,
Blob('int main(char* argv){}'))),
r4.name: Resource(r4, Content(None, Blob('[mains]\n !r3.cpp')))
}
block_holder = BlockHolder(BlockName('user/block'), res)
process_holder(block_holder, ParseProcessor())
self.assertTrue(res['user/block/r3.cpp'].cell.hasMain)
changes, _ = process_holder(block_holder, MainConfigProcessor())
# Checks
self.assertFalse(res['user/block/r1.h'].cell.hasMain)
self.assertFalse(res['user/block/r2.cpp'].cell.hasMain)
self.assertFalse(res['user/block/r3.cpp'].cell.hasMain)
self.assertEqual(0, len(changes.upserted))
def dep_overwriten_in_blocks_test(self):
""" Blocks: C, B (None version)
Deps: A
C -> A -> B
"""
references = References()
references[va].add('a.h')
vbn = BlockVersion(vb.block, None)
b = Resource(SimpleCell('user/blockb/b.h'))
a = Resource(SimpleCell('user/blocka/a.h'))
a2 = Resource(SimpleCell('user/blocka/a2.h'))
a.cell.dependencies.explicit.add(a2.name)
a2.cell.dependencies.explicit.add(b.name)
tables = {va: [vb], vb: []}
api = FakeApi(zip([va, va, vb], [a, a2, b]), tables)
base_table = BlockVersionTable([vc, vbn])
biiout = OutputStream()
graph, closure, _ = build_closure(api,
references,
base_table,
biiout=biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va])
expected_graph.add_edge(va, vbn)
self.assertEqual(expected_graph, graph)
expected_closure = Closure({
a.name: ClosureItem(a, va),
a2.name: ClosureItem(a2, va)
})
self.assertEqual(expected_closure, closure)
self.assertEqual("", str(biiout))
def simple_test(self):
""" Blocks: C
Deps: A, B
C -> A -> B
"""
references = References()
references[va].add('a.h')
base_table = BlockVersionTable(
[vc, va]) # The result including or excluding va is same
b = Resource(SimpleCell('user/blockb/b.h'))
a = Resource(SimpleCell('user/blocka/a.h'))
a2 = Resource(SimpleCell('user/blocka/a2.h'))
a.cell.dependencies.explicit.add(a2.name)
a2.cell.dependencies.explicit.add(b.name)
tables = {va: [vb], vb: []}
api = FakeApi(zip([va, va, vb], [a, a2, b]), tables)
biiout = OutputStream()
graph, closure, _ = build_closure(api,
references,
base_table,
biiout=biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va, vb])
expected_graph.add_edge(va, vb)
self.assertEqual(expected_graph, graph)
expected_closure = Closure({
a.name: ClosureItem(a, va),
a2.name: ClosureItem(a2, va),
b.name: ClosureItem(b, vb)
})
self.assertEqual(expected_closure, closure)
self.assertEqual("", str(biiout))
def test_find_mains(self):
'''basic check that header is implemented by source'''
resources = {
'blink.h':
Resource(
SimpleCell('usr/block/blink.h', CPP),
Content(id_=None, load=Blob(header), parser=DRLCPPParser())),
'blink.cpp':
Resource(
SimpleCell('usr/block/blink.cpp', CPP),
Content(id_=None,
load=Blob(implementation),
parser=DRLCPPParser())),
'mainblink.cpp':
Resource(SimpleCell('usr/block/mainblink.cpp', CPP),
Content(id_=None, load=Blob(main), parser=DRLCPPParser()))
}
block_holder = BlockHolder(BlockName('user/block'), resources)
for r in resources.itervalues():
r.content.parse()
r.content.updated = False
processor = ArduinoEntryPointProcesor()
processor.do_process(block_holder, Mock())
mainblink = block_holder['mainblink.cpp'].cell
content = block_holder['mainblink.cpp'].content
self.assertTrue(mainblink.hasMain)
self.assertFalse(content.updated)
self.assertFalse(content.blob_updated)
def overwrite_test(self):
""" Blocks: C (defines in requirements B2)
Deps: A, B2
C -> A -> B1
"""
references = References()
references[va].add('a.h')
b = Resource(SimpleCell('user/blockb/b.h'))
b2 = Resource(SimpleCell('user/blockb/b.h'), CPP)
a = Resource(SimpleCell('user/blocka/a.h'))
a2 = Resource(SimpleCell('user/blocka/a2.h'))
a.cell.dependencies.explicit.add(a2.name)
a2.cell.dependencies.explicit.add(b.name)
tables = {va: [vb], vb: [], vb2: []}
api = FakeApi(zip([va, va, vb, vb2], [a, a2, b, b2]), tables)
base_table = BlockVersionTable([vc, va, vb2]) # Note B2 defined here
biiout = OutputStream()
graph, closure, _ = build_closure(api,
references,
base_table,
biiout=biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va, vb2])
expected_graph.add_edge(va, vb2)
self.assertEqual(expected_graph, graph)
expected_closure = Closure({
a.name: ClosureItem(a, va),
a2.name: ClosureItem(a2, va),
b.name: ClosureItem(b2, vb2)
})
self.assertEqual(expected_closure, closure)
self.assertEqual("", str(biiout))
def parse_virtual_test(self):
response = OutputStream()
cell = VirtualCell('usr/block/sort_controllers.py')
resource = Resource(cell, None)
self.assertFalse(resource.parse(response))
self.assertIn(
'You\'re trying to parse a virtual file: usr/block/sort_controllers.py',
str(response))
def python_parse_failure_test(self, parser):
""" Weird bug miguel found.
Python parser failure was causing 'You're trying to parse a virtual file' message to appear
"""
response = OutputStream()
parser.side_effect = Exception
cell = SimpleCell("usr/block/sort_controllers.py", biitype=PYTHON)
content = Content(id_=1, load=Blob('print "hello"'), parser=None, is_parsed=False)
resource = Resource(cell, content)
self.assertFalse(resource.parse(response))
self.assertIn("Error parsing usr/block/sort_controllers.py file", str(response))
def test_nonzero_one_file_content(self):
changes = Changes()
changes.modified['modified_cont'] = Modification(
Resource(SimpleCell('usr/block/pretty.js'),
Content(id_=None, load=Blob('mod_content'))),
Resource(SimpleCell('usr/block/pretty.js'),
Content(id_=None, load=Blob('mod_content2'))))
p = PublishRequest(BlockVersion.loads('usr/block: 3'))
p.msg = "Test Msg"
p.changes = changes
self.assertTrue(bool(p))
def virtual_test(self):
references = References()
references[va].add('a.h')
code = (
'def virtual(settings):\n\tif(settings.os.family == "windows"):return "win"\n'
'\telse: return "nix"')
a = Resource(VirtualCell('user/blocka/a.h', code, {'win', 'nix'}))
awin = Resource(SimpleCell('user/blocka/win/a.h'))
anix = Resource(SimpleCell('user/blocka/nix/a.h'))
b = Resource(SimpleCell('user/blockb/b.h'))
d1 = Resource(SimpleCell('user/blockd/d.h'))
awin.cell.dependencies.explicit.add(b.name)
anix.cell.dependencies.explicit.add(d1.name)
tables = {va: [vb, vd1], vb: [], vd1: []}
api = FakeApi(zip([va, va, va, vb, vd1], [a, awin, anix, b, d1]),
tables)
#With windows settings
settings = Settings(OSInfo(OSFamily("Windows")))
biiout = OutputStream()
graph, closure, _ = build_closure(api, references, {}, settings,
biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va, vb])
expected_graph.add_edge(va, vb)
self.assertEqual(expected_graph, graph)
expected_closure = Closure({
a.name: ClosureItem(a, va),
awin.name: ClosureItem(awin, va),
b.name: ClosureItem(b, vb),
})
self.assertEqual(expected_closure, closure)
self.assertEqual("", str(biiout))
#Change settings
settings = Settings(OSInfo(OSFamily("Linux")))
biiout = OutputStream()
graph, closure, _ = build_closure(api, references, {}, settings,
biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va, vd1])
expected_graph.add_edge(va, vd1)
self.assertEqual(expected_graph, graph)
expected_closure = Closure({
a.name: ClosureItem(a, va),
anix.name: ClosureItem(anix, va),
d1.name: ClosureItem(d1, vd1),
})
self.assertEqual(expected_closure, closure)
self.assertEqual("", str(biiout))
def prepare_context(self, config):
r1 = SimpleCell('user/block/r1.h')
r2 = SimpleCell('user/block/r2.cpp')
r3 = SimpleCell('user/block2/r3.cpp')
r4 = SimpleCell('user/block/' + BIICODE_FILE)
self.res = {r1.name: Resource(r1, None),
r2.name: Resource(r2, None),
r3.name: Resource(r3, None),
r4.name: Resource(r4, Content(None, Blob("[mains]\n" + config)))}
self.block_holder = BlockHolder(BlockName('user/block'), self.res)
self.processor = MainConfigProcessor()
def test_mains_with_filter(self):
r1 = SimpleCell('user/block/r1.h', CPP)
r2 = SimpleCell('user/block/r2.cpp', CPP)
r3 = SimpleCell('user/block/no_mains/r3.cpp', CPP)
r4 = SimpleCell('user/block/no_mains/r4.cpp', CPP)
r5 = SimpleCell('user/block/' + BIICODE_FILE)
r6 = SimpleCell('user/block/new_mains/r6.cpp', CPP)
r7 = SimpleCell('user/block/new_mains/r7.cpp', CPP)
r8 = SimpleCell('user/block/exe_file1.hh', CPP)
r9 = SimpleCell('user/block/exe_file2.hh', CPP)
res = {
r1.name:
Resource(r1, Content(None, Blob(''))),
r2.name:
Resource(r2, Content(None, Blob(''))),
r3.name:
Resource(r3, Content(None, Blob('int main(char* argv){}'))),
r4.name:
Resource(r4, Content(None, Blob('int main(char* argv){}'))),
r5.name:
Resource(
r5,
Content(None,
Blob('[mains]\n!no_mains/*\nnew_mains/*\n*.hh'))),
r6.name:
Resource(r6, Content(None, Blob(''))),
r7.name:
Resource(r7, Content(None, Blob(''))),
r8.name:
Resource(r8, Content(None, Blob(''))),
r9.name:
Resource(r9, Content(None, Blob('')))
}
block_holder = BlockHolder(BlockName('user/block'), res)
process_holder(block_holder, ParseProcessor())
self.assertTrue(res['user/block/no_mains/r3.cpp'].cell.hasMain)
self.assertTrue(res['user/block/no_mains/r4.cpp'].cell.hasMain)
self.assertFalse(res['user/block/new_mains/r6.cpp'].cell.hasMain)
self.assertFalse(res['user/block/new_mains/r7.cpp'].cell.hasMain)
self.assertFalse(res['user/block/exe_file1.hh'].cell.hasMain)
self.assertFalse(res['user/block/exe_file2.hh'].cell.hasMain)
process_holder(block_holder, MainConfigProcessor())
# Checks
self.assertFalse(res['user/block/r1.h'].cell.hasMain)
self.assertFalse(res['user/block/r2.cpp'].cell.hasMain)
self.assertFalse(res['user/block/no_mains/r3.cpp'].cell.hasMain)
self.assertFalse(res['user/block/no_mains/r4.cpp'].cell.hasMain)
self.assertTrue(res['user/block/new_mains/r6.cpp'].cell.hasMain)
self.assertTrue(res['user/block/new_mains/r7.cpp'].cell.hasMain)
self.assertTrue(res['user/block/exe_file1.hh'].cell.hasMain)
self.assertTrue(res['user/block/exe_file2.hh'].cell.hasMain)
def test_modify_content(self):
'''just modify the content of a file'''
r1 = SimpleCell(self.brl_block.block_name + 'r1.h')
content = Content(id_=None, load=Blob('bye'))
edition_resources = {'r1.h': Resource(r1, content)}
changes = compare(self.last_version_resources, edition_resources)
self.assertEqual(0, len(changes.deleted))
self.assertEqual(0, len(changes.created))
self.assertEqual(0, len(changes.renames))
self.assertEqual(1, len(changes.modified))
self.assertEqual(Resource(r1, content), changes.modified['r1.h'].new)
def base_version_test(self):
hive_holder = HiveHolder({}, {})
parents_resource = Resource(
SimpleCell(a1.block_name + BIICODE_FILE),
Content(id_=None, load=Blob('[parent]\n ' + str(a1))))
hive_holder.add_holder(BlockHolder(a1.block_name, {parents_resource}))
parents_resource = Resource(
SimpleCell(b2.block_name + BIICODE_FILE),
Content(id_=None, load=Blob('[parent]\n * ' + str(b2))))
hive_holder.add_holder(BlockHolder(b2.block_name, {parents_resource}))
hive_holder.add_holder(BlockHolder(cn.block_name, {}))
result_table = BlockVersionTable(
[b.parent for b in hive_holder.block_holders])
self.assertEqual(result_table, BlockVersionTable([a1, b2, cn]))
def test_add_item(self):
c1 = Closure()
r1 = Cell('user/block/name1')
version = BlockVersion(BRLBlock('owner/user/block/branch'), 13)
biiout = OutputStream()
resource = Resource(r1, None)
c1.add_item(resource, version, biiout)
r2 = Cell('user/block/name1')
r2.hasMain = True
resource2 = Resource(r2, None)
version2 = BlockVersion(BRLBlock('owner/user/block/branch'), 14)
c1.add_item(resource2, version2, biiout)
self.assertEqual(ClosureItem(resource, version), c1['user/block/name1'])
self.assertIn('Incompatible dependency', str(biiout))
def python_parse_failure_test(self, parser):
""" Weird bug miguel found.
Python parser failure was causing 'You're trying to parse a virtual file' message to appear
"""
response = OutputStream()
parser.side_effect = Exception
cell = SimpleCell('usr/block/sort_controllers.py', biitype=PYTHON)
content = Content(id_=1,
load=Blob('print "hello"'),
parser=None,
is_parsed=False)
resource = Resource(cell, content)
self.assertFalse(resource.parse(response))
self.assertIn('Error parsing usr/block/sort_controllers.py file',
str(response))
def _cells_setup(self, block_name, cells_names, biitype):
resources = []
block_name = BlockName(block_name)
for x in cells_names:
cell = SimpleCell(block_name + x, BiiType(biitype))
resources.append(Resource(cell, Mock()))
return BlockHolder(block_name, resources)
def virtual_dependencies_test(self):
sphereh = 'dummy/geom/sphere.h'
sphereh_test = 'dummy/geom/test/sphere.h'
sphereh_dev = 'dummy/geom/develop/sphere.h'
block_holder = self._cells_setup(
'dummy/geom',
['main.cpp', 'test/sphere.h', 'main2.cpp', 'develop/sphere.h'],
CPP)
block_holder._resources['sphere.h'] = Resource(VirtualCell(sphereh),
None)
block_holder['test/sphere.h'].cell.container = BlockCellName(sphereh)
block_holder['develop/sphere.h'].cell.container = BlockCellName(
sphereh)
block_holder['main.cpp'].cell.dependencies.unresolved = {
CPPDeclaration(sphereh_test)
}
block_holder['main2.cpp'].cell.dependencies.unresolved = {
CPPDeclaration(sphereh_dev)
}
_, outputstream = process_holder(block_holder, DependenciesProcessor())
warn = 'Block dummy/geom has absolute paths, like: #include "dummy/geom/develop/sphere.h"'
self.assertIn(warn, str(outputstream))
# Checks
main_cell = block_holder['main.cpp'].cell
self.check_dependency_set(main_cell.dependencies,
resolved=[sphereh_test],
explicit=[sphereh])
main_cell = block_holder['main2.cpp'].cell
self.check_dependency_set(main_cell.dependencies,
resolved=[sphereh_dev],
explicit=[sphereh])
def _process_virtual_config(self, block_name, virtual, virtuals, realizations, biiout):
'''Params:
block_name : BlockName
virtual: dictionary
'''
for virtual_parse_result in virtual.itervalues():
for cell_name in virtual_parse_result.apply:
block_cell_name = block_name + cell_name
try:
old_cell = self.block_holder[cell_name].cell
except KeyError:
old_cell = None
#Build a new virtual cell with the new data, keeping old if existing
new_cell = VirtualCell(block_cell_name, virtual_parse_result.code,
virtual_parse_result.leaves)
if old_cell is None:
new_cell.type = BiiType.from_extension(block_cell_name.extension)
else:
new_cell.type = old_cell.type
virtual_resource = Resource(new_cell, None)
self.block_holder.add_resource(virtual_resource)
self._process_leaves(new_cell, realizations, biiout)
virtuals.add(block_cell_name)
def test_store_published_resources(self):
s = References()
brl_block = BRLBlock('dummy/dummy/block/master')
block_version = BlockVersion(brl_block, 0)
s[block_version] = [
CellName("alf.c"),
CellName("willy.c"),
CellName('maya.h'),
CellName('win/maya.h'),
CellName('nix/maya.h')
]
alf = Resource(SimpleCell("dummy/block/alf.c"),
Content(ID((0, 1, 2)), Blob("Hello Alf")))
alf.cell.ID = ID((0, 1, 2))
willy = Resource(SimpleCell("dummy/block/willy.c"),
Content(ID((0, 1, 3)), Blob("Hello Willy")))
willy.cell.ID = ID((0, 1, 45))
maya_v = Resource(VirtualCell("dummy/block/maya.h"), None)
maya_v.cell.ID = ID((0, 1, 3))
maya_win = Resource(SimpleCell("dummy/block/win/maya.h"),
Content(ID((0, 1, 4)), Blob("Hello Maya")))
maya_win.cell.ID = ID((0, 1, 4))
maya_nix = Resource(SimpleCell("dummy/block/nix/maya.h"),
Content(ID((0, 1, 5)), Blob("Hello Maya")))
maya_nix.cell.ID = ID((0, 1, 5))
# Expected return
referenced_resources = ReferencedResources()
referenced_resources[block_version].update({
CellName("alf.c"):
alf,
CellName("willy.c"):
willy,
CellName('maya.h'):
maya_v,
CellName('win/maya.h'):
maya_win,
CellName('nix/maya.h'):
maya_nix,
})
self.db.create_published_resources(referenced_resources)
retrieved = self.db.get_published_resources(s)
self.assertEquals(referenced_resources, retrieved)
def _process_resources(block_holder):
for (cell, content) in block_holder.simple_resources:
# Cell from server has the CellID as ID, we need BlockCellName
cell.ID = cell.name
if content:
content = Content(cell.name, content.load, created=True)
r = Resource(cell, content)
block_holder.add_resource(r)
def get_block_holder(block_name, resources_defs):
resources = {}
for cell_name, (typ, text) in resources_defs.iteritems():
if typ is None:
typ = UNKNOWN
cell = SimpleCell(block_name + cell_name, typ)
resources[cell_name] = Resource(
cell, Content(block_name + cell_name, load=Blob(text)))
return BlockHolder(block_name, resources)
def setUp(self):
testUser = BRLUser('compareUser')
self.brl_block = BRLBlock('%s/%s/%s/master' %
(testUser, testUser, 'modulea'))
r1 = SimpleCell(self.brl_block.block_name + 'r1.h')
content = Content(id_=None, load=Blob('hello'))
self.r1 = r1
self.c1 = content
self.last_version_resources = {'r1.h': Resource(r1, content)}
def test_create_resource(self):
r1 = SimpleCell(self.brl_block.block_name + 'r1.h')
content = Content(id_=None, load=Blob('hello'))
r2 = SimpleCell(self.brl_block.block_name + 'r2.h')
content2 = Content(id_=None, load=Blob('bye'))
edition_resources = {
'r1.h': Resource(r1, content),
'r2.h': Resource(r2, content2)
}
changes = compare(self.last_version_resources, edition_resources)
self.assertEqual(0, len(changes.deleted))
self.assertEqual(1, len(changes.created))
self.assertEqual(0, len(changes.renames))
self.assertEqual(0, len(changes.modified))
self.assertEqual(Resource(r2, content2), changes.created['r2.h'])
def _prepare_context(self, my_conf):
if my_conf:
my_conf = "[dependencies]\n " + my_conf
self.processor = DependenciesConfigurationProcessor()
self.r1 = BlockCellName('user/block/r1.h')
self.r2 = BlockCellName('user/block/r2.cpp')
self.r3 = BlockCellName('user/block/r3.cpp')
r1 = SimpleCell(self.r1, CPP)
r2 = SimpleCell(self.r2, CPP)
r3 = SimpleCell('user/block/r3.cpp', CPP)
r4 = SimpleCell('user/block/' + BIICODE_FILE)
res = {
r1.name: Resource(r1, Content(None, Blob("hi"))),
r2.name: Resource(r2, Content(None, Blob("hi"))),
r3.name: Resource(r3, Content(None, Blob("hi"))),
r4.name: Resource(r4, Content(None, Blob(my_conf)))
}
return BlockHolder(BlockName('user/block'), res)
def __init__(self, hive, dict_cells, dict_contents):
self.hive = hive
resource_dict = defaultdict(list)
for block_cell_name, cell in dict_cells.iteritems():
content = dict_contents.get(block_cell_name)
resource_dict[block_cell_name.block_name].append(
Resource(cell, content))
self._block_holders = {
block_name: BlockHolder(block_name, resources)
for block_name, resources in resource_dict.iteritems()
}
def test_modify_content_diff(self):
r1 = SimpleCell(self.brl_block.block_name + 'r1.h')
content = Content(id_=None, load=Blob('bye'))
edition_resources = {'r1.h': Resource(r1, content)}
changes = compare(self.last_version_resources, edition_resources)
diff = compute_diff(changes, resource_diff_function)
self.assertEqual(0, len(diff.deleted))
self.assertEqual(0, len(diff.created))
self.assertEqual(0, len(diff.renames))
self.assertEqual(1, len(diff.modified))
self.assertEqual(
'--- base\n\n+++ other\n\n@@ -1 +1 @@\n\n-hello\n+bye',
diff.modified['r1.h'].content)
#print '--- base\n\n+++ other\n\n@@ -1 +1 @@\n\n-hello\n+bye'
self.assertEqual(
Resource(None,
'--- base\n\n+++ other\n\n@@ -1 +1 @@\n\n-hello\n+bye'),
diff.modified['r1.h'])
def test_create_missing_simple_resources(self):
resources = {'bii/virtual.bii': Resource(SimpleCell('user/block/bii/virtual.bii'),
Content(None, Blob(myConf1)))}
self.block_holder = BlockHolder(BlockName('user/block'), resources)
VirtualConfigurationProcessor().do_process(self.block_holder, OutputStream())
self._sphere_os_checks('sphere.h')
self._sphere_os_checks('sphere.cpp')
self.assertEqual(None, self.block_holder['sphere.h'].content)
self.assertEqual(None, self.block_holder['sphere.cpp'].content)
def __init__(self, dict_cells, dict_contents):
self.hive_dependencies = None # MUST BE ALWAYS BE ASSIGNED before usage
self.settings = None
resource_dict = defaultdict(list)
for block_cell_name, cell in dict_cells.iteritems():
content = dict_contents.get(block_cell_name)
resource_dict[block_cell_name.block_name].append(
Resource(cell, content))
self._block_holders = {
block_name: BlockHolder(block_name, resources)
for block_name, resources in resource_dict.iteritems()
}
def _process_resources(block_holder):
processor_changes = ProcessorChanges()
for (cell, content) in block_holder.simple_resources:
# Cell from server has the CellID as ID, we need BlockCellName
cell.ID = cell.name
if content:
# content.ID = cell.name hive.add_resource does it
content._is_parsed = False # It is necessary to parse it
content.ID = cell.name # It is edition, should have ID=BlockCellName
r = Resource(cell, content)
block_holder.add_resource(r)
processor_changes.upsert(r.name, r.content, blob_changed=True)
return processor_changes
def parse_virtual_test(self):
response = OutputStream()
cell = VirtualCell("usr/block/sort_controllers.py")
resource = Resource(cell, None)
self.assertFalse(resource.parse(response))
self.assertIn("You're trying to parse a virtual file: usr/block/sort_controllers.py", str(response))
