Пример #1
0
 def product(self, product_id, user_id=None):
     query = self.client.query(self.namespace, data_type)
     if user_id:
         query.select('specialized')
         query.where(predicates.equals('id', product_id))
     else:
         query.select('general')
         query.where(predicates.equals('id', _id))
     return query.results()
Пример #2
0
    def test_background_execute_expressions_and_predicate(self):
        """
        Ensure that Scan.execute_background() gets applied to records that match the predicate.
        NOTE: the predicate overrides the expressions
        """
        test_bin = 'Stpredold'
        keys = [(TEST_NS, TEST_SET, i) for i in range(50)]

        expr = exp.Or(
            exp.Eq(exp.IntBin('number'), 2),
            exp.Eq(exp.IntBin('number'), 3)
        )

        policy = {
            'expressions': expr.compile()
        }

        number_predicate = predicates.equals('number', 4)

        scan = self.as_connection.scan(TEST_NS, TEST_SET)
        scan.where(number_predicate)
        scan.apply(TEST_UDF_MODULE, TEST_UDF_FUNCTION, [test_bin])
        job_id = scan.execute_background(policy)
        wait_for_job_completion(self.as_connection, job_id)

        for key in keys:
            _, _, bins = self.as_connection.get(key)
            if bins['number'] == 4:
                assert(bins[test_bin] == 'aerospike')
            else:
                assert(bins.get(test_bin) is None)
Пример #3
0
    def test_background_execute_predexp_and_predicate(self):
        """
        Ensure that Scan.execute_background() gets applied to records that match the predicate
        NOTE: the predicate overrides the predexp
        """
        test_bin = 'Stpredold'
        keys = [(TEST_NS, TEST_SET, i) for i in range(50)]

        predexp = [
            as_predexp.integer_bin('number'),
            as_predexp.integer_value(2),
            as_predexp.integer_equal(),
            as_predexp.integer_bin('number'),
            as_predexp.integer_value(3),
            as_predexp.integer_equal(),
            as_predexp.predexp_or(2)
        ]

        number_predicate = predicates.equals('number', 4)

        policy = {'predexp': predexp}

        scan = self.as_connection.scan(TEST_NS, TEST_SET)
        scan.where(number_predicate)
        scan.apply(TEST_UDF_MODULE, TEST_UDF_FUNCTION, [test_bin])
        job_id = scan.execute_background(policy)
        # Give time for the scan to finish
        wait_for_job_completion(self.as_connection, job_id)

        for key in keys:
            _, _, bins = self.as_connection.get(key)
            if bins['number'] == 4:
                assert (bins[test_bin] == 'aerospike')
            else:
                assert (bins.get(test_bin) is None)
Пример #4
0
    def test_background_execute_with_ops_and_preds(self):
        """
        Ensure that Scan.execute_background() applies ops to records that match the predicate
        """
        test_bin = 'St1'
        keys = [(TEST_NS, TEST_SET, i) for i in range(50)]

        scan = self.as_connection.scan(TEST_NS, TEST_SET)
        number_predicate = predicates.equals('number', 3)
        # scan.apply(TEST_UDF_MODULE, TEST_UDF_FUNCTION, [test_bin])

        ops = [operations.append(test_bin, 'new_val')]

        scan.add_ops(ops)
        scan.where(number_predicate)
        job_id = scan.execute_background()
        # Give time for the scan to finish
        wait_for_job_completion(self.as_connection, job_id)

        _, _, num_5_record = self.as_connection.get((TEST_NS, TEST_SET, 5))
        assert num_5_record[test_bin] == 'aerospike'

        _, _, num_3_record = self.as_connection.get((TEST_NS, TEST_SET, 3))
        assert num_3_record[test_bin] == 'aerospikenew_val'

        # cleanup
        ops = [operations.write(test_bin, 'aerospike')]

        scan.add_ops(ops)
        job_id = scan.execute_background()
        wait_for_job_completion(self.as_connection, job_id)

        validate_records(self.as_connection, keys,
                         lambda rec: rec[test_bin] == 'aerospike')
