def _publishDependentCell(self, block_id):
low, high = self._biigraph._get_range_block(block_id)
count = 0
d = self.lbcn
bcn = d[block_id]
brl = self._getBlockBRL(bcn)
for row in range(low, high + 1):
r = SimpleCell(d[block_id])
r.root = ID((0, bcn.block_name[-1:], 0))
deps = DependencySet()
dep_table = BlockVersionTable()
for block in range(block_id):
time = self._biigraph._get_dep_elem_offset(row, block)
if time != -1:
deps.add_implicit(d[block])
dep_table[d[block].block_name] = \
BlockVersion(self._getBlockBRL(d[block]), time)
r.dependencies = deps
pack = PublishRequest(BlockVersion(brl, count - 1))
pack.tag = STABLE
count += 1
pack.cells.append(r)
pack.contents[r.name.cell_name] = Content(id_=None, load=Blob('hola {0}'.
format(r.name.cell_name)))
pack.deptable = dep_table
self.service.publish(pack)
def make_published_resource(block, block_cell_name):
if isinstance(block_cell_name, basestring):
moduleCellName = BlockCellName(block_cell_name)
sr = SimpleCell(block_cell_name)
sr.type = BiiType.from_extension(moduleCellName.extension)
sr.ID = UserID(1) + 1 + 2
return sr
def publish(self, brl_block, resource_info, version_tag=STABLE, dep_versions=None):
""" make a simple publication of a single file named block_cell_name to block
brl_block. If block does not exist, it creates it. It mantains coherence of root Ids
for the find checks
param resource_info: {cell_name: (blob, explicits)}
"""
try:
block = self.store.read_block(brl_block)
version = BlockVersion(brl_block, len(block.deltas) - 1)
except NotInStoreException:
version = BlockVersion(brl_block, -1)
publish_request = PublishRequest(version)
publish_request.tag = version_tag
block_name = brl_block.block_name
for cell_name, (blob, dependencies) in resource_info.iteritems():
if dependencies is not None:
cell = SimpleCell(block_name + cell_name)
if isinstance(dependencies, DependencySet):
cell.dependencies = dependencies
else:
cell.dependencies.explicit.update([BlockCellName(d) for d in dependencies])
publish_request.cells.append(cell)
if blob is not None:
blob = Blob(blob) if isinstance(blob, str) else blob
publish_request.contents[cell_name] = Content(id_=None, load=blob)
if isinstance(dep_versions, BlockVersion):
dep_versions = [dep_versions]
publish_request.deptable = BlockVersionTable(dep_versions)
self.service.publish(publish_request)
def make_simple_cell(block_cell_name, hive=None):
if isinstance(block_cell_name, basestring):
block_cell_name = BlockCellName(block_cell_name)
cell = SimpleCell(block_cell_name)
cell.type = BiiType.from_extension(block_cell_name.extension)
if hive:
changes = ProcessorChanges()
changes.upsert(cell.name, cell, None)
hive.update(changes)
return cell
def test_simple_published_cell(self):
# Simple publish resource
simpleresource = SimpleCell("user/block/path/to/file.h")
simpleresource.ID = ID()
simpleresource.root = ID()
# Include inside "a" the "kls" attribute
s = simpleresource.serialize()
self.assertEqual(s[Deserializer.POLIMORPHIC_KEYWORD],
ClassTypedSerializer.getValue(simpleresource.__class__))
ob = CellDeserializer(ID).deserialize(s)
self.assert_bii_equal(simpleresource, ob)
def test_simple_edition_cell_with_container(self):
virtual_cell = BlockCellName('user/block/path/file.h')
simpleresource = SimpleCell("user/block/path/to/file.h")
simpleresource.ID = BlockCellName("user/block/path/to/file.h")
simpleresource.root = ID()
simpleresource.dependencies.add_implicit(BlockCellName("user/block/path/file.h"))
simpleresource.container = virtual_cell
s = simpleresource.serialize()
self.assertEqual(s[Deserializer.POLIMORPHIC_KEYWORD],
ClassTypedSerializer.getValue(SimpleCell))
ob = CellDeserializer(BlockCellName).deserialize(s)
self.assert_bii_equal(ob, simpleresource)
def _process_leaves(self, virtual_cell, realizations, biiout):
'''for a virtual cell, creates the leaves if they don't exist
@param virtual_cell: the cell that serves as base
@param realizations: a set to add the leaves BlockCellNames
@param biiout: biiout
'''
block_cell_name = virtual_cell.name
for leave in virtual_cell.resource_leaves:
realizations.add(leave)
try:
cell = self.block_holder[leave.cell_name].cell
except KeyError:
#The leave it is pointing does not exist
biiout.info('%s virtual realization not existing, creating it' % leave)
cell = SimpleCell(leave)
cell.type = virtual_cell.type
content = Content(leave, Blob(""), created=True)
content.parser = parser_factory(cell.type, cell.name.cell_name)
self.block_holder.add_resource(Resource(cell, content))
cell.container = block_cell_name
def test_publish_concurrent_modification(self):
self.store = TestingMemServerStore()
brl = 'user'
self.store.create_user(User(brl))
self.service = BiiService(self.store, brl)
self.brl_block = BRLBlock('user/user/block/master')
request = PublishRequest(BlockVersion(self.brl_block, -1))
request.cells.append(SimpleCell('user/block/r1.h'))
request.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
request.deptable = BlockVersionTable()
request.tag = DEV
self.service.publish(request)
'''Branch 1 (from master) creates new resource'''
self.brl_block1 = BRLBlock('user/user/block/branch1')
request = PublishRequest(BlockVersion(self.brl_block, 0))
request.cells.append(SimpleCell('user/block/r2.h'))
request.contents['r2.h'] = Content(id_=None, load=Blob('adios'))
request.deptable = BlockVersionTable()
with self.assertRaisesRegexp(BiiException, 'Concurrent modification'):
self.service.publish(request)
def _process_leaves(self, virtual_cell, realizations, biiout):
'''for a virtual cell, creates the leaves if they don't exist
@param virtual_cell: the cell that serves as base
@param realizations: a set to add the leaves BlockCellNames
@param biiout: biiout
'''
block_cell_name = virtual_cell.name
for leave in virtual_cell.resource_leaves:
realizations.add(leave)
try:
cell = self.block_holder[leave.cell_name].cell
except KeyError:
#The leave it is pointing does not exist
biiout.info('%s virtual realization not existing, creating it' % leave)
cell = SimpleCell(leave)
cell.type = virtual_cell.type
content = Content(leave, Blob(""))
content.parser = parser_factory(cell.type, cell.name.cell_name)
self.block_holder.add_resource(Resource(cell, content))
self.processor_changes.upsert(cell.name, content, blob_changed=True)
cell.container = block_cell_name
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 test_publish_no_contents(self, enqueuer):
brl = BRLBlock('owner/user/block/branch')
store = Mock(MongoServerStore)
store.read_block_permissions = Mock(
return_value=ElementPermissions(brl, private=False))
p = PublishService(store, 'authUser')
pack = PublishRequest(BlockVersion(brl, -1))
pack.cells.append(SimpleCell('user/block/r1.h'))
pack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
pack.versiontag = 'mytag'
with self.assertRaisesRegexp(PublishException, 'DEV'):
p.publish(pack)
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_add_modify_delete_cell(self):
publish_request = PublishRequest(BlockVersion(self.brl, -1))
publish_request.cells.append(SimpleCell('user/block/r1.h'))
publish_request.cells.append(SimpleCell('user/block/r2.h'))
publish_request.cells.append(SimpleCell('user/block/r3.h'))
publish_request.contents['r1.h'] = Content(id_=None, load=None)
publish_request.tag = STABLE
self.block.add_publication(publish_request)
ids0 = set(self.block.cells.get_all_ids(0).values())
names0 = set(self.block.cells.get_all_ids(0).keys())
expected_ids0 = set([
ID(self.block_id + 0),
ID(self.block_id + 1),
ID(self.block_id + 2)
])
expected_names0 = set(['r1.h', 'r2.h', 'r3.h'])
self.assertEqual(expected_ids0, ids0)
self.assertEqual(expected_names0, names0)
publish_request = PublishRequest(BlockVersion(self.brl, 0))
publish_request.deleted.append('r1.h')
publish_request.cells.append(SimpleCell('user/block/r2.h'))
publish_request.cells.append(SimpleCell('user/block/r4.h'))
publish_request.tag = STABLE
self.block.add_publication(publish_request)
self.assertEqual(expected_ids0, ids0)
self.assertEqual(expected_names0, names0)
prev = self.block.cells.get_all_ids(0)
id3 = prev['r3.h']
expected = set([id3, ID(self.block_id + 3), ID(self.block_id + 4)])
self.assertEqual(expected,
set(self.block.cells.get_all_ids(1).values()))
expected = set(['r4.h', 'r2.h', 'r3.h'])
self.assertEqual(expected, set(self.block.cells.get_all_ids(1).keys()))
self.assertEqual(expected, set(self.block.last_version_cells().keys()))
def publish(self,
brl_block,
resource_info,
version_tag=STABLE,
dep_versions=None):
""" make a simple publication of a single file named block_cell_name to block
brl_block. If block does not exist, it creates it. It mantains coherence of root Ids
for the find checks
param resource_info: {cell_name: (blob, explicits)}
"""
try:
block = self.store.read_block(brl_block)
version = BlockVersion(brl_block, len(block.deltas) - 1)
except NotInStoreException:
version = BlockVersion(brl_block, -1)
publish_request = PublishRequest(version)
publish_request.tag = version_tag
block_name = brl_block.block_name
for cell_name, (blob, dependencies) in resource_info.iteritems():
if dependencies is not None:
cell = SimpleCell(block_name + cell_name)
if isinstance(dependencies, DependencySet):
cell.dependencies = dependencies
else:
cell.dependencies.explicit.update(
[BlockCellName(d) for d in dependencies])
publish_request.cells.append(cell)
if blob is not None:
blob = Blob(blob) if isinstance(blob, str) else blob
publish_request.contents[cell_name] = Content(id_=None,
load=blob)
if isinstance(dep_versions, BlockVersion):
dep_versions = [dep_versions]
publish_request.deptable = BlockVersionTable(dep_versions)
self.service.publish(publish_request)
def diamond_test(self, conflict):
""" Blocks: C
Deps: A, B, D1-D2
C -> A, B; A->D1, B->D2
"""
references = References()
references[va].add('a.h')
references[vb].add('b.h')
b = Resource(SimpleCell('user/blockb/b.h'))
a = Resource(SimpleCell('user/blocka/a.h'))
d1 = Resource(SimpleCell('user/blockd/d.h'))
if conflict:
d2 = Resource(SimpleCell('user/blockd/d.h', CPP))
else:
d2 = Resource(SimpleCell('user/blockd/d.h'))
a.cell.dependencies.explicit.add(d1.name)
b.cell.dependencies.explicit.add(d2.name)
tables = {va: [vd1], vb: [vd2], vd1: [], vd2: []}
api = FakeApi(zip([va, vb, vd1, vd2], [a, b, d1, d2]), tables)
base_table = BlockVersionTable([vc, va, vb])
biiout = OutputStream()
graph, closure, _ = build_closure(api,
references,
base_table,
biiout=biiout)
expected_graph = BlockVersionGraph()
expected_graph.add_nodes([va, vb, vd1, vd2])
expected_graph.add_edge(va, vd1)
expected_graph.add_edge(vb, vd2)
self.assertEqual(expected_graph, graph)
self.assertEqual({a.name, b.name, d1.name}, set(closure.keys()))
if conflict:
self.assertIn('Incompatible dependency "user/blockd/d.h"',
str(biiout))
else:
self.assertEqual("", str(biiout))
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 test_check_publish_block(self):
# 1. Onwer can write the block if its private
brl = BRLBlock("goku/goku/block/master")
self._add_block_to_user("goku", brl, True)
ensure = Security("goku", self.store)
self._subscribe("goku", "enterprise_275_50_x")
pack = PublishRequest(BlockVersion(brl, -1))
pack.cells.append(SimpleCell('user/block/r1.h'))
pack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
pack.versiontag = 'mytag'
ensure.check_publish_block(brl, pack)
# If the owner is not paying he can't write
ensure = Security("goku", self.store)
self._subscribe("goku", "free")
self.assertRaises(ForbiddenException, ensure.check_publish_block, brl, pack)
self._subscribe("goku", "enterprise_275_50_x")
# 1b. But other not granted user can't write
ensure = Security("freezer", self.store)
self._subscribe("freezer", "enterprise_275_50_x")
self.assertRaises(ForbiddenException, ensure.check_publish_block, brl, pack)
# 2. If bulma is granted as administrator or write he can write
ensure = Security("bulma", self.store)
self._subscribe("bulma", "enterprise_275_50_x")
goku = self.store.read_user("goku")
goku.administrators.grant("bulma")
self.store.update_user(goku)
ensure.check_publish_block(brl, pack)
goku.administrators.revoke("bulma")
self.store.update_user(goku)
self.assertRaises(ForbiddenException, ensure.check_publish_block, brl, pack)
bper = ElementPermissions(brl, private=True)
bper.write.grant("bulma")
self.store.upsert_block_permissions(bper)
ensure.check_publish_block(brl, pack)
bper.write.remove("bulma")
self.store.upsert_block_permissions(bper)
self.assertRaises(ForbiddenException, ensure.check_publish_block, brl, pack)
# 3. If we give read permissions only, user cant write
bper = ElementPermissions(brl, private=True)
bper.read.grant("bulma")
self.store.upsert_block_permissions(bper)
self.assertRaises(ForbiddenException, ensure.check_publish_block, brl, pack)
def _process_from_contents(self, contents):
'''param contents: dict{name:code snippets}.
Will create a HiveHolder, fill with the data and process it'''
resources = []
for name, content in contents.iteritems():
cell = SimpleCell(name, CPP)
block_name = cell.name.block_name
resources.append(
Resource(
cell,
Content(name, load=Blob(content), parser=DRLCPPParser())))
block_holder = BlockHolder(block_name, resources)
self._process(block_holder)
return block_holder
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 _publishIndependentCell(self,
block_cell_name,
nVersions=10,
version_tag=None):
'''publishes nVersions of each cell'''
block_brl = self._getBlockBRL(block_cell_name)
for v in range(0, nVersions):
r = SimpleCell(block_cell_name)
pack = PublishRequest(BlockVersion(block_brl, v - 1))
pack.tag = version_tag if version_tag is not None else STABLE
pack.cells.append(r)
pack.deptable = BlockVersionTable()
pack.contents[r.name.cell_name] = Content(
id_=None, load=Blob('hola {0}'.format(v)))
self.service.publish(pack)
def setUp(self):
self.conn.drop_database(self._testMethodName)
self.store = MongoServerStore(self.conn, self._testMethodName)
self.mother = ModelCreator(self.store)
self.user = self.mother.make_test_user()
self.p = PublishService(self.store, self.user.ID)
self.brl = BRLBlock('%s/%s/block/master' %
(self.user.ID, self.user.ID))
pack = PublishRequest(BlockVersion(self.brl, -1))
pack.cells.append(SimpleCell('%s/block/r1.h' % self.user.ID))
pack.cells.append(SimpleCell('%s/block/r2.h' % self.user.ID))
pack.cells.append(SimpleCell('%s/block/r3.h' % self.user.ID))
pack.contents['r1.h'] = Content(id_=None, load=Blob('r1'))
pack.contents['r2.h'] = Content(id_=None, load=Blob('r2'))
pack.contents['r3.h'] = Content(id_=None, load=Blob('r3'))
pack.deptable = BlockVersionTable()
self.pack = pack
self.cell_collection = self.store.db[
GenericServerStore.PUBLISHED_CELL_ST]
self.content_collection = self.store.db[
GenericServerStore.PUBLISHED_CONTENT_ST]
self.block_collection = self.store.db[GenericServerStore.BLOCK_ST]
def commit_config(self):
'''
Returns:
None if the config file didnt change. The config file Resource in case
it was created or modified
'''
new_content = self.config.dumps()
if new_content:
name = self.block_name + BIICODE_FILE
new_res = Resource(SimpleCell(name, TEXT),
Content(name, load=Blob(new_content)))
self.add_resource(new_res)
return new_res
return None
def get_block_holder(block_cell_names, biitype=BiiType(UNKNOWN)):
'''Given a working set, a list of resources and a biitype constant
- Adds every resource to the working set and assign given type
- Read test files from disk as binary or systext depending on given type and creates contents
- Fills a wsHolder with given resources and created contents
'''
resources = []
for name in block_cell_names:
cell = SimpleCell(name, biitype)
content = make_content(name, biitype)
resources.append(Resource(cell, content))
block_name = BlockCellName(iter(block_cell_names).next()).block_name
return BlockHolder(block_name, resources)
def test_has_main_and_dependency_declarations(self):
processor = ParseProcessor()
block_holder = mother.get_block_holder(['user/geom/main.cpp'], CPP)
processor.do_process(block_holder, OutputStream())
main = block_holder['main.cpp'].cell
self.assertTrue(main.hasMain, 'Main method not detected by parse processor')
self.check_dependency_set(main.dependencies, unresolved=['iostream', 'sphere.h'])
# now remove #include
load = block_holder['main.cpp'].content.load.bytes
load = load.replace('#include "sphere.h"', '')
block_holder.add_resource(Resource(SimpleCell('user/geom/main.cpp', CPP),
Content('user/geom/main.cpp', Blob(load))))
processor.do_process(block_holder, OutputStream())
main = block_holder['main.cpp'].cell
self.check_dependency_set(main.dependencies, unresolved=['iostream'])
def test_publish_rejected(self):
store = Mock(MongoServerStore)
user = Mock()
user.blocks = {}
store.read_user = Mock(return_value=user)
block = Mock(Block)
block.add_publication.return_value = (Mock(), Mock())
store.read_block.return_value = block
brl = BRLBlock('user/user/block/branch')
p = PublishService(store, 'authUser')
pack = PublishRequest(BlockVersion(brl, -1))
pack.cells.append(SimpleCell('user/block/r1.h'))
pack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
pack.deptable = BlockVersionTable()
with self.assertRaises(ForbiddenException):
p.publish(pack)
def test_read_published_blocks_info(self, store_cls):
"""Insert a block and read all published blocks info (brl, lastpubdate)"""
if store_cls == MongoServerStore:
store = MongoServerStore(self.conn, self.__class__.__name__)
else:
store = TestingMemServerStore()
block = Block(ID((23, 23)), BRLBlock("bonjovi/bonjovi/itsmylife/master"))
ppack = PublishRequest(block.last_version())
r1 = SimpleCell('user/block/r1.h')
ppack.cells.append(r1)
ppack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
block.add_publication(ppack)
store.create_block(block, False)
ret = store.read_published_blocks_info()
first = ret.next()
self.assertEquals(first[0], "bonjovi/bonjovi/itsmylife/master")
self.assertEquals(first[1].__class__, datetime.datetime)
def checkin_block_files(hive_holder, block_name, files, processor_changes, biiout):
'''
Params:
hive_holder: HiveHolder
block_name: BlockName
files: {cell_name: content}
processor_changes: ProcessorChanges
biiout: biiout
'''
block_name = BlockName(block_name)
types_blobs = obtain_types_blobs(files) # {cell_name: (TYPE, Content/CellType/None)}
# FIXME: What happens if merge result is larger than individual files, reject???
changevalidator.remove_large_cells(types_blobs, biiout)
try:
block_holder = hive_holder[block_name]
except KeyError:
block_holder = BlockHolder(block_name, [])
hive_holder.add_holder(block_holder)
for cell_name, (biitype, blob) in types_blobs.iteritems():
block_cell_name = block_name + cell_name
cell = SimpleCell(block_cell_name, biitype)
try:
resource = block_holder[cell_name]
except KeyError:
content = Content(block_cell_name, load=blob)
processor_changes.upsert(block_cell_name, content)
else:
content = resource.content
if content is None or blob != content.load:
content = Content(block_cell_name, load=blob)
processor_changes.upsert(block_cell_name, content)
resource = Resource(cell, content)
block_holder.add_resource(resource)
for cell_name, resource in block_holder.resources.items():
if cell_name not in types_blobs:
if resource.content is not None:
processor_changes.delete(resource.name)
block_holder.delete_resource(cell_name)
hive_holder.hive.update(processor_changes)
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_simple_edition_cell_with_container(self):
virtual_cell = BlockCellName('user/block/path/file.h')
simpleresource = SimpleCell("user/block/path/to/file.h")
simpleresource.ID = BlockCellName("user/block/path/to/file.h")
simpleresource.root = ID()
simpleresource.dependencies.add_implicit(
BlockCellName("user/block/path/file.h"))
simpleresource.container = virtual_cell
s = simpleresource.serialize()
self.assertEqual(s[Deserializer.POLIMORPHIC_KEYWORD],
ClassTypedSerializer.getValue(SimpleCell))
ob = CellDeserializer(BlockCellName).deserialize(s)
self.assert_bii_equal(ob, simpleresource)
def migrate_block_holder(block_holder, biiout):
""" Necessary for bii-open, that has a different flow to process
"""
block_name = block_holder.block_name
resources = block_holder.resources
files = {
name: resource.content.load.load
for name, resource in resources.iteritems()
if isinstance(resource.cell, SimpleCell)
}
migration = migrate_block_files(block_name, files, biiout)
if migration is None:
return
config_text, block_deleted = migration
for deleted in block_deleted:
block_holder.delete_resource(deleted)
name = block_name + BIICODE_FILE
new_res = Resource(SimpleCell(name, TEXT),
Content(name, load=Blob(config_text)))
block_holder.add_resource(new_res)
def test_duplicated_first_level(self):
brls = {'gtest1': 'dummy/block/include/gtest/gtest.h',
'getest2': 'dummy/block/fused-src/gtest/gtest.h',
'getest-all1': 'dummy/block/fused-src/gtest/gtest-all.cc',
'getest-all2': 'dummy/block/src/gtest-all.cc',
'sample': 'dummy/block/samples/sample_unittest.cc'
}
cells = {x: SimpleCell(x) for x in brls.values()}
cells_names = [x.name.cell_name for x in cells.itervalues()]
block_holder = self._cells_setup('dummy/block', cells_names, CPP)
getest_all1 = block_holder['fused-src/gtest/gtest-all.cc'].cell
getest_all1.dependencies.unresolved = {CPPDeclaration('gtest.h')}
getest_all2 = block_holder['src/gtest-all.cc'].cell
getest_all2.dependencies.unresolved = {CPPDeclaration('gtest.h')}
sample = block_holder['samples/sample_unittest.cc'].cell
sample.dependencies.unresolved = {CPPDeclaration('gtest.h')}
process_holder(block_holder, DependenciesProcessor())
# Checks
self.assertEquals(0, len(getest_all1.dependencies.unresolved))
self.assertEquals(1, len(getest_all2.dependencies.unresolved))
self.assertEquals(1, len(sample.dependencies.unresolved))
def test_duplicated_n_level(self):
brls = {'gtest1': 'dummy/block/a1/b/c/gtest/gtest.h',
'getest2': 'dummy/block/a2/gtest/gtest.h',
'getest-all1': 'dummy/block/a1/gtest-all.cc',
'getest-all2': 'dummy/block/a3/gtest-all.cc',
'getest-all3': 'dummy/block/a1/b2/gtest-all.cc',
}
cells = {x: SimpleCell(x) for x in brls.values()}
cells_names = [x.name.cell_name for x in cells.itervalues()]
block_holder = self._cells_setup('dummy/block', cells_names, CPP)
getest_all1 = block_holder['a1/gtest-all.cc'].cell
getest_all1.dependencies.unresolved = {CPPDeclaration('b/c/gtest/gtest.h')}
getest_all2 = block_holder['a3/gtest-all.cc'].cell
getest_all2.dependencies.unresolved = {CPPDeclaration('gtest.h')}
getest_all3 = block_holder['a1/b2/gtest-all.cc'].cell
getest_all3.dependencies.unresolved = {CPPDeclaration('../b/c/gtest/gtest.h')}
process_holder(block_holder, DependenciesProcessor())
# Checks
self.assertEquals(0, len(getest_all1.dependencies.unresolved))
self.assertEquals(1, len(getest_all2.dependencies.unresolved))
self.assertEquals(0, len(getest_all3.dependencies.unresolved))
def test_include_partial(self):
brls = {'main': 'dummy/block/main.cpp',
'astar': 'dummy/block/algorithms/astar.h',
'solver_h': 'dummy/block/solver/solver.h',
'solver_cpp': 'dummy/block/solver/solver.cpp'
}
cells = {x: SimpleCell(x) for x in brls.values()}
cells_names = [x.name.cell_name for x in cells.itervalues()]
block_holder = self._cells_setup('dummy/block', cells_names, CPP)
main = block_holder['main.cpp'].cell
main.dependencies.unresolved = {CPPDeclaration('solver/solver.h')}
solver_h = block_holder['solver/solver.h'].cell
solver_h.dependencies.unresolved = {CPPDeclaration('../algorithms/astar.h')}
solver_cpp = block_holder['solver/solver.cpp'].cell
solver_cpp.dependencies.unresolved = {CPPDeclaration('solver.h')}
process_holder(block_holder, DependenciesProcessor())
# Checks
self.assertEquals(set(), cells[brls['main']].dependencies.unresolved)
self.assertEquals(set(), cells[brls['solver_h']].dependencies.unresolved)
self.assertEquals(set(), cells[brls['solver_cpp']].dependencies.unresolved)
def get_holder(self):
contents = self.read_edition_contents()
# creation of cells
cells = {name: SimpleCell(name) for name in contents}
hive_holder = HiveHolder(cells, contents)
return hive_holder
def make_simple_cell(block_cell_name):
if isinstance(block_cell_name, basestring):
block_cell_name = BlockCellName(block_cell_name)
cell = SimpleCell(block_cell_name)
cell.type = BiiType.from_extension(block_cell_name.extension)
return cell
def test_publish(self, enqueuer):
brl = BRLBlock('owner/user/block/branch')
# moduleID=BlockID(UserID(123),456)
store = Mock(MongoServerStore)
store.read_block_permissions = Mock(
return_value=ElementPermissions(brl, private=False))
user = User("owner")
user.numeric_id = 1
user.blocks = {}
store.read_user = Mock(return_value=user)
block = Mock(Block)
block.last_version.return_value = Mock(BlockVersion)
block.add_publication.return_value = (Mock(list), Mock(list),
Mock(list), Mock(list))
block.deltas = []
ensure = Security('authUser', store)
ensure.check_create_block = Mock(return_value=True)
ensure.check_write_block = Mock(return_value=True)
ensure.check_read_block = Mock(return_value=True)
store.read_block.return_value = block
store.read_published_cells.return_value = {}
p = PublishService(store, 'authUser')
p.security = ensure
pack = PublishRequest(BlockVersion(brl, -1))
pack.cells.append(SimpleCell('user/block/r1.h'))
pack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
pack.cells.append(SimpleCell('user/block/r2.h'))
pack.contents['r2.h'] = Content(id_=None, load=Blob('hola'))
pack.cells.append(SimpleCell('user/block/r3.h'))
pack.contents['r3.h'] = Content(id_=None, load=Blob('hola'))
pack.deptable = BlockVersionTable()
p.publish(pack)
block.add_publication.assert_called_once_with(pack, p.auth_user)
store.update_block.assert_called_once_with(block)
self.assertEqual(1, store.create_published_cells.call_count)
self.assertEqual(1, store.create_published_contents.call_count)
# Check sizes
self.assertEquals(user.blocks_bytes, 12) # 12 bytes "hola" * 3
# Publish again, see the size incremented
pack._bytes = None # Lazy computed
p.publish(pack)
self.assertEquals(user.blocks_bytes,
24) # 24 bytes: "hola" * 3 * 2 publications
# Max size exceeded for user
user.max_workspace_size = 25
self.assertRaises(ForbiddenException, p.publish, pack)
# Try to publish only 1 byte
pack._bytes = None # Lazy computed
pack.cells = []
pack.contents = {}
pack.cells.append(SimpleCell('user/block/r1.h'))
pack.contents['r1.h'] = Content(id_=None, load=Blob('h'))
p.publish(pack)
def make_simple_cell(block_cell_name):
if isinstance(block_cell_name, basestring):
block_cell_name = BlockCellName(block_cell_name)
cell = SimpleCell(block_cell_name)
cell.type = BiiType.from_extension(block_cell_name.extension)
return cell
