memcached_test 0.1.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. checksums.yaml +4 -4
  2. data/lib/memcached_test/client.rb +33 -19
  3. data/lib/memcached_test/commands_format.rb +8 -8
  4. data/lib/memcached_test/memcached.rb +10 -10
  5. data/lib/memcached_test/server.rb +27 -48
  6. data/lib/memcached_test/version.rb +1 -1
  7. data/spec/memcached_test/memcached_spec.rb +36 -35
  8. data/spec/memcached_test/server-client_spec.rb +214 -12
  9. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 34548c86a43ed1b1ff7682817f74329f7b21391e507353104834b6810d16222e
4
- data.tar.gz: 2b98e3bc75adafb2c623d36d806b3cc439804c8df6fba011cd62e2b764f3067e
3
+ metadata.gz: cb8ed8951b7be08bb84a1bec1b962f83de8053ce02d6db177711106f5e2f906e
4
+ data.tar.gz: 8dc22ecbbcd40a959d4460f01005819e1e11a6b04991a8bf9ff8248f8137ef28
5
5
  SHA512:
6
- metadata.gz: a4b9d5f9d94c5c186f3d5eb2c9f506ded7011bf2cec7cba024189b105c6da39319156e14864b3d1fb8fa3a014f126e0efecc06faba56eb827c8219133b00f0d4
7
- data.tar.gz: 6668cabe909f6b9b0c6117273968a0a743175dfbef1eefa5d789009e6b5c9b5eda50cd0591fe6ed8a0899db940ed8c908bfa7005341307720568f503e880a244
6
+ metadata.gz: 5a131cb6470edbce7609f55bf6b6ed98b6824ef02e393e8a23edd051efcf7850fd873ffe23b6868b5243a47d382111af0d25fda4eb0ce7c7db151d92db0ae656
7
+ data.tar.gz: ad9190e8b430412a1cbaa9496c31afe6aa2707aabc826a5e6a6a1d88487579a5c901a572dbe424ed9971a7432803c8a58bb94f7eec7c69086982a2efb03ff456
data/lib/memcached_test/client.rb CHANGED
@@ -2,6 +2,8 @@ require 'socket'
2
2
 
3
3
  module MemcachedTest
4
4
  class Client
5
+ attr_reader :socket
6
+
5
7
  def initialize(host, port)
6
8
  @socket = TCPSocket.open(host, port)
7
9
  end
@@ -77,56 +79,68 @@ module MemcachedTest
77
79
 
78
80
  def set(key, flags, exptime, bytes, noreply = '', data)
79
81
  if noreply == ''
80
- @socket.puts("set #{key} #{flags} #{exptime} #{bytes} #{data}")
82
+ @socket.puts("set #{key} #{flags} #{exptime} #{bytes}")
83
+ @socket.puts("#{data}")
81
84
  else
82
- @socket.puts("set #{key} #{flags} #{exptime} #{bytes} #{noreply} #{data}")
85
+ @socket.puts("set #{key} #{flags} #{exptime} #{bytes} #{noreply}")
86
+ @socket.puts("#{data}")
83
87
  end
84
88
  return @socket.gets() unless noreply == 'noreply'
85
89
  end
86
90
 
87
91
  def add(key, flags, exptime, bytes, noreply = '', data)
88
92
  if noreply == ''
89
- @socket.puts("add #{key} #{flags} #{exptime} #{bytes} #{data}")
93
+ @socket.puts("add #{key} #{flags} #{exptime} #{bytes}")
94
+ @socket.puts("#{data}")
90
95
  else
91
- @socket.puts("add #{key} #{flags} #{exptime} #{bytes} #{noreply} #{data}")
96
+ @socket.puts("add #{key} #{flags} #{exptime} #{bytes} #{noreply}")
97
+ @socket.puts("#{data}")
92
98
  end
93
- return @socket.gets()
99
+ return @socket.gets() unless noreply == 'noreply'
94
100
  end
95
101
 
96
102
  def replace(key, flags, exptime, bytes, noreply = '', data)
97
103
  if noreply == ''
98
- @socket.puts("replace #{key} #{flags} #{exptime} #{bytes} #{data}")
104
+ @socket.puts("replace #{key} #{flags} #{exptime} #{bytes}")
105
+ @socket.puts("#{data}")
99
106
  else
100
- @socket.puts("replace #{key} #{flags} #{exptime} #{bytes} #{noreply} #{data}")
107
+ @socket.puts("replace #{key} #{flags} #{exptime} #{bytes} #{noreply}")
108
+ @socket.puts("#{data}")
101
109
  end
102
- return @socket.gets()
110
+ return @socket.gets() unless noreply == 'noreply'
103
111
  end
104
112
 
105
- def append(key, flags, exptime, bytes, noreply = '', data)
113
+ def append(key, bytes, noreply = '', data)
106
114
  if noreply == ''
107
- @socket.puts("append #{key} #{flags} #{exptime} #{bytes} #{data}")
115
+ @socket.puts("append #{key} #{bytes}")
116
+ @socket.puts("#{data}")
108
117
  else