Пример #5
0
    def queryTweetsByUsername(self):
        print("\n********** Query Tweets By Username **********\n")
        #  Get username
        username = str()
        username = input("Enter username: "******"test", "tweets", "username", "username_index", None)
            #time.sleep(5)
            #print("\nString Secondary Index Created ")

            # Create Query and Set equality Filter on username
            # Exercise Q3
            tweetQuery = self.client.query("test", "tweets")
            # Select bin(s) you would like to retrieve
            tweetQuery.select('tweet')
            tweetQuery.where(p.equals('username',username))

            # Define the Call back to print Tweets for given Username
            # Exercise Q3
            def tweetQueryCallback(input_tuple):
              (key, meta, record)=input_tuple
              print(record["tweet"])

            # Execute query and for each record invoke the callback
            # Exercise Q3
            tweetQuery.foreach(tweetQueryCallback)
          except Exception as e :
            print("error: {0}".format(e), file=sys.stderr)
    def test_query_with_put_in_callback(self):
        """
            Invoke query() with put in callback
        """
        policy = {
            'timeout': 1000
        }
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))
        records = []
        def callback((key,metadata,record)):
            records.append(record)
            key = ('test', 'demo', 'put_in_callback')
            rec = {
                    'name' : 'name%s' % (str(8)),
                    'test_age'  : 8,
                    }
            TestQuery.client.put(key, rec)

        query.foreach(callback, policy)

        key = ('test', 'demo', 'put_in_callback')
        key1, meta, bins = TestQuery.client.get( key )

        key = ('test', 'demo', 'put_in_callback')
        TestQuery.client.remove(key)
        assert bins == { 'test_age': 8, 'name': 'name8'}
Пример #7
0
    def test_query_with_put_in_callback(self):
        """
            Invoke query() with put in callback
        """
        policy = {'timeout': 1000}
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))
        records = []

        def callback(input_tuple):
            _, _, record = input_tuple
            records.append(record)
            key = ('test', 'demo', 'put_in_callback')
            rec = {
                'name': 'name%s' % (str(8)),
                'test_age': 8,
            }
            self.client.put(key, rec)

        query.foreach(callback, policy)

        key = ('test', 'demo', 'put_in_callback')
        _, _, bins = self.client.get(key)

        key = ('test', 'demo', 'put_in_callback')
        self.client.remove(key)
        assert bins == {'test_age': 8, 'name': 'name8'}
Пример #8
0
 def aerospike_search_by_name(self):
     start = time.time()
     query = self.aero.query('uia-schedule', 'departments')
     query.where(p.equals('name', 'Pedagogikk masterprogram 2.sem, valgretning spesialpedagogikk'))
     data = query.results({'timeout' : 20000})
     elapsed = time.time() - start
     self.stats['aerospike']['search_by_name'] = elapsed
    def test_background_execute_predexp_and_predicate(self, clean_test_background):
        """
        Ensure that Query.execute_background() gets applied to records that match the predicate
        NOTE: the predicate overrides the predexp
        """
        test_bin = 'tpredold'
        keys = [(TEST_NS, TEST_SET, i) for i in range(500)]

        expr = exp.Or(
            exp.Eq(exp.IntBin('number'), 2),
            exp.Eq(exp.IntBin('number'), 3)
        )

        number_predicate = predicates.equals('number', 4)

        policy = {
            'expressions': expr.compile()
        }

        query = self.as_connection.query(TEST_NS, TEST_SET)
        query.where(number_predicate)
        query.apply(TEST_UDF_MODULE, TEST_UDF_FUNCTION, [test_bin])
        query.execute_background(policy)
        # Give time for the query to finish
        time.sleep(5)

        for key in keys:
            _, _, bins = self.as_connection.get(key)
            if bins['number'] == 4:
                assert(bins[test_bin] == 'aerospike')
            else:
                assert(bins.get(test_bin) is None)
Пример #10
0
 def aerospike_search_by_id(self):
     start = time.time()
     query = self.aero.query('uia-schedule', 'departments')
     query.where(p.equals('id', '#SPLUSE2E830'))
     data = query.results({'timeout' : 20000})
     elapsed = time.time() - start
     self.stats['aerospike']['search_by_id'] = elapsed
Пример #11
0
def get_ltv_by_phone_query(phone_number):
    query = client.query(namespace, customerSet)
    query.where(p.equals("phone_number", phone_number))
    query.select("lifetime_value")
    for record in query.results():
        (key, meta, bins) = record
        return bins.get("lifetime_value")
    logging.error('Requested phone number is not found ' + str(phone_number))
 def test_query_with_results_invalid_nobins_options(self):
     """
         Invoke query() with correct arguments
     """
     query = self.as_connection.query('test', 'demo')
     query.select('name', 'test_age')
     query.where(p.equals('test_age', 1))
     with pytest.raises(e.ParamError):
         records = query.results(options={'nobins': "false"})
