def test_tag_policy_update(self):
for i, tag in enumerate([BETA, ALPHA, DEV]):
# Do not update
request = self.build_update_request(BlockVersion(self.brl, i), self.name)
result = self.service.find(request, BiiResponse())
self.check_result(result)
# update
request.policy = Policy.loads("*: %s" % tag)
result = self.service.find(request, BiiResponse())
self.check_result(result, updated=[(self.brl, i + 1, {self.name})])
def test_bii_response(self):
m = BiiResponse()
m.debug("Manamana tu tu tururu")
m.info("Info bla bla bla")
m.warn("Doh!!")
m.error("Mhhhhh")
s = serialize(m)
#print str(s)
m2 = BiiResponse.deserialize(s)
#print str(m2)
#print str(m2.serialize())
self.assertEqual(m, m2)
def test_find_two_files_at_a_time(self):
"""Starts with one include, finds it, then two more includes, finish when all are found.
Found items are taken into account in FindRequest.existing
"""
NUM_FILES = 10
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
names_a = [
BlockCellName(self.user + "/blocka/a%d.h" % i)
for i in range(NUM_FILES)
]
resources_info = {"a%d.h" % i: ("a", []) for i in range(NUM_FILES)}
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, resources_info)
# Use the same request object, to accumulate existing (already found) files
request = FinderRequest()
request.policy = Policy.default()
version = BlockVersion(brl_a, 0) # The version is always the same
for i in range(0, NUM_FILES, 2):
declaration1 = CPPDeclaration(names_a[i])
declaration2 = CPPDeclaration(names_a[i + 1])
request.unresolved = {declaration1, declaration2}
result = self.service.find(request, BiiResponse())
self.check_result(result,
resolved=[(brl_a, 0,
{names_a[i], names_a[i + 1]})])
# The found one is added to the existing, for next iteration
request.existing[version][declaration1] = {names_a[i]}
request.existing[version][declaration2] = {names_a[i + 1]}
self.assertEqual(len(request.existing[version]), i + 2)
def test_diamond_single_solution(self):
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
brl_c = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockc'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
for _ in range(20):
publisher.publish(brl_a, {'a.h': ('a', [])})
name_b = BlockCellName(self.user + "/blockb/b.h")
name_c = BlockCellName(self.user + "/blockc/c.h")
for i in range(0, 20):
if i % 2 == 0:
publisher.publish(brl_b, {'b.h': ('b', [name_a])},
dep_versions=BlockVersion(brl_a, i))
if (i % 2 == 1 or i == 10):
publisher.publish(brl_c, {'c.h': ('c', [name_a])},
dep_versions=BlockVersion(brl_a, i))
request = self.build_unresolved_request([name_b, name_c])
result = self.service.find(request, BiiResponse())
self.check_result(result,
resolved=[(brl_b, 5, {name_b}),
(brl_c, 5, {name_c})])
def decode_return_content(res, response=None):
if 'content-type' in res.headers and res.headers['content-type'] == "application/bson":
tmp = decode_bson(res.content)
if response is not None:
response_server = BiiResponse.deserialize(tmp["info"])
response_server.biiout(response)
return tmp["return"]
else:
return res.content
def decode_return_content(res, response=None):
if 'content-type' in res.headers and res.headers[
'content-type'] == "application/bson":
tmp = decode_bson(res.content)
if response is not None:
response_server = BiiResponse.deserialize(tmp["info"])
response_server.biiout(response)
return tmp["return"]
else:
return res.content
def test_tag_policy_find(self):
""" change tag policy to find BETA and DEV """
request = self.build_unresolved_request(self.name)
request.policy = Policy.loads("*: BETA")
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(self.brl, 1, {self.name})])
request = self.build_unresolved_request(self.name)
request.policy = Policy.loads("*: ALPHA")
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(self.brl, 2, {self.name})])
request = self.build_unresolved_request(self.name)
request.policy = Policy.loads("*: DEV")
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(self.brl, 3, {self.name})])
request = self.build_unresolved_request(self.name)
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(self.brl, 0, {self.name})])
def test_simple_find(self):
'''Test including a single block with 1 file 1 version without further dependencies,
always last version
'''
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
for i in range(4):
publisher.publish(brl_a, {'a.h': ('a', [])})
# self.publish(brl_a, name_a)
request = self.build_unresolved_request(name_a)
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(brl_a, i, {name_a})])
def test_disallow_cycles(self):
""" a find cannot return a block that is already in the src blocks of the hive """
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, {'a.h': ('a', [])})
request = self.build_unresolved_request(name_a)
request.block_names.add(name_a.block_name)
response = BiiResponse()
result = self.service.find(request, response)
# TODO: return a message to user saying that it is because a cycle
self.assertIn('No block candidates found', str(response))
self.check_result(result, unresolved=request.unresolved)
def testFinderCompatibleTest(self):
''' Generates compatible problem critical in the last two versions '''
last_block = self._biigraph.get_num_blocks() - 1
self._biigraph.make_independent(last_block, last_block - 1)
t = self._biigraph._get_range_block(last_block - 2)
self._biigraph.make_dependent(last_block, t[0])
self._biigraph.make_dependent(last_block - 1, t[0])
self._publish_graph()
# Solve
request = self._unresolvedDependencyRequest(self.lbcn)
result = self.service.find(request, BiiResponse())
self.assertEqual(len(self.lbcn), len(result.resolved))
def test_find_transitive(self):
'''Test including a block with other dependencies, without conflicts '''
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, {'a.h': ('a', [])})
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
name_b = BlockCellName(self.user + "/blockb/b.h")
#self.publish(brl_b, name_b, deps={name_b: name_a}, dep_versions=BlockVersion(brl_a, 0))
publisher.publish(brl_b, {'b.h': ('b', [name_a])},
dep_versions=BlockVersion(brl_a, 0))
request = self.build_unresolved_request(name_b)
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(brl_b, 0, {name_b})])
def test_simple_update(self):
'''Test finding updates in a simple block with 1 file with no more dependencies '''
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, {'a.h': ('a', [])})
#self.publish(brl_a, name_a)
for i in range(1, 10):
time.sleep(0.05)
publisher.publish(brl_a, {'a.h': ('a', [])})
#self.publish(brl_a, name_a)
request = self.build_update_request(BlockVersion(brl_a, i - 1),
name_a)
result = self.service.find(request, BiiResponse())
ref_updated = [(brl_a, i, {name_a})]
self.check_result(result, updated=ref_updated)
def wrapper(*args, **kwargs):
'''Capture possible exceptions to manage the return'''
logger.info("Called: %s" % (str(callback.__name__)))
# Add the parameter handle as a keyword argument.
try:
if "response" in inspect.getargspec(context.callback)[0]:
biiresponse = BiiResponse()
kwargs["response"] = biiresponse
else:
biiresponse = None
return_value = callback(
*args, **kwargs) # kwargs has :xxx variables from url
return self.prepare_response(return_value, biiresponse)
except HTTPResponse:
raise # Normal response!!!!
except Exception as exc:
message, code = get_message_and_code_from_exception(exc)
return self.abort_response(code, message, biiresponse)
def test_files_from_different_blocks(self):
"""This test solves the bug that appeared when user included 2 different headers
from different blocks A, B, such A->B, and the files included were not modified among
different versions.
The problem was the finder discarding subsequent hypothesis because it thought they will
be the same based on ids (cells, contents) and dep_table. This is not true, they might
not have changed, but their dependencies have changed, so every block_version must have
it's own hypothesis
"""
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
names = [
BlockCellName(self.user + "/blocka/path/to/a%d.h" % i)
for i in range(1, 3)
]
resources_info = {
"path/to/a%d.h" % i: ("a", [names[0]] if i == 2 else [])
for i in range(1, 3)
}
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, resources_info)
version_a0 = BlockVersion(brl_a, 0)
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
publisher.publish(brl_b, {'path/to/b.h': ('b', [names[1]])},
dep_versions=version_a0)
# publish 2 versions more of B, with a new file b2
for i in range(2):
publisher.publish(brl_b, {'path/to/b2.h': ('b', [])},
dep_versions=version_a0)
#publish a new A version, changing file a1
publisher.publish(brl_a, {'path/to/a1.h': ('a', [])})
request = self.build_unresolved_request(
['find_user/blocka/path/to/a2.h', 'find_user/blockb/path/to/b.h'])
result = self.service.find(request, BiiResponse())
self.check_result(result,
resolved=[
(brl_a, 0, {'find_user/blocka/path/to/a2.h'}),
(brl_b, 2, {'find_user/blockb/path/to/b.h'})
])
def test_disallow_cycles_transitive(self):
""" A find must not find any block name that is in the current src blocks, even
transitively.
"""
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, {'a.h': ('a', [])})
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
name_b = BlockCellName(self.user + "/blockb/b.h")
publisher.publish(brl_b, {'b.h': ('b', [name_a])},
dep_versions=BlockVersion(brl_a, 0))
request = self.build_unresolved_request(name_b)
request.block_names.add(name_a.block_name)
response = BiiResponse()
result = self.service.find(request, response)
self.assertIn("Can't find a compatible solution", str(response))
self.assertIn('it has cycles', str(response))
self.check_result(result, unresolved=request.unresolved)
def testFinderIncompatibleTest(self):
''' 'Generates incompatible problem with consistent closures '''
last_block = self._biigraph.get_num_blocks() - 1
self._biigraph.make_independent(last_block, last_block - 1)
t = self._biigraph._get_range_block(last_block - 2)
self._biigraph.make_dependent(last_block, t[0])
self._biigraph.make_dependent(last_block - 1, t[0] + 1)
self._publish_graph()
# Solve (profile code has been commented)
request = self._unresolvedDependencyRequest(self.lbcn)
# DigraphTest.pr.enable()
result = self.service.find(request, BiiResponse())
# DigraphTest.pr.disable()
# s = io.FileIO('C:/Users/pablo/Desktop/profile.txt','w')
# ps = pstats.Stats(DigraphTest.pr, stream=s)
# ps.strip_dirs().sort_stats(-1).print_stats()
# s.close()
logger.debug('\n-------------Finder result-----------------------\n')
logger.debug(result.resolved)
self.assertEqual(0, len(result.resolved))
def test_bii_response(self):
m = BiiResponse()
m.debug("Manamana tu tu tururu")
m.info("Info bla bla bla")
m.warn("Doh!!")
m.error("Mhhhhh")
s = serialize(m)
#print str(s)
m2 = BiiResponse.deserialize(s)
#print str(m2)
#print str(m2.serialize())
self.assertEqual(m, m2)
