def __init__(self, **kwargs):
# Default Quorum, Yes, No and Abstain columns to 0.
for col in ("Quorum", "Yes", "No", "Abstain"):
if col not in kwargs:
kwargs.update({col: 0})
super().__init__(**kwargs)
if self.Agenda is None:
raise IntegrityError(statement="Column Agenda cannot be null.",
orig="TU_VoteInfo.Agenda",
params=("NULL"))
if self.User is None:
raise IntegrityError(statement="Column User cannot be null.",
orig="TU_VoteInfo.User",
params=("NULL"))
if self.Submitted is None:
raise IntegrityError(statement="Column Submitted cannot be null.",
orig="TU_VoteInfo.Submitted",
params=("NULL"))
if self.End is None:
raise IntegrityError(statement="Column End cannot be null.",
orig="TU_VoteInfo.End",
params=("NULL"))
if not self.Submitter:
raise IntegrityError(
statement="Foreign key SubmitterID cannot be null.",
orig="TU_VoteInfo.SubmitterID",
params=("NULL"))
def test_create_user_with_non_existing_referral(self):
request = testing.DummyRequest()
request.params['email'] = '*****@*****.**'
test_uuid = str(uuid.uuid4())
request.params['referral'] = test_uuid
mock_referral = mock(Referral)
mock_referral.num_referrals = 0
mock_referral.user_id = 1
request.dbsession = mock(sqlalchemy.orm.session.Session)
mock_user = mock(User)
mock_user.id = 1
# TODO: take another look at mocking this constructor
when(referral_program.models.user).User(
email=ANY(str)).thenReturn(mock_user)
when(request.dbsession).add(ANY(User))
mock_referral_query = query.Query([])
when(request.dbsession).query(Referral).thenReturn(mock_referral_query)
err = IntegrityError('', params=None, orig=None)
err.args = [
'''(psycopg2.errors.ForeignKeyViolation) insert or update on table "referral" violates foreign key constraint "fk_referral_user_id_user"\nDETAIL: Key (user_id)=(360) is not present in table "user".\n
'''
]
when(mock_referral_query).filter_by(id=ANY).thenRaise(err)
view_being_tested = ReferralView(request)
response = view_being_tested.create_user()
self.assertEqual(response.status_code, 400)
def test_save_error(self, obj_session, simple_model, memory_db):
memory_db()
err = IntegrityError(None, None, None, None)
err.args = ('duplicate',)
obj_session().flush.side_effect = err
with pytest.raises(JHTTPConflict) as ex:
simple_model(id=4).save()
assert 'There was a conflict' in str(ex.value)
def test_save_error(self, obj_session, simple_model, memory_db):
memory_db()
err = IntegrityError(None, None, None, None)
err.args = ('duplicate', )
obj_session().flush.side_effect = err
with pytest.raises(JHTTPConflict) as ex:
simple_model(id=4).save()
assert 'There was a conflict' in str(ex.value)
def test_update_error(self, mock_upd, simple_model, memory_db):
memory_db()
err = IntegrityError(None, None, None, None)
err.args = ('duplicate',)
mock_upd.side_effect = err
with pytest.raises(JHTTPConflict) as ex:
simple_model(id=4).update({'name': 'q'})
assert 'There was a conflict' in str(ex.value)
def test_update_error(self, mock_upd, simple_model, memory_db):
memory_db()
err = IntegrityError(None, None, None, None)
err.args = ('duplicate', )
mock_upd.side_effect = err
with pytest.raises(JHTTPConflict) as ex:
simple_model(id=4).update({'name': 'q'})
assert 'There was a conflict' in str(ex.value)
def test_add_record_duplicate_entry(self):
"""test duplicate entries to add record.
test that when session.add throws Duplicate Entry exception,
no expcetion is thrown back.
"""
side_effect = IntegrityError(None, None, None, None)
side_effect.message = "Duplicate entry"
mock_session = self.mock_sessionmaker.return_value.__call__
mock_add = mock_session.im_self.add
mock_add.side_effect = side_effect
self.conn.add_record(self.transaction)
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.Description:
raise IntegrityError(
statement="Column Description cannot be null.",
orig="Terms.Description",
params=("NULL"))
if not self.URL:
raise IntegrityError(statement="Column URL cannot be null.",
orig="Terms.URL",
params=("NULL"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
if self.Requests is None:
raise IntegrityError(
statement="Column Requests cannot be null.",
orig="ApiRateLimit.Requests",
params=("NULL"))
if self.WindowStart is None:
raise IntegrityError(
statement="Column WindowStart cannot be null.",
orig="ApiRateLimit.WindowStart",
params=("NULL"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.User and not self.UserID:
raise IntegrityError(
statement="Foreign key UserID cannot be null.",
orig="PackageNotifications.UserID",
params=("NULL"))
if not self.PackageBase and not self.PackageBaseID:
raise IntegrityError(
statement="Foreign key PackageBaseID cannot be null.",
orig="PackageNotifications.PackageBaseID",
params=("NULL"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.User and not self.UsersID:
raise IntegrityError(
statement="Foreign key UsersID cannot be null.",
orig="AcceptedTerms.UserID",
params=("NULL"))
if not self.Term and not self.TermsID:
raise IntegrityError(
statement="Foreign key TermID cannot be null.",
orig="AcceptedTerms.TermID",
params=("NULL"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.Package and not self.PackageID:
raise IntegrityError(
statement="Primary key PackageID cannot be null.",
orig="PackageGroups.PackageID",
params=("NULL"))
if not self.Group and not self.GroupID:
raise IntegrityError(
statement="Primary key GroupID cannot be null.",
orig="PackageGroups.GroupID",
params=("NULL"))
def test_add_record_integrity_entry(self):
"""test add record that throws integrity error.
test that when session.add throws a different exception
than Duplicate Entry it will be rasied up.
"""
side_effect = IntegrityError(None, None, None, None)
side_effect.message = "Some other integrity error"
mock_session = self.mock_sessionmaker.return_value.__call__
mock_add = mock_session.im_self.add
mock_add.side_effect = IntegrityError("Some other integrity error",
None, None, None)
self.assertRaises(IntegrityError, self.conn.add_record,
self.transaction)
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.PackageBase and not self.PackageBaseID:
raise IntegrityError(
statement="Foreign key PackageBaseID cannot be null.",
orig="Packages.PackageBaseID",
params=("NULL"))
if self.Name is None:
raise IntegrityError(
statement="Column Name cannot be null.",
orig="Packages.Name",
params=("NULL"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.VoteInfo and not self.VoteID:
raise IntegrityError(
statement="Foreign key VoteID cannot be null.",
orig="TU_Votes.VoteID",
params=("NULL"))
if not self.User and not self.UserID:
raise IntegrityError(
statement="Foreign key UserID cannot be null.",
orig="TU_Votes.UserID",
params=("NULL"))
def test_update_records_db_error(self):
"""test database exception IntegrityError is caught"""
with mock.patch('sqlalchemy.orm.session.Session.commit',
side_effect=[IntegrityError('a', 'b', 'c', 'd'),
None]):
self.assertRaises(IntegrityError, self.app.update_storage, 'abc',
'nonbib_data', '{}')
def toggle_subscriptions():
req_data = request.get_json()
subreddit_name = req_data['subreddit']
subreddit = Subreddit.query.filter(Subreddit.name == subreddit_name).first()
subscription = Subscription.query.get((current_user.id, subreddit.id))
new_type = 'ADD'
try:
if request.method == 'DELETE':
db.session.delete(subscription)
new_type = 'REMOVE'
else:
if subscription:
raise IntegrityError('Entry already exists',
subscription, 'user_routes')
new_sub = Subscription(
user_id=current_user.id,
subreddit_id=subreddit.id
)
db.session.add(new_sub)
db.session.commit()
except IntegrityError:
return {"errors": "There was a problem processing your request."}
return {"subscription": subreddit_name, "type": new_type}
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not self.Name:
raise IntegrityError(statement="Column Name cannot be null.",
orig="PackageBlacklist.Name",
params=("NULL"))
def test_bai_create_retries_on_bais_in_db_change():
with mock.patch(
"inspirehep.pidstore.providers.bai.current_app"
) as mocked_app, mock.patch(
"inspirehep.pidstore.providers.bai.InspireBAIProvider.next_bai_number"
) as next_bai_mock, mock.patch(
"inspirehep.pidstore.providers.bai.InspireBAIProvider.query_pid_value"
) as query_pid_value_mock, mock.patch(
"inspirehep.pidstore.providers.bai.super") as super_mock:
mocked_app.config = {"PIDSTORE_BAI_RETRY_DELAY": 0}
next_bai_mock.side_effect = [123, 124]
expected_pid_value = "Test.124"
super_mock.return_value.create.side_effect = [
IntegrityError(None, None, None),
InspireBAIProvider(
PersistentIdentifier(
pid_type="bai",
pid_value=expected_pid_value,
pid_provider="bai",
status=PIDStatus.REGISTERED,
)),
]
query_pid_value_mock.return_value = []
created_bai = InspireBAIProvider.create(
data={"name": {
"value": "test"
}})
assert created_bai.pid.pid_value == expected_pid_value
assert super_mock.return_value.create.call_count == 2
def test_add_user(mock_db, test_client):
data = {'email': '*****@*****.**', 'password': '******'}
result = test_client.post('/users/',
content_type='application/json',
data=json.dumps(data, sort_keys=True))
assert result.status_code == 201
assert result.json['email'] == "*****@*****.**"
mock_db.session.commit.assert_called_once_with()
# User exists
mock_db.session.commit.side_effect = IntegrityError(
'Already exists', None, None)
result = test_client.post('/users/',
content_type='application/json',
data=json.dumps(data, sort_keys=True))
assert result.status_code == 201
assert result.data == b'{}\n'
# No password (OIDC)
data['password'] = None
mock_db.session.commit.side_effect = None
result = test_client.post('/users/',
content_type='application/json',
data=json.dumps(data, sort_keys=True))
assert result.status_code == 201
assert result.json['email'] == "*****@*****.**"
def delete(cls, route_id):
bus = Bus.query.filter(Bus.route_id == route_id).first()
if bus:
raise IntegrityError(u'数据完整性异常')
del_obj = cls.get(route_id)
db.session.delete(del_obj)
db.session.commit()
def post(self):
"""
:return:
"""
model = self._model
_, builder = self._response.get_mimetype_accept()
data = self._validate_new_data()
resource = model.query.filter_by(**data).first()
try:
if resource:
raise IntegrityError(statement=None, params=None, orig=None)
resource = model(**data)
res = self._add_resource(resource)
except IntegrityError:
res = {} # prevent warning
self._db.session().rollback()
flask.abort(status.CONFLICT)
return self._response_with_etag(
builder, (res, status.CREATED, self._location_header(resource)), res
)
def test_rawmessagealreadyexists_returnsSuccess(self, mocked_DBSession):
mocked_DBSession.add.side_effect = IntegrityError(1, 2, 3, 4)
request = testing.DummyRequest(post=self.body)
response = recieve_message(request)
expected = {'payload': {'success': True, 'error': None}}
self.assertEquals(response, expected)
def test_not_email(self):
"""Assert an IntegrityError without the email key results in a 500 error"""
err = IntegrityError('SQL Statement', {}, None)
msg, errno = app.integrity_error_handler(err)
self.assertEqual(500, errno)
self.assertEqual('The server encountered an unexpected error', msg)
def delete_from_db(self):
for category in self.categories:
if not category.deleted:
raise IntegrityError("Cannot delete an image if it's associated with existing categories", params=None, orig=None)
for category in self.categories:
category.image = None
db.session.delete(self)
db.session.commit()
def test_integrity(self):
error = IntegrityError(orig=MagicMock(), statement='', params={})
res = data_integrity(error, MagicMock())
self.assertEqual(
{
'message':
'this operation violates the data integrity and could not be executed '
}, res)
def test_integrity_error_returns_500(self):
with mock.patch('server.db.session.commit') as db_mock:
db_mock.side_effect = IntegrityError(None, None, None, None)
r = self.app.post(self.endpoints['responses'], data=test_message)
self.assertEqual(r.status_code, 500)
db.session.remove()
db.drop_all()
def test_add_batch_existing_categories(self):
categories = [Category()]
self.db.session.commit.side_effect = IntegrityError(statement='test',
params={},
orig=[])
with pytest.raises(BadRequest):
self.repo.add_batch(categories)
def test_add_account_gce(mock_db, mock_handle_request, test_client):
request = {
'user_id': 'user1',
'account_name': 'test',
'credentials': {
'type': 'string',
'project_id': 'string',
'private_key_id': 'string',
'private_key': 'string',
'client_email': 'string',
'client_id': 'string',
'auth_uri': 'string',
'token_uri': 'string',
'auth_provider_x509_cert_url': 'string',
'client_x509_cert_url': 'string'
},
'bucket': 'bucket1',
'region': 'us-east-1'
}
response = test_client.post('/gce_accounts/',
content_type='application/json',
data=json.dumps(request, sort_keys=True))
assert response.status_code == 201
assert response.json['name'] == 'test'
assert response.json['region'] == 'us-east-1'
# Mash Exception
mock_db.session.commit.side_effect = Exception('Broken')
response = test_client.post('/gce_accounts/',
content_type='application/json',
data=json.dumps(request, sort_keys=True))
mock_db.session.rollback.assert_called_once_with()
assert response.status_code == 400
assert response.data == b'{"msg":"Unable to create GCE account: Broken"}\n'
# Integrity Error
mock_db.session.commit.side_effect = IntegrityError('Broken', None, None)
response = test_client.post('/gce_accounts/',
content_type='application/json',
data=json.dumps(request, sort_keys=True))
assert response.status_code == 400
assert response.data == b'{"msg":"Account already exists"}\n'
# No testing account
request['is_publishing_account'] = True
response = test_client.post('/gce_accounts/',
content_type='application/json',
data=json.dumps(request, sort_keys=True))
assert response.status_code == 400
msg = b'{"msg":"Unable to create GCE account: ' \
b'Jobs using a GCE publishing account require ' \
b'the use of a test account."}\n'
assert response.data == msg
def add_movie(self, a_movie: 'Movie') -> None:
results = self.__session_cm.session.query(Movie).filter_by(
_title=a_movie.title).filter_by(
_release_year=a_movie.release_year).all()
if not results:
with self.__session_cm as scm:
result = scm.session.execute(
f"SELECT id FROM directors WHERE full_name = '{a_movie.director.director_full_name}'"
).fetchone()
if not result:
scm.session.execute(
f"INSERT INTO directors (full_name) VALUES ('{a_movie.director.director_full_name}')"
)
scm.commit()
result = scm.session.execute(
f"SELECT id FROM directors WHERE full_name = '{a_movie.director.director_full_name}'"
).fetchone()
scm.session.execute(
f"INSERT INTO movies (title, release_year, description, director_id, runtime_minutes) VALUES ('{a_movie.title}', {a_movie.release_year}, '{a_movie.description}', {result[0]}, {a_movie.runtime_minutes})"
)
scm.commit()
movie_index = scm.session.execute(
f"SELECT id FROM movies WHERE title = '{a_movie.title}' AND release_year = {a_movie.release_year}"
).fetchone()
for item in a_movie.genres:
result = scm.session.execute(
f"SELECT id FROM genres WHERE name = '{item.genre_name}'"
).fetchone()
if not result:
scm.session.execute(
f"INSERT INTO genres (name) VALUES ('{item.genre_name}')"
)
scm.commit()
result = scm.session.execute(
f"SELECT id FROM genres WHERE name = '{item.genre_name}'"
).fetchone()
scm.session.execute(
f"INSERT INTO movies_genres (movie_id, genre_id) VALUES ({movie_index[0]}, {result[0]})"
)
scm.commit()
for item in a_movie.actors:
result = scm.session.execute(
f"SELECT id FROM actors WHERE full_name = '{item.actor_full_name}'"
).fetchone()
if not result:
scm.session.execute(
f"INSERT INTO actors (full_name) VALUES ('{item.actor_full_name}')"
)
scm.commit()
result = scm.session.execute(
f"SELECT id FROM actors WHERE full_name = '{item.actor_full_name}'"
).fetchone()
scm.session.execute(
f"INSERT INTO movies_actors (movie_id, actor_id) VALUES ({movie_index[0]}, {result[0]})"
)
scm.commit()
else:
raise IntegrityError("SQL INSERT INTO movies", f"{a_movie}", "")
def test_create_referral_with_invalid_user(self):
from referral_program.views.views import ReferralView
# Setup our dummy request before using it
request = testing.DummyRequest()
request.matchdict['user_id'] = '777'
request.dbsession = mock(sqlalchemy.orm.session.Session)
when(request.dbsession).add(ANY(Referral))
err = IntegrityError('', params=None, orig=None)
err.args = [
'''(psycopg2.errors.ForeignKeyViolation) insert or update on table "referral" violates foreign key constraint "fk_referral_user_id_user"\nDETAIL: Key (user_id)=(360) is not present in table "user".\n
''']
when(request.dbsession).flush().thenRaise(err)
view_being_tested = ReferralView(request)
response = view_being_tested.create_referral()
self.assertEqual(response.status_code, 400)
def test_put_rds_no_overwrite(self):
model = QuestionnaireState(USER_ID, STATE_DATA, VERSION)
setattr(model, '_use_dynamo', False)
with mock.patch('app.data_model.models.db.session.add', side_effect=IntegrityError('', '', '')) as add, \
self.assertRaises(ItemAlreadyExistsError):
data_access.put(model, overwrite=False)
self.assertTrue(add.called)