def get_ltv_by_phone(client, namespace, set, phone_number):
    try:
        results = client.query(namespace, set).select('phone', 'ltv').where(p.equals('phone', phone_number)).results()
        if len(results) > 0:
            return results[0][2]['ltv']
        else:
            logging.error('Requested phone number \'{0}\' is not found'.format(phone_number))
    except ex.AerospikeError as e:
        logging.error("Error: {0} [{1}]".format(e.msg, e.code))
Пример #14
0
def get_ltv_by_phone(phone_number, namespace='test', aero_set='demo'):
    query = client.query(namespace, aero_set)
    query.select('ltv')
    query.where(p.equals('phone', phone_number))
    try:
        (key, metadata, record) = query.results()[0]
        return record['ltv']
    except IndexError:
        logging.error('Requested phone number is not found ' + str(phone_number))
Пример #15
0
 def test_query_with_results_invalid_nobins_options(self):
     """
         Invoke query() with correct arguments
     """
     query = self.as_connection.query('test', 'demo')
     query.select('name', 'test_age')
     query.where(p.equals('test_age', 1))
     with pytest.raises(e.ParamError):
         records = query.results(options={'nobins': "false"})
Пример #16
0
def get_ltv_by_phone(phone_number):
    query = client.query("test", "cust_set")
    query.where(p.equals("phone", phone_number))
    query.select("ltv")
    print(query)
    for record in query.results():
        (key, meta, bins) = record
        return bins.get("ltv")
    logging.error('Requested phone number is not found ' + str(phone_number))
    def test_query_with_unicode_binnames_in_select_and_where(self):
        """
            Invoke query() with unicode bin names in select
        """
        query = TestQuery.client.query('test', 'demo')
        query.select(u'name', u'test_age', 'addr')
        query.where(p.equals(u'test_age', 7))

        records = query.results()
        assert len(records) == 1
        assert records[0][2] == {'test_age': 7, 'name': u'name7', 'addr': u'name7'}

        query = TestQuery.client.query('test', 'demo')
        query.select(u'name', 'addr')
        query.where(p.equals(u'addr', u'name9'))

        records = query.results()
        assert records[0][2] == {'name': 'name9', 'addr': u'name9'}
Пример #18
0
 def manager(self, data_type, _id=None):
     if _id:
         query = self.client.query(self.namespace, data_type)
         query.where(predicates.equals('id', _id))
         return query.results()
     else:
         # return all results
         all_objects = self.client.scan(self.namespace, data_type)
         data = all_objects.results()
         return data
    def test_query_with_results_nobins_options(self):
        """
            Invoke query() with correct arguments
        """
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = query.results(options={'nobins': True})
        assert len(records) == 1
    def test_query_with_results_method(self):
        """
            Invoke query() with correct arguments
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = query.results()
        assert len(records) == 1
Пример #21
0
    def test_query_with_results_method(self):
        """
            Invoke query() with correct arguments
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = query.results()
        assert len(records) == 1
Пример #22
0
    def test_query_with_results_nobins_options(self):
        """
            Invoke query() with correct arguments
        """
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = query.results(options={'nobins': True})
        assert len(records) == 1
