def setUp(self):
unittest.TestCase.setUp(self)
self.store = TestingMemServerStore()
self.store.create_user(User("goku"))
self.store.create_user(User("krilin"))
self.store.create_user(User("freezer"))
self.store.create_user(User("bulma"))
self.public_brl = BRLBlock("goku/goku/block/ballno1")
bper = ElementPermissions(self.public_brl, private=False)
self.store.upsert_block_permissions(bper)
goku = self.store.read_user("goku")
goku.add_block(self.public_brl)
self.store.update_user(goku)
def test_basic(self):
store = TestingMemServerStore()
brl_user = '******'
store.create_user(User(brl_user))
brl_block = BRLBlock('user/user/block/master')
publisher = TestPublisher(brl_user, store)
publisher.publish(
brl_block, {
'r1.h': ('r1', ['user/block/r2.h']),
'r2.h': ('r2', []),
'r3.h': ('r3', [])
})
store = MemServerStore(store)
translator = ReferenceTranslatorService(store, brl_user)
ver = BlockVersion(brl_block, 0)
missing = References()
missing[ver].add('r1.h')
closure = CompatibilityClosure(missing)
full_graph = BlockVersionGraph()
full_graph.add_nodes([ver])
build_compatibility_closure(translator, closure, {ver}, full_graph)
self.assertEqual(References(), closure.broken)
expected = set()
expected.add('user/block/r1.h')
expected.add('user/block/r2.h')
self.assertEqual(expected, closure.block_cell_names)
def setUp(self):
unittest.TestCase.setUp(self)
self.user = User("laso")
self.user.password = "******"
self.user.numeric_id = ID((22, ))
self.user.firstname = "Jose"
self.user.lastname = "Gomez"
self.user.country = "ES"
self.user.description = "Developer"
self.user.email = "*****@*****.**"
self.user.visible_email = True
self.user.allow_mailing = True
self.user.active = True
self.user.staff = False
self.user.joined_date = UtcDatetime.get_current_utc_datetime()
self.user.last_api_call = UtcDatetime.get_current_utc_datetime()
self.user.add_block(BRLBlock("laso/laso/block/master"), ["arduino"])
# Profile fields
self.user.street_1 = "Melancolia Street"
self.user.street_2 = "123"
self.user.city = "Madrid"
self.user.postal_code = "28027"
self.user.region = "Madrid"
self.user.vat = "B81884306"
self.user.tax_id = "ESB81884306"
self.utc_datetime = UtcDatetime.deserialize(datetime.datetime.now())
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)
def make_test_user(self):
uid = self._db.generate_user_id()
name = BRLUser('TestUser%d' % uid)
user = User(name)
user.password = '******'
user.active = True
self._db.create_user(user, uid)
return user
def test_login_and_register(self):
# User exists with same token, url must be login url
uid, brl_user = self.store.generate_non_persistent_user()
managers = {
"google": MockOAuthManager("google", brl_user),
"github": MockOAuthManager("github", brl_user)
}
oauth_service = OAuthService(self.store, managers)
user = User(brl_user)
user.oauth_google_token = "ACCESS_TOKEN_google_%s" % brl_user
self.store.create_user(user, uid)
state_string = generate_state_string("google")
url = oauth_service.handle_register_or_login(state_string, "somecode")
self.assertIn("/accounts/login?", url)
# User exists but not token, just email, so user is saved
# with access token and go to login
uid, brl_user = self.store.generate_non_persistent_user()
managers = {
"google": MockOAuthManager("google", brl_user),
"github": MockOAuthManager("github", brl_user)
}
oauth_service = OAuthService(self.store, managers)
user = User(brl_user)
user.email = "*****@*****.**" % brl_user
self.store.create_user(user, uid)
state_string = generate_state_string("github")
url = oauth_service.handle_register_or_login(state_string, "somecode")
user = self.store.read_user(brl_user)
self.assertEquals(user.oauth_github_token,
"ACCESS_TOKEN_github_%s" % brl_user)
self.assertIn("/accounts/login?", url)
# User NO NOT exist (token nor email are found)
# with access token and go to register page
managers = {
"google": MockOAuthManager("google", "fakeuser"),
"github": MockOAuthManager("github", "fakeuser")
}
oauth_service = OAuthService(self.store, managers)
state_string = generate_state_string("github")
url = oauth_service.handle_register_or_login(state_string, "somecode")
self.assertIn("/accounts/signup?access_token=ACCESS_TOKEN_github", url)
self.assertIn("provider=github", url)
def test_performance_breadth(self):
store = MongoServerStore(self.conn, self.__class__.__name__)
store.create_user(User("user2"))
publisher = TestPublisher("user2", store)
brl_block = BRLBlock('user2/user2/block/master')
count = 1000
resource_info = {}
for i in xrange(count):
deps = DependencySet()
if i > 0:
deps = DependencySet()
for j in range(max(0, i - 25), i):
deps.explicit.add(BlockCellName('user2/block/cell%d.h' %
j))
deps.resolved.add(
CPPDeclaration('user2/block/cell%d.h' % j))
deps.unresolved.add(CPPDeclaration('path/to/file.h'))
deps.implicit.add(BlockCellName('user2/block/cell%d.h' % j))
resource_info['cell%d.h' % i] = 'content %d' % i, deps
publisher.publish(brl_block, resource_info)
timer = self.get_timer()
start_time = timer()
store = MemServerStore(store)
#print 'MEMSTORE SIZE 0', asizeof(store) / 1000000.0
translator = ReferenceTranslatorService(store, "user2")
version = BlockVersion(brl_block, 0)
missing = References()
missing[version].add('cell%d.h' % (count - 1))
closure = CompatibilityClosure(missing)
full_graph = BlockVersionGraph()
full_graph.add_nodes([version])
build_compatibility_closure(translator, closure, [version], full_graph)
elapsed_time = timer() - start_time
#print 'Closure time', elapsed_time
#print 'CLOSURE SIZE ', asizeof(closure) / 1000000.0
#print 'MEMSTORE SIZE ', asizeof(store) / 1000000.0
# print 'MINCELLS SIZE ', asizeof(store.min_cells)/1000000.0
self.assertEqual({brl_block.block_name + c
for c in resource_info}, closure.block_cell_names)
self.assertLess(elapsed_time, 7)
def test_change_subscription(self):
# Create users for test
self.store.create_user(User("cooper"))
ensure = Security("cooper", self.store)
self._subscribe("cooper", "startup_35_5_x")
# Coop has a private block
private_brl = BRLBlock("cooper/cooper/private_block/master")
self._add_block_to_user("cooper", private_brl, True)
for tmp in xrange(4):
new_user = BRLUser("user%s" % tmp)
ensure.check_grant_read_or_write_permissions_to(new_user, private_brl)
bper = self.store.read_block_permissions(private_brl)
bper.write.grant(new_user)
self.store.upsert_block_permissions(bper)
# Try to downgrade to personal plan
with self.assertRaisesRegexp(ForbiddenException, "You are currently using 4 users, "
"reduce to 1 before plan downgrade"):
ensure.check_can_change_current_subscription("cooper", "personal_7_1_x")
# Remove collaborators to 1
for tmp in xrange(3):
new_user = BRLUser("user%s" % tmp)
ensure.check_grant_read_or_write_permissions_to(new_user, private_brl)
bper = self.store.read_block_permissions(private_brl)
bper.write.revoke(new_user)
self.store.upsert_block_permissions(bper)
# Try to downgrade to personal plan
ensure.check_can_change_current_subscription("cooper", "personal_7_1_x")
# Try to downgrade to free plan
with self.assertRaisesRegexp(ForbiddenException, "You are currently using 1 users, "
"reduce to 0 before plan downgrade"):
ensure.check_can_change_current_subscription("cooper", "free")
# Remove last collaborator
bper = self.store.read_block_permissions(private_brl)
bper.write.revoke("user3")
self.store.upsert_block_permissions(bper)
with self.assertRaisesRegexp(ForbiddenException, "You have 1 private blocks, "
"reduce it to 0 before plan downgrade"):
ensure.check_can_change_current_subscription("cooper", "free")
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_performance_depth(self):
brl_user = '******'
store = MongoServerStore(self.conn, self.__class__.__name__)
store.create_user(User(brl_user))
publisher = TestPublisher(brl_user, store)
brl_block = BRLBlock('user/user/block/master')
count = 500
resource_info = {
'cell%d.h' % i:
('content %d' % i, ['user/block/cell%d.h' % (i - 1)] if i else [])
for i in range(count)
}
publisher.publish(brl_block, resource_info)
timer = self.get_timer()
start_time = timer()
# prof = cProfile.Profile()
# prof.enable()
store = MemServerStore(store)
# print 'MEMSTORE DEPTH SIZE 0', asizeof(store) / 1000000.0
translator = ReferenceTranslatorService(store, brl_user)
version = BlockVersion(brl_block, 0)
missing = References()
missing[version].add('cell%d.h' % (count - 1))
closure = CompatibilityClosure(missing)
full_graph = BlockVersionGraph()
full_graph.add_nodes([version])
build_compatibility_closure(translator, closure, [version], full_graph)
self.assertEqual(References(), closure.broken)
#print 'CLOSURE SIZE ', asizeof(closure) / 1000000.0
#print 'MEMSTORE SIZE ', asizeof(store) / 1000000.0
elapsed_time = timer() - start_time
#print 'Closure time', elapsed_time
self.assertEqual({brl_block.block_name + c
for c in resource_info}, closure.block_cell_names)
self.assertLess(elapsed_time, 5)
def test_subscription_limits(self):
# Create users for test
self.store.create_user(User("cooper"))
self.store.create_user(User("bob"))
self.store.create_user(User("lady_lug"))
# Coop has a private block and a public block
public_brl = BRLBlock("cooper/cooper/public_block/master")
private_brl = BRLBlock("cooper/cooper/private_block/master")
self._add_block_to_user("cooper", public_brl, False)
self._add_block_to_user("cooper", private_brl, True)
# 1 contributor and unlimited private blocks
self._subscribe("cooper", "personal_7_1_x")
# Add an administrator
ensure = Security("cooper", self.store)
ensure.check_grant_administrator_for("cooper", "bob")
cooper = self.store.read_user("cooper")
cooper.administrators.grant("bob")
self.store.update_user(cooper)
# Try to add another one, it must fail
self.assertRaises(PlanUpgradeNeeded,
ensure.check_grant_administrator_for,
"cooper", "lady_lug")
# Try to add write permissions to a public block. Its ok
ensure.check_grant_read_or_write_permissions_to("lady_lug", public_brl)
# Try to add write permissions to a private block, but a bob (already admin)
ensure.check_grant_read_or_write_permissions_to("bob", private_brl)
# Try to add write permissions to a private block. It must fail
self.assertRaises(PlanUpgradeNeeded,
ensure.check_grant_read_or_write_permissions_to,
"lady_lug", private_brl)
# Remove Adminsitrator, try to add write permissions in a private block. Its ok
cooper = self.store.read_user("cooper")
cooper.administrators.revoke("bob")
self.store.update_user(cooper)
ensure.check_grant_read_or_write_permissions_to("lady_lug", private_brl)
cooper.administrators.grant("lady_lug")
self.store.update_user(cooper)
# Subscribe to a bigger plan and check limits
self._subscribe("cooper", "startup_35_5_x")
# Add 4 more
for tmp in xrange(4):
new_user = BRLUser("user%s" % tmp)
ensure.check_grant_read_or_write_permissions_to(new_user, private_brl)
bper = self.store.read_block_permissions(private_brl)
bper.write.grant(new_user)
self.store.upsert_block_permissions(bper)
# The sixth must fail
self.assertRaises(PlanUpgradeNeeded,
ensure.check_grant_read_or_write_permissions_to,
"new_user", private_brl)
# unless user is already a contributor
ensure.check_grant_read_or_write_permissions_to("lady_lug", private_brl)
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)
