def get_renames(auth_user, bson_data):
service = BiiService(app.store, auth_user)
# Don t want a set, want a list
block = BRLBlock.deserialize(bson_data["block"])
t1 = bson_data["t1"]
t2 = bson_data["t2"]
return service.get_renames(block, t1, t2)
def find(auth_user, bson_data, response):
service = BiiService(app.store, auth_user)
# TODO: Remove this try except when next incompatible version
try:
finder_request = FinderRequest.deserialize(bson_data["data"])
except KeyError: # Keep some retro-compatibility with old policies format
bson_data["data"][FinderRequest.SERIAL_POLICY] = Policy.default().serialize()
finder_request = FinderRequest.deserialize(bson_data["data"])
response.warn("Detected deprecated policy format (version < 2.7),"
"discarding them. Update biicode!")
return service.find(finder_request, response)
def setUp(self):
""" all find tests have a user, store, and BiiService """
self.user = BRLUser('find_user')
self.store = TestingMemServerStore()
user = User(self.user)
user.password = '******'
self.store.create_user(user)
self.service = BiiService(self.store, self.user)
class TestPublisher(object):
def __init__(self, brl_user, store):
self.brl_user = brl_user
self.store = store
self.service = BiiService(self.store, self.brl_user)
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)
class BaseDigraphTest(TestWithMongo):
def _initUser(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
def _getBlockCellNames(self, dim):
'''generates names from dim list'''
bcns = [
BlockCellName(self.testUser.ID + '/module%s/cell%s' % (i, i))
for i in range(len(dim))
]
return bcns
def _getBlockBRL(self, block_cell_name):
return BRLBlock('{0}/{1}/master'.format(self.testUser.ID,
block_cell_name.block_name))
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 _unresolvedDependencyRequest(self, unresolved_deps):
request = FinderRequest()
unresolved = set()
for dep in unresolved_deps:
unresolved.add(CPPDeclaration(dep))
request.unresolved = unresolved
request.policy = Policy.default()
return request
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)
class TestPublisher(object):
def __init__(self, brl_user, store):
self.brl_user = brl_user
self.store = store
self.service = BiiService(self.store, self.brl_user)
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)
class BaseDigraphTest(TestWithMongo):
def _initUser(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
def _getBlockCellNames(self, dim):
'''generates names from dim list'''
bcns = [BlockCellName(self.testUser.ID + '/module%s/cell%s' % (i, i))
for i in range(len(dim))]
return bcns
def _getBlockBRL(self, block_cell_name):
return BRLBlock('{0}/{1}/master' .format(self.testUser.ID, block_cell_name.block_name))
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 _unresolvedDependencyRequest(self, unresolved_deps):
request = FinderRequest()
unresolved = set()
for dep in unresolved_deps:
unresolved.add(CPPDeclaration(dep))
request.unresolved = unresolved
request.policy = Policy.default()
return request
class BiiApiTest(TestWithMongo):
_multiprocess_shared_ = True
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
def test_get_cells_snapshot_invalid_version(self):
b = self.mother.make_block(self.testUser)
version = BlockVersion(block=b.ID, time=1)
self.assertRaises(NotFoundException, self.service.get_cells_snapshot, version)
def testNotFoundExceptions(self):
self.assertRaises(NotFoundException, self.service.get_cells_snapshot,
BlockVersion('user/user/block/master', 3))
def test_get_version_by_tag(self):
brl_block = BRLBlock('%s/%s/TestBlock/master' % (self.testUser.ID, self.testUser.ID))
publish_request = PublishRequest(BlockVersion(brl_block, -1))
publish_request.tag = STABLE
publish_request.versiontag = 'mytag'
publish_request.cells.append(SimpleCell(brl_block.block_name + 'r1.h'))
publish_request.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
publish_request.deptable = BlockVersionTable()
self.service.publish(publish_request)
publish_request = PublishRequest(BlockVersion(brl_block, 0, 'mytag'))
publish_request.tag = STABLE
publish_request.versiontag = 'mytag'
publish_request.cells.append(SimpleCell(brl_block.block_name + 'r12.h'))
publish_request.contents['r2.h'] = Content(id_=None, load=Blob('hola'))
publish_request.deptable = BlockVersionTable()
self.service.publish(publish_request)
block_version = self.service.get_version_by_tag(brl_block, 'mytag')
self.assertEquals(1, block_version.time)
def test_tag_nofound(self):
brl_block = BRLBlock('%s/%s/TestBlock/master' % (self.testUser.ID, self.testUser.ID))
with self.assertRaises(NotFoundException):
self.service.get_version_by_tag(brl_block, 'mytag')
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 test(http_basic_credentials, bson_data, response):
"""DEPRECATED, FOR ALERT USERS FOR UPDATING CLIENT. DELETE IN 2015 OR 1.1"""
service = BiiService(app.store, http_basic_credentials.user)
server_info = service.get_server_info()
return server_info
def diff(auth_user, bson_data):
service = BiiService(app.store, auth_user)
baseVersion = BlockVersion.deserialize(bson_data["base"])
otherVersion = BlockVersion.deserialize(bson_data["other"])
return service.compute_diff(baseVersion, otherVersion)
def __init__(self, brl_user, store):
self.brl_user = brl_user
self.store = store
self.service = BiiService(self.store, self.brl_user)
def require_auth(auth_user):
service = BiiService(app.store, auth_user)
return service.require_auth()
def get_version_delta_info(auth_user, owner_name=None, block_name=None, branch_name=None,
version=None):
brl = BRLBlock(owner_name + "/" + block_name + "/" + branch_name)
version = BlockVersion(brl, version)
service = BiiService(app.store, auth_user)
return service.get_version_delta_info(version)
class PublishServiceTest(unittest.TestCase):
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)
@patch.object(Enqueuer, "enqueue_job")
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)
@patch.object(Enqueuer, "enqueue_job")
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)
@patch.object(Enqueuer, "enqueue_job")
def test_publish_dev_with_tag(self, enqueuer):
brl = BRLBlock('owner/user/block/branch')
store = Mock(MongoServerStore)
store.read_block_permissions = Mock(
return_value=ElementPermissions(brl, private=False))
user = Mock()
user.blocks = {}
store.read_user = Mock(return_value=user)
block = Mock(Block)
block.add_publication.return_value = (['mock_id'], [], [], [])
block.deltas = []
ensure = Security('authUser', store)
ensure.check_read_block = Mock(return_value=True)
ensure.check_create_block = Mock(return_value=True)
ensure.check_write_block = Mock(return_value=True)
ensure.check_publish_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.deptable = BlockVersionTable()
p.publish(pack)
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 get_version_info_test(self):
store = Mock(GenericServerStore)
# Block doesn't exist and user is other
p = PublishService(store, 'any_user')
block_brl = BRLBlock("user/user/theblock/master")
store.read_block_permissions = Mock(side_effect=NotInStoreException())
block_info = p.get_block_info(block_brl)
self.assertFalse(block_info.can_write)
# Now block exists
store.read_block_permissions = Mock(
return_value=ElementPermissions(block_brl))
# Block exists and user is the authorized one
p = PublishService(store, 'theuser')
block_brl = BRLBlock("theuser/theuser/theblock/master")
block_info = p.get_block_info(block_brl)
self.assertTrue(block_info.can_write)
# No authorized write to an existing block
p = PublishService(store, 'wronguser')
user = Mock(User)
user.administrators = Permissions()
store.read_user = Mock(return_value=user)
block_info = p.get_block_info(block_brl)
self.assertFalse(block_info.can_write)
# Authorized user with an existing block
p = PublishService(store, 'theuser')
block_brl = BRLBlock("theuser/theuser/theblock/master")
block_info = p.get_block_info(block_brl)
self.assertTrue(block_info.can_write)
def authenticate(http_basic_credentials): # Required http_basic_authentication_bottle_plugin
""" http_basic_credentials are not checked, only parsed from request"""
service = BiiService(app.store, None)
return service.authenticate(http_basic_credentials.user,
http_basic_credentials.password)
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
def __init__(self, brl_user, store):
self.brl_user = brl_user
self.store = store
self.service = BiiService(self.store, self.brl_user)
class PublishServiceTest(unittest.TestCase):
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)
@patch.object(Enqueuer, "enqueue_job")
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)
@patch.object(Enqueuer, "enqueue_job")
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)
@patch.object(Enqueuer, "enqueue_job")
def test_publish_dev_with_tag(self, enqueuer):
brl = BRLBlock('owner/user/block/branch')
store = Mock(MongoServerStore)
store.read_block_permissions = Mock(return_value=ElementPermissions(brl, private=False))
user = Mock()
user.blocks = {}
store.read_user = Mock(return_value=user)
block = Mock(Block)
block.add_publication.return_value = (['mock_id'], [], [], [])
block.deltas = []
ensure = Security('authUser', store)
ensure.check_read_block = Mock(return_value=True)
ensure.check_create_block = Mock(return_value=True)
ensure.check_write_block = Mock(return_value=True)
ensure.check_publish_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.deptable = BlockVersionTable()
p.publish(pack)
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 get_version_info_test(self):
store = Mock(GenericServerStore)
# Block doesn't exist and user is other
p = PublishService(store, 'any_user')
block_brl = BRLBlock("user/user/theblock/master")
store.read_block_permissions = Mock(side_effect=NotInStoreException())
block_info = p.get_block_info(block_brl)
self.assertFalse(block_info.can_write)
# Now block exists
store.read_block_permissions = Mock(return_value=ElementPermissions(block_brl))
# Block exists and user is the authorized one
p = PublishService(store, 'theuser')
block_brl = BRLBlock("theuser/theuser/theblock/master")
block_info = p.get_block_info(block_brl)
self.assertTrue(block_info.can_write)
# No authorized write to an existing block
p = PublishService(store, 'wronguser')
user = Mock(User)
user.administrators = Permissions()
store.read_user = Mock(return_value=user)
block_info = p.get_block_info(block_brl)
self.assertFalse(block_info.can_write)
# Authorized user with an existing block
p = PublishService(store, 'theuser')
block_brl = BRLBlock("theuser/theuser/theblock/master")
block_info = p.get_block_info(block_brl)
self.assertTrue(block_info.can_write)
def get_server_info(auth_user, bson_data):
"""bson_data is currently used only for log user client version etc
in statistic trough bii_user_trace bottle plugin"""
service = BiiService(app.store, auth_user)
server_info = service.get_server_info()
return server_info
def get_block_info(auth_user, owner_name=None, block_name=None, branch_name=None):
service = BiiService(app.store, auth_user)
brl_block = BRLBlock(owner_name + "/" + block_name + "/" + branch_name)
return service.get_block_info(brl_block)
def publish(auth_user, bson_data):
service = BiiService(app.store, auth_user)
publish_request = PublishRequest.deserialize(bson_data["data"])
return service.publish(publish_request)
def get_version_by_tag(auth_user, owner_name=None, block_name=None, branch_name=None, tag=None):
brl = BRLBlock(owner_name + "/" + block_name + "/" + branch_name)
service = BiiService(app.store, auth_user)
return service.get_version_by_tag(brl, tag)
def get_dep_table(auth_user, owner_name=None, block_name=None, version=None, branch_name=None):
service = BiiService(app.store, auth_user)
brlBlock = BRLBlock(owner_name + "/" + block_name + "/" + branch_name)
blockversion = BlockVersion(brlBlock, version)
return service.get_dep_table(blockversion)
def get_published_resources(auth_user, bson_data):
service = BiiService(app.store, auth_user)
references = References.deserialize(bson_data["data"])
return service.get_published_resources(references)
def get_cells_snapshot(auth_user, bson_data):
"""Get all cell names from a specific BlockVersion"""
service = BiiService(app.store, auth_user)
blockversion = BlockVersion.deserialize(bson_data["data"])
return service.get_cells_snapshot(blockversion)
