amistad 0.9.2 → 0.10.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (13) hide show
  1. checksums.yaml +7 -0
  2. data/Gemfile.lock +81 -68
  3. data/README.markdown +1 -1
  4. data/amistad.gemspec +6 -6
  5. data/lib/amistad/active_record_friend_model.rb +7 -25
  6. data/lib/amistad/mongo_mapper_friend_model.rb +0 -11
  7. data/lib/amistad/mongoid_friend_model.rb +0 -10
  8. data/lib/amistad/version.rb +1 -1
  9. data/spec/activerecord/activerecord_spec_helper.rb +0 -3
  10. data/spec/activerecord/friend_spec.rb +0 -3
  11. data/spec/support/activerecord/friendship_examples.rb +29 -29
  12. data/spec/support/friend_examples.rb +226 -226
  13. metadata +48 -84
data/spec/support/friend_examples.rb CHANGED
@@ -1,407 +1,407 @@
1
1
  shared_examples_for "a friend model" do
2
2
  context "when creating friendships" do
3
3
  it "should invite other users to friends" do
4
- @john.invite(@jane).should be_true
5
- @victoria.invite(@john).should be_true
4
+ expect(@john.invite(@jane)).to eq(true)
5
+ expect(@victoria.invite(@john)).to eq(true)
6
6
  end
7
7
 
8
8
  it "should approve only friendships requested by other users" do
9
- @john.invite(@jane).should be_true
10
- @jane.approve(@john).should be_true
11
- @victoria.invite(@john).should be_true
12
- @john.approve(@victoria).should be_true
9
+ expect(@john.invite(@jane)).to eq(true)
10
+ expect(@jane.approve(@john)).to eq(true)
11
+ expect(@victoria.invite(@john)).to eq(true)
12
+ expect(@john.approve(@victoria)).to eq(true)
13
13
  end
14
14
 
15
15
  it "should not invite an already invited user" do
16
- @john.invite(@jane).should be_true
17
- @john.invite(@jane).should be_false
18
- @jane.invite(@john).should be_false
16
+ expect(@john.invite(@jane)).to eq(true)
17
+ expect(@john.invite(@jane)).to eq(false)
18
+ expect(@jane.invite(@john)).to eq(false)
19
19
  end
20
20
 
21
21
  it "should not invite an already approved user" do
22
- @john.invite(@jane).should be_true
23
- @jane.approve(@john).should be_true
24
- @jane.invite(@john).should be_false
25
- @john.invite(@jane).should be_false
22
+ expect(@john.invite(@jane)).to eq(true)
23
+ expect(@jane.approve(@john)).to eq(true)
24
+ expect(@jane.invite(@john)).to eq(false)
25
+ expect(@john.invite(@jane)).to eq(false)
26
26
  end
27
27
 
28
28
  it "should not invite an already blocked user" do
29
- @john.invite(@jane).should be_true
30
- @jane.block(@john).should be_true
31
- @jane.invite(@john).should be_false
32
- @john.invite(@jane).should be_false
29
+ expect(@john.invite(@jane)).to eq(true)
30
+ expect(@jane.block(@john)).to eq(true)
31
+ expect(@jane.invite(@john)).to eq(false)
32
+ expect(@john.invite(@jane)).to eq(false)
33
33
  end
34
34
 
35
35
  it "should not approve a self requested friendship" do
36
- @john.invite(@jane).should be_true
37
- @john.approve(@jane).should be_false
38
- @victoria.invite(@john).should be_true
39
- @victoria.approve(@john).should be_false
36
+ expect(@john.invite(@jane)).to eq(true)
37
+ expect(@john.approve(@jane)).to eq(false)
38
+ expect(@victoria.invite(@john)).to eq(true)
39
+ expect(@victoria.approve(@john)).to eq(false)
40
40
  end
41
41
 
42
42
  it "should not create a friendship with himself" do
43
- @john.invite(@john).should be_false
43
+ expect(@john.invite(@john)).to eq(false)
44
44
  end
