def test_join_unvalidated(self):
        import ptahcrowd
        from ptahcrowd.provider import CrowdUser
        from ptahcrowd.registration import Registration

        user = CrowdUser(username='username', email='email')
        ptah.get_session().add(user)
        ptah.get_session().flush()

        CROWD = ptah.get_settings(ptahcrowd.CFG_ID_CROWD)
        CROWD['allow-unvalidated'] = False

        request = self.make_request(
            POST = {'username': 'test',
                    'email': '[email protected]',
                    'password': '12345',
                    'confirm_password': '12345'})
        form = Registration(None, request)
        form.update_form()
        res = form.register_handler()

        self.assertIsInstance(res, HTTPFound)
        self.assertEqual(res.headers['location'], 'http://example.com')

        user = ptah.auth_service.get_principal_bylogin('[email protected]')
        self.assertIsInstance(user, CrowdUser)
        self.assertEqual(user.username, 'test')

        self.assertIn('Validation email has been sent.',
                      request.render_messages())

    def test_join(self):
        from ptahcrowd.provider import CrowdUser
        from ptahcrowd.registration import Registration

        user = CrowdUser(username='username', email='email')
        ptah.get_session().add(user)
        ptah.get_session().flush()

        request = self.make_request(
            POST = {'username': 'test',
                    'email': '[email protected]',
                    'password': '12345',
                    'confirm_password': '12345'})
        request.environ['HTTP_HOST'] = 'example.com'

        form = Registration(None, request)
        form.update_form()
        res = form.register_handler()

        self.assertIsInstance(res, HTTPFound)
        self.assertEqual(res.headers['location'],
                         'http://example.com/login-success.html')

        user = ptah.auth_service.get_principal_bylogin('[email protected]')
        self.assertIsInstance(user, CrowdUser)
        self.assertEqual(user.name, 'test')

    def test_sqla_table_editrec_remove(self):
        from ptah.manage.sqla import SQLAModule, EditRecord

        rec = TestSqlaModuleTable()
        rec.name = 'Test record'
        ptah.get_session().add(rec)
        ptah.get_session().flush()

        rec_id = rec.id

        mod = SQLAModule(None, DummyRequest())
        table = mod['psqla-test_sqla_table']

        rec = table[rec_id]

        request = self.make_request(
            POST={'form.buttons.remove': 'Remove'})

        form = EditRecord(rec, request)
        form.csrf = False
        res = form()

        self.assertIn('Table record has been removed.',
                      request.render_messages())
        self.assertIsInstance(res, HTTPFound)
        self.assertEqual(res.headers['location'], '..')

        rec = ptah.get_session().query(TestSqlaModuleTable).filter(
            TestSqlaModuleTable.id == rec_id).first()
        self.assertIsNone(rec, None)

    def test_model_edit_node(self):
        from ptahcms.manage.model import ModelModule, EditRecord

        content = Content2()
        content.title = 'Content test'

        Session = ptah.get_session()
        Session.add(content)
        Session.flush()

        rowid = content.__id__
        transaction.commit()

        mod = ModelModule(None, DummyRequest())
        model = mod['content2'][rowid]

        form = EditRecord(
            model, DummyRequest(
                POST={'title': 'Content', 'form.buttons.modify': 'Modify'}))
        form.csrf = False
        form.update()

        self.assertIn("Model record has been modified.",
                      ptah.view.render_messages(form.request))
        transaction.commit()

        Session = ptah.get_session()
        content = Session.query(Content2) \
            .filter(Content2.__id__ == rowid).first()
        self.assertEqual(content.title, 'Content')

    def _create_content(self):
        import ptahcms

        factory = ptahcms.ApplicationFactory(
            ApplicationRoot, '/test', 'root', 'Root App')
        self.factory = factory

        class MyContent(ptahcms.Content):
            __mapper_args__ = {'polymorphic_identity': 'mycontent'}
            __uri_factory__ = ptah.UriFactory('test')

        root = factory()

        folder = MyContent(
            __name__ = 'folder',
            __parent__ = root,
            __path__ = '%sfolder/'%root.__path__)
        self.folder_uri = folder.__uri__

        content = MyContent(
            __name__ = 'content',
            __parent__ = folder,
            __path__ = '%scontent/'%folder.__path__)
        self.content_uri = content.__uri__

        ptah.get_session().add(folder)
        ptah.get_session().add(content)
        transaction.commit()

    def verify_handler(self):
        data, errors = self.extract()

        if errors:
            self.message(errors, 'form-error')
            return

        entry = self.entry
        request = self.request
        new_user = False
        email = data['email']

        user = self.session.query(ptahcrowd.CrowdUser).filter(
            ptahcrowd.CrowdUser.email == email).first()
        if user is None:
            new_user = True

            # create user
            tinfo = ptahcrowd.get_user_type()

            user = tinfo.create(
                name=entry.name,
                login=email,
                email=email,
                password=entry.access_token)
            tinfo.add(user)

            # fixme: temporary
            ptah.get_session().flush()

            uri = user.__uri__
            entry.uri = uri
            entry.email = email
        else:
            uri = user.__uri__

        data = {'uri': uri,
                'email': email,
                'uid': entry.uid}

        t = ptah.token.service.generate(TOKEN_TYPE, json.dumps(data))
        template = VerifyTemplate(entry, request, email=email, token=t)
        template.send()

        # login
        if new_user:
            self.message('Email verification email has been sent.')
            cfg = ptah.get_settings(ptahcrowd.CFG_ID_CROWD, request.registry)
            if cfg['validation']:
                if cfg['allow-unvalidated']:
                    entry.uri = uri
                    return login(uri, request)
            else:
                entry.uri = uri
                return login(uri, request)
        else:
            self.message('User with this email already exists. '
                         'You have to verify email before you can login.')

        return HTTPFound(location=request.application_url)

    def test_upgrade_several(self):
        from ptah.migrate import revision, Version

        ptah.register_migration('test1', 'test1:path', 'Test migration')
        ptah.register_migration('test2', 'test2:path', 'Test migration')

        self.init_ptah()

        versions = dict((v.package, v.version_num)
                        for v in ptah.get_session().query(Version).all())

        rev1 = revision('test1')
        rev2 = revision('test2')

        sys.argv[:] = ['ptah-migrate', 'ptah.ini', 'upgrade', 'test1', 'test2']

        migrate.main()

        self._reset_stdout()

        versions = dict((v.package, v.version_num)
                        for v in ptah.get_session().query(Version).all())

        self.assertIn('test1', versions)
        self.assertIn('test2', versions)
        self.assertEqual(versions['test1'], rev1)
        self.assertEqual(versions['test2'], rev2)

    def test_model_remove(self):
        from ptahcms.manage.model import ModelModule, ModelView

        content = Content1()
        content.title = 'Content test'

        Session = ptah.get_session()
        Session.add(content)
        Session.flush()

        rowid = content.__id__
        transaction.commit()

        mod = ModelModule(None, DummyRequest())
        model = mod['content1']

        form = ModelView(
            model, DummyRequest(
                POST=MultiDict(
                    list({'rowid':rowid,
                          'form.buttons.remove': 'Remove'}.items()))))
        form.csrf = False
        res = form.update()

        self.assertIsInstance(res, HTTPFound)

        transaction.commit()

        Session = ptah.get_session()
        rec = Session.query(Content1).filter(
            Content1.__id__ == rowid).first()
        self.assertIsNone(rec)

    def test_join_error(self):
        from ptahcrowd.provider import CrowdUser
        from ptahcrowd.registration import Registration

        user = CrowdUser(username='username', email='email')
        ptah.get_session().add(user)
        ptah.get_session().flush()

        request = self.make_request(
            POST = {'username': 'test',
                    'email': 'custom login',
                    'password': '12345',
                    'confirm_password': '123456'})

        form = Registration(None, request)
        form.update_form()

        data, errors = form.extract()
        self.assertEqual(len(errors), 1)
        self.assertEqual(errors[0].msg[0], 'Invalid email address')

        form.register_handler()
        self.assertIn('Please fix indicated errors.',
                      request.render_messages())

        request = self.make_request(
            POST = {'username': 'test',
                    'email': '[email protected]',
                    'password': '12345',
                    'confirm_password': '12345'})
        form = Registration(None, request)
        form.update_form()
        data, errors = form.extract()
        self.assertEqual(len(errors), 0)

    def test_join(self):
        from ptahcrowd.provider import CrowdUser
        from ptahcrowd.registration import Registration

        user = CrowdUser(username='username', email='email')
        ptah.get_session().add(user)
        ptah.get_session().flush()

        class Stub(object):
            status = ''
            def send(self, frm, to, msg):
                Stub.status = 'Email has been sended'

        MAIL = ptah.get_settings(ptah.CFG_ID_PTAH)
        MAIL['mailer'] = Stub()

        request = self.make_request(
            POST = {'username': 'test',
                    'email': '[email protected]',
                    'password': '12345',
                    'confirm_password': '12345'})
        request.environ['HTTP_HOST'] = 'example.com'

        form = Registration(None, request)
        form.update_form()
        res = form.register_handler()

        self.assertIsInstance(res, HTTPFound)
        self.assertEqual(res.headers['location'],
                         'http://example.com/login-success.html')

        user = ptah.auth_service.get_principal_bylogin('[email protected]')
        self.assertIsInstance(user, CrowdUser)
        self.assertEqual(user.name, 'test')