109
- @socket.puts("append #{key} #{flags} #{exptime} #{bytes} #{noreply} #{data}")
118
+ @socket.puts("append #{key} #{bytes} #{noreply}")
119
+ @socket.puts("#{data}")
110
120
  end
111
- return @socket.gets()
121
+ return @socket.gets() unless noreply == 'noreply'
112
122
  end
113
123
 
114
- def prepend(key, flags, exptime, bytes, noreply = '', data)
124
+ def prepend(key, bytes, noreply = '', data)
115
125
  if noreply == ''
116
- @socket.puts("prepend #{key} #{flags} #{exptime} #{bytes} #{data}")
126
+ @socket.puts("prepend #{key} #{bytes}")
127
+ @socket.puts("#{data}")
117
128
  else
118
- @socket.puts("prepend #{key} #{flags} #{exptime} #{bytes} #{noreply} #{data}")
129
+ @socket.puts("prepend #{key} #{bytes} #{noreply}")
130
+ @socket.puts("#{data}")
119
131
  end
120
- return @socket.gets()
132
+ return @socket.gets() unless noreply == 'noreply'
121
133
  end
122
134
 
123
135
  def cas(key, flags, exptime, bytes, cas, noreply = '', data)
124
136
  if noreply == ''
125
- @socket.puts("cas #{key} #{flags} #{exptime} #{bytes} #{cas} #{data}")
137
+ @socket.puts("cas #{key} #{flags} #{exptime} #{bytes} #{cas}")
138
+ @socket.puts("#{data}")
126
139
  else
127
- @socket.puts("cas #{key} #{flags} #{exptime} #{bytes} #{cas} #{noreply} #{data}")
140
+ @socket.puts("cas #{key} #{flags} #{exptime} #{bytes} #{cas} #{noreply}")
141
+ @socket.puts("#{data}")
128
142
  end
129
- return @socket.gets()
143
+ return @socket.gets() unless noreply == 'noreply'
130
144
  end
131
145
 
132
146
  end
data/lib/memcached_test/commands_format.rb CHANGED
@@ -4,17 +4,17 @@ module MemcachedTest
4
4
  class Commands_format
5
5
  include Ruby::Enum
6
6
 
7
- define :get, /^get (?<keys>(\w|[ ])+)/
8
- define :gets, /^gets (?<keys>(\w|[ ])+)/
7
+ define :get, /^(?<command>get) (?<keys>(\w|[ ])+)/
8
+ define :gets, /^(?<command>gets) (?<keys>(\w|[ ])+)/
9
9
 