45
45
 
46
46
  it "should not approve a non-existent friendship" do
47
- @peter.approve(@john).should be_false
47
+ expect(@peter.approve(@john)).to eq(false)
48
48
  end
49
49
  end
50
50
 
51
51
  context "when listing friendships" do
52
52
  before(:each) do
53
- @john.invite(@jane).should be_true
54
- @peter.invite(@john).should be_true
55
- @john.invite(@james).should be_true
56
- @james.approve(@john).should be_true
57
- @mary.invite(@john).should be_true
58
- @john.approve(@mary).should be_true
53
+ expect(@john.invite(@jane)).to eq(true)
54
+ expect(@peter.invite(@john)).to eq(true)
55
+ expect(@john.invite(@james)).to eq(true)
56
+ expect(@james.approve(@john)).to eq(true)
57
+ expect(@mary.invite(@john)).to eq(true)
58
+ expect(@john.approve(@mary)).to eq(true)
59
59
  end
60
60
 
61
61
  it "should list all the friends" do
62
- @john.friends.should =~ [@mary, @james]
62
+ expect(@john.friends).to match_array([@mary, @james])
63
63
  end
64
64
 
65
65
  it "should not list non-friended users" do
66
- @victoria.friends.should be_empty
67
- @john.friends.should =~ [@mary, @james]
68
- @john.friends.should_not include(@peter)
69
- @john.friends.should_not include(@victoria)
66
+ expect(@victoria.friends).to be_empty
67
+ expect(@john.friends).to match_array([@mary, @james])
68
+ expect(@john.friends).to_not include(@peter)
69
+ expect(@john.friends).to_not include(@victoria)
70
70
  end
71
71
 
72
72
  it "should list the friends who invited him" do
73
- @john.invited_by.should == [@mary]
73
+ expect(@john.invited_by).to eq([@mary])
74
74
  end
75
75
 
76
76
  it "should list the friends who were invited by him" do
77
- @john.invited.should == [@james]
77
+ expect(@john.invited).to eq([@james])
78
78
  end
79
79
 
80
80
  it "should list the pending friends who invited him" do
81
- @john.pending_invited_by.should == [@peter]
81
+ expect(@john.pending_invited_by).to eq([@peter])
82
82
  end
83
83
 
84
84
  it "should list the pending friends who were invited by him" do
85
- @john.pending_invited.should == [@jane]
85
+ expect(@john.pending_invited).to eq([@jane])
86
86
  end
87
87
 
88
88
  it "should list the friends he has in common with another user" do
89
- @james.common_friends_with(@mary).should == [@john]
89
+ expect(@james.common_friends_with(@mary)).to eq([@john])
90
90
  end
91
91
 
92
92
  it "should not list the friends he does not have in common" do
93
- @john.common_friends_with(@mary).count.should == 0
94
- @john.common_friends_with(@mary).should_not include(@james)
95
- @john.common_friends_with(@peter).count.should == 0
96
- @john.common_friends_with(@peter).should_not include(@jane)
93
+ expect(@john.common_friends_with(@mary).count).to eq(0)
94
+ expect(@john.common_friends_with(@mary)).to_not include(@james)
95
+ expect(@john.common_friends_with(@peter).count).to eq(0)
96
+ expect(@john.common_friends_with(@peter)).to_not include(@jane)
97
97
  end
98
98
 
99
99
  it "should check if a user is a friend" do
100
- @john.friend_with?(@mary).should be_true
101
- @mary.friend_with?(@john).should be_true
102
- @john.friend_with?(@james).should be_true
103
- @james.friend_with?(@john).should be_true
100
+ expect(@john.friend_with?(@mary)).to eq(true)
101
+ expect(@mary.friend_with?(@john)).to eq(true)
102
+ expect(@john.friend_with?(@james)).to eq(true)
103
+ expect(@james.friend_with?(@john)).to eq(true)
104
104
  end
105
105
 
106
106
  it "should check if a user is not a friend" do