def enableUser():
    email = sys.argv[1]
    ploud_config.initializeConfig()
    dsn = PLOUD.dsn
    models.initialize_sql(dsn)
    config = Configurator()
    config.manager.push({'registry': config.registry, 'request': None})

    conn = ploud_config.PLOUD_POOL.getconn()
    cursor = conn.cursor()

    cursor.execute("SELECT email FROM waitinglist "
                   "WHERE completed = %s and email=%s",(False,email))

    row = cursor.fetchone()
    if row is None:
        print "Can't find email: %s"%email
        return

    transaction.begin()
    password = ''.join(
        [random.choice(ALLOWED_SITE_NAME_CHARS) for i in range(8)])
    user = models.User(email, password)
    user.type = 0
    token = user.token
    ptah.get_session().add(user)
    print email, token
    signup.send_activation(email, token)

    cursor.execute("UPDATE waitinglist SET completed = %s WHERE email=%s",
                   (True, email))
    cursor.close()
    conn.commit()
    transaction.commit()

    def test_sqla_table_editrec_basics(self):
        from ptah.manage.sqla import SQLAModule, EditRecord

        rec = TestSqlaModuleTable()
        rec.name = 'Test record'
        ptah.get_session().add(rec)
        ptah.get_session().flush()

        rec_id = rec.id

        request = self.make_request()

        mod = SQLAModule(None, request)
        table = mod['psqla-test_sqla_table']

        rec = table[rec_id]

        form = EditRecord(rec, request)
        form.update_form()

        self.assertEqual(form.label, 'record 1')
        self.assertEqual(form.form_content(),
                         {'name': 'Test record'})

        request = DummyRequest(
            POST={'form.buttons.cancel': 'Cancel'})

        form = EditRecord(rec, request)
        res = form()

        self.assertIsInstance(res, HTTPFound)
        self.assertEqual(res.headers['location'], '..')

    def test_sqla_table_view_model_nodes(self):
        from ptah.manage.sqla import SQLAModule

        rec = TestSqlaModuleContent(title='test')
        ptah.get_session().add(rec)
        ptah.get_session().flush()

        #uri = rec.__uri__
        #type_uri = rec.__type__.__uri__

        request = DummyRequest(params={'batch': 1})

        mod = SQLAModule(None, request)
        table = mod['psqla-ptah_nodes']

        render_view_to_response(table, request, '', False).text
        #self.assertIn(url_quote_plus(uri), res)
        #self.assertIn(url_quote_plus(type_uri), res)

        request = DummyRequest(params={'batch': 'unknown'})
        render_view_to_response(table, request, '', False).text
        #self.assertIn(url_quote_plus(uri), res)

        request = DummyRequest(params={'batch': '0'})
        render_view_to_response(table, request, '', False).text

    def test_loadapi_load(self):
        content = Content(title='Content')
        uri = content.__uri__

        ptah.get_session().add(content)
        transaction.commit()

        content = ptahcms.load(uri)
        self.assertEqual(content.__uri__, uri)

    def updateAction(form):
        data, errors = form.extract()
        if errors:
            form.message(errors, 'form-error')
            return

        category = models.Category(name = data['name'])
        ptah.get_session().add(category)

        form.message('Category has been created.')
        return HTTPFound(location='/')

    def updateAction(form):
        data, errors = form.extract()
        if errors:
            form.message(errors, 'form-error')
            return

        link = models.Link(title = data['title'],
                           href = data['href'],
                           color = data['color'])
        ptah.get_session().add(link)

        form.message('Link has been created.')
        return HTTPFound(location='/')

    def test_sqla_table_remove(self):
        from ptah.manage.sqla import SQLAModule, TableView

        rec = TestSqlaModuleTable()
        rec.name = 'Test record'
        ptah.get_session().add(rec)
        ptah.get_session().flush()

        rec_id = rec.id

        request = self.make_request()
        mod = SQLAModule(None, request)
        table = mod['psqla-test_sqla_table']

        request = self.make_request(
            POST=MultiDict([('form.buttons.remove', 'Remove')]))

        form = TableView(table, request)
        form.csrf = False
        form.update_form()

        self.assertIn('lease select records for removing.',
                      request.render_messages())

        request = self.make_request(
            POST=MultiDict([('form.buttons.remove', 'Remove'),
                            ('rowid', 'wrong')]))

        form = TableView(table, request)
        form.csrf = False
        form.update_form()

        #self.assertIn('Please select records for removing.',
        #              request.render_messages())

        request = self.make_request(
            POST=MultiDict([('form.buttons.remove', 'Remove'),
                            ('rowid', rec_id),
                            ('csrf-token',
                             self.request.session.get_csrf_token())]))

        form = TableView(table, request)
        form.csrf = True
        form.update_form()

        self.assertIn('Select records have been removed.',
                      request.render_messages())

        rec = ptah.get_session().query(TestSqlaModuleTable).filter(
            TestSqlaModuleTable.id == rec_id).first()
        self.assertIsNone(rec, None)

    def test_sqla_table_view_model(self):
        from ptah.manage.sqla import SQLAModule

        ptah.get_session().add(TestSqlaModuleContent(title='test'))

        request = self.make_request()

        mod = SQLAModule(None, request)
        table = mod['psqla-test_sqla_content']

        res = render_view_to_response(table, request, '', False).text
        self.assertIn('Inherits from:', res)
        self.assertIn('ptah_node', res)
        self.assertNotIn('form.buttons.add', res)

    def test_get_bylogin(self):
        from ptahcrowd.provider import \
             CrowdAuthProvider, CrowdUser

        provider = CrowdAuthProvider()
        self.assertIsNone(provider.get_principal_bylogin('test'))

        user = CrowdUser(username='test', email='[email protected]',
                         password=ptah.pwd_tool.encode('12345'))
        ptah.get_session().add(user)
        ptah.get_session().flush()

        user = provider.get_principal_bylogin('test')
        self.assertIsInstance(user, CrowdUser)
        self.assertEqual(user.username, 'test')

    def __call__(self, request=None):
        root = self._sql_get_root.first(name=self.name, type=self.type.__uri__)
        if root is None:
            root = self.type.create(title=self.title,
                                    description=self.description,
                                    public=self.public)
            root.__name_id__ = self.name
            root.__path__ = self.path
            Session = ptah.get_session()
            Session.add(root)
            Session.flush()

        root.__root_path__ = self.path
        policy = self.policy(request)
        if self.parent_factory:
            root.__parent__ = self.parent_factory()
        else:
            root.__parent__ = policy
        root.__default_root__ = self.default_root

        if request is not None:
            set_policy(policy)
            request.root = root

        if self.parent_factory:
            policy.__parent__ = self.parent_factory()

        return root