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_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 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_serialization(self): self.user.add_block(BRLBlock("laso/laso/block2/master"), tags=["ONE", "TWO"], description="The good block") self.user.add_block(BRLBlock("laso/laso/block3/master")) self.user.administrators.grant("pepito") self.user.administrators.grant("josete") tokens = [ SocialAccountToken("xxzc", "zxcc", self.utc_datetime), SocialAccountToken("xxzc", "zxcc", self.utc_datetime) ] social_account = SocialAccount("zcas", self.utc_datetime, self.utc_datetime, tokens, "zcc") self.user.social_accounts = {"google": social_account} self.user.publish_counter = 10 self.user.reuse_counter = 7 self.user.read_api_counter = 99 seri = self.user.serialize() user2 = User.deserialize(seri) self.assertTrue(self._user_equal(self.user, user2)) self.assertEqual(user2.read_api_counter, 99) self.assertEqual(user2.reuse_counter, 7) self.assertEqual(user2.publish_counter, 10) self.assertEqual(set(user2.administrators), {"pepito", "josete"}) self.assertEqual(self.user.region, "Madrid")
def exists_user_id_ignoring_case(self, brl_user): '''Check if user already exists with a case insensitive pattern''' import re dbcol = self.db[GenericServerStore.USER_ST] doc = dbcol.find_one({User.SERIAL_ID_KEY: re.compile('^' + re.escape(brl_user) + '$', re.IGNORECASE)}) return User.deserialize(doc) if doc else None
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 read_user_by_oauth_token(self, provider, token): '''Reads user by github or google token''' cols = {"google": User.SERIAL_OAUTH_GOOGLE_TOKEN, "github": User.SERIAL_OAUTH_GITHUB_TOKEN} dbcol = self.db[GenericServerStore.USER_ST] doc = dbcol.find_one({cols[provider]: token}) return User.deserialize(doc) if doc else None
def test_serialization(self): self.user.add_block(BRLBlock("laso/laso/block2/master"), tags=["ONE", "TWO"], description="The good block") self.user.add_block(BRLBlock("laso/laso/block3/master")) self.user.administrators.grant("pepito") self.user.administrators.grant("josete") tokens = [SocialAccountToken("xxzc", "zxcc", self.utc_datetime), SocialAccountToken("xxzc", "zxcc", self.utc_datetime)] social_account = SocialAccount("zcas", self.utc_datetime, self.utc_datetime, tokens, "zcc") self.user.social_accounts = {"google": social_account} self.user.publish_counter = 10 self.user.reuse_counter = 7 self.user.read_api_counter = 99 seri = self.user.serialize() user2 = User.deserialize(seri) self.assertTrue(self._user_equal(self.user, user2)) self.assertEqual(user2.read_api_counter, 99) self.assertEqual(user2.reuse_counter, 7) self.assertEqual(user2.publish_counter, 10) self.assertEqual(set(user2.administrators), {"pepito", "josete"}) self.assertEqual(self.user.region, "Madrid")
def exists_user_id_ignoring_case(self, brl_user): '''Check if user already exists with a case insensitive pattern''' import re dbcol = self.db[GenericServerStore.USER_ST] doc = dbcol.find_one({ User.SERIAL_ID_KEY: re.compile('^' + re.escape(brl_user) + '$', re.IGNORECASE) }) return User.deserialize(doc) if doc else None
def read_user_by_oauth_token(self, provider, token): '''Reads user by github or google token''' cols = { "google": User.SERIAL_OAUTH_GOOGLE_TOKEN, "github": User.SERIAL_OAUTH_GITHUB_TOKEN } dbcol = self.db[GenericServerStore.USER_ST] doc = dbcol.find_one({cols[provider]: token}) return User.deserialize(doc) if doc else None
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_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_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 read_user_by_email(self, email): '''Reads user by email''' dbcol = self.db[GenericServerStore.USER_ST] doc = dbcol.find_one({User.SERIAL_EMAIL: email}) return User.deserialize(doc) if doc else None
def register(self, brl_user, email, plain_password, allow_mailing, provider=None, access_token=None, invited_by=None): ''' :param: user is a web_api.model.User ''' # Validate password if len(plain_password) < MIN_PASSWORD_LENGTH: logger.debug("Invalid password length for %s" % email) raise ControledErrorException("Password length must" " be %s characters min" % MIN_PASSWORD_LENGTH) # Search users with same email if self.store.read_user_by_email(email): logger.debug("Email '%s' already exists!" % email) raise ControledErrorException("Email '%s' already exists! Forgot password? " "Go to login and click on forgot password" % email) try: brl_user = BRLUser(brl_user) bii_user = User(brl_user) bii_user.password = plain_password except InvalidNameException as e: raise ControledErrorException(e) # Search invited_by user (by mail or login) friend = None if invited_by: if "@" in invited_by: # email address friend = self.store.read_user_by_email(invited_by) friend = friend.ID if friend else None else: # Login friend_object = self.store.exists_user_id_ignoring_case(invited_by) if friend_object and friend_object.active: friend = invited_by if not friend: raise ControledErrorException("User %s doesn't exist" % invited_by) bii_user.invited_by = friend # Check the existing of user name (User.ID), with case-insensitive if self.store.exists_user_id_ignoring_case(brl_user): logger.debug("User name '%s' already exists!" % brl_user) raise ControledErrorException("Username '%s' already exists! " "Choose other username" % brl_user) try: bii_user.email = email bii_user.allow_mailing = allow_mailing manager = JWTConfirmEmailManagerFactory.new() token = manager.get_token_for(brl_user) bii_user.confirmation_token = token bii_user.joined_date = datetime.datetime.now() bii_user.active = False oauth_service = get_oauth_service(self.store) oauth_user_info = oauth_service.get_user_info(provider, access_token) self.store.create_user(bii_user) if oauth_user_info: # If user has changed the oauth email, not confirm the account if oauth_user_info[1] == bii_user.email: bii_user.active = True try: register_signup(self.store, brl_user) except Exception as exc: logger.error("Can't register sign-up in background! %s" % str(exc)) bii_user.fill_user_oauth_token(provider, access_token) self.store.update_user(bii_user) return bii_user except Exception as e: logger.error("Error creating user at mongo: %s" % str(e)) logger.error(traceback.format_exc()) raise e
class UserTest(unittest.TestCase): 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 test_serialization(self): self.user.add_block(BRLBlock("laso/laso/block2/master"), tags=["ONE", "TWO"], description="The good block") self.user.add_block(BRLBlock("laso/laso/block3/master")) self.user.administrators.grant("pepito") self.user.administrators.grant("josete") tokens = [ SocialAccountToken("xxzc", "zxcc", self.utc_datetime), SocialAccountToken("xxzc", "zxcc", self.utc_datetime) ] social_account = SocialAccount("zcas", self.utc_datetime, self.utc_datetime, tokens, "zcc") self.user.social_accounts = {"google": social_account} self.user.publish_counter = 10 self.user.reuse_counter = 7 self.user.read_api_counter = 99 seri = self.user.serialize() user2 = User.deserialize(seri) self.assertTrue(self._user_equal(self.user, user2)) self.assertEqual(user2.read_api_counter, 99) self.assertEqual(user2.reuse_counter, 7) self.assertEqual(user2.publish_counter, 10) self.assertEqual(set(user2.administrators), {"pepito", "josete"}) self.assertEqual(self.user.region, "Madrid") def test_add_repeated_block(self): brlb = BRLBlock("laso/laso/block/master") self.assertRaises(DuplicateBlockException, self.user.add_block, brlb) def test_create_duplicate_block_different_case(self): ''' Attempt to create two blocks with diferent casing eg: MyBlock and myblock ''' name1 = BRLBlock('%s/%s/testblock/trunk' % (self.user.ID, self.user.ID)) name2 = BRLBlock('%s/%s/TestBlock/trunk' % (self.user.ID, self.user.ID)) self.user.add_block(name1) with self.assertRaisesRegexp(BiiException, 'There is already a block named'): self.user.add_block(name2) def test_add_tag_to_block(self): brlb = BRLBlock("laso/laso/block2/master") self.user.add_block(brlb) self.user.add_block_tag(brlb, "arduino") self.assertEquals(self.user.get_block_tags(brlb), set(["arduino"])) def test_add_block_with_tag(self): brlb = BRLBlock("laso/laso/block2/master") self.user.add_block(brlb, tags=["arduino"]) self.assertEquals(self.user.get_block_tags(brlb), set(["arduino"])) def test_change_block_description(self): brlb = BRLBlock("laso/laso/block/master") self.user.set_block_description(brlb, "other") self.assertEquals(self.user.get_block_description(brlb), "other") def test_forbidden(self): brlb = BRLBlock(name="novita/laso/theblock/master") self.assertRaises(ForbiddenException, self.user.add_block, brlb) def _user_equal(self, user, other): '''Equals method''' if user is other: return True return isinstance(other, user.__class__) \ and user.ID == other.ID \ and user.numeric_id == other.numeric_id \ and user._encrypted_password == other._encrypted_password \ and user.firstname == other.firstname \ and user.lastname == other.lastname \ and user.country == other.country \ and user.description == other.description \ and user.email == other.email \ and user.visible_email == other.visible_email \ and user.allow_mailing == other.allow_mailing \ and user.active == other.active \ and user.staff == other.staff \ and user.joined_date == other.joined_date \ and user.confirmation_date == other.confirmation_date \ and user.confirmation_token == other.confirmation_token \ and user.block_counter == other.block_counter \ and user.blocks == other.blocks \ and user.administrators == other.administrators \ and user.read_api_counter == other.read_api_counter \ and user.publish_counter == other.publish_counter \ and user.street_1 == other.street_1 \ and user.street_2 == other.street_2 \ and user.city == other.city \ and user.postal_code == other.postal_code \ and user.region == other.region \ and user.tax_id == other.tax_id\ and user.vat == other.vat
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)
class UserTest(unittest.TestCase): 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 test_serialization(self): self.user.add_block(BRLBlock("laso/laso/block2/master"), tags=["ONE", "TWO"], description="The good block") self.user.add_block(BRLBlock("laso/laso/block3/master")) self.user.administrators.grant("pepito") self.user.administrators.grant("josete") tokens = [SocialAccountToken("xxzc", "zxcc", self.utc_datetime), SocialAccountToken("xxzc", "zxcc", self.utc_datetime)] social_account = SocialAccount("zcas", self.utc_datetime, self.utc_datetime, tokens, "zcc") self.user.social_accounts = {"google": social_account} self.user.publish_counter = 10 self.user.reuse_counter = 7 self.user.read_api_counter = 99 seri = self.user.serialize() user2 = User.deserialize(seri) self.assertTrue(self._user_equal(self.user, user2)) self.assertEqual(user2.read_api_counter, 99) self.assertEqual(user2.reuse_counter, 7) self.assertEqual(user2.publish_counter, 10) self.assertEqual(set(user2.administrators), {"pepito", "josete"}) self.assertEqual(self.user.region, "Madrid") def test_add_repeated_block(self): brlb = BRLBlock("laso/laso/block/master") self.assertRaises(DuplicateBlockException, self.user.add_block, brlb) def test_create_duplicate_block_different_case(self): ''' Attempt to create two blocks with diferent casing eg: MyBlock and myblock ''' name1 = BRLBlock('%s/%s/testblock/trunk' % (self.user.ID, self.user.ID)) name2 = BRLBlock('%s/%s/TestBlock/trunk' % (self.user.ID, self.user.ID)) self.user.add_block(name1) with self.assertRaisesRegexp(BiiException, 'There is already a block named'): self.user.add_block(name2) def test_add_tag_to_block(self): brlb = BRLBlock("laso/laso/block2/master") self.user.add_block(brlb) self.user.add_block_tag(brlb, "arduino") self.assertEquals(self.user.get_block_tags(brlb), set(["arduino"])) def test_add_block_with_tag(self): brlb = BRLBlock("laso/laso/block2/master") self.user.add_block(brlb, tags=["arduino"]) self.assertEquals(self.user.get_block_tags(brlb), set(["arduino"])) def test_change_block_description(self): brlb = BRLBlock("laso/laso/block/master") self.user.set_block_description(brlb, "other") self.assertEquals(self.user.get_block_description(brlb), "other") def test_forbidden(self): brlb = BRLBlock(name="novita/laso/theblock/master") self.assertRaises(ForbiddenException, self.user.add_block, brlb) def _user_equal(self, user, other): '''Equals method''' if user is other: return True return isinstance(other, user.__class__) \ and user.ID == other.ID \ and user.numeric_id == other.numeric_id \ and user._encrypted_password == other._encrypted_password \ and user.firstname == other.firstname \ and user.lastname == other.lastname \ and user.country == other.country \ and user.description == other.description \ and user.email == other.email \ and user.visible_email == other.visible_email \ and user.allow_mailing == other.allow_mailing \ and user.active == other.active \ and user.staff == other.staff \ and user.joined_date == other.joined_date \ and user.confirmation_date == other.confirmation_date \ and user.confirmation_token == other.confirmation_token \ and user.block_counter == other.block_counter \ and user.blocks == other.blocks \ and user.administrators == other.administrators \ and user.read_api_counter == other.read_api_counter \ and user.publish_counter == other.publish_counter \ and user.street_1 == other.street_1 \ and user.street_2 == other.street_2 \ and user.city == other.city \ and user.postal_code == other.postal_code \ and user.region == other.region \ and user.tax_id == other.tax_id\ and user.vat == other.vat