def test__allocate_hosting_port_returns_none_if_binding_fails(self):
with self.router() as r, self.port() as p1:
r_id = r['router']['id']
p1_id = p1['port']['id']
self._router_interface_action('add', r_id, None, p1_id)
plugging_drv_mock = mock.MagicMock()
plugging_drv_mock.allocate_hosting_port.return_value = {
'allocated_port_id': p1_id,
'allocated_vlan': 10
}
adm_ctx = bc.context.get_admin_context()
p1_db = self._core_plugin._get_port(adm_ctx, p1_id)
ctx_mock = mock.MagicMock()
ctx_mock.session = mock.MagicMock()
ctx_mock.session.begin = adm_ctx.session.begin
ctx_mock.session.add = mock.MagicMock()
ctx_mock.session.add.side_effect = db_exc.DBReferenceError(
'cisco_port_mappings',
'foreign key constraint',
p1_id,
'ports',
inner_exception=inner_db_exc.IntegrityError("Invalid insert",
params="",
orig=None))
res = self.l3_plugin._allocate_hosting_port(
ctx_mock, r_id, p1_db, 'fake_hd_id', plugging_drv_mock)
self.assertIsNone(res)
def test_reprocess_in_create_raw_key(self):
# This mock simulates the case where the create raw key function
# is called and received a duplicate key. It raises an
# IntegrityError which triggers our reprocessing code if the
# reprocessing feature is enabled.
mock_session = Mock()
mock_session.flush = Mock(
side_effect=core_exc.IntegrityError("test", "test", "test"))
mock_session.query.filter = Mock()
raw_id = Mock()
raw_id.id = "123"
filter_ret_mock = Mock()
filter_ret_mock.one = Mock(return_value=raw_id)
filter_mock = Mock()
filter_mock.filter = Mock(return_value=filter_ret_mock)
mock_session.query = Mock(return_value=filter_mock)
test_etl = ETL(setup_path=example_setup_path)
test_etl.settings = test_etl.settings._replace(
should_reprocess=True) # creating a new settings namedtuple.
test_etl.RAW_KEY_MODEL = Mock()
actual_id = test_etl._create_raw_key(mock_session, "123", "123")
assert actual_id == '123'
def update_product(cls, product_id, name):
try:
row = cls.query.filter_by(ProductID=product_id).first()
row.ProductName = name
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def update_date_deleted(cls, product_id, date):
try:
row = cls.query.filter_by(ProductID=product_id).first()
row.DateDeleted = date
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def update_company(cls, companycode, name):
try:
row = cls.query.filter_by(CompanyCode=companycode).first()
row.CompanyName = name
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def update_date_deleted(cls, companycode, date):
try:
row = cls.query.filter_by(CompanyCode=companycode).first()
row.DateDeleted = date
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def update_product_sellers(cls, product_id, company_ID):
try:
row = cls.query.filter_by(ProductID=product_id).first()
row.CompanyCode = company_ID
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def update_product_valuations(cls, product_id, price, date_entered):
try:
row = cls.query.filter_by(ProductID=product_id).first()
row.ProductPrice = price
row.DateOfValuation = date_entered
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
except exc.InterfaceError:
raise exc.InterfaceError("", "", 1)
def wrap_ibm_db_errors(statement, params):
try:
yield
except Database.OperationalError as e:
error = int(error_re.search(e._message).groups()[0])
errors = [268, 691, 530, 391]
if error in errors:
raise exc.IntegrityError(statement, params, e) from e
raise
def test_main_success_no_dip_creation(self):
"""Test a success where one AIP was already processed."""
effect = exc.IntegrityError({}, [], "")
session_add_patch = mock.patch("sqlalchemy.orm.Session.add", side_effect=effect)
with TmpDir(TMP_DIR), TmpDir(OUTPUT_DIR), session_add_patch:
ret = create_dips_job.main(**self.args)
assert ret is None
dip_path = os.path.join(
OUTPUT_DIR, "test_B-3ea465ac-ea0a-4a9c-a057-507e794de332"
)
assert not os.path.isdir(dip_path)
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
traceback.print_exc(file=sys.stdout)
except exc.InterfaceError:
raise exc.InterfaceError("", "", 1)
except:
print("Unknown Error occurred")
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
print("The currency couldn't be saved to the database")
traceback.print_exc(file=sys.stdout)
except exc.InterfaceError:
raise exc.InterfaceError("", "", 1)
except:
print("Unknown Error occurred")
def test_main_success_no_dip_creation(self):
"""Test a success where one AIP was already processed."""
effect = exc.IntegrityError({}, [], '')
session_add_patch = mock.patch('sqlalchemy.orm.Session.add',
side_effect=effect)
with TmpDir(TMP_DIR), TmpDir(OUTPUT_DIR), session_add_patch:
ret = create_dips_job.main(SS_URL, SS_USER_NAME, SS_API_KEY,
LOCATION_UUID, TMP_DIR, OUTPUT_DIR,
DATABASE_FILE)
assert ret is None
dip_path = os.path.join(
OUTPUT_DIR, 'test_B_3ea465ac-ea0a-4a9c-a057-507e794de332_DIP')
assert not os.path.isdir(dip_path)
def test_ibm_db_sa_raise_if_duplicate_entry_error_no_match(self):
# Tests that the session._raise_if_duplicate_entry_error method
# does not raise a DBDuplicateEntry exception when it's not a matching
# integrity error.
statement = ('ALTER TABLE instance_types ADD CONSTRAINT '
'uniq_name_x_deleted UNIQUE (name, deleted)')
params = None
orig = sqla_exc.SQLAlchemyError(
'SQL0542N The column named "NAME" cannot be a column of a '
'primary key or unique key constraint because it can contain null '
'values.')
integrity_error = sqla_exc.IntegrityError(statement, params, orig)
session._raise_if_duplicate_entry_error(integrity_error, 'ibm_db_sa')
def setter(self, **kw):
""" Inserts new entry or updates existing entry.
Assumptions:
- the table has a primary key named 'id'
- the table has a single unique constraint on its natural key
Insert details:
- attempt insert
- if it works, return new id otherwise continue onto update
Update details
- if id provided, update based on id
- if id not provided, update based on unique constraint
- if constraint violation occurs - manually generate exception!
Returns number of rows inserted.
"""
kw_insert = {}
#broken code - not sure what it did exactly!
for key in kw.keys():
if kw[key] not in self.insert_defaulted:
kw_insert[key] = kw[key]
try:
ins_sql = self._table.insert()
result = ins_sql.execute(kw_insert)
#print kw_insert
if result.rowcount == 0:
raise KeyError # by missing column
else:
return result.lastrowid
except exc.IntegrityError, except_detail:
# possibly caused by violation of primary key constraint
# possibly caused by violation of check or fk key constraint
# print 'insert exception'
# print e
kw_update = {}
for key in kw.keys():
if kw[key] not in self.update_defaulted:
kw_update[key] = kw[key]
upd_sql = self._table.update()
upd_sql = self._create_where(upd_sql, kw_update)
#print kw_update
result = upd_sql.execute(kw_update)
if result.rowcount == 0: # this is the only way to catch
print 'update exception'
print except_detail # might want to get rid of this
print result
# usually constraint violations
raise exc.IntegrityError(upd_sql, kw_update, None)
return 0
def test_ibm_db_sa_raise_if_duplicate_entry_error_duplicate(self):
# Tests that the session._raise_if_duplicate_entry_error method
# translates the duplicate entry integrity error for the DB2 engine.
statement = ('INSERT INTO key_pairs (created_at, updated_at, '
'deleted_at, deleted, name, user_id, fingerprint) VALUES '
'(?, ?, ?, ?, ?, ?, ?)')
params = ['20130918001123627099', None, None, 0, 'keypair-23474772',
'974a7c9ffde6419f9811fcf94a917f47',
'7d:2c:58:7f:97:66:14:3f:27:c7:09:3c:26:95:66:4d']
orig = sqla_exc.SQLAlchemyError(
'SQL0803N One or more values in the INSERT statement, UPDATE '
'statement, or foreign key update caused by a DELETE statement are'
' not valid because the primary key, unique constraint or unique '
'index identified by "2" constrains table "NOVA.KEY_PAIRS" from '
'having duplicate values for the index key.')
integrity_error = sqla_exc.IntegrityError(statement, params, orig)
self.assertRaises(db_exc.DBDuplicateEntry,
session._raise_if_duplicate_entry_error,
integrity_error, 'ibm_db_sa')
def update_trade(cls, tradeID, product, buyingParty, sellingParty,
notionalValue, notionalCurrency, quantity, maturityDate,
underlyingValue, underlyingCurrency, strikePrice):
try:
row = cls.query.filter_by(TradeID=tradeID).first()
row.ProductID = product
row.BuyingParty = buyingParty
row.SellingParty = sellingParty
row.NotionalValue = notionalValue
row.NotionalCurrency = notionalCurrency
row.Quantity = quantity
row.MaturityDate = maturityDate
row.UnderlyingValue = underlyingValue
row.UnderlyingCurrency = underlyingCurrency
row.StrikePrice = strikePrice
row.LastModifiedDate = date_now = str(date_func.today())
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def test_create_user_unsuccessful(config, runner_factory):
runner = runner_factory(AccountsService)
container = get_container(runner, AccountsService)
storage = replace_dependencies(container, "storage")
runner.start()
storage.users.create.side_effect = exc.IntegrityError(statement="",
params="",
orig="")
payload = {
"email": "*****@*****.**",
"password": "******",
"display_name": "Test Account",
}
with entrypoint_hook(container, "create_user") as create_user:
with pytest.raises(UserAlreadyExists):
create_user(user_details=payload)
assert storage.users.create.call_args == call(payload["email"],
payload["password"],
payload["display_name"])
def update(self):
raise db_exception.DBError(
inner_exception=exc.IntegrityError('a', 'a', 'a'))
class TableTools(object):
""" Provides generic and simple tools for managing data within a table.
"""
def __init__(self, metadata, engine):
self.metadata = metadata
self.engine = engine
self._table = None
self._table_name = None
self._unique_constraints = None
self.insert_defaulted = [] # cols added here aren't inserted
self.update_defaulted = [] # cols added here aren't updated
def deleter(self, **kw):
""" Requires the key of the row.
Returns a count of rows deleted (will be either 0 or 1).
Will only work on tables with primary keys.
Does not confirm that it has the key for the row - so can be
dangerous.
Note - it may not delete anything if an insufficient unique
key is provided.
Uses 'generative sql' to build up query.
"""
try:
gener_sql = self._table.delete()
gener_sql = self._create_where(gener_sql, kw)
result = gener_sql.execute()
except KeyError:
# could mean row was not there
# could mean that part of key was missing?
return 0
assert result.rowcount in [0, 1]
return result.rowcount
def getter(self, **kw):
""" Requires the key of the row
Returns a single row if found, otherwise returns None
Will only work on tables with primary keys.
Uses 'generative sql' to build up query.
"""
gener_sql = self._table.select()
gener_sql = self._create_where(gener_sql, kw)
result = gener_sql.execute()
rows = result.fetchall()
assert len(rows) in [0, 1]
try:
return rows[0]
except IndexError: # no rows found
return None
def get_id(self, **kw):
""" Requires the key of the row - for tables with a primary key
that is a surrogate key and a natural key defined within a
unique constraint.
Returns a single row if found, otherwise returns None
No longer being used - but kept around just in case
Uses 'generative sql' to build up query.
"""
gener_sql = self._table.select()
#uk = self._get_unique_constraints()
gener_sql = self._create_where(gener_sql, kw)
result = gener_sql.execute()
rows = result.fetchall()
try:
return rows[0].id
except AttributeError: # no rows found
return None
def lister(self, **kw):
""" Returns all rows for the table, not in any particular order.
Inputs:
- assumes some args, but ignores them
- these are only included because of the way that these functions
are called.
Outputs:
- all rows & columns for table
"""
sel_sql = self._table.select()
result = sel_sql.execute()
rows = result.fetchall()
return rows
def setter(self, **kw):
""" Inserts new entry or updates existing entry.
Assumptions:
- the table has a primary key named 'id'
- the table has a single unique constraint on its natural key
Insert details:
- attempt insert
- if it works, return new id otherwise continue onto update
Update details
- if id provided, update based on id
- if id not provided, update based on unique constraint
- if constraint violation occurs - manually generate exception!
Returns number of rows inserted.
"""
kw_insert = {}
#broken code - not sure what it did exactly!
for key in kw.keys():
if kw[key] not in self.insert_defaulted:
kw_insert[key] = kw[key]
try:
ins_sql = self._table.insert()
result = ins_sql.execute(kw_insert)
#print kw_insert
if result.rowcount == 0:
raise KeyError # by missing column
else:
return result.lastrowid
except exc.IntegrityError, except_detail:
# possibly caused by violation of primary key constraint
# possibly caused by violation of check or fk key constraint
# print 'insert exception'
# print e
#print except_detail
kw_update = {}
for key in kw.keys():
if kw[key] not in self.update_defaulted:
kw_update[key] = kw[key]
upd_sql = self._table.update()
upd_sql = self._create_where(upd_sql, kw_update)
#print kw_update
try:
result = upd_sql.execute(kw_update)
except exc.IntegrityError, except_detail:
print 'insert failed, update failed'
print except_detail
raise
if result.rowcount == 0: # this is the only way to catch
print 'update exception'
print except_detail # might want to get rid of this
print result
# usually constraint violations
raise exc.IntegrityError(upd_sql, kw_update, None)
return 0
def delete_company(cls, companycode):
try:
cls.query.filter_by(CompanyCode=companycode).delete()
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def delete_product(cls, product_id):
try:
cls.query.filter_by(ProductID=product_id).delete()
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
def delete_trade(cls, trade_id):
try:
cls.query.filter_by(TradeID=trade_id).delete()
db.session.commit()
except exc.IntegrityError:
raise exc.IntegrityError("", "", 1)
