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_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 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