test_bootstrap_flask.py

import unittest

from flask import Flask, render_template_string, current_app, request, flash
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, BooleanField, PasswordField, FileField,\
    MultipleFileField, RadioField, HiddenField
from wtforms.validators import DataRequired, Length

from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy


class HelloForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired(), Length(1, 20)])
    password = PasswordField('Password', validators=[DataRequired(), Length(8, 150)])
    remember = BooleanField('Remember me')
    submit = SubmitField()


class BootstrapTestCase(unittest.TestCase):

    def setUp(self):
        self.app = Flask(__name__)
        self.app.testing = True
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
        self.app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
        self.app.secret_key = 'for test'
        self.bootstrap = Bootstrap(self.app)  # noqa
        self.bootswatch_themes = [
            'cerulean', 'cosmo', 'cyborg', 'darkly', 'default', 'flatly', 'journal', 'litera',
            'lumen', 'lux', 'materia', 'minty', 'pulse', 'sandstone', 'simplex', 'sketchy', 'slate',
            'solar', 'spacelab', 'superhero', 'united', 'yeti'
        ]

        @self.app.route('/')
        def index():
            return render_template_string('{{ bootstrap.load_css() }}{{ bootstrap.load_js() }}')

        self.context = self.app.test_request_context()
        self.context.push()
        self.client = self.app.test_client()

    def tearDown(self):
        self.context.pop()

    def test_extension_init(self):
        self.assertIn('bootstrap', current_app.extensions)

    def test_load_css(self):
        rv = self.bootstrap.load_css()
        self.assertIn('bootstrap.min.css', rv)

    def test_load_js(self):
        rv = self.bootstrap.load_js()
        self.assertIn('bootstrap.min.js', rv)

    def test_local_resources(self):
        current_app.config['BOOTSTRAP_SERVE_LOCAL'] = True

        response = self.client.get('/')
        data = response.get_data(as_text=True)
        self.assertNotIn('https://cdn.jsdelivr.net/npm/bootstrap', data)
        self.assertIn('bootstrap.min.js', data)
        self.assertIn('bootstrap.min.css', data)
        self.assertIn('jquery.min.js', data)

        with self.client.get('/bootstrap/static/css/bootstrap.min.css') as css_response:
            self.assertNotEqual(css_response.status_code, 404)
        with self.client.get('/bootstrap/static/js/bootstrap.min.js') as js_response:
            self.assertNotEqual(js_response.status_code, 404)
        with self.client.get('/bootstrap/static/jquery.min.js') as jquery_response:
            self.assertNotEqual(jquery_response.status_code, 404)

        css_rv = self.bootstrap.load_css()
        js_rv = self.bootstrap.load_js()
        self.assertIn('/bootstrap/static/css/bootstrap.min.css', css_rv)
        self.assertIn('/bootstrap/static/js/bootstrap.min.js', js_rv)
        self.assertNotIn('https://cdn.jsdelivr.net/npm/bootstrap', css_rv)
        self.assertNotIn('https://cdn.jsdelivr.net/npm/bootstrap', js_rv)

    def test_cdn_resources(self):
        response = self.client.get('/')
        data = response.get_data(as_text=True)
        self.assertIn('https://cdn.jsdelivr.net/npm/bootstrap', data)
        self.assertIn('bootstrap.min.js', data)
        self.assertIn('bootstrap.min.css', data)

        css_rv = self.bootstrap.load_css()
        js_rv = self.bootstrap.load_js()
        self.assertNotIn('/bootstrap/static/css/bootstrap.min.css', css_rv)
        self.assertNotIn('/bootstrap/static/js/bootstrap.min.js', js_rv)
        self.assertIn('https://cdn.jsdelivr.net/npm/bootstrap', css_rv)
        self.assertIn('https://cdn.jsdelivr.net/npm/bootstrap', js_rv)

    def test_bootswatch_local(self):
        current_app.config['BOOTSTRAP_SERVE_LOCAL'] = True

        for theme in self.bootswatch_themes:
            current_app.config['BOOTSTRAP_BOOTSWATCH_THEME'] = theme
            data = self.client.get('/').get_data(as_text=True)
            self.assertNotIn('https://cdn.jsdelivr.net/npm/bootswatch', data)
            self.assertIn('swatch/%s/bootstrap.min.css' % theme, data)
            with self.client.get('/bootstrap/static/css/swatch/%s/bootstrap.min.css' % theme) as css_response:
                self.assertNotEqual(css_response.status_code, 404)

    def test_bootswatch_cdn(self):
        current_app.config['BOOTSTRAP_SERVE_LOCAL'] = False

        for theme in self.bootswatch_themes:
            current_app.config['BOOTSTRAP_BOOTSWATCH_THEME'] = theme
            data = self.client.get('/').get_data(as_text=True)
            self.assertIn('https://cdn.jsdelivr.net/npm/bootswatch', data)
            self.assertIn('dist/%s/bootstrap.min.css' % theme, data)
            css_rv = self.bootstrap.load_css()
            self.assertNotIn('/bootstrap/static/css/swatch/%s/bootstrap.min.css' % theme, data)
            self.assertIn('https://cdn.jsdelivr.net/npm/bootswatch', css_rv)

    def test_render_field(self):
        @self.app.route('/field')
        def test():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_field %}
            {{ render_field(form.username) }}
            {{ render_field(form.password) }}
            ''', form=form)

        response = self.client.get('/field')
        data = response.get_data(as_text=True)
        self.assertIn('<input class="form-control" id="username" name="username"', data)
        self.assertIn('<input class="form-control" id="password" name="password"', data)

    def test_render_form(self):
        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
                    {% from 'bootstrap/form.html' import render_form %}
                    {{ render_form(form) }}
                    ''', form=form)

        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('<input class="form-control" id="username" name="username"', data)
        self.assertIn('<input class="form-control" id="password" name="password"', data)

    def test_render_form_row(self):
        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
                    {% from 'bootstrap/form.html' import render_form_row %}
                    {{ render_form_row([form.username, form.password]) }}
                    ''', form=form)
        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="form-row">', data)
        self.assertIn('<div class="col">', data)

    def test_render_form_row_row_class(self):
        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
                    {% from 'bootstrap/form.html' import render_form_row %}
                    {{ render_form_row([form.username, form.password], row_class='row') }}
                    ''', form=form)
        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="row">', data)

    def test_render_form_row_col_class_default(self):
        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
                    {% from 'bootstrap/form.html' import render_form_row %}
                    {{ render_form_row([form.username, form.password], col_class_default='col-md-6') }}
                    ''', form=form)
        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="col-md-6">', data)

    def test_render_form_row_col_map(self):
        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
                    {% from 'bootstrap/form.html' import render_form_row %}
                    {{ render_form_row([form.username, form.password], col_map={'username': 'col-md-6'}) }}
                    ''', form=form)
        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="col">', data)
        self.assertIn('<div class="col-md-6">', data)

    def test_render_pager(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)

        @self.app.route('/pager')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(100):
                m = Message()
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            return render_template_string('''
                            {% from 'bootstrap/pagination.html' import render_pager %}
                            {{ render_pager(pagination) }}
                            ''', pagination=pagination, messages=messages)

        response = self.client.get('/pager')
        data = response.get_data(as_text=True)
        self.assertIn('<nav aria-label="Page navigation">', data)
        self.assertIn('Previous', data)
        self.assertIn('Next', data)
        self.assertIn('<li class="page-item disabled">', data)

        response = self.client.get('/pager?page=2')
        data = response.get_data(as_text=True)
        self.assertIn('<nav aria-label="Page navigation">', data)
        self.assertIn('Previous', data)
        self.assertIn('Next', data)
        self.assertNotIn('<li class="page-item disabled">', data)

    def test_render_pagination(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)

        @self.app.route('/pagination')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(100):
                m = Message()
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            return render_template_string('''
                                    {% from 'bootstrap/pagination.html' import render_pagination %}
                                    {{ render_pagination(pagination) }}
                                    ''', pagination=pagination, messages=messages)

        response = self.client.get('/pagination')
        data = response.get_data(as_text=True)
        self.assertIn('<nav aria-label="Page navigation">', data)
        self.assertIn('<a class="page-link" href="#">1 <span class="sr-only">(current)</span></a>', data)
        self.assertIn('10</a>', data)

        response = self.client.get('/pagination?page=2')
        data = response.get_data(as_text=True)
        self.assertIn('<nav aria-label="Page navigation">', data)
        self.assertIn('1</a>', data)
        self.assertIn('<a class="page-link" href="#">2 <span class="sr-only">(current)</span></a>', data)
        self.assertIn('10</a>', data)

    def test_render_nav_item(self):
        @self.app.route('/nav_item')
        def test():
            return render_template_string('''
                    {% from 'bootstrap/nav.html' import render_nav_item %}
                    {{ render_nav_item('test', 'Home') }}
                    ''')

        response = self.client.get('/nav_item')
        data = response.get_data(as_text=True)
        self.assertIn('<a class="nav-item nav-link active"', data)

    def test_render_breadcrumb_item(self):
        @self.app.route('/breadcrumb_item')
        def test():
            return render_template_string('''
                    {% from 'bootstrap/nav.html' import render_breadcrumb_item %}
                    {{ render_breadcrumb_item('test', 'Home') }}
                    ''')

        response = self.client.get('/breadcrumb_item')
        data = response.get_data(as_text=True)
        self.assertIn('<li class="breadcrumb-item active"  aria-current="page">', data)

    def test_render_static(self):
        @self.app.route('/test_static')
        def test():
            return render_template_string('''
                            {% from 'bootstrap/utils.html' import render_static %}
                            {{ render_static('css', 'test.css') }}
                            {{ render_static('js', 'test.js') }}
                            {{ render_static('icon', 'test.ico') }}
                            ''')

        response = self.client.get('/test_static')
        data = response.get_data(as_text=True)
        self.assertIn('<link rel="stylesheet" href="/static/test.css" type="text/css">', data)
        self.assertIn('<script type="text/javascript" src="/static/test.js"></script>', data)
        self.assertIn('<link rel="icon" href="/static/test.ico">', data)

    def test_render_messages(self):
        @self.app.route('/messages')
        def test_messages():
            flash('test message', 'danger')
            return render_template_string('''
                            {% from 'bootstrap/utils.html' import render_messages %}
                            {{ render_messages() }}
                            ''')

        @self.app.route('/container')
        def test_container():
            flash('test message', 'danger')
            return render_template_string('''
                            {% from 'bootstrap/utils.html' import render_messages %}
                            {{ render_messages(container=True) }}
                            ''')

        @self.app.route('/dismissible')
        def test_dismissible():
            flash('test message', 'danger')
            return render_template_string('''
                            {% from 'bootstrap/utils.html' import render_messages %}
                            {{ render_messages(dismissible=True) }}
                            ''')

        @self.app.route('/dismiss_animate')
        def test_dismiss_animate():
            flash('test message', 'danger')
            return render_template_string('''
                            {% from 'bootstrap/utils.html' import render_messages %}
                            {{ render_messages(dismissible=True, dismiss_animate=True) }}
                            ''')

        response = self.client.get('/messages')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="alert alert-danger"', data)

        response = self.client.get('/container')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="container flashed-messages">', data)

        response = self.client.get('/dismissible')
        data = response.get_data(as_text=True)
        self.assertIn('alert-dismissible', data)
        self.assertIn('<button type="button" class="close" data-dismiss="alert"', data)
        self.assertNotIn('fade show', data)

        response = self.client.get('/dismiss_animate')
        data = response.get_data(as_text=True)
        self.assertIn('alert-dismissible', data)
        self.assertIn('<button type="button" class="close" data-dismiss="alert"', data)
        self.assertIn('fade show', data)

    # test WTForm fields for render_form and render_field
    def test_render_form_enctype(self):
        class SingleUploadForm(FlaskForm):
            avatar = FileField('Avatar')

        class MultiUploadForm(FlaskForm):
            photos = MultipleFileField('Multiple photos')

        @self.app.route('/single')
        def single():
            form = SingleUploadForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        @self.app.route('/multi')
        def multi():
            form = SingleUploadForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.get('/single')
        data = response.get_data(as_text=True)
        self.assertIn('multipart/form-data', data)

        response = self.client.get('/multi')
        data = response.get_data(as_text=True)
        self.assertIn('multipart/form-data', data)

    # test render_kw class for WTForms field
    def test_form_render_kw_class(self):

        class TestForm(FlaskForm):
            username = StringField('Username')
            password = PasswordField('Password', render_kw={'class': 'my-password-class'})
            submit = SubmitField(render_kw={'class': 'my-awesome-class'})

        @self.app.route('/render_kw')
        def render_kw():
            form = TestForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.get('/render_kw')
        data = response.get_data(as_text=True)
        self.assertIn('class="form-control"', data)
        self.assertNotIn('class="form-control "', data)
        self.assertIn('class="form-control my-password-class"', data)
        self.assertIn('my-awesome-class', data)
        self.assertIn('btn', data)

    # test WTForm field description for BooleanField
    def test_form_description_for_booleanfield(self):

        class TestForm(FlaskForm):
            remember = BooleanField('Remember me', description='Just check this')

        @self.app.route('/description')
        def description():
            form = TestForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.get('/description')
        data = response.get_data(as_text=True)
        self.assertIn('Remember me', data)
        self.assertIn('<small class="form-text text-muted">Just check this</small>', data)

    def test_button_size(self):
        self.assertEqual(current_app.config['BOOTSTRAP_BTN_SIZE'], 'md')
        current_app.config['BOOTSTRAP_BTN_SIZE'] = 'lg'

        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('btn-lg', data)

        @self.app.route('/form2')
        def test_overwrite():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form, button_size='sm') }}
            ''', form=form)

        response = self.client.get('/form2')
        data = response.get_data(as_text=True)
        self.assertNotIn('btn-lg', data)
        self.assertIn('btn-sm', data)

    def test_button_style(self):
        self.assertEqual(current_app.config['BOOTSTRAP_BTN_STYLE'], 'primary')
        current_app.config['BOOTSTRAP_BTN_STYLE'] = 'secondary'

        @self.app.route('/form')
        def test():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.get('/form')
        data = response.get_data(as_text=True)
        self.assertIn('btn-secondary', data)

        @self.app.route('/form2')
        def test_overwrite():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form, button_style='success') }}
            ''', form=form)

        response = self.client.get('/form2')
        data = response.get_data(as_text=True)
        self.assertNotIn('btn-primary', data)
        self.assertIn('btn-success', data)

        @self.app.route('/form3')
        def test_button_map():
            form = HelloForm()
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form, button_map={'submit': 'warning'}) }}
            ''', form=form)

        response = self.client.get('/form3')
        data = response.get_data(as_text=True)
        self.assertNotIn('btn-primary', data)
        self.assertIn('btn-warning', data)

    def test_error_message_for_radiofield_and_booleanfield(self):
        class TestForm(FlaskForm):
            remember = BooleanField('Remember me', validators=[DataRequired()])
            option = RadioField(choices=[('dog', 'Dog'), ('cat', 'Cat'), ('bird', 'Bird'), ('alien', 'Alien')],
                                validators=[DataRequired()])

        @self.app.route('/error', methods=['GET', 'POST'])
        def error():
            form = TestForm()
            if form.validate_on_submit():
                pass
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_form %}
            {{ render_form(form) }}
            ''', form=form)

        response = self.client.post('/error', follow_redirects=True)
        data = response.get_data(as_text=True)
        self.assertIn('This field is required', data)

    def test_render_simple_table(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            text = db.Column(db.Text)

        @self.app.route('/table')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(10):
                m = Message(text='Test message {}'.format(i+1))
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            titles = [('id', '#'), ('text', 'Message')]
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages, titles) }}
                                    ''', titles=titles, messages=messages)

        response = self.client.get('/table')
        data = response.get_data(as_text=True)
        self.assertIn('<table class="table">', data)
        self.assertIn('<th scope="col">#</th>', data)
        self.assertIn('<th scope="col">Message</th>', data)
        self.assertIn('<th scope="col">Message</th>', data)
        self.assertIn('<th scope="row">1</th>', data)
        self.assertIn('<td>Test message 1</td>', data)

    def test_render_customized_table(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            text = db.Column(db.Text)

        @self.app.route('/table')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(10):
                m = Message(text='Test message {}'.format(i+1))
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            titles = [('id', '#'), ('text', 'Message')]
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages, titles, table_classes='table-striped',
                                    header_classes='thead-dark', caption='Messages') }}
                                    ''', titles=titles, messages=messages)

        response = self.client.get('/table')
        data = response.get_data(as_text=True)
        self.assertIn('<table class="table table-striped">', data)
        self.assertIn('<thead class="thead-dark">', data)
        self.assertIn('<caption>Messages</caption>', data)

    def test_render_responsive_table(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            text = db.Column(db.Text)

        @self.app.route('/table')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(10):
                m = Message(text='Test message {}'.format(i+1))
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            titles = [('id', '#'), ('text', 'Message')]
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages, titles, responsive=True,
                                    responsive_class='table-responsive-sm') }}
                                    ''', titles=titles, messages=messages)

        response = self.client.get('/table')
        data = response.get_data(as_text=True)
        self.assertIn('<div class="table-responsive-sm">', data)

    def test_build_table_titles(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            text = db.Column(db.Text)

        @self.app.route('/table')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(10):
                m = Message(text='Test message {}'.format(i+1))
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages) }}
                                    ''', messages=messages)

        response = self.client.get('/table')
        data = response.get_data(as_text=True)
        self.assertIn('<table class="table">', data)
        self.assertIn('<th scope="col">#</th>', data)
        self.assertIn('<th scope="col">Text</th>', data)
        self.assertIn('<th scope="col">Text</th>', data)
        self.assertIn('<th scope="row">1</th>', data)
        self.assertIn('<td>Test message 1</td>', data)

    def test_build_table_titles_with_empty_data(self):

        @self.app.route('/table')
        def test():
            messages = []
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages) }}
                                    ''', messages=messages)

        response = self.client.get('/table')
        self.assertEqual(response.status_code, 200)

    def test_render_table_with_actions(self):
        db = SQLAlchemy(self.app)

        class Message(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            text = db.Column(db.Text)

        @self.app.route('/table/<message_id>/view')
        def test_view_message(message_id):
            return 'Viewing {}'.format(message_id)

        @self.app.route('/table')
        def test():
            db.drop_all()
            db.create_all()
            for i in range(10):
                m = Message(text='Test message {}'.format(i+1))
                db.session.add(m)
            db.session.commit()
            page = request.args.get('page', 1, type=int)
            pagination = Message.query.paginate(page, per_page=10)
            messages = pagination.items
            titles = [('id', '#'), ('text', 'Message')]
            return render_template_string('''
                                    {% from 'bootstrap/table.html' import render_table %}
                                    {{ render_table(messages, titles, show_actions=True,
                                    view_url=url_for('test_view_message', message_id=':primary_key')) }}
                                    ''', titles=titles, messages=messages)

        response = self.client.get('/table')
        data = response.get_data(as_text=True)
        self.assertIn('<a href="/table/1/view">', data)
        self.assertIn('<img src="/bootstrap/static/img/view.svg" alt="View">', data)

    def test_render_hidden_errors(self):
        class TestForm(FlaskForm):
            hide = HiddenField('Hide', validators=[DataRequired('Hide field is empty.')])
            submit = SubmitField()

        @self.app.route('/error', methods=['GET', 'POST'])
        def error():
            form = TestForm()
            if form.validate_on_submit():
                pass
            return render_template_string('''
            {% from 'bootstrap/form.html' import render_field, render_hidden_errors %}
            <form method="post">
                {{ form.hidden_tag() }}
                {{ render_hidden_errors(form) }}
                {{ render_field(form.submit) }}
            </form>
            ''', form=form)

        response = self.client.post('/error', follow_redirects=True)
        data = response.get_data(as_text=True)
        self.assertIn('Hide field is empty.', data)

    def test_render_icon(self):
        @self.app.route('/icon')
        def icon():
            return render_template_string('''
            {% from 'bootstrap/utils.html' import render_icon %}
                {{ render_icon('heart') }}
            ''')

        @self.app.route('/icon-size')
        def icon_size():
            return render_template_string('''
            {% from 'bootstrap/utils.html' import render_icon %}
                {{ render_icon('heart', 32) }}
            ''')

        @self.app.route('/icon-style')
        def icon_style():
            return render_template_string('''
            {% from 'bootstrap/utils.html' import render_icon %}
                {{ render_icon('heart', color='primary') }}
            ''')

        @self.app.route('/icon-color')
        def icon_color():
            return render_template_string('''
            {% from 'bootstrap/utils.html' import render_icon %}
                {{ render_icon('heart', color='green') }}
            ''')

        response = self.client.get('/icon')
        data = response.get_data(as_text=True)
        self.assertIn('bootstrap-icons.svg#heart', data)
        self.assertIn('width="1em"', data)
        self.assertIn('height="1em"', data)

        response = self.client.get('/icon-size')
        data = response.get_data(as_text=True)
        self.assertIn('bootstrap-icons.svg#heart', data)
        self.assertIn('width="32"', data)
        self.assertIn('height="32"', data)

        response = self.client.get('/icon-style')
        data = response.get_data(as_text=True)
        self.assertIn('bootstrap-icons.svg#heart', data)
        self.assertIn('text-primary', data)

        response = self.client.get('/icon-color')
        data = response.get_data(as_text=True)
        self.assertIn('bootstrap-icons.svg#heart', data)
        self.assertIn('style="color: green"', data)

    def test_render_icon_config(self):
        self.app.config['BOOTSTRAP_ICON_SIZE'] = 100
        self.app.config['BOOTSTRAP_ICON_COLOR'] = 'success'

        @self.app.route('/icon')
        def icon():
            return render_template_string('''
            {% from 'bootstrap/utils.html' import render_icon %}
                {{ render_icon('heart') }}
            ''')

        response = self.client.get('/icon')
        data = response.get_data(as_text=True)
        self.assertIn('width="100"', data)
        self.assertIn('height="100"', data)
        self.assertIn('text-success', data)