def add_fixtures(self):
     from pysite.models import DbSession
     from pprint import pprint
     sess = DbSession()
     transaction.begin()
     try:
         # Add in this sequence
         for g in self.__class__.FIXT_GROUPS:
             data = self.fixtures[g]
             print("***", g)
             for it in data:
                 it['owner'] = UNIT_TESTER_UID
                 pprint(it)
                 if g == 'roles':
                     usrmanager.add_role(it)
                 elif g == 'principals':
                     usrmanager.add_principal(it)
                 elif g == 'vmail_domains':
                     vmailmanager.add_domain(it)
                 elif g == 'vmail_mailboxes':
                     vmailmanager.add_mailbox(it)
                 elif g == 'vmail_aliases':
                     vmailmanager.add_alias(it)
                 else:
                     raise Exception("Unknown fixture group: '{0}'".format(
                         g))
         transaction.commit()
     except Exception as e:
         transaction.abort()
         raise e

 def inject_changes():
     # Change the database just after the list of objects
     # to analyze has been determined.
     child2 = PersistentMapping()
     root['child2'] = child2
     transaction.commit()
     expect_oids.append(child2._p_oid)

def _import_users(context: IResource, registry: Registry, filename: str):
    users_info = _load_users_info(filename)
    users_info = [_normalize_user_info(u) for u in users_info]
    users = find_service(context, 'principals', 'users')
    groups = find_service(context, 'principals', 'groups')
    for user_info in users_info:
        user_by_name, user_by_email = _locate_user(user_info,
                                                   context,
                                                   registry)
        if user_by_name or user_by_email:
            logger.info('Updating user {} ({})'.format(user_info['name'],
                                                       user_info['email']))
            _update_user(user_by_name, user_by_email, user_info, groups)
        else:
            logger.info('Creating user {}'.format(user_info['name']))
            send_invitation = user_info.get('send_invitation_mail', False)
            activate = not send_invitation
            user = _create_user(user_info, users, registry, groups,
                                activate=activate)
            if send_invitation:
                logger.info('Sending invitation mail to {}'.format(user.name))
                _send_invitation_mail(user, user_info, registry)
            badge_names = user_info.get('badges', [])
            if badge_names:
                logger.info('Assign badge for user {}'.format(user.name))
                badges = _create_badges(user, badge_names, registry)
                _assign_badges(user, badges, registry)
    transaction.commit()

    def checkAutoReconnect(self):
        # Verify auto-reconnect
        db = DB(self._storage)
        try:
            c1 = db.open()
            r = c1.root()
            r['alpha'] = 1
            transaction.commit()
            c1.close()

            c1._storage._load_conn.close()
            c1._storage._store_conn.close()
            # ZODB5 implicitly calls sync
            # immediately when a connection is opened;
            # fake that here for older releases.
            c2 = db.open()
            self.assertIs(c2, c1)
            c2.sync()
            r = c2.root()
            self.assertEqual(r['alpha'], 1)
            r['beta'] = PersistentMapping()
            c2.add(r['beta'])
            transaction.commit()
            c2.close()
        finally:
            db.close()

    def checkPackBatchLockNoWait(self):
        # Exercise the code in the pack algorithm that attempts to get the
        # commit lock but will sleep if the lock is busy.
        self._storage = self.make_storage(pack_batch_timeout=0)

        adapter = self._storage._adapter
        test_conn, test_cursor = adapter.connmanager.open()

        slept = []
        def sim_sleep(seconds):
            slept.append(seconds)
            adapter.locker.release_commit_lock(test_cursor)
            test_conn.rollback()
            adapter.connmanager.close(test_conn, test_cursor)

        db = DB(self._storage)
        try:
            # add some data to be packed
            c = db.open()
            r = c.root()
            r['alpha'] = PersistentMapping()
            transaction.commit()
            del r['alpha']
            transaction.commit()

            # Pack, with a commit lock held
            now = packtime = time.time()
            while packtime <= now:
                packtime = time.time()
            adapter.locker.hold_commit_lock(test_cursor)
            self._storage.pack(packtime, referencesf, sleep=sim_sleep)

            self.assertTrue(len(slept) > 0)
        finally:
            db.close()

