def test_first(self): db = sqlsoup.SqlSoup(engine) MappedUsers = db.users user = db.users.filter(db.users.name == 'Bhargan Basepair').one() eq_( user, MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1)) db.rollback() user = db.users.get('Bhargan Basepair') eq_( user, MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1)) db.rollback() user = db.users.filter_by(name='Bhargan Basepair').one() eq_( user, MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1)) db.rollback()
def test_relations(self): db = sqlsoup.SqlSoup(engine) db.users.relate('loans', db.loans) MappedLoans = db.loans MappedUsers = db.users eq_( db.users.get('Joe Student').loans, [ MappedLoans(book_id=1, user_name=u'Joe Student', loan_date=datetime.datetime(2006, 7, 12, 0, 0)) ]) db.rollback() eq_( db.users.filter(~db.users.loans.any()).all(), [ MappedUsers(name=u'Bhargan Basepair', email='*****@*****.**', password=u'basepair', classname=None, admin=1) ]) db.rollback() del db._cache['users'] db.users.relate('loans', db.loans, order_by=db.loans.loan_date, cascade='all, delete-orphan')
def test_clear(self): db = sqlsoup.SqlSoup(engine) eq_(db.loans.count(), 1) _ = db.loans.insert(book_id=1, user_name='Bhargan Basepair') db.expunge_all() db.flush() eq_(db.loans.count(), 1)
def test_mapped_join(self): db = sqlsoup.SqlSoup(engine) join1 = MappedJoin = db.join(db.users, db.loans, isouter=True) mj = join1.filter_by(name='Joe Student').all() eq_(mj, [ MappedJoin( name=u'Joe Student', email=u'*****@*****.**', password=u'student', classname=None, admin=0, book_id=1, user_name=u'Joe Student', loan_date=datetime.datetime(2006, 7, 12, 0, 0), ) ]) db.rollback() join2 = MappedJoin = db.join(join1, db.books) mj = join2.all() eq_(mj, [ MappedJoin( name=u'Joe Student', email=u'*****@*****.**', password=u'student', classname=None, admin=0, book_id=1, user_name=u'Joe Student', loan_date=datetime.datetime(2006, 7, 12, 0, 0), id=1, title=u'Mustards I Have Known', published_year=u'1989', authors=u'Jones', ) ]) eq_( db.with_labels(join1).c.keys(), [ u'users_name', u'users_email', u'users_password', u'users_classname', u'users_admin', u'loans_book_id', u'loans_user_name', u'loans_loan_date', ]) labeled_loans = db.with_labels(db.loans) eq_( db.join(db.users, labeled_loans, isouter=True).c.keys(), [ u'name', u'email', u'password', u'classname', u'admin', u'loans_book_id', u'loans_user_name', u'loans_loan_date', ])
def test_cls_crud(self): db = sqlsoup.SqlSoup(engine) MappedUsers = db.users db.users.filter_by(name='Bhargan Basepair' ).update(dict(name='Some New Name')) u1 = db.users.filter_by(name='Some New Name').one() eq_(u1, MappedUsers(name=u'Some New Name', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1))
def test_map_to_no_pk_selectable(self): db = sqlsoup.SqlSoup(engine) table = Table('users', db._metadata, Column('id', Integer)) assert_raises_message(sqlsoup.PKNotFoundError, "table 'users' does not have a primary ", db.map_to, 'users', selectable=table)
def test_order_by(self): db = sqlsoup.SqlSoup(engine) MappedUsers = db.users users = db.users.order_by(db.users.name).all() eq_(users, [MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1), MappedUsers(name=u'Joe Student', email=u'*****@*****.**', password=u'student', classname=None, admin=0)])
def test_map_to_attr_present(self): db = sqlsoup.SqlSoup(engine) users = db.users assert_raises_message(exc.InvalidRequestError, "Attribute 'users' is already mapped", db.map_to, 'users', tablename='users')
def test_map_to_nothing(self): db = sqlsoup.SqlSoup(engine) assert_raises_message( exc.ArgumentError, "'tablename' or 'selectable' argument is " "required.", db.map_to, 'users', )
def test_dont_persist_alias(self): db = sqlsoup.SqlSoup(engine) MappedBooks = db.books b = db.books._table s = select([b.c.published_year, func.count('*').label('n')], from_obj=[b], group_by=[b.c.published_year]) s = s.alias('years_with_count') years_with_count = db.map(s, primary_key=[s.c.published_year]) assert_raises(exc.InvalidRequestError, years_with_count.insert, published_year='2007', n=1)
def test_map_to_table_not_string(self): db = sqlsoup.SqlSoup(engine) table = Table('users', db._metadata, Column('id', Integer, primary_key=True)) assert_raises_message(exc.ArgumentError, "'tablename' argument must be a string.", db.map_to, 'users', tablename=table)
def test_map_table(self): db = sqlsoup.SqlSoup(engine) users = Table('users', db._metadata, autoload=True) MappedUsers = db.map(users) users = MappedUsers.order_by(db.users.name).all() eq_(users, [MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1), MappedUsers(name=u'Joe Student', email=u'*****@*****.**', password=u'student', classname=None, admin=0)])
def test_map_to_string_not_selectable(self): db = sqlsoup.SqlSoup(engine) assert_raises_message(exc.ArgumentError, "'selectable' argument must be a " "table, select, join, or other " "selectable construct.", db.map_to, 'users', selectable='users')
def test_selectable(self): db = sqlsoup.SqlSoup(engine) MappedBooks = db.books b = db.books._table s = select([b.c.published_year, func.count('*').label('n')], from_obj=[b], group_by=[b.c.published_year]) s = s.alias('years_with_count') years_with_count = db.map(s, primary_key=[s.c.published_year]) eq_(years_with_count.filter_by(published_year='1989').all(), [MappedBooks(published_year=u'1989', n=1)])
def test_map_to_invalid_schema(self): db = sqlsoup.SqlSoup(engine) table = Table('users', db._metadata, Column('id', Integer)) assert_raises_message(exc.ArgumentError, "'tablename' argument is required when " "using 'schema'.", db.map_to, 'users', selectable=table, schema='hoho')
def test_map_to_table_or_selectable(self): db = sqlsoup.SqlSoup(engine) table = Table('users', db._metadata, Column('id', Integer, primary_key=True)) assert_raises_message( exc.ArgumentError, "'tablename' and 'selectable' arguments are mutually exclusive", db.map_to, 'users', tablename='users', selectable=table)
def test_explicit_session(self): Session = scoped_session(sessionmaker()) db = sqlsoup.SqlSoup(engine, session=Session) try: MappedUsers = db.users sess = Session() assert db.users._query.session is db.users.session is sess row = db.users.insert(name='new name', email='new email') assert row in sess finally: sess.rollback() sess.close()
def test_whereclause(self): db = sqlsoup.SqlSoup(engine) MappedUsers = db.users where = or_(db.users.name == 'Bhargan Basepair', db.users.email == '*****@*****.**') users = \ db.users.filter(where).order_by(desc(db.users.name)).all() eq_(users, [MappedUsers(name=u'Joe Student', email=u'*****@*****.**', password=u'student', classname=None, admin=0), MappedUsers(name=u'Bhargan Basepair', email=u'*****@*****.**', password=u'basepair', classname=None, admin=1)])
def daemon_loop(self, db_connection_url): '''Main processing loop for Non-Tunneling Agent. :param options: database information - in the event need to reconnect ''' self.local_vlan_map = {} old_local_bindings = {} old_vif_ports = {} db_connected = False while True: if not db_connected: time.sleep(self.reconnect_interval) db = sqlsoup.SqlSoup(db_connection_url) db_connected = True LOG.info("Connecting to database \"%s\" on %s" % (db.engine.url.database, db.engine.url.host)) all_bindings = {} try: flavor_key = db.flavors.network_id port_key = db.ports.network_id query = db.session.query(db.ports) joined = query.join((db.flavors, flavor_key == port_key)) where = db.flavors.flavor == 'openvswitch' ports = joined.filter(where).all() except Exception, e: LOG.info("Unable to get port bindings! Exception: %s" % e) db_connected = False continue for port in ports: if self.target_v2_api: all_bindings[port.id] = port else: all_bindings[port.interface_id] = port vlan_bindings = {} try: flavor_key = db.flavors.network_id vlan_key = db.vlan_bindings.network_id query = db.session.query(db.vlan_bindings) joined = query.join((db.flavors, flavor_key == vlan_key)) where = db.flavors.flavor == 'openvswitch' vlan_binds = joined.filter(where).all() except Exception, e: LOG.info("Unable to get vlan bindings! Exception: %s" % e) db_connected = False continue
def test_raw_sql(self): db = sqlsoup.SqlSoup(engine) rp = db.execute('select name, email from users order by name') eq_(rp.fetchall(), [('Bhargan Basepair', '*****@*****.**' ), ('Joe Student', '*****@*****.**')]) # test that execute() shares the same transactional context as # the session db.execute("update users set email='foo bar'") eq_(db.execute('select distinct email from users').fetchall(), [('foo bar', )]) db.rollback() eq_(db.execute('select distinct email from users').fetchall(), [(u'*****@*****.**', ), (u'*****@*****.**', )])
def test_crud(self): # note we're testing autoflush here too... db = sqlsoup.SqlSoup(engine) MappedLoans = db.loans user = db.users.filter_by(name='Bhargan Basepair').one() book_id = db.books.filter_by(title='Regional Variation in Moss' ).first().id loan_insert = db.loans.insert(book_id=book_id, user_name=user.name) loan = db.loans.filter_by(book_id=2, user_name='Bhargan Basepair').one() eq_(loan, loan_insert) l2 = MappedLoans(book_id=2, user_name=u'Bhargan Basepair', loan_date=loan.loan_date) eq_(loan, l2) db.expunge(l2) db.delete(loan) loan = db.loans.filter_by(book_id=2, user_name='Bhargan Basepair').first() assert loan is None
def daemon_loop(self, db_connection_url): '''Main processing loop for Non-Tunneling Agent. :param options: database information - in the event need to reconnect ''' self.local_vlan_map = {} old_local_bindings = {} old_vif_ports = {} db_connected = False while True: if not db_connected: time.sleep(self.reconnect_interval) db = sqlsoup.SqlSoup(db_connection_url) db_connected = True LOG.info("Connecting to database \"%s\" on %s" % (db.engine.url.database, db.engine.url.host)) all_bindings = {} try: ports = db.ports.all() except Exception, e: LOG.info("Unable to get port bindings! Exception: %s" % e) db_connected = False continue for port in ports: if self.target_v2_api: all_bindings[port.id] = port else: all_bindings[port.interface_id] = port vlan_bindings = {} try: vlan_binds = db.vlan_bindings.all() except Exception, e: LOG.info("Unable to get vlan bindings! Exception: %s" % e) db_connected = False continue
def daemon_loop(self, db_connection_url): '''Main processing loop for Tunneling Agent. :param options: database information - in the event need to reconnect ''' old_local_bindings = {} old_vif_ports = {} old_tunnel_ips = set() db = sqlsoup.SqlSoup(db_connection_url) LOG.info("Connecting to database \"%s\" on %s" % (db.engine.url.database, db.engine.url.host)) while True: try: all_bindings = dict((p.interface_id, Port(p)) for p in db.ports.all()) all_bindings_vif_port_ids = set(all_bindings) lsw_id_bindings = dict((bind.network_id, bind.vlan_id) for bind in db.vlan_bindings.all()) tunnel_ips = set(x.ip_address for x in db.tunnel_ips.all()) self.manage_tunnels(tunnel_ips, old_tunnel_ips, db) # Get bindings from OVS bridge. vif_ports = self.int_br.get_vif_ports() new_vif_ports = dict([(p.vif_id, p) for p in vif_ports]) new_vif_ports_ids = set(new_vif_ports.keys()) old_vif_ports_ids = set(old_vif_ports.keys()) dead_vif_ports_ids = (new_vif_ports_ids - all_bindings_vif_port_ids) dead_vif_ports = [new_vif_ports[p] for p in dead_vif_ports_ids] disappeared_vif_ports_ids = (old_vif_ports_ids - new_vif_ports_ids) new_local_bindings_ids = (all_bindings_vif_port_ids. intersection(new_vif_ports_ids)) new_local_bindings = dict([(p, all_bindings.get(p)) for p in new_vif_ports_ids]) new_bindings = set( (p, old_local_bindings.get(p), new_local_bindings.get(p)) for p in new_vif_ports_ids) changed_bindings = set([b for b in new_bindings if b[2] != b[1]]) LOG.debug('all_bindings: %s', all_bindings) LOG.debug('lsw_id_bindings: %s', lsw_id_bindings) LOG.debug('new_vif_ports_ids: %s', new_vif_ports_ids) LOG.debug('dead_vif_ports_ids: %s', dead_vif_ports_ids) LOG.debug('old_vif_ports_ids: %s', old_vif_ports_ids) LOG.debug('new_local_bindings_ids: %s', new_local_bindings_ids) LOG.debug('new_local_bindings: %s', new_local_bindings) LOG.debug('new_bindings: %s', new_bindings) LOG.debug('changed_bindings: %s', changed_bindings) # Take action. for p in dead_vif_ports: LOG.info("No quantum binding for port " + str(p) + "putting on dead vlan") self.port_dead(p) for b in changed_bindings: port_id, old_port, new_port = b p = new_vif_ports[port_id] if old_port: old_net_uuid = old_port.network_id LOG.info("Removing binding to net-id = " + old_net_uuid + " for " + str(p) + " added to dead vlan") self.port_unbound(p, old_net_uuid) all_bindings[p.vif_id].op_status = OP_STATUS_DOWN if not new_port: self.port_dead(p) if new_port: new_net_uuid = new_port.network_id if new_net_uuid not in lsw_id_bindings: LOG.warn("No ls-id binding found for net-id '%s'" % new_net_uuid) continue lsw_id = lsw_id_bindings[new_net_uuid] self.port_bound(p, new_net_uuid, lsw_id) all_bindings[p.vif_id].op_status = OP_STATUS_UP LOG.info("Port %s on net-id = %s bound to %s " % ( str(p), new_net_uuid, str(self.local_vlan_map[new_net_uuid]))) for vif_id in disappeared_vif_ports_ids: LOG.info("Port Disappeared: " + vif_id) if vif_id in all_bindings: all_bindings[vif_id].op_status = OP_STATUS_DOWN old_port = old_local_bindings.get(vif_id) if old_port: self.port_unbound(old_vif_ports[vif_id], old_port.network_id) # commit any DB changes and expire # data loaded from the database db.commit() # sleep and re-initialize state for next pass time.sleep(self.polling_interval) old_tunnel_ips = tunnel_ips old_vif_ports = new_vif_ports old_local_bindings = new_local_bindings except: LOG.exception("Main-loop Exception:") self.rollback_until_success(db)
def test_connection(self): db = sqlsoup.SqlSoup(engine) conn = db.connection() rp = conn.execute('select name, email from users order by name') eq_(rp.fetchall(), [('Bhargan Basepair', '*****@*****.**' ), ('Joe Student', '*****@*****.**')])
def test_relate_m2o(self): db = sqlsoup.SqlSoup(engine) db.loans.relate('user', db.users) u1 = db.users.filter(db.users.c.name == 'Joe Student').one() eq_(db.loans.first().user, u1)
def test_bad_names(self): db = sqlsoup.SqlSoup(engine) # print db.bad_names.c.id print db.bad_names.c.query
def test_entity(self): db = sqlsoup.SqlSoup(engine) tablename = 'loans' eq_(db.entity(tablename), db.loans)
def test_entity_with_different_base(self): class subclass(object): pass db = sqlsoup.SqlSoup(engine, base=subclass) assert issubclass(db.entity('loans'), subclass)
def test_nosuchtable(self): db = sqlsoup.SqlSoup(engine) assert_raises(exc.NoSuchTableError, getattr, db, 'nosuchtable')
def test_no_pk(self): db = sqlsoup.SqlSoup(engine) assert_raises(sqlsoup.PKNotFoundError, getattr, db, 'nopk')