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)