예제 #1
0
    def test_next_verify_are_there_more_results_and_next_page_called(
            self, mock_are_there_more_results, mock_next_page, mock_session,
            mock_value_holder_to_ion_value):
        updated_result = '1'

        def update_page():
            stream_cursor._page = {
                'NextPageToken': None,
                'Values': [updated_result]
            }
            stream_cursor._index = 0

        mock_are_there_more_results.return_value = True
        mock_value_holder_to_ion_value.side_effect = lambda val: val
        mock_session.return_value = None
        mock_next_page.return_value = None
        mock_next_page.side_effect = update_page
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                     MOCK_TRANSACTION_ID)
        stream_cursor._index = len(MOCK_ION_BINARY_VALUES)

        self.assertEqual(next(stream_cursor), updated_result)
        mock_next_page.assert_called_once_with()
        mock_are_there_more_results.assert_called_once_with()
        mock_value_holder_to_ion_value.assert_called_once_with(updated_result)
    def test_next_with_next_page_returns_empty_values_and_not_none_token(self, mock_session):
        mock_session.return_value = None
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session, MOCK_TRANSACTION_ID)
        stream_cursor._index = len(MOCK_ION_BINARY_VALUES)

        mock_session._fetch_page.side_effect = [{'Page': {'NextPageToken': 'token', 'Values': []}},
                                                {'Page': {'NextPageToken': None, 'Values': []}}]
        self.assertRaises(StopIteration, next, stream_cursor)
    def test_next_page(self, mock_session):
        mock_session.return_value = None
        mock_session._fetch_page.return_value = {'Page': MOCK_STATEMENT_RESULT}
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session, MOCK_TRANSACTION_ID)
        stream_cursor._next_page()

        mock_session._fetch_page.assert_called_once_with(stream_cursor._transaction_id, MOCK_TOKEN)
        self.assertEqual(stream_cursor._page, MOCK_STATEMENT_RESULT)
        self.assertEqual(stream_cursor._index, 0)
    def test_next_when_next_page_returns_empty_values_and_none_token(self, mock_session, mock_next_page):
        mock_session.return_value = None

        def next_page():
            stream_cursor._page = {'NextPageToken': None, 'Values': []}
            stream_cursor._index = 0

        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session, MOCK_TRANSACTION_ID)
        stream_cursor._index = len(MOCK_ION_BINARY_VALUES)
        mock_next_page.side_effect = next_page
        self.assertRaises(StopIteration, next, stream_cursor)
예제 #5
0
def create_stream_cursor(mock_session, mock_statement_result_execute,
                         mock_statement_result_fetch):
    """
    Create a stream cursor with execute and fetch page statement results.
    """
    mock_session.return_value = None
    mock_session._fetch_page.return_value = mock_statement_result_fetch

    stream_cursor = StreamCursor(mock_statement_result_execute, mock_session,
                                 "1")
    stream_cursor._value_holder_to_ion_value = MagicMock(
        name='_value_holder_to_ion_value')

    return stream_cursor
예제 #6
0
    def test_next_page(self, mock_session):
        mock_session.return_value = None

        fetch_page_statement_result = generate_statement_result(
            MOCK_READ_IOS, MOCK_WRITE_IOS, MOCK_PROCESSING_TIME, None, False,
            MOCK_ION_BINARY_VALUES)
        mock_session._fetch_page.return_value = fetch_page_statement_result
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                     MOCK_TRANSACTION_ID)
        stream_cursor._next_page()

        mock_session._fetch_page.assert_called_once_with(
            stream_cursor._transaction_id, MOCK_TOKEN)
        self.assertEqual(stream_cursor._page, MOCK_PAGE_WITHOUT_TOKEN)
        self.assertEqual(stream_cursor._index, 0)
