def _get_flask_app(roles=False, **kwargs):
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(
SECRET_KEY, db=db, roles=roles, password_minlen=3, **kwargs)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.add(user)
user2 = User(login=u'foo', password='******')
db.add(user2)
db.commit()
app = Flask('test')
app.secret_key = os.urandom(32)
app.testing = True
@app.route('/protected/')
@auth.protected()
def protected():
return u'Welcome'
authcode.setup_for_flask(auth, app)
auth.session = {}
return auth, app, user
def test_role_model():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db, roles=True)
Role = auth.Role
db.create_all()
role = Role(name=u'admin')
db.session.add(role)
db.commit()
assert role.name == u'admin'
assert repr(role) == '<Role admin>'
def test_user_model_to_dict():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db, roles=True)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
db.commit()
user_dict = user.to_dict()
assert user_dict
def test_backwards_compatibility():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
db.commit()
assert user._password == user.password
user._password = '******'
assert user.password == 'raw'
def test_formset_missing_objs():
db = SQLAlchemy()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User',
backref=db.backref('addresses', lazy='dynamic'))
def __repr__(self):
return self.email
db.create_all()
class FormAddress(f.Form):
_model = Address
email = f.Text(validate=[f.ValidEmail])
def __repr__(self):
return '<FormAddress %s>' % (self.email.value,)
class FormUser(f.Form):
_model = User
name = f.Text()
addresses = f.FormSet(FormAddress, parent='user')
user = User(name=u'John Doe')
db.add(user)
a1 = Address(email=u'*****@*****.**', user=user)
db.add(a1)
a2 = Address(email=u'*****@*****.**', user=user)
db.add(a2)
a3 = Address(email=u'*****@*****.**', user=user)
db.add(a3)
db.commit()
print([(a.id, a.email) for a in user.addresses])
data = {
'name': u'Jane Doe',
'formaddress.1-email': u'*****@*****.**',
'formaddress.3-email': u'*****@*****.**',
'formaddress.4-email': u'*****@*****.**',
}
form = FormUser(data, user)
assert form.is_valid()
assert form.addresses.missing_objs == [a2]
def test_custom_templates():
db = SQLAlchemy('sqlite:///:memory:')
options = {
'template_sign_in': 'sign-in.html',
'template_sign_out': 'sign-out.html',
'template_reset': 'reset-password.html',
'template_reset_email': 'reset-password-email.html',
'template_change_password': '******',
}
inbox = []
def send_email(user, subject, msg):
inbox.append(msg)
auth = authcode.Auth(SECRET_KEY, db=db, **options)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.add(user)
db.commit()
custom_templates = os.path.join(
os.path.dirname(__file__),
'custom_templates'
)
app = Flask('test', template_folder=custom_templates)
app.secret_key = os.urandom(32)
app.testing = True
authcode.setup_for_flask(auth, app, send_email=send_email)
auth.session = {}
client = app.test_client()
resp = client.get(auth.url_sign_in)
assert resp.data == b'OK SIGN IN'
resp = client.get(auth.url_reset_password)
assert resp.data == b'OK RESET PASSWORD'
data = dict(login=user.login, _csrf_token=auth.get_csrf_token())
resp = client.post(auth.url_reset_password, data=data)
assert inbox[0] == 'OK RESET PASSWORD EMAIL'
auth.login(user)
resp = client.get(auth.url_change_password)
assert resp.data == b'OK CHANGE PASSWORD'
url = '{0}?_csrf_token={1}'.format(auth.url_sign_out, auth.get_csrf_token())
resp = client.get(url)
assert resp.data == b'OK SIGN OUT'
def test_multiple_databases():
db1 = SQLAlchemy(URI1)
db2 = SQLAlchemy(URI2)
ToDo1 = create_test_model(db1)
ToDo2 = create_test_model(db2)
db1.create_all()
db2.create_all()
db1.add(ToDo1('A', 'a'))
db1.add(ToDo1('B', 'b'))
db2.add(ToDo2('Q', 'q'))
db1.add(ToDo1('C', 'c'))
db1.commit()
db2.commit()
assert db1.query(ToDo1).count() == 3
assert db2.query(ToDo2).count() == 1
def test_aggregated_query():
db = SQLAlchemy(URI1)
class Unit(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
price = db.Column(db.Integer)
db.create_all()
db.add(Unit(price=25))
db.add(Unit(price=5))
db.add(Unit(price=10))
db.add(Unit(price=3))
db.commit()
res = db.query(db.func.sum(Unit.price).label('price')).first()
assert res.price == 43
def test_user_model():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db, roles=True)
assert auth.users_model_name == 'User'
assert auth.roles_model_name == 'Role'
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
db.commit()
assert user.login == u'meh'
assert user.email == user.login
assert hasattr(user, 'password')
assert hasattr(user, 'last_sign_in')
assert repr(user) == '<User meh>'
def test_multiple_databases():
db1 = SQLAlchemy(URI1)
db2 = SQLAlchemy(URI2)
ToDo1 = create_test_model(db1)
ToDo2 = create_test_model(db2)
db1.create_all()
db2.create_all()
db1.add(ToDo1('A', 'a'))
db1.add(ToDo1('B', 'b'))
db2.add(ToDo2('Q', 'q'))
db1.add(ToDo1('C', 'c'))
db1.commit()
db2.commit()
assert db1.query(ToDo1).count() == 3
assert db2.query(ToDo2).count() == 1
def test_aggregated_query():
db = SQLAlchemy(URI1)
class Unit(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
price = db.Column(db.Integer)
db.create_all()
db.add(Unit(price=25))
db.add(Unit(price=5))
db.add(Unit(price=10))
db.add(Unit(price=3))
db.commit()
res = db.query(db.func.sum(Unit.price).label('price')).first()
assert res.price == 43
def test_save():
db = SQLAlchemy()
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
subject = db.Column(db.Unicode, nullable=False)
email = db.Column(db.Unicode)
message = db.Column(db.UnicodeText, nullable=False)
db.create_all()
class MyContactForm(f.Form):
_model = Contact
subject = f.Text(validate=[f.Required])
email = f.Text(validate=[f.ValidEmail])
message = f.Text(validate=[
f.Required(message=u'write something!')
])
# Create new object
data = {
'subject': u'foo',
'message': u'bar',
'email': u'*****@*****.**',
}
form = MyContactForm(data)
assert form.is_valid()
contact = form.save()
print('contact', contact.__dict__)
assert isinstance(contact, Contact)
assert contact.id is None
assert contact.subject == data['subject']
assert contact.message == data['message']
assert contact.email == data['email']
db.commit()
# Update object
data['message'] = u'lalala'
form = MyContactForm(data, obj=contact)
assert form.is_valid()
contact = form.save()
assert contact.id is not None
assert contact.message == data['message']
db.commit()
def test_prefix_save():
db = SQLAlchemy()
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
subject = db.Column(db.Unicode, nullable=False)
email = db.Column(db.Unicode)
message = db.Column(db.UnicodeText, nullable=False)
db.create_all()
class MyContactForm(f.Form):
_model = Contact
subject = f.Text(validate=[f.Required])
email = f.Text(validate=[f.ValidEmail])
message = f.Text(validate=[
f.Required(message=u'write something!')
])
data = {
'meh-subject': u'Hello',
'meh-message': u'Welcome',
}
form = MyContactForm(data, prefix='meh')
assert form.is_valid()
contact = form.save()
assert isinstance(contact, Contact)
db.commit()
assert contact.subject == data['meh-subject']
assert contact.message == data['meh-message']
data = {
'meh-subject': u'foo',
'meh-message': u'bar',
}
form = MyContactForm(data, obj=contact, prefix='meh')
assert form.is_valid()
assert form.has_changed
form.save()
db.commit()
assert contact.subject == data['meh-subject']
assert contact.message == data['meh-message']
def test_user_model_methods():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
db.commit()
assert User.by_id(user.id) == user
assert User.by_id(33) is None
assert User.by_login(u'meh') == user
assert User.by_login(u'foobar') is None
assert user.has_password('foobar')
assert not user.has_password('abracadabra')
assert user.get_token()
assert user.get_uhmac()
def test_reconfigure(tmpdir):
db = SQLAlchemy(URI1, echo=False)
class CustomQuery(BaseQuery):
some_attr = 1
class Model(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
db.add(Model())
db.commit()
tmp_db_file = tmpdir.mkdir('test_reconfigure').join('db.sqlite')
uri = 'sqlite:///%s' % tmp_db_file.strpath.replace('\\', '/')
db.reconfigure(uri=uri, echo=True, query_cls=CustomQuery)
assert not Model.__table__.exists(db.engine)
assert (uri, True) == db.connector._connected_for
assert isinstance(db.query(Model), CustomQuery)
assert db.query(Model).some_attr == 1
def create_test_model():
db = SQLAlchemy('sqlite://')
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Part(db.Model):
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey(Item.id))
item = db.relationship('Item', backref='parts')
db.create_all()
for i in range(1, 26):
item = Item()
db.add(item)
db.commit()
item = db.query(Item).first()
for j in range(1, 26):
db.add(Part(item=item))
db.commit()
return db, Item, Part
def create_test_model():
db = SQLAlchemy('sqlite://')
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Part(db.Model):
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey(Item.id))
item = db.relationship('Item', backref='parts')
db.create_all()
for i in range(1, 26):
item = Item()
db.add(item)
db.commit()
item = db.query(Item).first()
for j in range(1, 26):
db.add(Part(item=item))
db.commit()
return db, Item, Part
def test_role_model_methods():
db = SQLAlchemy('sqlite:///:memory:')
auth = authcode.Auth(SECRET_KEY, db=db, roles=True)
Role = auth.Role
db.create_all()
role = Role(name=u'admin')
db.session.add(role)
db.commit()
assert Role.by_id(role.id) == role
assert Role.by_id(33) is None
assert Role.by_name(u'admin') == role
assert Role.by_name(u'foobar') is None
assert Role.get_or_create(u'admin') == role
role2 = Role.get_or_create(u'owner')
db.commit()
assert role2 != role
assert db.query(Role).count() == 2
assert list(role.users) == []
assert list(role2.users) == []
def test_missing_fields_obj():
db = SQLAlchemy()
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
subject = db.Column(db.Unicode)
db.create_all()
class ContactForm(f.Form):
_model = Contact
subject = f.Text()
contact = Contact(subject=u'foobar')
db.add(contact)
db.commit()
form = ContactForm({}, contact)
new_contact = form.save()
assert new_contact.subject == u'foobar'
form = ContactForm({'subject': u''}, contact)
new_contact = form.save()
assert new_contact.subject == u''
id = Column(Integer, primary_key=True)
parent_id = Column(Integer, ForeignKey('parent.id'))
child_attr = db.Column(String(20))
parent = relationship('Parent')
db.create_all()
p1 = Parent(name="Akshay")
db.add(p1)
c1 = Child(child_attr="Child1")
c1.parent_id = p1.id
db.add(c1)
p2 = Parent(name="Piyush")
db.add(p2)
c2 = Child(child_attr="Child2")
c2.parent_id = p2.id
db.add(c2)
for user in db.query(Parent):
print user.name, '\t', user.id
for user in db.query(Child):
print user.id, user.parent_id, user.child_attr
db.commit()
def test_lazy_user():
db = SQLAlchemy()
auth = authcode.Auth(SECRET_KEY, db=db)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
db.commit()
storage = Meh()
lazy = utils.LazyUser(auth, storage)
assert not storage.user
assert not lazy
storage.user = None
auth.login(user)
assert lazy
assert storage.user == user
storage.user = None
assert lazy.login == user.login
assert storage.user == user
storage.user = None
lazy.login = u'yeah'
assert user.login == u'yeah'
assert storage.user == user
storage.user = None
assert repr(lazy) == repr(user)
assert storage.user == user
storage.user = None
assert str(lazy) == str(user)
assert storage.user == user
storage.user = None
assert text_type(lazy) == text_type(user)
assert storage.user == user
storage.user = None
assert lazy.__doc__ == user.__doc__
assert storage.user == user
storage.user = None
assert user.__dict__ == lazy.__dict__
assert storage.user == user
storage.user = None
assert dir(lazy) == dir(user)
assert storage.user == user
storage.user = None
assert lazy == user
assert storage.user == user
storage.user = None
assert not lazy != user
assert storage.user == user
storage.user = None
assert lazy and user == user
assert storage.user == user
storage.user = None
assert lazy or user == user
assert storage.user == user
storage.user = None
assert hash(lazy) == hash(user)
assert storage.user == user
storage.user = None
delattr(lazy, 'last_sign_in')
assert storage.user == user
assert getattr(user, 'last_sign_in', None) is None
count+=1
product.product_other_picture = '|'.join(true)
db.session.add(product)
db.session.commit()
break
except:
if soup.findAll("div", {"class": "ui-image-viewer-thumb-wrap"}):
print 'OK_SetFlag_to_1'
product.product_test_one_flag = 1
db.session.add(product)
db.session.commit()
count += 1
break
else:
print 'Change Proxy'
renew_connection()
else:
count += 1
a = raw_input()
os = raw_input()
if a == '1':
db.create_all()
get_products_list()
db.commit()
elif a =='2':
get_all_picture()
def test_lazy_user_unusual_methods():
class UserMixin(object):
items = []
def __lt__(self, other):
return True
def __le__(self, other):
return True
def __gt__(self, other):
return True
def __ge__(self, other):
return True
def __call__(self, *args, **kwargs):
return 'called'
def __setitem__(self, key, value):
self.items[key] = value
def __delitem__(self, key):
del self.items[key]
def __getitem__(self, i):
return self.items[i]
def __contains__(self, i):
return i in self.items
def __iter__(self):
return iter(self.items)
def __add__(self, other):
return 42
def __sub__(self, other):
return 42
def __mul__(self, other):
return 42
def __floordiv__(self, other):
return 42
def __mod__(self, other):
return 42
def __divmod__(self, other):
return (42, 0)
def __pow__(self, other):
return 42
def __lshift__(self, other):
return 42
def __rshift__(self, other):
return 42
def __and__(self, other):
return 42
def __or__(self, other):
return 42
def __xor__(self, other):
return 42
def __div__(self, other):
return 42
def __truediv__(self, other):
return 42
def __neg__(self):
return -42
def __pos__(self):
return 42
def __abs__(self):
return 42
def __len__(self):
return 42
def __complex__(self):
return 42j
def __int__(self):
return 42
def __float__(self):
return 42.0
def __invert__(self):
return 42
def __enter__(self):
return self.items.insert(0, 'enter')
def __exit__(self, *args, **kwargs):
return self.items.append('exit')
db = SQLAlchemy()
auth = authcode.Auth(SECRET_KEY, db=db, UserMixin=UserMixin)
User = auth.User
db.create_all()
user = User(login=u'meh', password='******')
db.session.add(user)
other = User(login=u'foobar', password='******')
db.session.add(other)
db.commit()
storage = Meh()
lazy = utils.LazyUser(auth, storage)
user.items = 'a b c d e f g'.split(' ')
auth.login(user)
assert lazy >= user
assert lazy <= user
assert lazy > user
assert lazy < user
assert lazy() == 'called'
lazy[0] = 'a' # __setitem__
assert user.items[0] == 'a'
del lazy[1] # __delitem__
assert lazy[1] == 'c' # __getitem__
assert 'f' in lazy # __contains__
assert list(iter(lazy)) == list(iter(user)) # __iter__
assert lazy + 1 == 42 # __add__
assert lazy - 1 == 42 # __sub__
assert lazy * 3 == 42 # __mul__
assert lazy / 3 == 42 # __div__
assert lazy.__floordiv__(3) == 42 # __floordiv__
assert lazy.__truediv__(3) == 42 # __truediv__
assert lazy % 33 == 42 # __mod__
assert divmod(lazy, 5) == (42, 0) # __divmod__
assert lazy ** 3 == 42 # __pow__
assert lazy << 1 == 42 # __lshift__
assert lazy >> 1 == 42 # __rshift__
assert lazy & 6 == 42 # __and__
assert lazy | 6 == 42 # __or__
assert lazy ^ 6 == 42 # __xor__
assert -lazy == -42 # __neg__
assert +lazy == 42 # __pos__
assert abs(lazy) == 42 # __abs__
assert len(lazy) == 42 # __len__
assert int(lazy) == 42 # __int__
assert float(lazy) == 42.0 # __float__
assert ~lazy == 42 # __invert__
assert lazy.__complex__() == 42j # __complex__
with lazy: # __enter__ and __exit__
pass
assert user.items[0] == 'enter'
assert user.items[-1] == 'exit'
def test_cascade_save():
db = SQLAlchemy()
class ModelA(db.Model):
id = db.Column(db.Integer, primary_key=True)
a1 = db.Column(db.Unicode, nullable=False)
a2 = db.Column(db.Unicode)
class ModelB(db.Model):
id = db.Column(db.Integer, primary_key=True)
b1 = db.Column(db.Unicode, nullable=False)
b2 = db.Column(db.Unicode)
db.create_all()
class FormA(f.Form):
_model = ModelA
a1 = f.Text(validate=[f.Required])
a2 = f.Text()
class FormB(f.Form):
_model = ModelB
b1 = f.Text(validate=[f.Required])
b2 = f.Text()
class WrapForm(f.Form):
wr = f.Text()
fa = FormA()
fb = FormB()
data = {
'wr': u'foo',
'fa.a1': u'AAA1',
'fa.a2': u'AAA2',
'fb.b1': u'BBB1',
'fb.b2': u'BBB2',
}
form = WrapForm(data)
assert form.is_valid()
form.save()
db.commit()
assert db.query(ModelA).count() == 1
assert db.query(ModelB).count() == 1
obja = db.query(ModelA).first()
assert obja.a1 == data['fa.a1']
assert obja.a2 == data['fa.a2']
objb = db.query(ModelB).first()
assert objb.b1 == data['fb.b1']
assert objb.b2 == data['fb.b2']
# Update
data = {
'wr': u'foo',
'fa.a1': u'A1',
'fa.a2': u'A2',
'fb.b1': u'B1',
'fb.b2': u'B2',
}
objs = {
'fa': obja,
'fb': objb
}
form = WrapForm(data, obj=objs)
assert form.is_valid()
form.save()
db.commit()
assert db.query(ModelA).count() == 1
assert db.query(ModelB).count() == 1
obja = db.query(ModelA).first()
assert obja.a1 == data['fa.a1']
assert obja.a2 == data['fa.a2']
objb = db.query(ModelB).first()
assert objb.b1 == data['fb.b1']
assert objb.b2 == data['fb.b2']
def test_formset_model():
db = SQLAlchemy()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship(
'User', backref=db.backref('addresses', lazy='dynamic')
)
def __repr__(self):
return '<Address %s>' % (self.email,)
db.create_all()
class FormAddress(f.Form):
_model = Address
email = f.Text(validate=[f.ValidEmail])
def __repr__(self):
return '<FormAddress %s>' % (self.email.value,)
class FormUser(f.Form):
_model = User
name = f.Text()
addresses = f.FormSet(FormAddress, parent='user')
# Save
data = {
'name': u'John Doe',
'addresses.1-email': u'*****@*****.**',
'addresses.2-email': u'*****@*****.**',
'addresses.3-email': u'*****@*****.**',
}
form = FormUser(data)
assert form.is_valid()
user = form.save()
db.commit()
assert db.query(User).count() == 1
assert db.query(Address).count() == 3
addr = db.query(Address).first()
assert addr.email == data['addresses.1-email']
assert addr.user == user
# Update
user = db.query(User).first()
data = {
'name': u'Max Smart',
'addresses.1-email': u'*****@*****.**',
'addresses.2-email': u'*****@*****.**',
'addresses.3-email': u'*****@*****.**',
}
form = FormUser(data, obj=user)
assert form.is_valid()
form.save()
db.commit()
assert user.name == data['name']
assert db.query(Address).count() == 3
addr = db.query(Address).first()
assert addr.email == data['addresses.1-email']
assert addr.user == user