Пример #23
0
def get_ltv_by_phone(client, phone_number):
    query = client.query('test', 'customer')
    query.select('ltv')
    query.where(p.equals('phone_number', phone_number))
    records = query.results()
    for record in records:
        return (record[2]['ltv'])
    logging.error(
        'Requested phone number %s is not found in (\'test\',\'customer\')' %
        str(phone_number))
    def test_query_with_where_none_value(self):
        """
            Invoke query() with where is null value
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        with pytest.raises(Exception) as exception:
            query.where(p.equals('test_age', None))

        assert exception.value[0] == -2L
        assert exception.value[1] == 'predicate is invalid.'
Пример #25
0
def get_ltv_by_phone(phone_number):
  
  query = client.query('test', 'demo')   
  query.select('ltv')
  query.where(p.equals('phone', phone_number))
  ltvs = []
  def matched_names((key, metadata, bins)):
    ltvs.append(bins['ltv'])
  
  query.foreach(matched_names,  {'total_timeout':2000} )
  return ltvs
Пример #26
0
    def get_ltv_by_phone(self, phone_number):
        """ Get LTV value using phone_number"""
        query = self.client.query(self.key['namespace'], self.key['set'])
        try:
            (key, meta, record) = query.where(p.equals('phone', phone_number)).select('ltv').results()[0]
            logging.debug(record)
        except ex.AerospikeError as e:
            logging.error('Requested phone number is not found ' + str(phone_number))
            logging.debug(e)
            record = {'ltv': None}

        return record['ltv']
Пример #27
0
def get_ltv_by_phone(phone_number):
    query = client.query("test", "customers").select("phone_number", "ltv")
    query.where(p.equals("phone_number", phone_number))
    try:
        results = query.results()
    except exception.IndexNotFound:
        logging.error("There is no secondary index defined for 'phone_number'")
        return None
    if results:
        return results[0][2].get("ltv")
    logging.error(
        "Record with phone_number → {} was not found!".format(phone_number))
Пример #28
0
    def test_query_with_where_none_value(self):
        """
            Invoke query() with where is null value
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        try:
            query.where(p.equals('test_age', None))

        except e.ParamError as exception:
            assert exception.code == -2
            assert exception.msg == 'predicate is invalid.'