107
- @john.friend_with?(@jane).should be_false
108
- @jane.friend_with?(@john).should be_false
109
- @john.friend_with?(@peter).should be_false
110
- @peter.friend_with?(@john).should be_false
107
+ expect(@john.friend_with?(@jane)).to eq(false)
108
+ expect(@jane.friend_with?(@john)).to eq(false)
109
+ expect(@john.friend_with?(@peter)).to eq(false)
110
+ expect(@peter.friend_with?(@john)).to eq(false)
111
111
  end
112
112
 
113
113
  it "should check if a user has any connections with another user" do
114
- @john.connected_with?(@jane).should be_true
115
- @jane.connected_with?(@john).should be_true
116
- @john.connected_with?(@peter).should be_true
117
- @peter.connected_with?(@john).should be_true
114
+ expect(@john.connected_with?(@jane)).to eq(true)
115
+ expect(@jane.connected_with?(@john)).to eq(true)
116
+ expect(@john.connected_with?(@peter)).to eq(true)
117
+ expect(@peter.connected_with?(@john)).to eq(true)
118
118
  end
119
119
 
120
120
  it "should check if a user does not have any connections with another user" do
121
- @victoria.connected_with?(@john).should be_false
122
- @john.connected_with?(@victoria).should be_false
121
+ expect(@victoria.connected_with?(@john)).to eq(false)
122
+ expect(@john.connected_with?(@victoria)).to eq(false)
123
123
  end
124
124
 
125
125
  it "should check if a user was invited by another" do
126
- @jane.invited_by?(@john).should be_true
127
- @james.invited_by?(@john).should be_true
126
+ expect(@jane.invited_by?(@john)).to eq(true)
127
+ expect(@james.invited_by?(@john)).to eq(true)
128
128
  end
129
129
 
130
130
  it "should check if a user was not invited by another" do
131
- @john.invited_by?(@jane).should be_false
132
- @victoria.invited_by?(@john).should be_false
131
+ expect(@john.invited_by?(@jane)).to eq(false)
132
+ expect(@victoria.invited_by?(@john)).to eq(false)
133
133
  end
134
134
 
135
135
  it "should check if a user has invited another user" do
136
- @john.invited?(@jane).should be_true
137
- @john.invited?(@james).should be_true
136
+ expect(@john.invited?(@jane)).to eq(true)
137
+ expect(@john.invited?(@james)).to eq(true)
138
138
  end
139
139
 
140
140
  it "should check if a user did not invite another user" do
141
- @jane.invited?(@john).should be_false
142
- @james.invited?(@john).should be_false
143
- @john.invited?(@victoria).should be_false
144
- @victoria.invited?(@john).should be_false
141
+ expect(@jane.invited?(@john)).to eq(false)
142
+ expect(@james.invited?(@john)).to eq(false)
143
+ expect(@john.invited?(@victoria)).to eq(false)
144
+ expect(@victoria.invited?(@john)).to eq(false)
145
145
  end
146
146
  end
147
147
 
148
148
  context "when removing friendships" do
149
149
  before(:each) do
150
- @jane.invite(@james).should be_true
151
- @james.approve(@jane).should be_true
152
- @james.invite(@victoria).should be_true
153
- @victoria.approve(@james).should be_true
154
- @victoria.invite(@mary).should be_true
155
- @mary.approve(@victoria).should be_true
156
- @victoria.invite(@john).should be_true
157
- @john.approve(@victoria).should be_true
158
- @peter.invite(@victoria).should be_true
159
- @victoria.invite(@elisabeth).should be_true
150
+ expect(@jane.invite(@james)).to eq(true)
151
+ expect(@james.approve(@jane)).to eq(true)
152
+ expect(@james.invite(@victoria)).to eq(true)
153
+ expect(@victoria.approve(@james)).to eq(true)
154
+ expect(@victoria.invite(@mary)).to eq(true)
155
+ expect(@mary.approve(@victoria)).to eq(true)
156
+ expect(@victoria.invite(@john)).to eq(true)
157
+ expect(@john.approve(@victoria)).to eq(true)
158
+ expect(@peter.invite(@victoria)).to eq(true)
159
+ expect(@victoria.invite(@elisabeth)).to eq(true)
160
160
  end