def bootStrapSubscriber(event):
    """The actual subscriber to the bootstrap IDataBaseOpenedEvent

    Boostrap a Zope3 instance given a database object This first checks if the
    root folder exists and has a site manager.  If it exists, nothing else
    is changed.  If no root folder exists, one is added.
    """

    db, connection, root, root_folder = getInformationFromEvent(event)
    root_created = False

    if root_folder is None:
        root_created = True
        # ugh... we depend on the root folder implementation
        root_folder = rootFolder()
        root[ZopePublication.root_name] = root_folder
        if not ISite.providedBy(root_folder):
            site_manager = site.LocalSiteManager(root_folder)
            root_folder.setSiteManager(site_manager)

        transaction.commit()

    connection.close()

    zope.event.notify(interfaces.DatabaseOpenedWithRoot(db))

    def test_statusmap_on_objects_having_inactive_content(self, browser):
        # Create a container which will hold the content used for this test.
        # The container does not play an important role in the test.
        folder = create(Builder('folder').titled('Container'))

        # Create some content used in this test.
        create(Builder('folder')
               .titled('Active Folder')
               .within(folder))
        create(Builder('folder')
               .titled('Inactive Folder')
               .having(effectiveDate=DateTime() + 10)
               .within(folder))

        # A user not having the permission to access inactive content can only
        # change the state of the container and the active folder inside the
        # container, but not the inactive folder inside the container.
        # Thus the inactive folder must not be visible in the statusmap view.
        setRoles(self.portal, TEST_USER_ID, ['Contributor'])
        transaction.commit()
        browser.login().visit(folder, view="@@statusmap")
        self.assertEqual(
            ['Container', 'Active Folder'],
            browser.css('.listing tr td span').text
        )

        # A manager can also change the state of the inactive folder.
        # Thus the inactive folder must be visible in the statusmap view too.
        setRoles(self.portal, TEST_USER_ID, ['Manager'])
        transaction.commit()
        browser.login().visit(folder, view="@@statusmap")
        self.assertEqual(
            ['Container', 'Active Folder', 'Inactive Folder'],
            browser.css('.listing tr td span').text
        )

    def test_statusmap_on_inactive_content(self, browser):
        inactive_folder = create(Builder('folder')
                                 .titled('Inactive Folder')
                                 .having(effectiveDate=DateTime() + 10)
                                 .within(self.portal))

        create(Builder('folder')
               .titled('Active Folder')
               .within(inactive_folder))

        # A user not having the permission to access inactive content must
        # be able to change the state of the inactive content itself, i.e.
        # calling the statusmap view on an inactive context.
        setRoles(self.portal, TEST_USER_ID, ['Contributor'])
        transaction.commit()
        browser.login().visit(inactive_folder, view="@@statusmap")
        self.assertEqual(
            ['Inactive Folder', 'Active Folder'],
            browser.css('.listing tr td span').text
        )

        # The same applies to a user having the permission to access inactive
        # content.
        setRoles(self.portal, TEST_USER_ID, ['Manager'])
        transaction.commit()
        browser.login().visit(inactive_folder, view="@@statusmap")
        self.assertEqual(
            ['Inactive Folder', 'Active Folder'],
            browser.css('.listing tr td span').text
        )

 def activateCondition(self, name=None):
     registry = getUtility(IRegistry)
     settings = registry.forInterface(ISettings)
     settings.enabled = True
     if name:
         settings.activated = set((name,))
     transaction.commit()

def _registerPackage(module_, init_func=None):
    """Registers the given python package as a Zope 2 style product
    """

    if not hasattr(module_, '__path__'):
        raise ValueError("Must be a package and the " \
                         "package must be filesystem based")
    
    app = Zope2.app()
    try:
        product = initializeProduct(module_, 
                                    module_.__name__, 
                                    module_.__path__[0],
                                    app)

        product.package_name = module_.__name__

        if init_func is not None:
            newContext = ProductContext(product, app, module_)
            init_func(newContext)
    finally:
        try:
            import transaction
            transaction.commit()
        finally:
            app._p_jar.close()

def get_login_headers(request, user):
    headers = remember(request, user.email)
    user.last_login_date = datetime.now()
    DBSession.add(user)
    DBSession.flush()
    transaction.commit()
    return headers

def checkin_documents_for_user(portal, options):
    """Attempts to check in all documents checked out by a particular user.
    """
    username = options.user

    # Assume security context of user
    user = portal.acl_users.getUser(username)
    user = user.__of__(portal.acl_users)
    newSecurityManager(portal, user)

    catalog = getToolByName(portal, 'portal_catalog')
    docs = catalog(portal_type='opengever.document.document')
    checked_out_docs = [b.getObject() for b in docs if b.checked_out == username]

    for obj in checked_out_docs:
        manager = getMultiAdapter((obj, obj.REQUEST), ICheckinCheckoutManager)
        if not manager.is_checkin_allowed():
            print "WARNING: Checkin not allowed for document %s" % obj.absolute_url()
            print checkin_not_allowed_reason(obj)
        else:
            if not options.dryrun:
                manager.checkin(comment=options.comment)
                print "Checked in document %s" % obj.absolute_url()
            else:
                print "Would checkin document %s" % obj.absolute_url()

    if not options.dryrun:
        transaction.commit()

 def delete_restore_single_result(self, result_id):
     try:
         DBSession.query(VMRestoreResult).filter(VMRestoreResult.id == result_id).delete()
         LOGGER.info('VM restore single result is deleted.')
         transaction.commit()
     except Exception as ex:
         LOGGER.error(to_str(ex).replace("'", ''))

 def registerLocalUser(cls, email='', password='', groups=None):
     from quizsmith.app.models import Groups
     if groups == None:
         groups = [Groups.by(3).first()]
     user = Users(email=email, password=password, groups=groups)
     DBSession.add(user)
     transaction.commit()

    def __call__(self, name, content_type, data):
        ctr = getToolByName(self.context, 'content_type_registry')
        type_ = ctr.findTypeName(name.lower(), '', '') or 'File'

        # XXX: quick fix for german umlauts
        name = name.decode("utf8")

        normalizer = getUtility(IFileNameNormalizer)
        chooser = INameChooser(self.context)

        # otherwise I get ZPublisher.Conflict ConflictErrors
        # when uploading multiple files
        upload_lock.acquire()

        # this should fix #8
        newid = chooser.chooseName(normalizer.normalize(name),
                                   self.context.aq_parent)
        try:
            transaction.begin()
            obj = ploneutils._createObjectByType(type_,
                                                 self.context, newid)
            mutator = obj.getPrimaryField().getMutator(obj)
            mutator(data, content_type=content_type)
            obj.setTitle(name)
            obj.reindexObject()

            notify(ObjectInitializedEvent(obj))
            notify(ObjectModifiedEvent(obj))

            transaction.commit()
        finally:
            upload_lock.release()
        return obj

 def registerNonLocalUser(cls, email='', fullname='', groups=None):
     from quizsmith.app.models import Groups
     if not groups:
         groups = [Groups.by(3).first()]
     user = Users(email=email, fullname=fullname, is_local=False, groups=groups)
     DBSession.add(user)
     transaction.commit()