10
- define :set, /^set (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
11
- define :add, /^add (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
12
- define :replace, /^replace (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
10
+ define :set, /^(?<command>set) (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)?/
11
+ define :add, /^(?<command>add) (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)?/
12
+ define :replace, /^(?<command>replace) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)?/
13
13
 
14
- define :append, /^append (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
15
- define :prepend, /^prepend (?<key>\w+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
14
+ define :append, /^(?<command>append) (?<key>\w+) (?<bytes>\d+)(?<noreply> noreply)?/
15
+ define :prepend, /^(?<command>prepend) (?<key>\w+) (?<bytes>\d+)(?<noreply> noreply)?/
16
16
 
17
- define :cas, /^cas (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+) (?<cas_id>\d+)(?<noreply> noreply)? (?<data>(\w|[ ])+)/
17
+ define :cas, /^(?<command>cas) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+) (?<cas>\d+)(?<noreply> noreply)?/
18
18
 
19
19
  define :flush_all, /^flush_all(?<noreply> noreply)?/
20
20
  end
data/lib/memcached_test/memcached.rb CHANGED
@@ -36,11 +36,11 @@ module MemcachedTest
36
36
 
37
37
  def set(key, flags, exptime, bytes, data)
38
38
  if @cache.key?(key)
39
- item = Memcached_item.new(flags, exptime, bytes, @cache[key].cas + 1, data)
39
+ item = Memcached_item.new(flags, exptime, bytes, @cache[key].cas.to_i + 1, data[0, bytes.to_i])
40
40
  @cache[key] = item
41
41
  return "STORED\r\n"
42
42
  else
43
- item = Memcached_item.new(flags, exptime, bytes, 1, data)
43
+ item = Memcached_item.new(flags, exptime, bytes, 1, data[0, bytes.to_i])
44
44
  @cache[key] = item
45
45
  return "STORED\r\n"
46
46
  end
@@ -50,7 +50,7 @@ module MemcachedTest
50
50
  if @cache.key?(key)
51
51
  return "NOT_STORED\r\n"
52
52
  else
53
- item = Memcached_item.new(flags, exptime, bytes, 1, data)
53
+ item = Memcached_item.new(flags, exptime, bytes, 1, data[0, bytes.to_i])
54
54
  @cache[key] = item
55
55
  return "STORED\r\n"
56
56
  end
@@ -58,7 +58,7 @@ module MemcachedTest
58
58
 
59
59
  def replace(key, flags, exptime, bytes, data)
60
60
  if @cache.key?(key)
61
- item = Memcached_item.new(flags, exptime, bytes, @cache[key].cas + 1, data)
61
+ item = Memcached_item.new(flags, exptime, bytes, @cache[key].cas + 1, data[0, bytes.to_i])
62
62
  @cache[key] = item
63
63
  return "STORED\r\n"
64
64
  else
@@ -66,10 +66,10 @@ module MemcachedTest
66
66
  end
67
67
  end
68
68
 
69
- def append(key, flags, exptime, bytes, data)
69
+ def append(key, bytes, data)
70
70
  if @cache.key?(key)
71
71
  item_old = @cache[key]
72
- item_new = Memcached_item.new(flags, exptime, bytes, @cache[key].cas + 1, item_old.data + data)
72
+ item_new = Memcached_item.new(item_old.flags, item_old.exptime, item_old.bytes.to_i + bytes.to_i, @cache[key].cas + 1, item_old.data + data[0, bytes.to_i])
73
73
  @cache[key] = item_new
74
74
  return "STORED\r\n"
75
75
  else
@@ -77,10 +77,10 @@ module MemcachedTest
77
77
  end
78
78
  end
79
79
 
80
- def prepend(key, flags, exptime, bytes, data)
80
+ def prepend(key, bytes, data)
81
81
  if @cache.key?(key)
82
82
  item_old = @cache[key]
83
- item_new = Memcached_item.new(flags, exptime, bytes, @cache[key].cas + 1, data + item_old.data)
83
+ item_new = Memcached_item.new(item_old.flags, item_old.exptime, item_old.bytes.to_i + bytes.to_i, @cache[key].cas + 1, data[0, bytes.to_i] + item_old.data)
84
84
  @cache[key] = item_new
85
85
  return "STORED\r\n"
86
86
  else
@@ -90,8 +90,8 @@ module MemcachedTest
90
90
 
91
91
  def cas(key, flags, exptime, bytes, cas, data)
92
92
  if @cache.key?(key)
93
- if @cache[key].cas == cas
94
- item = Memcached_item.new(flags, exptime, bytes, cas, data)
93
+ if @cache[key].cas == cas.to_i
94
+ item = Memcached_item.new(flags, exptime, bytes, cas.to_i + 1, data[0, bytes.to_i])
95
95
  @cache[key] = item
96
96
  return "STORED\r\n"
97
97
  else
data/lib/memcached_test/server.rb CHANGED
@@ -4,6 +4,8 @@ require_relative 'commands_format'
4
4
 
5
5
  module MemcachedTest
6
6
  class Server
7
+ attr_reader :server_socket
8
+
7
9
  def initialize(socket_address, socket_port)
8
10
  @server_socket = TCPServer.open(socket_address, socket_port)
9
11
  @memcached = Memcached.new
@@ -12,7 +14,6 @@ module MemcachedTest
12
14
  def run
13
15
  loop{
14
16
  client_connection = @server_socket.accept
15
- #foreach client that connects
16
17
  Thread.start(client_connection) do |conn|
17
18
  puts "Connection established #{conn}"
18
19
 
@@ -60,73 +61,42 @@ module MemcachedTest
60
61
  client.puts ("VALUE #{resultados[0]} #{resultados[1]} #{resultados[3]} #{resultado[4]}\r\n#{resultados[5]}\r\n")
61
62
  client.puts ("END\r\n")
62
63
  else
63
- client.append ("NOT_FOUND\r\n")
64
+ client.puts ("NOT_FOUND\r\n")
64
65
  end
65
66
 
66
67
  when Commands_format.set
67
- key = $~['key']
68
- flags = $~['flags']
69
- exptime = $~['exptime']
70
- bytes = $~['bytes']
71
- noreply = !$~['noreply'].nil?
72
- data = $~['data']
73
-
68
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
69
+ data = client.gets.chomp
74
70
  response = @memcached.set(key, flags, exptime, bytes, data)
75
71
  client.puts response unless noreply
76
72
 
77
73
  when Commands_format.add
78
- key = $~['key']
79
- flags = $~['flags']
80
- exptime = $~['exptime']
81
- bytes = $~['bytes']
82
- noreply = !$~['noreply'].nil?
83
- data = $~['data']
84
-
74
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
75
+ data = client.gets.chomp
85
76
  response = @memcached.add(key, flags, exptime, bytes, data)
86
77
  client.puts response unless noreply
87
78
 
88
79
  when Commands_format.replace
89
- key = $~['key']
90
- flags = $~['flags']
91
- exptime = $~['exptime']
92
- bytes = $~['bytes']
93
- noreply = !$~['noreply'].nil?
94
- data = $~['data']
95
-
80
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
81
+ data = client.gets.chomp
96
82
  response = @memcached.replace(key, flags, exptime, bytes, data)
97
83
  client.puts response unless noreply
98
84
 
99
85
  when Commands_format.append
100
- key = $~['key']
101
- flags = $~['flags']
102
- exptime = $~['exptime']
103
- bytes = $~['bytes']
104
- noreply = !$~['noreply'].nil?
105
- data = $~['data']
106
-
107
- response = @memcached.append(key, flags, exptime, bytes, data)
86
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
87
+ data = client.gets.chomp
88
+ response = @memcached.append(key, bytes, data)
108
89
  client.puts response unless noreply
109
90
 
110
91
  when Commands_format.prepend
111
- key = $~['key']
112
- flags = $~['flags']
113
- exptime = $~['exptime']
114
- bytes = $~['bytes']
115
- noreply = !$~['noreply'].nil?
116
- data = $~['data']
117
-
118
- response = @memcached.prepend(key, flags, exptime, bytes, data)
92
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
93
+ data = client.gets.chomp
94
+ response = @memcached.prepend(key, bytes, data)
119
95
  client.puts response unless noreply
120
96
 
121
97
  when Commands_format.cas
122
- key = $~['key']
123
- flags = $~['flags']
124
- exptime = $~['exptime']
125
- bytes = $~['bytes']
126
- cas = $~['cas']
127
- noreply = !$~['noreply'].nil?
128
- data = $~['data']
129
-
98
+ key, flags, exptime, bytes, noreply, cas = self.pass_parameters($~)
99
+ data = client.gets.chomp
130
100
  response = @memcached.cas(key, flags, exptime, bytes, cas, data)
131
101
  client.puts response unless noreply
132
102
 
@@ -135,7 +105,7 @@ module MemcachedTest
135
105
  client.puts response if $~['noreply'].nil?
136
106
 
137
107
  else
138
- client.puts "Invalid command, please retry"
108
+ client.puts "ERROR\r\n"
139
109
  end
140
110
  end
141
111
 
@@ -147,5 +117,14 @@ module MemcachedTest
147
117
  }
148
118
  end
149
119
 
120
+ def pass_parameters(reg_exp)
121
+ key = reg_exp['key']
122
+ flags = reg_exp['flags'] unless reg_exp['command'] == 'append' || reg_exp['command'] == 'prepend'
123
+ exptime = reg_exp['exptime'] unless reg_exp['command'] == 'append' || reg_exp['command'] == 'prepend'
124
+ bytes = reg_exp['bytes']
125
+ noreply = !reg_exp['noreply'].nil?
126
+ cas = reg_exp['cas'] if reg_exp['command'] == 'cas'
127
+ return key, flags, exptime, bytes, noreply, cas
128
+ end
150
129
  end
151
130
  end
data/lib/memcached_test/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module MemcachedTest
2
- VERSION = "0.1.0"
2
+ VERSION = "1.0.0"
3
3
  end
data/spec/memcached_test/memcached_spec.rb CHANGED
@@ -8,22 +8,22 @@ describe MemcachedTest::Memcached do
8
8
  describe ".set" do
9
9
  context "given the correct parameters" do
10
10
  it "set a value asociated to a key that doesn't exist" do
11
- return_set = @mem.set("key", 10, 500, 20, "Data to be stored")
11
+ return_set = @mem.set("key", 10, 500, 17, "Data to be stored")
12
12
  expect(return_set).to eql("STORED\r\n" )
13
13
  end
14
14
  it "set a value asociated to a key that exists" do
15
15
  @mem.set("key", 10, 500, 20, "Data to be stored")
16
- return_set = @mem.set("key", 10, 500, 20, "New data to be stored")
16
+ return_set = @mem.set("key", 10, 500, 21, "New data to be stored")
17
17
  expect(return_set).to eql("STORED\r\n" )
18
18
  end
19
19
  it "correctly set cas = 1" do
20
- @mem.set("key", 10, 500, 20, "Data to be stored")
20
+ @mem.set("key", 10, 500, 17, "Data to be stored")
21
21
  expect(@mem.gets(["key"])[0][4]).to eql(1)
22
22
  end
23
23
  it "correctly set cas > 1" do
24
- @mem.set("key", 10, 500, 20, "Data to be stored")
25
- @mem.set("key", 10, 500, 20, "New data to be stored")
26
- @mem.set("key", 10, 500, 20, "New data to be stored 2")
24
+ @mem.set("key", 10, 500, 17, "Data to be stored")
25
+ @mem.set("key", 10, 500, 21, "New data to be stored")
26
+ @mem.set("key", 10, 500, 23, "New data to be stored 2")
27
27
  expect(@mem.gets(["key"])[0][4]).to eql(3)
28
28
  end
29
29
  end
@@ -32,10 +32,10 @@ describe MemcachedTest::Memcached do
32
32
  describe ".get" do
33
33
  context "given a key that exists" do
34
34
  it "get a value asociated to a key" do
35
- @mem.set("key", 10, 0, 20, "Data to be stored")
35
+ @mem.set("key", 10, 0, 17, "Data to be stored")
36
36
 
37
37
  return_get = @mem.get(["key"])
38
- expect(return_get).to eql([["key", 10, nil, 20, "Data to be stored"]])
38
+ expect(return_get).to eql([["key", 10, nil, 17, "Data to be stored"]])
39
39
  end
40
40
  end
41
41
  context "given a key that doesn't exist" do
@@ -49,11 +49,11 @@ describe MemcachedTest::Memcached do
49
49
  describe ".gets" do
50
50
  context "given multiple keys that exists" do
51
51
  it "get a values asociated to 2 keys" do
52
- @mem.set("key", 10, 0, 10, "Data to be stored")
53
- @mem.set("key2", 20, 0, 10, "Data to be stored2")
52
+ @mem.set("key", 10, 0, 17, "Data to be stored")
53
+ @mem.set("key2", 20, 0, 18, "Data to be stored2")
54
54
 
55
55
  return_gets = @mem.gets(["key", "key2"])
56
- expect(return_gets).to eql([["key", 10, nil, 10, 1, "Data to be stored"],["key2", 20, nil, 10, 1, "Data to be stored2"]])
56
+ expect(return_gets).to eql([["key", 10, nil, 17, 1, "Data to be stored"],["key2", 20, nil, 18, 1, "Data to be stored2"]])
57
57
  end
58
58
  end
59
59
  context "given a key that doesn't exist" do
@@ -67,12 +67,12 @@ describe MemcachedTest::Memcached do
67
67
  describe ".add" do
68
68
  context "given the correct parameters" do
69
69
  it "set a value asociated to a key that doesn't exist" do
70
- return_set = @mem.add("key", 10, 500, 20, "Data to be stored")
70
+ return_set = @mem.add("key", 10, 500, 17, "Data to be stored")
71
71
  expect(return_set).to eql("STORED\r\n")
72
72
  end
73
73
  it "set a value asociated to a key that exists" do
74
74
  @mem.add("key", 10, 500, 20, "Data to be stored")
75
- return_set = @mem.add("key", 10, 500, 20, "Data to be stored")
75
+ return_set = @mem.add("key", 10, 500, 17, "Data to be stored")
76
76
  expect(return_set).to eql("NOT_STORED\r\n")
77
77
  end
78
78
  end
@@ -81,12 +81,12 @@ describe MemcachedTest::Memcached do
81
81
  describe ".replace" do
82
82
  context "given the correct parameters" do
83
83
  it "set a value asociated to a key that exists" do
84
- @mem.set("key", 10, 500, 20, "Data to be stored")
85
- return_set = @mem.replace("key", 10, 500, 20, "New data to be stored")
84
+ @mem.set("key", 10, 500, 17, "Data to be stored")
85
+ return_set = @mem.replace("key", 10, 500, 21, "New data to be stored")
86
86
  expect(return_set).to eql("STORED\r\n")
87
87
  end
88
88
  it "set a value asociated to a key that doesn't exist" do
89
- return_set = @mem.replace("key", 10, 500, 20, "New data to be stored")
89
+ return_set = @mem.replace("key", 10, 500, 21, "New data to be stored")
90
90
  expect(return_set).to eql("NOT_STORED\r\n")
91
91
  end
92
92
  end
@@ -95,20 +95,20 @@ describe MemcachedTest::Memcached do
95
95
  describe ".append" do
96
96
  context "given a key that exists" do
97
97
  it "correctly make the operation" do
98
- @mem.set("key", 10, 500, 20, "Data to be")
99
- return_set = @mem.append("key", 10, 500, 20, " stored")
98
+ @mem.set("key", 10, 10, 20, "Data to be")
99
+ return_set = @mem.append("key", 7, " stored")
100
100
  expect(return_set).to eql("STORED\r\n")
101
101
  end
102
102
  it "data join correctly" do
103
- @mem.set("key", 10, 500, 20, "Data to be")
104
- @mem.append("key", 10, 500, 20, " stored")
103
+ @mem.set("key", 10, 10, 10, "Data to be")
104
+ @mem.append("key", 7, " stored")
105
105
  return_data = @mem.get(["key"])
106
106
  expect(return_data[0][4]).to eql("Data to be stored")
107
107
  end
108
108
  end
109
109
  context "given a key that doesn't exist" do
110
110
  it "return not stored" do
111
- return_set = @mem.append("key", 10, 500, 20, " stored")
111
+ return_set = @mem.append("key", 7, " stored")
112
112
  expect(return_set).to eql("NOT_STORED\r\n")
113
113
  end
114
114
  end
@@ -117,20 +117,20 @@ describe MemcachedTest::Memcached do
117
117
  describe ".prepend" do
118
118
  context "given a key that exists" do
119
119
  it "correctly make the operation" do
120
- @mem.set("key", 10, 500, 20, "to be stored")
121
- return_set = @mem.prepend("key", 10, 500, 20, "Data ")
120
+ @mem.set("key", 10, 10, 12, "to be stored")
121
+ return_set = @mem.prepend("key", 5, "Data ")
122
122
  expect(return_set).to eql("STORED\r\n" )
123
123
  end
124
124
  it "data join correctly" do
125
- @mem.set("key", 10, 500, 20, "to be stored")
126
- @mem.prepend("key", 10, 500, 20, "Data ")
125
+ @mem.set("key", 10, 10, 12, "to be stored")
126
+ @mem.prepend("key", 5, "Data ")
127
127
  return_data = @mem.get(["key"])
128
128
  expect(return_data[0][4]).to eql("Data to be stored")
129
129
  end
130
130
  end
131
131
  context "given a key that doesn't exist" do
132
132
  it "return not stored" do
133
- return_set = @mem.prepend("key", 10, 500, 20, " stored")
133
+ return_set = @mem.prepend("key", 7, " stored")
134
134
  expect(return_set).to eql("NOT_STORED\r\n")
135
135
  end
136
136
  end
@@ -139,23 +139,24 @@ describe MemcachedTest::Memcached do
139
139
  describe ".cas" do
140
140
  context "given the correct parameters" do
141
141
  it "set a value to a key that exists with a correct cas_num = 1" do
142
- @mem.set("key", 10, 500, 20, "Data to be stored")
143
- return_set = @mem.cas("key", 10, 500, 20, 1, "New data to be stored")
142
+ @mem.set("key", 10, 500, 17, "Data to be stored")
143
+ return_set = @mem.cas("key", 10, 500, 21, 1, "New data to be stored")
144
144
  expect(return_set).to eql("STORED\r\n")
145
145
  end
146
146
  it "set a value to a key that exists with a correct cas_num > 1" do
147
- @mem.set("key", 10, 500, 20, "Data to be stored")
148
- @mem.set("key", 10, 500, 20, "New data to be stored")
149
- return_set = @mem.cas("key", 10, 500, 20, 2, "New data to be stored 2")
147
+ @mem.set("key", 10, 500, 17, "Data to be stored")
148
+ @mem.set("key", 10, 500, 21, "New data to be stored")
149
+ @mem.cas("key", 10, 500, 23, 2, "New data to be stored 2")
150
+ return_set = @mem.cas("key", 10, 500, 23, 3, "New data to be stored 3")
150
151
  expect(return_set).to eql("STORED\r\n")
151
152
  end
152
153
  it "set a value to a key that exists with an incorrect cas_num" do
153
- @mem.set("key", 10, 500, 20, "Data to be stored")
154
- return_set = @mem.cas("key", 10, 500, 20, 3, "New data to be stored")
154
+ @mem.set("key", 10, 500, 17, "Data to be stored")
155
+ return_set = @mem.cas("key", 10, 500, 21, 3, "New data to be stored")
155
156
  expect(return_set).to eql("EXISTS\r\n")
156
157
  end
157
158
  it "set a value asociated to a key that doesn't exist" do
158
- return_set = @mem.cas("key", 10, 500, 20, 2, "New data to be stored")
159
+ return_set = @mem.cas("key", 10, 500, 21, 2, "New data to be stored")
159
160
  expect(return_set).to eql("NOT_FOUND\r\n")
160
161
  end
161
162
  end
@@ -164,7 +165,7 @@ describe MemcachedTest::Memcached do
164
165
  describe ".delete" do
165
166
  context "given a key that exists" do
166
167
  it "correctly make the operation" do
167
- @mem.set("key", 10, 500, 20, "Data to be stored")
168
+ @mem.set("key", 10, 500, 17, "Data to be stored")
168
169
  response = @mem.delete("key")
169
170
  expect(response).to eql(true)
170
171
  end
data/spec/memcached_test/server-client_spec.rb CHANGED
@@ -1,18 +1,220 @@
1
1
  require 'memcached_test/server'
2
2
  require 'memcached_test/client'
3
3
 
4
+ include MemcachedTest
4
5
 
5
- describe '.set and .get' do
6
- context 'given the correct parameters' do
7
- it "set and get value asociated to a key that doesn't exist" do
8
- @server = Server.new('localhost', 11211)
9
- @server.run()
10
- sleep 1
11
- @client = Client.new('localhost', 11211)
12
- @client.set('test', 10, 100, 10, 'Data')
13
- a = @client.get('test')
14
- expect(a).to eql("VALUE test 10 10\r\nData\r\nEND\r\n")
15
- end
6
+ describe Server do
7
+ before(:example) do
8
+ @server = Server.new('localhost', 11211)
9
+ Thread.new { @server.run() }
10
+ sleep 1
11
+ @client = Client.new('localhost', 11211)
12
+ end
13
+
14
+ after(:example) do
15
+ @server.server_socket.close
16
+ @client.socket.close
17
+ end
18
+
19
+ describe '.set' do
20
+ context 'given the correct parameters' do
21
+ it "set a value asociated to a key that doesn't exist" do
22
+ response = @client.set('test', 10, 100, 4, 'Data')
23
+ expect(response).to eql("STORED\r\n")
24
+ end
25
+ it "set a value asociated to a key that exists" do
26
+ @client.set("key", 10, 500, 17, "Data to be stored")
27
+ response = @client.set("key", 10, 500, 21, "New data to be stored")
28
+ expect(response).to eql("STORED\r\n")
29
+ end
30
+ it "set a value but use noreply" do
31
+ response = @client.set("key", 10, 500, 17, 'noreply', "Data to be stored")
32
+ expect(response).to eql(nil)
33
+ end
34
+ end
35
+ end
36
+
37
+ describe '.get' do
38
+ context 'given the correct parameters' do
39
+ it "get value asociated to a key after a set" do
40
+ @client.set('test', 10, 100, 4, 'Data')
41
+ response = @client.get('test')
42
+ expect(response).to eql(["VALUE test 10 4\r\n", "Data\r\n", "END\r\n"])
43
+ end
44
+ it "get a values asociated to 2 keys" do
45
+ @client.set("key", 10, 0, 17, "Data to be stored")
46
+ @client.set("key2", 20, 0, 18, "Data to be stored2")
47
+
48
+ return_gets = @client.gets(["key", "key2"])
49
+ expect(return_gets).to eql(["VALUE key 10 17 1\r\n", "Data to be stored\r\n", "VALUE key2 20 18 1\r\n", "Data to be stored2\r\n", "END\r\n"])
50
+ end
51
+ end
52
+ context "given a key that doesn't exist" do
53
+ it "get an empty array" do
54
+ return_get = @client.get(["keyy"])
55
+ expect(return_get).to eql(["NOT_FOUND\r\n"])
56
+ end
57
+ end
58
+ end
59
+
60
+ describe '.gets' do
61
+ context 'given the correct parameters' do
62
+ it "gets value asociated to a key after a set" do
63
+ @client.set('test', 10, 100, 4, 'Data')
64
+ response = @client.gets('test')
65
+ expect(response).to eql(["VALUE test 10 4 1\r\n", "Data\r\n", "END\r\n"])
66
+ end
67
+ it "get a values asociated to 2 keys" do
68
+ @client.set("key", 10, 0, 17, "Data to be stored")
69
+ @client.set("key2", 20, 0, 18, "Data to be stored2")
70
+
71
+ response = @client.gets(["key", "key2"])
72
+ expect(response).to eql(["VALUE key 10 17 1\r\n", "Data to be stored\r\n", "VALUE key2 20 18 1\r\n", "Data to be stored2\r\n", "END\r\n"])
73
+ end
74
+ end
75
+ context "given a key that doesn't exist" do
76
+ it "get an empty array" do
77
+ response = @client.gets(["keyy"])
78
+ expect(response).to eql(["NOT_FOUND\r\n"])
79
+ end
80
+ end
81
+ end
82
+
83
+ describe '.add' do
84
+ context 'given the correct parameters' do
85
+ it "add a value asociated to a key that doesn't exist" do
86
+ response = @client.add('test', 10, 100, 4, 'data')
87
+ expect(response).to eql("STORED\r\n")
88
+ end
89
+ it "get value asociated to a key after an add" do
90
+ @client.add('test', 10, 100, 4, 'Data')
91
+ response = @client.get('test')
92
+ expect(response).to eql(["VALUE test 10 4\r\n", "Data\r\n", "END\r\n"])
93
+ end
94
+ it "add a value asociated to a key that doesn't exist" do
95
+ response = @client.add("key", 10, 500, 17, "Data to be stored")
96
+ expect(response).to eql("STORED\r\n")
97
+ end
98
+ it "add a value asociated to a key that exists" do
99
+ @client.add("key", 10, 500, 17, "Data to be stored")
100
+ response = @client.add("key", 10, 500, 17, "Data to be stored")
101
+ expect(response).to eql("NOT_STORED\r\n")
102
+ end
103
+ it "add a value but use noreply" do
104
+ response = @client.add("key", 10, 500, 17, 'noreply', "Data to be stored")
105
+ expect(response).to eql(nil)
106
+ end
107
+ end
108
+ end
109
+
110
+ describe '.replace' do
111
+ context 'given the correct parameters' do
112
+ it "replace a values asociated to a key" do
113
+ @client.set('test', 10, 100, 4, 'Data')
114
+ @client.replace('test', 10, 100, 8, 'New Data')
115
+ response = @client.get('test')
116
+ expect(response).to eql(["VALUE test 10 8\r\n", "New Data\r\n", "END\r\n"])
117
+ end
118
+ it "replace a value asociated to a key that exists" do
119
+ @client.set("key", 10, 500, 17, "Data to be stored")
120
+ response = @client.replace("key", 10, 500, 21, "New data to be stored")
121
+ expect(response).to eql("STORED\r\n")
122
+ end
123
+ it "replace a value asociated to a key that doesn't exist" do
124
+ response = @client.replace("key", 10, 500, 21, "New data to be stored")
125
+ expect(response).to eql("NOT_STORED\r\n")
126
+ end
127
+ it "replace a value but use noreply" do
128
+ @client.set("key", 10, 500, 17, "Data to be stored")
129
+ response = @client.replace("key", 10, 500, 21, 'noreply', "New data to be stored")
130
+ expect(response).to eql(nil)
131
+ end
132
+ end
133
+ end
134
+
135
+ describe '.prepend' do
136
+ context 'given the correct parameters' do
137
+ it "prepend data asociated to a key" do
138
+ @client.set('test', 10, 100, 4, 'data')
139
+ @client.prepend('test', 4, 'New ')
140
+ response = @client.get('test')
141
+ expect(response).to eql(["VALUE test 10 8\r\n", "New data\r\n", "END\r\n"])
142
+ end
143
+ it "prepend a key that exists" do
144
+ @client.set("key", 10, 500, 12, "to be stored")
145
+ return_set = @client.prepend("key", 5, "Data ")
146
+ expect(return_set).to eql("STORED\r\n" )
147
+ end
148
+ it "prepend a key that doesn't exist" do
149
+ return_set = @client.prepend("key", 7, " stored")
150
+ expect(return_set).to eql("NOT_STORED\r\n")
151
+ end
152
+ it "prepend a value but use noreply" do
153
+ @client.set("key", 10, 500, 17, "Data to be stored")
154
+ response = @client.prepend("key", 21, 'noreply', "New data to be stored")
155
+ expect(response).to eql(nil)
156
+ end
157
+ end
158
+ end
159
+
160
+ describe '.append' do
161
+ context 'given the correct parameters' do
162
+ it "append data asociated to a key" do
163
+ @client.add('test', 10, 100, 3, 'New')
164
+ @client.append('test', 5, ' data')
165
+ response = @client.get('test')
166
+ expect(response).to eql(["VALUE test 10 8\r\n", "New data\r\n", "END\r\n"])
167
+ end
168
+ it "append a key that exists" do
169
+ @client.set("key", 10, 500, 10, "Data to be")
170
+ return_set = @client.append("key", 7, " stored")
171
+ expect(return_set).to eql("STORED\r\n")
172
+ end
173
+ it "append a key that doesn't exist" do
174
+ return_set = @client.append("key", 7, " stored")
175
+ expect(return_set).to eql("NOT_STORED\r\n")
176
+ end
177
+ it "append a value but use noreply" do
178
+ @client.set("key", 10, 500, 20, "Data to be stored")
179
+ response = @client.append("key", 21, 'noreply', "New data to be stored")
180
+ expect(response).to eql(nil)
181
+ end
182
+ end
183
+ end
184
+
185
+ describe '.cas' do
186
+ context 'given the correct parameters' do
187
+ it "cas and then get a value asociated to a key that doesn't exist" do
188
+ @client.set("test", 10, 100, 17, "Data to be stored")
189
+ @client.cas('test', 10, 100, 21, 1, "New data to be stored")
190
+ response = @client.gets('test')
191
+ expect(response).to eql(["VALUE test 10 21 2\r\n", "New data to be stored\r\n", "END\r\n"])
192
+ end
193
+ it "set a value to a key that exists with a correct cas_num = 1" do
194
+ @client.set("key", 10, 500, 17, "Data to be stored")
195
+ return_set = @client.cas("key", 10, 500, 21, 1, "New data to be stored")
196
+ expect(return_set).to eql("STORED\r\n")
197
+ end
198
+ it "set a value to a key that exists with a correct cas_num > 1" do
199
+ @client.set("key", 10, 500, 17, "Data to be stored")
200
+ @client.set("key", 10, 500, 21, "New data to be stored")
201
+ return_set = @client.cas("key", 10, 500, 23, 2, "New data to be stored 2")
202
+ expect(return_set).to eql("STORED\r\n")
203
+ end
204
+ it "set a value to a key that exists with an incorrect cas_num" do
205
+ @client.set("key", 10, 500, 17, "Data to be stored")
206
+ return_set = @client.cas("key", 10, 500, 21, 3, "New data to be stored")
207
+ expect(return_set).to eql("EXISTS\r\n")
208
+ end
209
+ it "cas a value asociated to a key that doesn't exist" do
210
+ return_set = @client.cas("key", 10, 500, 21, 2, "New data to be stored")
211
+ expect(return_set).to eql("NOT_FOUND\r\n")
212
+ end
213
+ it "cas a value but use noreply" do
214
+ @client.set("key", 10, 500, 17, "Data to be stored")
215
+ response = @client.cas("key", 10, 500, 21, 1, 'noreply', "New data to be stored")
216
+ expect(response).to eql(nil)
16
217
  end
17
218
  end
18
-
219
+ end
220
+ end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: memcached_test
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.0
4
+ version: 1.0.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Matias Caporale
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2020-06-22 00:00:00.000000000 Z
11
+ date: 2020-06-29 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rspec