161
161
 
162
162
  it "should remove the friends invited by him" do
163
- @victoria.friends.size.should == 3
164
- @victoria.friends.should include(@mary)
165
- @victoria.invited.should include(@mary)
166
- @mary.friends.size.should == 1
167
- @mary.friends.should include(@victoria)
168
- @mary.invited_by.should include(@victoria)
169
-
170
- @victoria.remove_friendship(@mary).should be_true
171
- @victoria.friends.size.should == 2
172
- @victoria.friends.should_not include(@mary)
173
- @victoria.invited.should_not include(@mary)
174
- @mary.friends.size.should == 0
175
- @mary.friends.should_not include(@victoria)
176
- @mary.invited_by.should_not include(@victoria)
163
+ expect(@victoria.friends.size).to eq(3)
164
+ expect(@victoria.friends).to include(@mary)
165
+ expect(@victoria.invited).to include(@mary)
166
+ expect(@mary.friends.size).to eq(1)
167
+ expect(@mary.friends).to include(@victoria)
168
+ expect(@mary.invited_by).to include(@victoria)
169
+
170
+ expect(@victoria.remove_friendship(@mary)).to eq(true)
171
+ expect(@victoria.friends.size).to eq(2)
172
+ expect(@victoria.friends).to_not include(@mary)
173
+ expect(@victoria.invited).to_not include(@mary)
174
+ expect(@mary.friends.size).to eq(0)
175
+ expect(@mary.friends).to_not include(@victoria)
176
+ expect(@mary.invited_by).to_not include(@victoria)
177
177
  end
178
178
 
179
179
  it "should remove the friends who invited him" do
180
- @victoria.friends.size.should == 3
181
- @victoria.friends.should include(@james)
182
- @victoria.invited_by.should include(@james)
183
- @james.friends.size.should == 2
184
- @james.friends.should include(@victoria)
185
- @james.invited.should include(@victoria)
186
-
187
- @victoria.remove_friendship(@james).should be_true
188
- @victoria.friends.size.should == 2
189
- @victoria.friends.should_not include(@james)
190
- @victoria.invited_by.should_not include(@james)
191
- @james.friends.size.should == 1
192
- @james.friends.should_not include(@victoria)
193
- @james.invited.should_not include(@victoria)
180
+ expect(@victoria.friends.size).to eq(3)
181
+ expect(@victoria.friends).to include(@james)
182
+ expect(@victoria.invited_by).to include(@james)
183
+ expect(@james.friends.size).to eq(2)
184
+ expect(@james.friends).to include(@victoria)
185
+ expect(@james.invited).to include(@victoria)
186
+
187
+ expect(@victoria.remove_friendship(@james)).to eq(true)
188
+ expect(@victoria.friends.size).to eq(2)
189
+ expect(@victoria.friends).to_not include(@james)
190
+ expect(@victoria.invited_by).to_not include(@james)
191
+ expect(@james.friends.size).to eq(1)
192
+ expect(@james.friends).to_not include(@victoria)
193
+ expect(@james.invited).to_not include(@victoria)
194
194
  end
195
195
 
196
196
  it "should remove the pending friends invited by him" do
197
- @victoria.pending_invited.size.should == 1
198
- @victoria.pending_invited.should include(@elisabeth)
199
- @elisabeth.pending_invited_by.size.should == 1
200
- @elisabeth.pending_invited_by.should include(@victoria)
201
- @victoria.remove_friendship(@elisabeth).should be_true
197
+ expect(@victoria.pending_invited.size).to eq(1)
198
+ expect(@victoria.pending_invited).to include(@elisabeth)
199
+ expect(@elisabeth.pending_invited_by.size).to eq(1)
200
+ expect(@elisabeth.pending_invited_by).to include(@victoria)
201
+ expect(@victoria.remove_friendship(@elisabeth)).to eq(true)
202
202
  [@victoria, @elisabeth].map(&:reload)