def appmaker(zodb_root):
    if not 'app_root' in zodb_root:
        app_root = AppRoot()
        zodb_root['app_root'] = app_root
        import transaction
        transaction.commit()
    return zodb_root['app_root']

    def test_officeconnector_reauth_does_not_checkout(self, browser):
        api.portal.set_registry_record(
            'direct_checkout_and_edit_enabled',
            True,
            interface=IOfficeConnectorSettings)
        transaction.commit()

        # We cannot freeze time due to the test browser being threaded
        oc_url = create_oc_url(
            self.doc1.REQUEST, self.doc1, {'action': 'checkout'})
        decoded_oc_url = jwt.decode(oc_url.split(':')[-1], verify=False)

        redirector_js = browser.login().open(
            self.doc1,
            view='checkout_documents'
            '?_authenticator={}&mode=external&reauth=1'
            .format(createToken()),
            ).css('script.redirector')[0].text

        tokens_from_js = [token for token in redirector_js.split("\'")
                          if 'oc:' in token]

        self.assertEqual(3, len(tokens_from_js))

        parsed_oc_url = tokens_from_js[0]
        decoded_parsed_oc_url = jwt.decode(
            parsed_oc_url.split(':')[-1], verify=False)

        # Take out the timestamps
        del decoded_oc_url['exp']
        del decoded_parsed_oc_url['exp']

        self.assertEqual(decoded_oc_url, decoded_parsed_oc_url)
        self.assertFalse(self.get_manager(self.doc1).is_checked_out_by_current_user())

    def test_error_on_no_remaining_identities(self):
        # Given a user with only one connected identity, produce an error
        #   disabling the user from removing the only remaining identity.
        # Note, that the we prevent this from happening server side, but
        #   on the client side the user should be given the option to
        #   completely remove the user account.
        from .models import Identity, User
        with transaction.manager:
            # Create the user first...
            user = User()
            DBSession.add(user)
            DBSession.flush()
            user_id = user.id
        # It's easier to do this in two transactions to avoid unrealistic
        #   flushing issues.
        with transaction.manager:
            name = 'Hao'
            identity = Identity(name, name, 'openid')
            identity.user_id = str(user_id)
            DBSession.add(identity)
            DBSession.flush()
            identity_id = identity.id

        request = testing.DummyRequest()
        removed_identity_id = identity_id
        request.matchdict = {'user_id': user_id,
                             'identity_id': removed_identity_id,
                             }

        from .views import delete_user_identity
        from pyramid.httpexceptions import HTTPForbidden
        with self.assertRaises(HTTPForbidden):
            # Forbidden, you can't do this, ever.
            delete_user_identity(request)
        transaction.commit()

    def checkAutoReconnectOnSync(self):
        # Verify auto-reconnect.
        db = DB(self._storage)
        try:
            c1 = db.open()
            r = c1.root()

            c1._storage._load_conn.close()
            c1._storage.sync()
            # ZODB5 calls sync when a connection is opened. Our monkey
            # patch on a Connection makes sure that works in earlier
            # versions, but we don't have that patch on ZODB5. So test
            # the storage directly. NOTE: The load connection must be open.
            # to trigger the actual sync.

            r = c1.root()
            r['alpha'] = 1
            transaction.commit()
            c1.close()

            c1._storage._load_conn.close()
            c1._storage._store_conn.close()

            c2 = db.open()
            self.assertIs(c2, c1)

            r = c2.root()
            self.assertEqual(r['alpha'], 1)
            r['beta'] = PersistentMapping()
            c2.add(r['beta'])
            transaction.commit()
            c2.close()
        finally:
            db.close()