def test_values_none(self):
        # should have values
        self.assertRaises(ValueError, self.bound.bind, None)

        # prepared statement with no values
        prepared_statement = PreparedStatement(column_metadata=[],
                                               query_id=None,
                                               routing_key_indexes=[],
                                               query=None,
                                               keyspace='whatever',
                                               protocol_version=self.protocol_version)
        bound = prepared_statement.bind(None)
        self.assertListEqual(bound.values, [])
Exemple #2
0
    def test_values_none(self):
        # should have values
        self.assertRaises(ValueError, self.bound.bind, None)

        # prepared statement with no values
        prepared_statement = PreparedStatement(
            column_metadata=[],
            query_id=None,
            routing_key_indexes=[],
            query=None,
            keyspace='whatever',
            protocol_version=self.protocol_version)
        bound = prepared_statement.bind(None)
        self.assertListEqual(bound.values, [])
    def test_invalid_argument_type(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [(keyspace, column_family, 'foo1', Int32Type),
                           (keyspace, column_family, 'foo2', Int32Type)]

        prepared_statement = PreparedStatement(column_metadata=column_metadata,
                                               query_id=None,
                                               routing_key_indexes=[],
                                               query=None,
                                               keyspace=keyspace)
        bound_statement = BoundStatement(prepared_statement=prepared_statement)

        values = ['nonint', 1]

        try:
            bound_statement.bind(values)
        except TypeError as e:
            self.assertIn('foo1', str(e))
            self.assertIn('Int32Type', str(e))
            self.assertIn('str', str(e))
        else:
            self.fail('Passed invalid type but exception was not thrown')

        values = [1, ['1', '2']]

        try:
            bound_statement.bind(values)
        except TypeError as e:
            self.assertIn('foo2', str(e))
            self.assertIn('Int32Type', str(e))
            self.assertIn('list', str(e))
        else:
            self.fail('Passed invalid type but exception was not thrown')
    def test_inherit_fetch_size(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [
            ColumnMetadata(keyspace, column_family, 'foo1', Int32Type),
            ColumnMetadata(keyspace, column_family, 'foo2', Int32Type)
        ]

        prepared_statement = PreparedStatement(column_metadata=column_metadata,
                                               query_id=None,
                                               routing_key_indexes=[],
                                               query=None,
                                               keyspace=keyspace,
                                               protocol_version=self.protocol_version)
        prepared_statement.fetch_size = 1234
        bound_statement = BoundStatement(prepared_statement=prepared_statement)
        self.assertEqual(1234, bound_statement.fetch_size)
Exemple #5
0
    def test_inherit_fetch_size(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [
            ColumnMetadata(keyspace, column_family, 'foo1', Int32Type),
            ColumnMetadata(keyspace, column_family, 'foo2', Int32Type)
        ]

        prepared_statement = PreparedStatement(
            column_metadata=column_metadata,
            query_id=None,
            routing_key_indexes=[],
            query=None,
            keyspace=keyspace,
            protocol_version=self.protocol_version)
        prepared_statement.fetch_size = 1234
        bound_statement = BoundStatement(prepared_statement=prepared_statement)
        self.assertEqual(1234, bound_statement.fetch_size)
    def test_too_few_parameters_for_key(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [(keyspace, column_family, 'foo1', Int32Type),
                           (keyspace, column_family, 'foo2', Int32Type)]

        prepared_statement = PreparedStatement(column_metadata=column_metadata,
                                               query_id=None,
                                               routing_key_indexes=[0, 1],
                                               query=None,
                                               keyspace=keyspace,
                                               protocol_version=2,
                                               fetch_size=1234)

        self.assertRaises(ValueError, prepared_statement.bind, (1, ))

        bound = prepared_statement.bind((1, 2))
        self.assertEqual(bound.keyspace, keyspace)
    def test_too_few_parameters_for_key(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [
            (keyspace, column_family, 'foo1', Int32Type),
            (keyspace, column_family, 'foo2', Int32Type)
        ]

        prepared_statement = PreparedStatement(column_metadata=column_metadata,
                                               query_id=None,
                                               routing_key_indexes=[0, 1],
                                               query=None,
                                               keyspace=keyspace,
                                               protocol_version=2)

        self.assertRaises(ValueError, prepared_statement.bind, (1,))

        bound = prepared_statement.bind((1, 2))
        self.assertEqual(bound.keyspace, keyspace)
Exemple #8
0
 def setUpClass(cls):
     cls.prepared = PreparedStatement(column_metadata=[
         ColumnMetadata('keyspace', 'cf', 'rk0', Int32Type),
         ColumnMetadata('keyspace', 'cf', 'rk1', Int32Type),
         ColumnMetadata('keyspace', 'cf', 'ck0', Int32Type),
         ColumnMetadata('keyspace', 'cf', 'v0', Int32Type)
     ],
                                      query_id=None,
                                      routing_key_indexes=[1, 0],
                                      query=None,
                                      keyspace='keyspace',
                                      protocol_version=cls.protocol_version)
     cls.bound = BoundStatement(prepared_statement=cls.prepared)
    def test_invalid_argument_type(self):
        keyspace = 'keyspace1'
        column_family = 'cf1'

        column_metadata = [(keyspace, column_family, 'foo1', Int32Type),
                           (keyspace, column_family, 'foo2', Int32Type)]

        prepared_statement = PreparedStatement(column_metadata=column_metadata,
                                               query_id=None,
                                               routing_key_indexes=[],
                                               query=None,
                                               keyspace=keyspace)
        bound_statement = BoundStatement(prepared_statement=prepared_statement)

        values = ['nonint', 1]

        try:
            bound_statement.bind(values)
        except InvalidParameterTypeError as e:
            self.assertEqual(e.col_name, 'foo1')
            self.assertEqual(e.expected_type, Int32Type)
            self.assertEqual(e.actual_type, str)
        else:
            self.fail('Passed invalid type but exception was not thrown')

        try:
            bound_statement.bind(values)
        except TypeError as e:
            self.assertEqual(e.col_name, 'foo1')
            self.assertEqual(e.expected_type, Int32Type)
            self.assertEqual(e.actual_type, str)
        else:
            self.fail('Passed invalid type but exception was not thrown')

        values = [1, ['1', '2']]

        try:
            bound_statement.bind(values)
        except InvalidParameterTypeError as e:
            self.assertEqual(e.col_name, 'foo2')
            self.assertEqual(e.expected_type, Int32Type)
            self.assertEqual(e.actual_type, list)
        else:
            self.fail('Passed invalid type but exception was not thrown')