203
- @victoria.pending_invited.size.should == 0
204
- @victoria.pending_invited.should_not include(@elisabeth)
205
- @elisabeth.pending_invited_by.size.should == 0
206
- @elisabeth.pending_invited_by.should_not include(@victoria)
203
+ expect(@victoria.pending_invited.size).to eq(0)
204
+ expect(@victoria.pending_invited).to_not include(@elisabeth)
205
+ expect(@elisabeth.pending_invited_by.size).to eq(0)
206
+ expect(@elisabeth.pending_invited_by).to_not include(@victoria)
207
207
  end
208
208
 
209
209
  it "should remove the pending friends who invited him" do
210
- @victoria.pending_invited_by.count.should == 1
211
- @victoria.pending_invited_by.should include(@peter)
212
- @peter.pending_invited.count.should == 1
213
- @peter.pending_invited.should include(@victoria)
214
- @victoria.remove_friendship(@peter).should be_true
210
+ expect(@victoria.pending_invited_by.count).to eq(1)
211
+ expect(@victoria.pending_invited_by).to include(@peter)
212
+ expect(@peter.pending_invited.count).to eq(1)
213
+ expect(@peter.pending_invited).to include(@victoria)
214
+ expect(@victoria.remove_friendship(@peter)).to eq(true)
215
215
  [@victoria, @peter].map(&:reload)
216
- @victoria.pending_invited_by.count.should == 0
217
- @victoria.pending_invited_by.should_not include(@peter)
218
- @peter.pending_invited.count.should == 0
219
- @peter.pending_invited.should_not include(@victoria)
216
+ expect(@victoria.pending_invited_by.count).to eq(0)
217
+ expect(@victoria.pending_invited_by).to_not include(@peter)
218
+ expect(@peter.pending_invited.count).to eq(0)
219
+ expect(@peter.pending_invited).to_not include(@victoria)
220
220
  end
221
221
  end
222
222
 
223
223
  context "when blocking friendships" do
224
224
  before(:each) do
225
- @john.invite(@james).should be_true
226
- @james.approve(@john).should be_true
227
- @james.block(@john).should be_true
228
- @mary.invite(@victoria).should be_true
229
- @victoria.approve(@mary).should be_true
230
- @victoria.block(@mary).should be_true
231
- @victoria.invite(@david).should be_true
232
- @david.block(@victoria).should be_true
233
- @john.invite(@david).should be_true
234
- @david.block(@john).should be_true
235
- @peter.invite(@elisabeth).should be_true
236
- @elisabeth.block(@peter).should be_true
237
- @jane.invite(@john).should be_true
238
- @jane.invite(@james).should be_true
239
- @james.approve(@jane).should be_true
240
- @victoria.invite(@jane).should be_true
241
- @victoria.invite(@james).should be_true
242
- @james.approve(@victoria).should be_true
225
+ expect(@john.invite(@james)).to eq(true)
226
+ expect(@james.approve(@john)).to eq(true)
227
+ expect(@james.block(@john)).to eq(true)
228
+ expect(@mary.invite(@victoria)).to eq(true)
229
+ expect(@victoria.approve(@mary)).to eq(true)
230
+ expect(@victoria.block(@mary)).to eq(true)
231
+ expect(@victoria.invite(@david)).to eq(true)
232
+ expect(@david.block(@victoria)).to eq(true)
233
+ expect(@john.invite(@david)).to eq(true)
234
+ expect(@david.block(@john)).to eq(true)
235
+ expect(@peter.invite(@elisabeth)).to eq(true)
236
+ expect(@elisabeth.block(@peter)).to eq(true)
237
+ expect(@jane.invite(@john)).to eq(true)
238
+ expect(@jane.invite(@james)).to eq(true)
239
+ expect(@james.approve(@jane)).to eq(true)
240
+ expect(@victoria.invite(@jane)).to eq(true)
241
+ expect(@victoria.invite(@james)).to eq(true)
242
+ expect(@james.approve(@victoria)).to eq(true)
243
243
  end
