def setUp(self):
super(BasicAppTestCase, self).setUp()
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return 'added'
@self.app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.db = db
def test_connection_kwargs(self):
"""Make sure additional connection kwargs work."""
# Figure out whether to use "MAX_POOL_SIZE" or "MAXPOOLSIZE" based
# on PyMongo version (former was changed to the latter as described
# in https://jira.mongodb.org/browse/PYTHON-854)
# TODO remove once PyMongo < 3.0 support is dropped
if pymongo.version_tuple[0] >= 3:
MAX_POOL_SIZE_KEY = 'MAXPOOLSIZE'
else:
MAX_POOL_SIZE_KEY = 'MAX_POOL_SIZE'
self.app.config['MONGODB_SETTINGS'] = {
'ALIAS': 'tz_aware_true',
'DB': 'flask_mongoengine_testing_tz_aware',
'TZ_AWARE': True,
'READ_PREFERENCE': ReadPreference.SECONDARY,
MAX_POOL_SIZE_KEY: 10,
}
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection.codec_options.tz_aware)
self.assertEqual(db.connection.max_pool_size, 10)
self.assertEqual(
db.connection.read_preference,
ReadPreference.SECONDARY
)
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'testing'
self.app.config['TESTING'] = True
self.app.config['TEMP_DB'] = True
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return flask.jsonify(result=self.Todo.objects())
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return flask.jsonify(result=todo)
@self.app.route('/show/<id>/')
def show(id):
return flask.jsonify(result=self.Todo.objects.get_or_404(id=id))
self.db = db
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'test_db'
self.app.config['TESTING'] = True
self.app.json_encoder = DummyEncoder
db = MongoEngine()
db.init_app(self.app)
self.db = db
def test_connection_default(self):
self.app.config['MONGODB_SETTINGS'] = {}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
def setup():
app = Flask(__name__)
app.config['SECRET_KEY'] = '1'
app.config['CSRF_ENABLED'] = False
app.config['MONGODB_SETTINGS'] = {'DB': 'tests'}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def setup():
app = Flask(__name__)
app.config["SECRET_KEY"] = "1"
app.config["CSRF_ENABLED"] = False
app.config["MONGODB_SETTINGS"] = {"DB": "tests"}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def create_app():
db = MongoEngine()
app = Flask(__name__)
app.config.from_object(Config)
# flask_security config
user_datastore = MongoEngineUserDatastore(db, Users, Roles)
security = Security(app, user_datastore)
# do some init
db.init_app(app)
create_user_role(user_datastore, db)
return app
def test_multiple_connections(self):
"""Make sure establishing multiple connections to a standalone
MongoDB and switching between them works.
"""
db = MongoEngine()
self.app.config['MONGODB_SETTINGS'] = [
{
'ALIAS': 'default',
'DB': 'flask_mongoengine_test_db_1',
'HOST': 'localhost',
'PORT': 27017
},
{
'ALIAS': 'alternative',
'DB': 'flask_mongoengine_test_db_2',
'HOST': 'localhost',
'PORT': 27017
},
]
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
meta = {'db_alias': 'alternative'}
db.init_app(self.app)
Todo.drop_collection()
# Test saving a doc via the default connection
with switch_db(Todo, 'default') as Todo:
todo = Todo()
todo.text = "Sample"
todo.title = "Testing"
todo.done = True
s_todo = todo.save()
f_to = Todo.objects().first()
self.assertEqual(s_todo.title, f_to.title)
# Make sure the doc doesn't exist in the alternative db
with switch_db(Todo, 'alternative') as Todo:
doc = Todo.objects().first()
self.assertEqual(doc, None)
# Make sure switching back to the default connection shows the doc
with switch_db(Todo, 'default') as Todo:
doc = Todo.objects().first()
self.assertNotEqual(doc, None)
def setUp(self):
db = MongoEngine()
app = Flask("corrdb")
# app.config.MONGODB_SETTINGS = { 'db': 'corrdb', 'host': '0.0.0.0', 'port': 27017 }
print(app.config.db)
app.config.from_object({'db': 'corrdb', 'host': '0.0.0.0', 'port': 27017 })
app.logger_name = "corrdb.app"
# Flask-MongoEngine instance
db.init_app(app)
# Custom Converters
app.url_map.converters['objectid'] = ObjectIDConverter
app.run(debug='--no-debug', host='0.0.0.0', port=5000, threaded=True)
def create_app(app_name=None, blueprints=None):
"""Create the flask app."""
if app_name is None:
app_name = "cowrie_api"
if blueprints is None:
blueprints = DEFAULT_BLUEPRINTS
app = Flask(app_name)
configure_app(app)
configure_logging(app)
db = MongoEngine()
db.app = app
db.init_app(app)
configure_blueprints(app, blueprints)
return app
def test_live_connection(self):
db = MongoEngine()
self.app.config['TEMP_DB'] = True
self.app.config['MONGODB_SETTINGS'] = {
'host' : 'localhost',
'port' : 27017
}
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
db.init_app(self.app)
Todo.drop_collection()
# Test persist
todo = Todo()
todo.text = "Sample"
todo.title = "Testing"
todo.done = True
s_todo = todo.save()
f_to = Todo.objects().first()
self.assertEqual(s_todo.title, f_to.title)
from flask_cors import CORS
from flask_mongoengine import MongoEngine
from flask_httpauth import HTTPBasicAuth
# Flask 实例
blog = Flask(__name__,
instance_relative_config=True,
static_folder = "../../dist/static",
template_folder= "../../dist")
# auth
auth = HTTPBasicAuth()
# 载入配置
blog.config.from_object('config')
blog.config.from_pyfile('config.py')
# 允许跨域
cors = CORS(blog, resource={"/api/*": {"origins": "*"}})
# 数据库初始化
db = MongoEngine()
db.init_app(blog)
# 所有路由由 vue 接管
@blog.route("/", defaults={'path': ''})
@blog.route('/<path:path>')
def catch_all(path):
return render_template("index.html")
import datetime
from flask import Flask
from flask_mongoengine import MongoEngine
db = MongoEngine()
app = Flask(__name__, static_url_path='/assets', static_folder='assets')
app.config['MONGODB_SETTINGS'] = {'DB': 'startup'}
db.init_app(app)
class Keyword(db.Document):
word = db.StringField(unique=True)
website = db.DictField()
weibo = db.DictField()
wechat = db.DictField()
facebook = db.DictField()
twitter = db.DictField()
instagram = db.DictField()
github = db.DictField()
created = db.DateTimeField()
updated = db.DateTimeField(default=datetime.datetime.now)
def save(self, *args, **kwargs):
if not self.created:
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
return super(Keyword, self).save(*args, **kwargs)
def __unicode__(self):
return self.word
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
# For Flask-WTF < 0.9
self.app.config['CSRF_ENABLED'] = False
# For Flask-WTF >= 0.9
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context('/'):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
meta = {'allow_inheritance': True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
lead_paragraph = db.StringField(max_length=200)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True, max_length=200)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(
TextPost,
field_args={'lead_paragraph': {'textarea': True}})
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']}))
self.assertFalse(form.validate())
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(form.title.type, 'StringField')
self.assertEqual(form.content.type, 'TextAreaField')
self.assertEqual(form.lead_paragraph.type, 'TextAreaField')
self.assertEquals(BlogPost.objects.first().title, 'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags': ['flask', 'mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags-0': 'flask',
'tags-1': 'mongodb',
'tags-2': 'mongoengine',
'tags-3': 'flask-mongoengine',
}), instance=post)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(post.tags, ['flask', 'mongodb', 'mongoengine', 'flask-mongoengine'])
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'url': 'http://flask-mongoengine.org',
'interest': '0',
}))
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={'dog': {'queryset': Dog.large_objects}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner, field_args={
'dog': {'allow_blank': True}
})
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate the options - should contain a dog (selected) and a
# blank option there should be an extra blank option.
choices = list(form.dog)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dog.pk)
# Validate selecting one item
form = DogOwnerForm(MultiDict({
'dog': dog.id,
}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({
'dog': u'__None',
}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner, field_args={
'dogs': {'allow_blank': True}
})
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate the options - both dogs should be selected and
# there should be an extra blank option.
choices = list(form.dogs)
self.assertEqual(len(choices), 3)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dogs[0].pk)
self.assertTrue(choices[2].checked)
self.assertEqual(choices[2].data, dogs[1].pk)
# Validate selecting two items
form = DogOwnerForm(MultiDict({
'dogs': [dog.id for dog in dogs],
}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({
'dogs': '__None',
}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context('/'):
db = self.db
choices = (('male', 'Male'), ('female', 'Female'), ('other', 'Other'))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={'answer': {'radio': True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, 'RadioField')
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context('/'):
db = self.db
class Item (db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with='owner_id')
Item.drop_collection()
object_id = bson.ObjectId()
Item(object_id, owner_item_id="1").save()
try:
Item(object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except Exception:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {'lst': {'label': 'Custom Label',
'field_args': {'widget': wtforms.widgets.HiddenInput(),
'label': "Hidden Input"}}}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
class PaginationTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(PaginationTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
self.app.config['CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_queryset_paginator(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
for i in range(42):
Post(title="post: %s" % i).save()
self.assertRaises(NotFound, Pagination, Post.objects, 0, 10)
self.assertRaises(NotFound, Pagination, Post.objects, 6, 10)
paginator = Pagination(Post.objects, 1, 10)
self._test_paginator(paginator)
def test_paginate_plain_list(self):
self.assertRaises(NotFound, Pagination, range(1, 42), 0, 10)
self.assertRaises(NotFound, Pagination, range(1, 42), 6, 10)
paginator = Pagination(range(1, 42), 1, 10)
self._test_paginator(paginator)
def test_list_field_pagination(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
comments = db.ListField(db.StringField())
comment_count = db.IntField()
comments = ["comment: %s" % i for i in range(42)]
post = Post(title="post has comments", comments=comments,
comment_count=len(comments)).save()
# Check without providing a total
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10)
self._test_paginator(paginator)
# Check with providing a total (saves a query)
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10, post.comment_count)
self._test_paginator(paginator)
paginator = post.paginate_field('comments', 1, 10)
self._test_paginator(paginator)
def _test_paginator(self, paginator):
self.assertEqual(5, paginator.pages)
self.assertEqual([1, 2, 3, 4, 5], list(paginator.iter_pages()))
for i in [1, 2, 3, 4, 5]:
if i == 1:
self.assertRaises(NotFound, paginator.prev)
self.assertFalse(paginator.has_prev)
else:
self.assertTrue(paginator.has_prev)
if i == 5:
self.assertRaises(NotFound, paginator.next)
self.assertFalse(paginator.has_next)
else:
self.assertTrue(paginator.has_next)
if i == 3:
self.assertEqual([None, 2, 3, 4, None],
list(paginator.iter_pages(0, 1, 1, 0)))
self.assertEqual(i, paginator.page)
self.assertEqual(i - 1, paginator.prev_num)
self.assertEqual(i + 1, paginator.next_num)
# Paginate to the next page
if i < 5:
paginator = paginator.next()
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = "test_db"
self.app.config["MONGODB_DB"] = self.db_name
self.app.config["TESTING"] = True
# For Flask-WTF < 0.9
self.app.config["CSRF_ENABLED"] = False
# For Flask-WTF >= 0.9
self.app.config["WTF_CSRF_ENABLED"] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context("/"):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({"binary": "1"}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context("/"):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
meta = {"allow_inheritance": True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
lead_paragraph = db.StringField(max_length=200)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True, max_length=200)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(
TextPost, field_args={"lead_paragraph": {"textarea": True}}
)
form = TextPostForm(
MultiDict(
{"title": "Using MongoEngine", "tags": ["mongodb", "mongoengine"]}
)
)
self.assertFalse(form.validate())
form = TextPostForm(
MultiDict(
{
"title": "Using MongoEngine",
"content": "See the tutorial",
"tags": ["mongodb", "mongoengine"],
}
)
)
self.assertTrue(form.validate())
form.save()
self.assertEqual(form.title.type, "StringField")
self.assertEqual(form.content.type, "TextAreaField")
self.assertEqual(form.lead_paragraph.type, "TextAreaField")
self.assertEqual(BlogPost.objects.first().title, "Using MongoEngine")
self.assertEqual(BlogPost.objects.count(), 1)
form = TextPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags": ["flask", "mongodb", "mongoengine"],
}
)
)
self.assertTrue(form.validate())
form.save()
self.assertEqual(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags-0": "flask",
"tags-1": "mongodb",
"tags-2": "mongoengine",
"tags-3": "flask-mongoengine",
}
),
instance=post,
)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(
post.tags, ["flask", "mongodb", "mongoengine", "flask-mongoengine"]
)
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"url": "http://flask-mongoengine.org",
"interest": "0",
}
)
)
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=["tags"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
BlogPostForm = model_form(BlogPost, exclude=["posted"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=["german sheppard", "wolfhound"])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(
DogOwner, field_args={"dog": {"queryset": Dog.large_objects}}
)
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(
DogOwner, field_args={"dog": {"allow_blank": True}}
)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate the options - should contain a dog (selected) and a
# blank option there should be an extra blank option.
choices = list(form.dog)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, "__None")
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dog.pk)
# Validate selecting one item
form = DogOwnerForm(MultiDict({"dog": dog.id}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({"dog": "__None"}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_modelselectfield_multiple(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(
DogOwner, field_args={"dogs": {"allow_blank": True}}
)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate the options - both dogs should be selected and
# there should be an extra blank option.
choices = list(form.dogs)
self.assertEqual(len(choices), 3)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, "__None")
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dogs[0].pk)
self.assertTrue(choices[2].checked)
self.assertEqual(choices[2].data, dogs[1].pk)
# Validate selecting two items
form = DogOwnerForm(MultiDict({"dogs": [dog.id for dog in dogs]}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({"dogs": "__None"}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context("/"):
db = self.db
choices = (("male", "Male"), ("female", "Female"), ("other", "Other"))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={"answer": {"radio": True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, "RadioField")
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context("/"):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={"password": {"password": True}})
form = UserForm(password="******")
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context("/"):
db = self.db
class Item(db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with="owner_id")
Item.drop_collection()
object_id = bson.ObjectId()
Item(owner_id=object_id, owner_item_id="1").save()
try:
Item(owner_id=object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except Exception:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context("/"):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {
"lst": {
"label": "Custom Label",
"field_args": {
"widget": wtforms.widgets.HiddenInput(),
"label": "Hidden Input",
},
}
}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string(
"{{ custom_form.lst.label }}", custom_form=custom_form
)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string(
"{{ custom_form.lst }}", custom_form=custom_form
)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(
required=True,
help_text="Some imaginative title to set the world on fire",
)
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(
form.title.description,
"Some imaginative title to set the world on fire",
)
def test_shared_field_args(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {
"title": {"validators": [wtforms.validators.Regexp("test")]}
}
TitleOnlyForm = model_form(
BlogPost, field_args=shared_field_args, exclude=["content"]
)
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
def create_app(is_sentry_on=False, **kwargs):
app = Flask(__name__)
app.config.update(kwargs or {})
db = MongoEngine()
CORS(app)
if 'TESTING' in kwargs and kwargs['TESTING']:
app.testing = True
db.init_app(
app, {
'MONGODB_SETTINGS': {
'db':
'testing',
'host':
'mongodb://*****:*****@ds111876.mlab.com:11876/testing'
}
})
# db.connection
else:
app.config['MONGODB_SETTINGS'] = {
'db':
'cheapbookdev',
'host':
'mongodb://*****:*****@ds053305.mlab.com:53305/cheapbookdev'
}
db.init_app(app)
import models
configs = models.Config.objects.get(config_id='initials')
app.config.from_object(configs)
app.config['DEBUG'] = False
mail = flask_mail.Mail()
mail.init_app(app=app)
if is_sentry_on:
sentry = Sentry(
dsn=
'https://*****:*****@sentry.io/177217'
)
sentry.init_app(app)
flask_mobility.Mobility().init_app(app=app)
from utils.exception_handler import error_dict, Handler
for e in error_dict:
app.register_error_handler(e, Handler(e).generate_response)
from utils.exceptions import general_exceptions
# @app.errorhandler(404)
# @app.errorhandler(401)
@app.errorhandler(500)
@json_response
def page_not_found_500(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.errorhandler(404)
@json_response
def page_not_found_404(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.before_request
def before_request():
request_data = save_request(request)
global_storage.request_data = request_data
@app.after_request
def after_request(resp):
resp_data = save_response(resp)
request_data = global_storage.request_data
traffic = models.Traffic(request=request_data, response=resp_data)
traffic.save()
return resp
import URLs
routes = URLs.get_urls()
for model in dir(models):
temp_class = getattr(models, model)
if inspect.isclass(temp_class) and issubclass(
temp_class, models.base.BaseDocument):
print(temp_class.__name__)
app.url_map.converters[
temp_class.__name__] = temp_class.get_converter()
for route in routes:
imported_class = route['cls']
route_object = imported_class()
app.add_url_rule(route['route'],
view_func=route_object.dispatcher,
endpoint=route['endpoint'],
methods=['GET', 'POST', 'PUT', 'DELETE'])
return app
"""
CRUD and filter tests
"""
import json
import unittest
from unittest.mock import MagicMock
from flask_mongoengine import MongoEngine
from app import APP
from authentification import JwtTokenAuthentication
from documents import Comment, User
DB = MongoEngine()
APP.config.from_pyfile('configs/testing.conf')
DB.init_app(APP)
class UnauthorizedTestCase(unittest.TestCase):
"""
Authorization method returns unauthorized 401
"""
def setUp(self):
self.authorized = JwtTokenAuthentication.authorized
JwtTokenAuthentication.authorized = MagicMock(return_value=False)
def tearDown(self):
JwtTokenAuthentication.authorized = self.authorized
class AuthorizedTestCase(unittest.TestCase):
"""
Authorization method returns authorized 200
def get_db_connection(app):
app.config['MONGODB_HOST'] = DB_URI
db = MongoEngine()
db.init_app(app)
return db
from flask import Flask, render_template, request, redirect
from flask_mongoengine import MongoEngine
from datetime import datetime
import mongoengine as me
app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = { #connection to databse
'db': 'mydb',
'host': 'localhost',
'port': 27017
}
db = MongoEngine()
db.init_app(app) #creates the object of database connection
class Task(me.Document): #creating database model
content = me.StringField(max_length=200, required=True)
created_on = me.DateTimeField(default=datetime.utcnow())
status = me.BooleanField(default=False)
@app.route('/', methods=['POST', 'GET']) #default routing function
def index():
if request.method == 'POST': #if method is POST
task_content = request.form['content'] #get the data from form and
new_task = Task(content=task_content) #create new object to store data
try:
new_task.save() #push this newly created object into database
from flask import Flask from config import Config from flask_mongoengine import MongoEngine from flask_restplus import Api api = Api() app = Flask(__name__) app.config.from_object(Config) #print(app.config.from_object(Config)) db = MongoEngine() db.init_app(app) api.init_app(app) from application import routes
from flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
from flask_security.utils import encrypt_password
import flask_admin
from flask_admin.contrib import sqla
from flask_mongoengine import MongoEngine
from flask_admin.contrib.mongoengine import ModelView
from flask_admin import helpers as admin_helpers
# Create Flask application
app = Flask(__name__)
app.config.from_pyfile('config.py')
# Creamos modelo relacional
db = SQLAlchemy(app)
#Creamos modelo
dbm = MongoEngine()
dbm.init_app(app)
# Define models
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
APP.secret_key = session_key("key.hex")
APP.jinja_env.add_extension('jinja2.ext.loopcontrols')
INTROMARKDOWN = intro(
"README.md",
"https://raw.githubusercontent.com/qeeqbox/analyzer/master/README.md")
APP.config['MONGODB_SETTINGS'] = json_settings[
environ["analyzer_env"]]["web_mongo"]
APP.config['SESSION_COOKIE_SAMESITE'] = "Lax"
QUEUE = QBQueue("analyzer",
json_settings[environ["analyzer_env"]]["redis_settings"])
ANALYZER_TIMEOUT = json_settings[environ["analyzer_env"]]["analyzer_timeout"]
FUNCTION_TIMEOUT = json_settings[environ["analyzer_env"]]["function_timeout"]
MALWARE_FOLDER = json_settings[environ["analyzer_env"]]["malware_folder"]
MONGO_DB = MongoEngine()
MONGO_DB.init_app(APP)
BCRYPT = Bcrypt(APP)
LOGIN_MANAGER = LoginManager()
LOGIN_MANAGER.setup_app(APP)
CSRF = CSRFProtect()
CSRF.init_app(APP)
Markdown(APP)
class Namespace:
'''
this namespace for switches
'''
def __init__(self, kwargs):
self.__dict__.update(kwargs)
