async def test_create_reports_fail_correctly(self): """Test that failure is reported, when write not acknowledged.""" self.collection.insert_one.return_value = InsertOneResult(None, False) success = await self.test_service.create("testcollection", self.data_stub) self.collection.insert_one.assert_called_once_with(self.data_stub) self.assertFalse(success)
async def test_create_inserts_data(self): """Test that create method works and returns success.""" self.collection.insert_one.return_value = futurized( InsertOneResult(ObjectId("0123456789ab0123456789ab"), True)) success = await self.test_service.create("test", self.data_stub) self.collection.insert_one.assert_called_once_with(self.data_stub) self.assertTrue(success)
async def test_create_folder_inserts_folder(self): """Test that create method works for folder and returns success.""" self.collection.insert_one.return_value = InsertOneResult( ObjectId("0000000000aa1111111111bb"), True) folder = await self.test_service.create("folder", self.folder_stub) self.collection.insert_one.assert_called_once_with(self.folder_stub) self.assertTrue(folder)
def insert_one(co_or_ta, document=None, **kwargs): db = get_db() dbType = current_app.config['DBTYPE'] if document is None or co_or_ta is None or db is None: return InsertOneResult() if dbType == "mongoDB": try: collection = db.get_collection(co_or_ta) result = collection.insert_one(document=document, **kwargs) if not result: return InsertOneResult() return result except Exception: traceback.print_exc() return InsertOneResult()
def insert_one(self, document, **kwargs): """Insert a single document into collection :param document: Document to insert :returns: :class:`Deferred` that called back with :class:`pymongo.results.InsertOneResult` """ inserted_ids, response = yield self._insert_one_or_many([document], **kwargs) if response: _check_write_command_response([[0, response]]) defer.returnValue( InsertOneResult(inserted_ids[0], self.write_concern.acknowledged))
def test_failed_mongo_insert(self, mocked_insert_one): mocked_insert_one.return_value = InsertOneResult(None, False) response = self.app.post( '/%s/movies' % self.api, headers=self.headers, data=json.dumps({}), content_type='application/json' ) self.assertEqual(response.status_code, 500) response_json = json.loads(response.data or '{}') self.assertDictContainsSubset( {'message': u'The resource can not be created'}, response_json )
def __init__(self, collection_name, **kwargs): super().__init__() self.name = collection_name find_one_result = kwargs.get("find_one_result", {"_id": 1}) inserted_id = kwargs.get("inserted_id", 1) create_indexes_result = kwargs.get("create_indexes_result", None) self.insert_one = AsyncMock(return_value=InsertOneResult( inserted_id=inserted_id, acknowledged=True)) self.delete_many = AsyncMock( return_value=DeleteResult(raw_result={}, acknowledged=True)) self.update_one = AsyncMock( return_value=UpdateResult(raw_result={}, acknowledged=True)) self.update_many = AsyncMock( return_value=UpdateResult(raw_result={}, acknowledged=True)) self.count_documents = AsyncMock(return_value=1) self.find_one = AsyncMock(return_value=find_one_result) self.create_indexes = AsyncMock(return_value=create_indexes_result)
def cart_add(item: dict) -> InsertOneResult: """ Add an item to a shopping cart """ LOGGER.debug('adding item to shopping cart: {}'.format(item['name'])) db = connect_to_db() # pylint: disable=invalid-name result = InsertOneResult(None, False) try: # TODO: implement validation items = items_list() for each in items: if item.get('name') == each['name']: result_remove = items_remove(each['name']) if result_remove.acknowledged: result = db.cart.insert_one(item) break except Exception as exception: # TODO: use specifc exceptions. Create a custom error exception LOGGER.error(exception) raise Exception('There was a DB problem') return result
def test_create_http_exception(mocker): """Test: create(self, data: dict) -> int HTTPException: Creation error.""" service = PhraseService( settings['db_name'], settings['cln_name'] ) insert_result = InsertOneResult(0, None) mock_insert_one = mocker.patch.object(Collection, 'insert_one') mock_insert_one.return_value = insert_result service.phrases.insert_one = mock_insert_one data = { 'author': 'create-author', 'text': 'created-text' } with pytest.raises(HTTPException) as ex: service.create(data) assert 400 == ex.value.status_code assert 'Creation error' == ex.value.detail
def insert_one(self, document, **kwargs): inserted_ids = yield self._insert_one_or_many([document], **kwargs) defer.returnValue(InsertOneResult(inserted_ids[0], self.write_concern.acknowledged))
def mock_insert_workaround(collection, document): inserted_id = collection.insert(document) return InsertOneResult(inserted_id, True)
def insert(self, document): self.inserted_items.append(document) return InsertOneResult(RawBSONDocument(BSON.encode(document)), True)
def insert_one(self, document, session=None): result = self.__insert(document) if result: result = result[0] return InsertOneResult(result or None, True)
def test_format_calledWithValidOperationResult_returnCorrectResult(self): expected = '{\n\t"acknowledged" : ' + 'true' + ',\n\t"insertedId" : ' + 'ObjectId("4d128b6ea794fc13a8000002")' + '\n}' actual = self.sut.format(InsertOneResult(ObjectId("4d128b6ea794fc13a8000002"), True)) self.assertEqual(actual, expected)
def insert_one(self, document, **kwargs): inserted_ids, response = yield self._insert_one_or_many([document], **kwargs) if response: _check_write_command_response([[0, response]]) defer.returnValue(InsertOneResult(inserted_ids[0], self.write_concern.acknowledged))
def mock_return(body): return InsertOneResult('5a80868574fdd6de0f4fa432', True)
def insert_mock(monkeypatch): with monkeypatch.context() as m: result = InsertOneResult(inserted_id=ObjectId(), acknowledged=True) m.setattr(Collection, "insert_one", MagicMock(return_value=result)) yield result.inserted_id