244
244
 
245
245
  it "should allow to block author of the invitation by invited user" do
246
- @john.block(@jane).should be_true
247
- @jane.block(@victoria).should be_true
246
+ expect(@john.block(@jane)).to eq(true)
247
+ expect(@jane.block(@victoria)).to eq(true)
248
248
  end
249
249
 
250
250
  it "should not allow to block invited user by invitation author" do
251
- @jane.block(@john).should be_false
252
- @victoria.block(@jane).should be_false
251
+ expect(@jane.block(@john)).to eq(false)
252
+ expect(@victoria.block(@jane)).to eq(false)
253
253
  end
254
254
 
255
255
  it "should allow to block approved users on both sides" do
256
- @james.block(@jane).should be_true
257
- @victoria.block(@james).should be_true
256
+ expect(@james.block(@jane)).to eq(true)
257
+ expect(@victoria.block(@james)).to eq(true)
258
258
  end
259
259
 
260
260
  it "should not allow to block not connected user" do
261
- @david.block(@peter).should be_false
262
- @peter.block(@david).should be_false
261
+ expect(@david.block(@peter)).to eq(false)
262
+ expect(@peter.block(@david)).to eq(false)
263
263
  end
264
264
 
265
265
  it "should not allow to block already blocked user" do
266
- @john.block(@jane).should be_true
267
- @john.block(@jane).should be_false
268
- @james.block(@jane).should be_true
269
- @james.block(@jane).should be_false
266
+ expect(@john.block(@jane)).to eq(true)
267
+ expect(@john.block(@jane)).to eq(false)
268
+ expect(@james.block(@jane)).to eq(true)
269
+ expect(@james.block(@jane)).to eq(false)
270
270
  end
271
271
 
272
272
  it "should list the blocked users" do
273
- @jane.blocked.should be_empty
274
- @peter.blocked.should be_empty
275
- @james.blocked.should == [@john]
276
- @victoria.blocked.should == [@mary]
277
- @david.blocked.should =~ [@john, @victoria]
273
+ expect(@jane.blocked).to be_empty
274
+ expect(@peter.blocked).to be_empty
275
+ expect(@james.blocked).to eq([@john])
276
+ expect(@victoria.blocked).to eq([@mary])
277
+ expect(@david.blocked).to match_array([@john, @victoria])
278
278
  end
279
279
 
280
280
  it "should not list blocked users in friends" do
281
- @james.friends.should =~ [@jane, @victoria]
281
+ expect(@james.friends).to match_array([@jane, @victoria])
282
282
  @james.blocked.each do |user|
283
- @james.friends.should_not include(user)
284
- user.friends.should_not include(@james)
283
+ expect(@james.friends).to_not include(user)
284
+ expect(user.friends).to_not include(@james)
285
285
  end
286
286
  end
287
287
 
288
288
  it "should not list blocked users in invited" do
289
- @victoria.invited.should == [@james]
289
+ expect(@victoria.invited).to eq([@james])
290
290
  @victoria.blocked.each do |user|
291
- @victoria.invited.should_not include(user)
292
- user.invited_by.should_not include(@victoria)
291
+ expect(@victoria.invited).to_not include(user)
292
+ expect(user.invited_by).to_not include(@victoria)
293
293
  end
294
294
  end
295
295
 
296
296
  it "should not list blocked users in invited pending by" do
297
- @david.pending_invited_by.should be_empty
297
+ expect(@david.pending_invited_by).to be_empty
298
298
  @david.blocked.each do |user|
299
- @david.pending_invited_by.should_not include(user)
300
- user.pending_invited.should_not include(@david)
299
+ expect(@david.pending_invited_by).to_not include(user)
300
+ expect(user.pending_invited).to_not include(@david)
301
301
  end
302
302
  end
303
303
 
304
304
  it "should check if a user is blocked" do
