Esempio n. 1
0
    def test_nested_sequence_serialization(self):
        '''Test serialization of a nested sequence'''

        expected = ''.join(
            chr(i) for i in itertools.chain(
                (5, 0, 0, 0),  # Sequence
                (3, 0, 0, 0),  # 3 steps
                (2, 0, 0, 0),  # Delete
                (3, 0, 0, 0),
                bytes_('key'),
                (5, 0, 0, 0),  # Sequence
                (2, 0, 0, 0),  # 2 steps
                (2, 0, 0, 0),  # Delete
                (3, 0, 0, 0),
                bytes_('key'),
                (1, 0, 0, 0),  # Set
                (3, 0, 0, 0),
                bytes_('key'),
                (5, 0, 0, 0),
                bytes_('value'),
                (5, 0, 0, 0),  # Sequence
                (0, 0, 0, 0),  # 0 steps
            ))

        received = ''.join(
            sequence.Sequence([
                sequence.Delete('key'),
                sequence.Sequence(
                    [sequence.Delete('key'),
                     sequence.Set('key', 'value')]),
                sequence.Sequence([])
            ]).serialize())

        self.assertEquals(expected, received)
Esempio n. 2
0
    def test_step(self):
        '''Test step checks'''

        self._run_test(
            protocol.STEP, (sequence.Set('key', 'value'), True),
            (sequence.Delete('key'), True), (sequence.Sequence([]), True),
            (sequence.Sequence([sequence.Set('key', 'value')]), True),
            (sequence.Sequence(
                [sequence.Set('key', 'value'),
                 sequence.Delete('key')]), True),
            (sequence.Sequence([
                sequence.Set('key', 'value'),
                sequence.Sequence(
                    [sequence.Set('key', 'value'),
                     sequence.Delete('key')])
            ]), True), (object(), False), (None, False), (sequence.Sequence(
                [sequence.Delete('key'), object()]), False))
Esempio n. 3
0
    def test_set_step_serialization(self):
        '''Test serialization of 'set' steps'''

        expected = ''.join(
            chr(i) for i in itertools.chain(
                (1, 0, 0, 0),
                (3, 0, 0, 0),
                bytes_('key'),
                (5, 0, 0, 0),
                bytes_('value'),
            ))

        received = ''.join(sequence.Set('key', 'value').serialize())

        self.assertEquals(expected, received)
Esempio n. 4
0
    def test_sequence_serialization(self):
        '''Test serialization of a sequence'''

        expected = ''.join(
            chr(i) for i in itertools.chain(
                (5, 0, 0, 0),
                (2, 0, 0, 0),
                (1, 0, 0, 0),
                (3, 0, 0, 0),
                bytes_('key'),
                (5, 0, 0, 0),
                bytes_('value'),
                (2, 0, 0, 0),
                (3, 0, 0, 0),
                bytes_('key'),
            ))

        received = ''.join(
            sequence.Sequence([
                sequence.Set('key', 'value'),
                sequence.Delete('key'),
            ]).serialize())

        self.assertEquals(expected, received)
Esempio n. 5
0
 def convert_set(step):
     return sequence.Set(step._key, step._value)
Esempio n. 6
0
    def test_scenario(self):
        '''Run a full-fledged scenario against the test server'''

        client = self._create_client()

        self.assertFalse(client.exists('key'))
        self.assertRaises(compat.ArakoonNotFound, client.get, 'key')
        self.assertRaises(compat.ArakoonNotFound, client.delete, 'key')

        client.set('key', 'value')
        self.assertTrue(client.exists('key'))
        self.assertEquals(client.get('key'), 'value')

        client.delete('key')
        self.assertFalse(client.exists('key'))

        for i in xrange(100):
            client.set('key_%d' % i, 'value')

        matches = client.prefix('key_')
        self.assertEquals(len(matches), 100)

        matches = client.prefix('key_1', 5)
        self.assertEquals(len(matches), 5)

        for match in matches:
            self.assertEquals(client.get(match), 'value')

        matches = client.range('key_10', True, 'key_15', False)
        self.assertEquals(len(matches), 5)
        self.assertEquals(set(matches),
            set('key_%d' % i for i in xrange(10, 15)))

        matches = client.range_entries('key_20', True, 'key_29', True, 20)
        self.assertEquals(len(matches), 10)

        for key, value in matches:
            self.assert_(key.startswith('key_2'))
            self.assertEquals(value, 'value')

        values = client.multiGet(['key_%d' % i for i in xrange(50)])
        self.assertEquals(len(values), 50)
        self.assert_(all(value == 'value' for value in values))

        self.assert_(client.expectProgressPossible())

        self.assertEquals(client.testAndSet('taskey', None, 'value0'), None)
        self.assertEquals(client.testAndSet('taskey', 'value0', 'value1'),
            'value0')
        self.assertEquals(client.testAndSet('taskey', 'value0', 'value2'),
            'value1')
        self.assertEquals(client.testAndSet('taskey', 'value1', None),
            'value1')
        self.assertFalse(client.exists('taskey'))

        sequence_ = compat.Sequence()
        sequence_.addSet('skey', 'value0')
        sequence_.addDelete('skey')
        sequence_.addSet('skey', 'value1')

        sequence2 = compat.Sequence()
        sequence2.addDelete('skey')
        sequence2.addSet('skey', 'value2')
        sequence2.addAssert('skey', 'value2')
        sequence2.addAssert('skey2', None)
        sequence_.addUpdate(sequence2)

        client.sequence(sequence_)
        client.sequence(sequence_, sync=False)
        client.sequence(sequence_, sync=True)

        self.assertEquals(client.get('skey'), 'value2')

        sequence_ = compat.Sequence()
        sequence_.addDelete('skey')
        sequence_.addDelete('skey2')

        self.assertRaises(compat.ArakoonNotFound, client.sequence, sequence_)

        # This is a bit out-of-place, but it's the only occasion where
        # sequence-with-a-list can be tested easily
        client._client.sequence([sequence.Set('skey', 'svalue3')])
        self.assertEquals(client.get('skey'), 'svalue3')
Esempio n. 7
0
    def test_step(self):
        '''Test encoding and decoding of Step values'''

        self.assertRaises(NotImplementedError,
            self._run_test, protocol.STEP, sequence.Set('key', 'value'))