Пример #29
0
    def test_query_with_where_none_value(self):
        """
            Invoke query() with where is null value
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        try:
            query.where(p.equals('test_age', None))

        except ParamError as exception:
            assert exception.code == -2L
            assert exception.msg == 'predicate is invalid.'
Пример #30
0
def get_ltv_by_phone(phone_number):
    try:
        query = _client.query(_namespace, _set)
        records  = query.select('phone', 'ltv').where(p.equals('phone', phone_number)).results()
        if len(records) > 0:
            #print(records)
            #print(records[0][2])
            return records[0][2]['ltv']
        else:
            logging.error('Requested phone number is not found {0}'.format(str(phone_number)))
    except ex.AerospikeError as e:
        logging.error('error: {0}'.format(e))
    def test_query_with_incorrect_bin_name(self):
        """
            Invoke query() with incorrect bin name
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name1', 'age1')
        query.where(p.equals('age1', 1))
        records = []
        def callback((key,metadata,record)):
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
Пример #32
0
def get_ltv_by_phone(phone_number):
    try:
        # Создаем запрос для поиска телефона
        # Оказывается, однажды созданный экземпляр Query при последующих вызовах других select и where никак на это не реагирует.
        # Приходится создавать новый, освобождая существующий.
        aeroQuery = client.query(aeroNameSpace, aeroSet)
        aeroQuery.select( "lifetime_value" )
        aeroQuery.where( predicates.equals("phone_number", phone_number) )
        records = aeroQuery.results( {'total_timeout':2000})
        (dummy1, dummy2, pDict) = records[0] # first found string
        return pDict.get( "lifetime_value" )
    except Exception as e:
        logging.error('Requested phone number is not found ' + str(phone_number))
    def test_query_with_unicode_binnames_in_select_and_where(self):
        """
            Invoke query() with unicode bin names in select
        """
        query = self.client.query('test', 'demo')
        query.select(u'name', u'test_age', 'addr')
        query.where(p.equals(u'test_age', 7))

        records = query.results()
        assert len(records) == 1
        assert records[0][2] == {
            'test_age': 7,
            'name': u'name7',
            'addr': u'name7'
        }

        query = self.client.query('test', 'demo')
        query.select(u'name', 'addr')
        query.where(p.equals(u'addr', u'name9'))

        records = query.results()
        assert records[0][2] == {'name': 'name9', 'addr': u'name9'}
    def test_query_with_where_incorrect(self):
        """
            Invoke query() with where is incorrect
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 165))
        records = []
        def callback((key,metadata,record)):
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
Пример #35
0
 def as_select_by_columns(self,
                          table,
                          where_field=None,
                          where_value=None,
                          columns=None):
     query = self.client.query(self.namespace, table)
     if type(columns) is list or type(columns) is set:
         query.select(*columns)
     elif not columns is None:
         query.select(columns)
     if where_field:
         query.where(p.equals(where_field, where_value))
     return query
    def test_aggregate_with_where_equals_value(self):
        """
            Invoke aggregate() with where is equal
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 2))
        query.apply('stream_example', 'count')
        records = []
        def user_callback(value):
            records.append(value)

        query.foreach(user_callback)
        assert records[0] == 1
    def test_query_with_multiple_foreach_on_same_query_object(self):
        """
            Invoke query() with multple foreach() call on same query object
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = []
        def callback((key,metadata,record)):
            records.append(key)

        query.foreach(callback)
        assert len(records) == 1
    def test_query_with_incorrect_bin_name(self):
        """
            Invoke query() with incorrect bin name
        """
        query = self.client.query('test', 'demo')
        query.select('name1', 'age1')
        query.where(p.equals('age1', 1))
        records = []

        def callback((key, metadata, record)):
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
    def test_query_with_invalid_nobins_value(self):
        """
            Invoke query() with options['nobins'] type
        """
        policy = {'total_timeout': 1000}
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        def callback(input_tuple):
            pass

        with pytest.raises(e.ParamError):
            query.foreach(callback, policy, {'nobins': 'False'})
def get_ltv_by_phone(phone_number):

    query = client.query("test", "demo")
    query.select("ltv")
    query.where(p.equals("phone", phone_number))
    ltvs = []

    def matches_phone(tuple_1):
        key, metadata, bins = tuple_1
        ltvs.append(bins["ltv"])

    query.foreach(matches_phone, {"total_timeout": 2000})

    return ltvs[0]
    def test_query_with_where_incorrect(self):
        """
            Invoke query() with where is incorrect
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 165))
        records = []

        def callback((key, metadata, record)):
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
Пример #42
0
    def test_query_with_invalid_nobins_value(self):
        """
            Invoke query() with options['nobins'] type
        """
        policy = {'total_timeout': 1000}
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        def callback(input_tuple):
            pass

        with pytest.raises(e.ParamError):
            query.foreach(callback, policy, {'nobins': 'False'})
    def test_query_without_callback_parameter(self):
        """
            Invoke query() with without callback
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))
        def callback((key,metadata,record)):
            assert metadata['gen'] != None

        with pytest.raises(TypeError) as typeError:
            query.foreach()

        assert "Required argument 'callback' (pos 1) not found" in typeError.value
    def test_query_with_nonindexed_bin(self):
        """
            Invoke query() with non-indexed bin
        """
        with pytest.raises(Exception) as exception:
            query = TestQuery.client.query('test', 'demo')
            query.select('name', 'no')
            query.where(p.equals('no', 1))
            def callback((key,metadata,record)):
                assert metadata['gen'] != None

            query.foreach(callback)

        assert exception.value[0] == 201L
        assert exception.value[1] == 'AEROSPIKE_ERR_INDEX_NOT_FOUND'
    def test_query_with_where_none_value(self):
        """
            Invoke query() with equality
            predicate comparing to None
            This is more of a predicate test

        """
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        try:
            query.where(p.equals('test_age', None))

        except e.ParamError as exception:
            assert exception.code == -2
            assert exception.msg == 'predicate is invalid.'
    def test_query_with_invalid_options_argument_type(self):
        """
            Invoke query() with incorrect options type, should be a dictionary
        """
        policy = {'timeout': 1000}
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        def callback(input_tuple):
            _, metadata, _ = input_tuple
            assert metadata['gen'] is None

        with pytest.raises(e.ParamError):
            query.foreach(callback, policy, "")
    def test_query_with_correct_parameters(self):
        """
            Invoke query() with correct arguments
        """
        query = TestQuery.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = []
        def callback((key,metadata,record)):
            records.append(key)

        query.foreach(callback)
        assert records
        assert len(records) == 1
    def test_neg_aggregate_with_where_incorrect(self):
        """
            Invoke aggregate() with where is incorrect
        """
        query = self.as_connection.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 165))
        query.apply('stream_example', 'count')
        records = []

        def user_callback(value):
            records.append(value)

        query.foreach(user_callback)
        assert records == []
    def test_query_with_incorrect_bin_name(self):
        """
            Invoke query() with incorrect bin name
        """
        query = self.client.query('test', 'demo')
        query.select('name1', 'age1')
        query.where(p.equals('age1', 1))
        records = []

        def callback(input_tuple):
            _, _, record = input_tuple
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
    def test_aggregate_with_where_equals_value(self):
        """
            Invoke aggregate() with where is equal
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 2))
        query.apply('stream_example', 'count')
        records = []

        def user_callback(value):
            records.append(value)

        query.foreach(user_callback)
        assert records[0] == 1