305
- @james.blocked?(@john).should be_true
306
- @victoria.blocked?(@mary).should be_true
307
- @david.blocked?(@john).should be_true
308
- @david.blocked?(@victoria).should be_true
305
+ expect(@james.blocked?(@john)).to eq(true)
306
+ expect(@victoria.blocked?(@mary)).to eq(true)
307
+ expect(@david.blocked?(@john)).to eq(true)
308
+ expect(@david.blocked?(@victoria)).to eq(true)
309
309
  end
310
310
  end
311
311
 
312
312
  context "when unblocking friendships" do
313
313
  before(:each) do
314
- @john.invite(@james).should be_true
315
- @james.approve(@john).should be_true
316
- @john.block(@james).should be_true
317
- @john.unblock(@james).should be_true
318
- @mary.invite(@victoria).should be_true
319
- @victoria.approve(@mary).should be_true
320
- @victoria.block(@mary).should be_true
321
- @victoria.unblock(@mary).should be_true
322
- @victoria.invite(@david).should be_true
323
- @david.block(@victoria).should be_true
324
- @david.unblock(@victoria).should be_true
325
- @john.invite(@david).should be_true
326
- @david.block(@john).should be_true
327
- @peter.invite(@elisabeth).should be_true
328
- @elisabeth.block(@peter).should be_true
329
- @jane.invite(@john).should be_true
330
- @jane.invite(@james).should be_true
331
- @james.approve(@jane).should be_true
332
- @victoria.invite(@jane).should be_true
333
- @victoria.invite(@james).should be_true
334
- @james.approve(@victoria).should be_true
314
+ expect(@john.invite(@james)).to eq(true)
315
+ expect(@james.approve(@john)).to eq(true)
316
+ expect(@john.block(@james)).to eq(true)
317
+ expect(@john.unblock(@james)).to eq(true)
318
+ expect(@mary.invite(@victoria)).to eq(true)
319
+ expect(@victoria.approve(@mary)).to eq(true)
320
+ expect(@victoria.block(@mary)).to eq(true)
321
+ expect(@victoria.unblock(@mary)).to eq(true)
322
+ expect(@victoria.invite(@david)).to eq(true)
323
+ expect(@david.block(@victoria)).to eq(true)
324
+ expect(@david.unblock(@victoria)).to eq(true)
325
+ expect(@john.invite(@david)).to eq(true)
326
+ expect(@david.block(@john)).to eq(true)
327
+ expect(@peter.invite(@elisabeth)).to eq(true)
328
+ expect(@elisabeth.block(@peter)).to eq(true)
329
+ expect(@jane.invite(@john)).to eq(true)
330
+ expect(@jane.invite(@james)).to eq(true)
331
+ expect(@james.approve(@jane)).to eq(true)
332
+ expect(@victoria.invite(@jane)).to eq(true)
333
+ expect(@victoria.invite(@james)).to eq(true)
334
+ expect(@james.approve(@victoria)).to eq(true)
335
335
  end
336
336
 
337
337
  it "should allow to unblock prevoiusly blocked user" do
338
- @david.unblock(@john).should be_true
339
- @elisabeth.unblock(@peter).should be_true
338
+ expect(@david.unblock(@john)).to eq(true)
339
+ expect(@elisabeth.unblock(@peter)).to eq(true)
340
340
  end
341
341
 
342
342
  it "should not allow to unblock not prevoiusly blocked user" do
343
- @john.unblock(@jane).should be_false
344
- @james.unblock(@jane).should be_false
345
- @victoria.unblock(@jane).should be_false
346
- @james.unblock(@victoria).should be_false
343
+ expect(@john.unblock(@jane)).to eq(false)
344
+ expect(@james.unblock(@jane)).to eq(false)
345
+ expect(@victoria.unblock(@jane)).to eq(false)
346
+ expect(@james.unblock(@victoria)).to eq(false)
347
347
  end
348
348
 
349
349
  it "should not allow to unblock blocked user by himself" do