예제 #7
0
    def test_next(self, mock_session, mock_value_holder_to_ion_value):
        mock_session.return_value = None
        mock_value_holder_to_ion_value.side_effect = lambda val: val

        MOCK_STATEMENT_RESULT_WITHOUT_NEXT_PAGE_TOKEN = {
            'FirstPage': MOCK_PAGE_WITHOUT_TOKEN,
            'TimingInformation': {
                'ProcessingTimeMilliseconds': MOCK_PROCESSING_TIME
            },
            'ConsumedIOs': {
                'ReadIOs': MOCK_READ_IOS,
                'WriteIOs': MOCK_WRITE_IOS
            }
        }

        stream_cursor = StreamCursor(
            MOCK_STATEMENT_RESULT_WITHOUT_NEXT_PAGE_TOKEN, mock_session,
            MOCK_TRANSACTION_ID)
        count = 0
        for value in MOCK_ION_BINARY_VALUES:
            self.assertEqual(stream_cursor._index, count)
            self.assertEqual(next(stream_cursor), value)
            mock_value_holder_to_ion_value.assert_called_with(value)
            count += 1
        self.assertRaises(StopIteration, next, stream_cursor)
    def test_StreamCursor(self, mock_session):
        mock_session.return_value = None
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session, MOCK_TRANSACTION_ID)

        self.assertEqual(stream_cursor._page, MOCK_STATEMENT_RESULT)
        self.assertEqual(stream_cursor._session, mock_session)
        self.assertEqual(stream_cursor._transaction_id, MOCK_TRANSACTION_ID)
        self.assertEqual(stream_cursor._index, 0)
        self.assertEqual(stream_cursor._is_open, True)
 def test_next(self, mock_session, mock_value_holder_to_ion_value):
     mock_session.return_value = None
     mock_value_holder_to_ion_value.side_effect = lambda val: val
     mock_statement_result_with_none_next_page_token = MOCK_STATEMENT_RESULT.copy()
     mock_statement_result_with_none_next_page_token.update({'NextPageToken': None})
     stream_cursor = StreamCursor(mock_statement_result_with_none_next_page_token, mock_session, MOCK_TRANSACTION_ID)
     count = 0
     for value in MOCK_ION_BINARY_VALUES:
         self.assertEqual(stream_cursor._index, count)
         self.assertEqual(next(stream_cursor), value)
         mock_value_holder_to_ion_value.assert_called_with(value)
         count += 1
     self.assertRaises(StopIteration, next, stream_cursor)
    def test_are_there_more_results(self, mock_session):
        mock_session.return_value = None
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session, MOCK_TRANSACTION_ID)
        stream_cursor._page = {'NextPageToken': 'token', 'Values': []}
        self.assertTrue(stream_cursor._are_there_more_results())

        stream_cursor._page = {'NextPageToken': None, 'Values': []}
        self.assertFalse(stream_cursor._are_there_more_results())
예제 #11
0
    def test_StreamCursor(self, mock_session):
        mock_session.return_value = None
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                     MOCK_TRANSACTION_ID)

        self.assertEqual(stream_cursor._page, MOCK_PAGE_WITH_TOKEN)
        self.assertEqual(stream_cursor._read_ios, MOCK_READ_IOS)
        self.assertEqual(stream_cursor._write_ios, MOCK_WRITE_IOS)
        self.assertEqual(stream_cursor._processing_time_milliseconds,
                         MOCK_PROCESSING_TIME)
        self.assertEqual(stream_cursor._session, mock_session)
        self.assertEqual(stream_cursor._transaction_id, MOCK_TRANSACTION_ID)
        self.assertEqual(stream_cursor._index, 0)
        self.assertEqual(stream_cursor._is_open, True)
예제 #12
0
    def test_iter(self, mock_session):
        mock_session.return_value = None
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                     MOCK_TRANSACTION_ID)

        self.assertEqual(iter(stream_cursor), stream_cursor)
예제 #13
0
    def test_value_holder_to_ion_value(self):
        ion_value = 'IonValue'
        value_holder = {'IonBinary': dumps(ion_value)}

        result = StreamCursor._value_holder_to_ion_value(value_holder)
        self.assertEqual(result, ion_value)
예제 #14
0
 def test_close(self, mock_session):
     mock_session.return_value = None
     stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                  MOCK_TRANSACTION_ID)
     stream_cursor.close()
     self.assertFalse(stream_cursor._is_open)
예제 #15
0
    def test_next_when_closed(self, mock_session):
        stream_cursor = StreamCursor(MOCK_STATEMENT_RESULT, mock_session,
                                     MOCK_TRANSACTION_ID)

        stream_cursor.close()
        self.assertRaises(ResultClosedError, next, stream_cursor)