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)