350
- @john.unblock(@david).should be_false
351
- @peter.unblock(@elisabeth).should be_false
350
+ expect(@john.unblock(@david)).to eq(false)
351
+ expect(@peter.unblock(@elisabeth)).to eq(false)
352
352
  end
353
353
 
354
354
  it "should list unblocked users in friends" do
355
- @john.friends.should == [@james]
356
- @mary.friends.should == [@victoria]
357
- @victoria.friends.should =~ [@mary, @james]
358
- @james.friends.should =~ [@john, @jane, @victoria]
355
+ expect(@john.friends).to eq([@james])
356
+ expect(@mary.friends).to eq([@victoria])
357
+ expect(@victoria.friends).to match_array([@mary, @james])
358
+ expect(@james.friends).to match_array([@john, @jane, @victoria])
359
359
  end
360
360
 
361
361
  it "should list unblocked users in invited" do
362
- @john.invited.should == [@james]
363
- @mary.invited.should == [@victoria]
362
+ expect(@john.invited).to eq([@james])
363
+ expect(@mary.invited).to eq([@victoria])
364
364
  end
365
365
 
366
366
  it "should list unblocked users in invited by" do
367
- @victoria.invited_by.should == [@mary]
368
- @james.invited_by.should =~ [@john, @jane, @victoria]
367
+ expect(@victoria.invited_by).to eq([@mary])
368
+ expect(@james.invited_by).to match_array([@john, @jane, @victoria])
369
369
  end
370
370
 
371
371
  it "should list unblocked users in pending invited" do
372
- @victoria.pending_invited.should =~ [@jane, @david]
372
+ expect(@victoria.pending_invited).to match_array([@jane, @david])
373
373
  end
374
374
 
375
375
  it "should list unblocked users in pending invited by" do
376
- @david.pending_invited_by.should == [@victoria]
376
+ expect(@david.pending_invited_by).to eq([@victoria])
377
377
  end
378
378
  end
379
379
 
380
380
  context "when counting friendships and blocks" do
381
381
  before do
382
- @john.invite(@james).should be_true
383
- @james.approve(@john).should be_true
384
- @john.invite(@victoria).should be_true
385
- @victoria.approve(@john).should be_true
386
- @elisabeth.invite(@john).should be_true
387
- @john.approve(@elisabeth).should be_true
382
+ expect(@john.invite(@james)).to eq(true)
383
+ expect(@james.approve(@john)).to eq(true)
384
+ expect(@john.invite(@victoria)).to eq(true)
385
+ expect(@victoria.approve(@john)).to eq(true)
386
+ expect(@elisabeth.invite(@john)).to eq(true)
387
+ expect(@john.approve(@elisabeth)).to eq(true)
388
388
 
389
- @victoria.invite(@david).should be_true
390
- @david.block(@victoria).should be_true
391
- @mary.invite(@victoria).should be_true
392
- @victoria.block(@mary).should be_true
389
+ expect(@victoria.invite(@david)).to eq(true)
390
+ expect(@david.block(@victoria)).to eq(true)
391
+ expect(@mary.invite(@victoria)).to eq(true)
392
+ expect(@victoria.block(@mary)).to eq(true)
393
393
  end
394
394
 
395
395
  it "should return the correct count for total_friends" do
396
- @john.total_friends.should == 3
397
- @elisabeth.total_friends.should == 1
398
- @james.total_friends.should == 1
399
- @victoria.total_friends.should == 1
396
+ expect(@john.total_friends).to eq(3)
397
+ expect(@elisabeth.total_friends).to eq(1)
398
+ expect(@james.total_friends).to eq(1)
399
+ expect(@victoria.total_friends).to eq(1)
400
400
  end
401
401
 
402
402
  it "should return the correct count for total_blocked" do
403
- @david.total_blocked.should == 1
404
- @victoria.total_blocked.should == 1
403
+ expect(@david.total_blocked).to eq(1)
404
+ expect(@victoria.total_blocked).to eq(1)
405
405
  end
406
406
  end
407
407
  end