Пример #51
0
    def test_query_with_policy(self):
        """
            Invoke query() with policy
        """
        policy = {'timeout': 1000}
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))
        records = []

        def callback((key, metadata, record)):
            records.append(record)

        query.foreach(callback, policy)
        assert len(records) == 1
    def test_query_with_where_incorrect(self):
        """
            Invoke query() with where is incorrect
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 165))
        records = []

        def callback(input_tuple):
            _, _, record = input_tuple
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
    def test_query_with_incorrect_bin_name(self):
        """
            Invoke query() with predicate comparing using non-extant bin name
        """
        query = self.as_connection.query('test', 'demo')
        query.select('name1', 'age1')
        query.where(p.equals('age1', 1))
        records = []

        def callback(input_tuple):
            _, _, record = input_tuple
            records.append(record)

        query.foreach(callback)
        assert len(records) == 0
    def test_query_with_multiple_foreach_on_same_query_object(self):
        """
            Invoke query() with multple foreach() call on same query object
        """
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        records = []

        def callback((key, metadata, record)):
            records.append(key)

        query.foreach(callback)
        assert len(records) == 1
    def test_query_with_incorrect_ns_set(self):
        """
            Invoke query() with incorrect ns and set
        """
        with pytest.raises(Exception) as exception:
            query = TestQuery.client.query('test1', 'demo1')
            query.select('name', 'test_age')
            query.where(p.equals('test_age', 1))
            def callback((key,metadata,record)):
                assert metadata['gen'] != None

            query.foreach(callback)

        assert exception.value[0] == 4L
        assert exception.value[1] == 'AEROSPIKE_ERR_REQUEST_INVALID'
Пример #56
0
    def test_query_with_ns_not_string(self):
        """
            Invoke query() with incorrect ns and set
        """
        try:
            query = self.client.query(1, 'demo')
            query.select('name', 'test_age')
            query.where(p.equals('test_age', 1))
            def callback((key,metadata,record)):
                assert metadata['gen'] != None

            query.foreach(callback)

        except ParamError as exception:
            assert exception.code == -2L
            assert exception.msg == 'Namespace should be a string'
Пример #57
0
    def test_query_with_select_bytearray(self):
        """
            Invoke query() with correct arguments
        """
        query = self.client.query('test', 'demo')
        query.select(bytearray("sal\0kj", "utf-8"))
        query.where(p.equals(bytearray("sal\0kj", "utf-8"), 80000))

        records = []

        def callback((key, metadata, record)):
            records.append(key)

        query.foreach(callback)
        assert records
        assert len(records) == 1
Пример #58
0
    def test_query_with_set_int(self):
        """
            Invoke query() with incorrect ns and set
        """
        try:
            query = self.client.query('test', 1)
            query.select('name', 'test_age')
            query.where(p.equals('test_age', 1))
            def callback((key,metadata,record)):
                assert metadata['gen'] != None

            query.foreach(callback)

        except ParamError as exception:
            assert exception.code == -2L
            assert exception.msg == 'Set should be string, unicode or None'
Пример #59
0
    def test_query_with_extra_argument(self):
        """
            Invoke query() with extra argument
        """
        policy = {'timeout': 1000}
        query = self.client.query('test', 'demo')
        query.select('name', 'test_age')
        query.where(p.equals('test_age', 1))

        def callback((key, metadata, record)):
            assert metadata['gen'] != None

        with pytest.raises(TypeError) as typeError:
            query.foreach(callback, policy, "")

        assert "foreach() takes at most 2 arguments (3 given)" in typeError.value
    def test_query_with_multiple_results_call_on_same_query_object(self):
        """
            Invoke query() with multple results() call on same query object
        """
        query = TestQuery.client.query('test', 'demo')
        query.select(u'name', u'test_age', 'addr')
        query.where(p.equals(u'test_age', 7))

        records = query.results()
        assert len(records) == 1
        assert records[0][2] == {'test_age': 7, 'name': u'name7', 'addr': u'name7'}

        records = []
        records = query.results()
        assert len(records) == 1
        assert records[0][2] == {'test_age': 7, 'name': u'name7', 'addr': u'name7'}