memcached/test/memcached-cas.test.js at 1c0bccc23d61ea8df5ed9b632b042ed76583f491 · 3rd-Eden/memcached · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
'use strict';

/**
 * Test dependencies
 */
var assert = require('assert')
  , common = require('./common')
  , Memcached = require('../')
  , should = require('should')
;

global.testnumbers = global.testnumbers || +(Math.random(10) * 1000000).toFixed();

/**
 * Expresso test suite for all `get` related
 * memcached commands
 */
describe('Memcached CAS', function () {
  /**
   * For a proper CAS update in memcached you will need to know the CAS value
   * of a given key, this is done by the `gets` command. So we will need to make
   * sure that a `cas` key is given.
   */
  it('set and gets for cas result', function (done) {
    var memcached = new Memcached(common.servers.single)
        , message = common.alphabet(256)
        , testnr = ++global.testnumbers
        , callbacks = 0;

      memcached.set('test:' + testnr, message, 1000, function (error, ok) {
        ++callbacks;

        assert.ok(!error);
        ok.should.be.true;

        memcached.gets('test:' + testnr, function (error, answer) {
          ++callbacks;

          assert.ok(!error);

          assert.ok(typeof answer === 'object');
          assert.ok(!!answer.cas);
          answer['test:' + testnr].should.eql(message);

          memcached.end(); // close connections
          assert.equal(callbacks, 2);
          done();
        });
      });
  });

  /**
   * Create a successful cas update, so we are sure we send a cas request correctly.
   */
  it('successful cas update', function(done) {
    var memcached = new Memcached(common.servers.single)
        , message = common.alphabet(256)
        , testnr = ++global.testnumbers
        , callbacks = 0;

      memcached.set('test:' + testnr, message, 1000, function (error, ok) {
        ++callbacks;
        assert.ok(!error);
        ok.should.be.true;

        memcached.gets('test:' + testnr, function (error, answer) {
          ++callbacks;
          assert.ok(!error);
          assert.ok(!!answer.cas);

          // generate new message for the cas update
          message = common.alphabet(256);
          memcached.cas('test:' + testnr, message, answer.cas, 1000, function (error, answer) {
            ++callbacks;
            assert.ok(!error);
            assert.ok(!!answer);

            memcached.get('test:' + testnr, function (error, answer) {
              ++callbacks;

              assert.ok(!error);
              answer.should.eql(message);

              memcached.end(); // close connections
              assert.equal(callbacks, 4);
              done();
            });
          });
        });
      });
  });

  /**
   * Create a unsuccessful cas update, which would indicate that the server has changed
   * while we where doing nothing.
   */
  it('unsuccessful cas update', function (done) {
     var memcached = new Memcached(common.servers.single)
        , message = common.alphabet(256)
        , testnr = ++global.testnumbers
        , callbacks = 0;

      memcached.set('test:' + testnr, message, 1000, function (error, ok) {
        ++callbacks;
        assert.ok(!error);
        ok.should.be.true;

        memcached.gets('test:' + testnr, function (error, answer) {
          ++callbacks;
          assert.ok(!error);
          assert.ok(!!answer.cas);

          // generate new message
          message = common.alphabet(256);
          memcached.set('test:' + testnr, message, 1000, function () {
            ++callbacks;

            memcached.cas('test:' + testnr, message, answer.cas, 1000, function (error, answer) {
              ++callbacks;
              assert.ok(!error);
              assert.ok(!answer);

              memcached.get('test:' + testnr, function (error, answer) {
                ++callbacks;

                assert.ok(!error);
                answer.should.eql(message);

                memcached.end(); // close connections
                assert.equal(callbacks, 5);
                done();
              });
            });
          });
        });
      });
  });
});