mongoid_ability 3.0.0 → 3.0.2

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 (41) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/test.yml +26 -0
  3. data/.gitignore +2 -0
  4. data/.travis.yml +8 -1
  5. data/Appraisals +31 -0
  6. data/CHANGELOG.md +8 -0
  7. data/Rakefile +3 -2
  8. data/gemfiles/7_0.gemfile +7 -0
  9. data/gemfiles/7_1.gemfile +7 -0
  10. data/gemfiles/7_2.gemfile +7 -0
  11. data/gemfiles/7_3.gemfile +7 -0
  12. data/gemfiles/7_4.gemfile +7 -0
  13. data/gemfiles/7_5.gemfile +7 -0
  14. data/gemfiles/8_0.gemfile +7 -0
  15. data/gemfiles/8_1.gemfile +7 -0
  16. data/lib/cancancan/model_adapters/mongoid_adapter.rb +51 -42
  17. data/lib/cancancan/model_additions.rb +2 -0
  18. data/lib/mongoid_ability/ability.rb +3 -1
  19. data/lib/mongoid_ability/find_lock.rb +2 -2
  20. data/lib/mongoid_ability/lock.rb +62 -77
  21. data/lib/mongoid_ability/locks_decorator.rb +2 -0
  22. data/lib/mongoid_ability/owner.rb +2 -0
  23. data/lib/mongoid_ability/subject.rb +11 -1
  24. data/lib/mongoid_ability/version.rb +3 -1
  25. data/lib/mongoid_ability.rb +0 -2
  26. data/mongoid_ability.gemspec +4 -4
  27. data/test/cancancan/model_adapters/mongoid_adapter_options_test.rb +69 -68
  28. data/test/cancancan/model_adapters/mongoid_adapter_test.rb +83 -69
  29. data/test/mongoid_ability/ability_basic_benchmark.rb +2 -2
  30. data/test/mongoid_ability/ability_basic_test.rb +14 -14
  31. data/test/mongoid_ability/ability_marshal_test.rb +8 -3
  32. data/test/mongoid_ability/ability_options_test.rb +16 -16
  33. data/test/mongoid_ability/ability_test.rb +31 -35
  34. data/test/mongoid_ability/find_lock_test.rb +9 -9
  35. data/test/mongoid_ability/lock_test.rb +20 -30
  36. data/test/mongoid_ability/owner_locks_test.rb +4 -4
  37. data/test/mongoid_ability/owner_test.rb +6 -6
  38. data/test/mongoid_ability/subject_test.rb +13 -13
  39. data/test/support/test_classes/my_flat_subject.rb +9 -0
  40. data/test/test_helper.rb +7 -10
  41. metadata +29 -24
data/test/cancancan/model_adapters/mongoid_adapter_options_test.rb CHANGED
@@ -1,101 +1,102 @@
1
- require 'test_helper'
1
+ require "test_helper"
2
2
 
3
3
  module CanCan
4
4
  module ModelAdapters
5
5
  describe MongoidAdapter do
6
- describe '.accessible_by' do
7
- let(:owner) { MyOwner.new }
8
- let(:ability) { MongoidAbility::Ability.new(owner) }
9
- let(:subject1) { MySubject.new }
10
-
11
- before do
12
- subject1.save!
13
- subject2.save!
14
- end
15
-
16
- describe 'Boolean' do
17
- let(:subject2) { MySubject.new(override: true) }
18
-
19
- describe 'positive' do
20
- before(:all) { MySubject.default_lock MyLock, :read, true, override: true }
21
-
22
- it { MySubject.accessible_by(ability).wont_include subject1 }
23
- it { MySubject.accessible_by(ability).must_include subject2 }
6
+ describe ".accessible_by" do
7
+ describe "Boolean" do
8
+ it "returns correct records when using positive locks" do
9
+ MySubject.default_lock MyLock, :read, true, override: true
10
+ unaccessible = MySubject.create!
11
+ accessible = MySubject.create!(override: true)
12
+
13
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
14
+ _(MySubject.accessible_by(ability)).must_include accessible
24
15
  end
25
16
 
26
- describe 'negative' do
27
- before(:all) do
28
- MySubject.default_lock MyLock, :read, true
29
- MySubject.default_lock MyLock, :read, false, override: true
30
- end
17
+ it "returns the correct records when using negative locks" do
18
+ MySubject.default_lock MyLock, :read, true
19
+ MySubject.default_lock MyLock, :read, false, override: true
20
+ accessible = MySubject.create!
21
+ unaccessible = MySubject.create!(override: true)
31
22
 
32
- it { MySubject.accessible_by(ability).must_include subject1 }
33
- it { MySubject.accessible_by(ability).wont_include subject2 }
23
+ _(MySubject.accessible_by(ability)).must_include accessible
24
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
34
25
  end
35
26
  end
36
27
 
37
- describe 'String' do
38
- let(:subject2) { MySubject.new(str_val: "Jan Tschichold") }
39
-
40
- describe 'positive' do
41
- before(:all) { MySubject.default_lock MyLock, :read, true, str_val: 'Jan Tschichold' }
28
+ describe "String" do
29
+ it "returns correct records when using positive locks" do
30
+ MySubject.default_lock MyLock, :read, true, str_val: "Jan Tschichold"
31
+ unaccessible = MySubject.create!
32
+ accessible = MySubject.create!(str_val: "Jan Tschichold")
42
33
 
43
- it { MySubject.accessible_by(ability).wont_include subject1 }
44
- it { MySubject.accessible_by(ability).must_include subject2 }
34
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
35
+ _(MySubject.accessible_by(ability)).must_include accessible
45
36
  end
46
37
 
47
- describe 'negative' do
48
- before(:all) do
49
- MySubject.default_lock MyLock, :read, true
50
- MySubject.default_lock MyLock, :read, false, str_val: 'Jan Tschichold'
51
- end
38
+ it "returns the correct records when using negative locks" do
39
+ MySubject.default_lock MyLock, :read, true
40
+ MySubject.default_lock MyLock, :read, false, str_val: "Jan Tschichold"
41
+ accessible = MySubject.create!
42
+ unaccessible = MySubject.create!(str_val: "Jan Tschichold")
52
43
 
53
- it { MySubject.accessible_by(ability).must_include subject1 }
54
- it { MySubject.accessible_by(ability).wont_include subject2 }
44
+ _(MySubject.accessible_by(ability)).must_include accessible
45
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
55
46
  end
56
47
  end
57
48
 
58
- describe 'Regexp' do
59
- let(:subject2) { MySubject.new(str_val: "Jan Tschichold") }
60
-
61
- describe 'positive' do
62
- before(:all) { MySubject.default_lock MyLock, :read, true, str_val: /tschichold/i }
49
+ describe "Regexp" do
50
+ it "returns correct records when using positive locks" do
51
+ MySubject.default_lock MyLock, :read, true, str_val: /tschichold/i
52
+ unaccessible = MySubject.create!
53
+ accessible = MySubject.create!(str_val: "Jan Tschichold")
63
54
 
64
- it { MySubject.accessible_by(ability).wont_include subject1 }
65
- it { MySubject.accessible_by(ability).must_include subject2 }
55
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
56
+ _(MySubject.accessible_by(ability)).must_include accessible
66
57
  end
67
58
 
68
- describe 'negative' do
69
- before(:all) do
70
- MySubject.default_lock MyLock, :read, true
71
- MySubject.default_lock MyLock, :read, false, str_val: /tschichold/i
72
- end
59
+ it "returns the correct records when using negative locks" do
60
+ MySubject.default_lock MyLock, :read, true
61
+ MySubject.default_lock MyLock, :read, false, str_val: /tschichold/i
62
+ accessible = MySubject.create!
63
+ unaccessible = MySubject.create!(str_val: "Jan Tschichold")
73
64
 
74
- it { MySubject.accessible_by(ability).must_include subject1 }
75
- it { MySubject.accessible_by(ability).wont_include subject2 }
65
+ _(MySubject.accessible_by(ability)).must_include accessible
66
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
76
67
  end
77
68
  end
78
69
 
79
- describe 'Array' do
80
- let(:subject2) { MySubject.new(str_val: "John") }
70
+ describe "Array" do
71
+ it "returns correct records when using positive locks" do
72
+ MySubject.default_lock MyLock, :read, true, str_val: %w[John Paul George Ringo]
73
+ unaccessible = MySubject.create!
74
+ accessible = MySubject.create!(str_val: "John")
81
75
 
82
- describe 'positive' do
83
- before(:all) { MySubject.default_lock MyLock, :read, true, str_val: %w(John Paul George Ringo) }
84
-
85
- it { MySubject.accessible_by(ability).wont_include subject1 }
86
- it { MySubject.accessible_by(ability).must_include subject2 }
76
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
77
+ _(MySubject.accessible_by(ability)).must_include accessible
87
78
  end
88
79
 
89
- describe 'negative' do
90
- before(:all) do
91
- MySubject.default_lock MyLock, :read, true
92
- MySubject.default_lock MyLock, :read, false, str_val: %w(John Paul George Ringo)
93
- end
80
+ it "returns the correct records when using negative locks" do
81
+ MySubject.default_lock MyLock, :read, true
82
+ MySubject.default_lock MyLock, :read, false, str_val: %w[John Paul George Ringo]
83
+ accessible = MySubject.create!
84
+ unaccessible = MySubject.create!(str_val: "John")
94
85
 
95
- it { MySubject.accessible_by(ability).must_include subject1 }
96
- it { MySubject.accessible_by(ability).wont_include subject2 }
86
+ _(MySubject.accessible_by(ability)).must_include accessible
87
+ _(MySubject.accessible_by(ability)).wont_include unaccessible
97
88
  end
98
89
  end
90
+
91
+ private
92
+
93
+ def owner
94
+ MyOwner.new
95
+ end
96
+
97
+ def ability
98
+ MongoidAbility::Ability.new(owner)
99
+ end
99
100
  end
100
101
  end
101
102
  end
data/test/cancancan/model_adapters/mongoid_adapter_test.rb CHANGED
@@ -25,37 +25,47 @@ module CanCan
25
25
 
26
26
  describe 'subject type locks' do
27
27
  describe 'default open locks' do
28
- before { MySubject.default_lock MyLock, :read, true }
28
+ before do
29
+ MySubject.default_lock MyLock, :read, true
30
+ end
31
+
32
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject }
33
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject1 }
34
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject2 }
29
35
 
30
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject }
31
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject1 }
32
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject2 }
36
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject }
37
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include my_subject1 }
38
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include my_subject2 }
33
39
 
34
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject }
35
- it { MySubject1.accessible_by(ability, :read).to_a.must_include my_subject1 }
36
- it { MySubject1.accessible_by(ability, :read).to_a.must_include my_subject2 }
40
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject }
41
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject1 }
42
+ it { _(MySubject2.accessible_by(ability, :read).to_a).must_include my_subject2 }
37
43
 
38
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject }
39
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject1 }
40
- it { MySubject2.accessible_by(ability, :read).to_a.must_include my_subject2 }
44
+ it 'works for non sci classes' do
45
+ MyFlatSubject.default_lock MyLock, :read, true
46
+ flat_subject = MyFlatSubject.create!
47
+
48
+ _(MyFlatSubject.accessible_by(ability, :read).to_a)
49
+ .must_include flat_subject
50
+ end
41
51
  end
42
52
 
43
53
  describe 'default closed locks' do
44
54
  before { MySubject.default_lock MyLock, :read, false }
45
55
 
46
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject }
47
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject1 }
48
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject2 }
56
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject }
57
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject1 }
58
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject2 }
49
59
 
50
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject }
51
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject1 }
52
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject2 }
60
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject }
61
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject1 }
62
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject2 }
53
63
 
54
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject }
55
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject1 }
56
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject2 }
64
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject }
65
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject1 }
66
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject2 }
57
67
 
58
- it { MySubject.accessible_by(ability, :read).selector.must_equal({}) }
68
+ it { _(MySubject.accessible_by(ability, :read).selector).must_equal({}) }
59
69
  end
60
70
 
61
71
  describe 'default combined locks' do
@@ -65,14 +75,14 @@ module CanCan
65
75
  MySubject2.default_lock MyLock, :read, false
66
76
  end
67
77
 
68
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject }
69
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject1 }
70
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject2 }
78
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject }
79
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject1 }
80
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject2 }
71
81
 
72
- it { MySubject1.accessible_by(ability, :read).to_a.must_include my_subject1 }
73
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject2 }
82
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include my_subject1 }
83
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject2 }
74
84
 
75
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject2 }
85
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject2 }
76
86
  end
77
87
 
78
88
  describe 'combined locks' do
@@ -84,14 +94,14 @@ module CanCan
84
94
  let(:role) { MyRole.new(my_locks: [lock]) }
85
95
  let(:owner) { MyOwner.new(my_roles: [role]) }
86
96
 
87
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject }
88
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject1 }
89
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject2 }
97
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject }
98
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject1 }
99
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject2 }
90
100
 
91
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject1 }
92
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include my_subject2 }
101
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject1 }
102
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include my_subject2 }
93
103
 
94
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject2 }
104
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject2 }
95
105
  end
96
106
  end
97
107
 
@@ -105,9 +115,9 @@ module CanCan
105
115
  MySubject.default_lock MyLock, :read, true
106
116
  end
107
117
 
108
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject }
109
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject1 }
110
- it { MySubject.accessible_by(ability, :read).to_a.must_include my_subject2 }
118
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject }
119
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject1 }
120
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include my_subject2 }
111
121
  end
112
122
 
113
123
  describe 'open id locks' do
@@ -118,9 +128,9 @@ module CanCan
118
128
  MySubject.default_lock MyLock, :read, false
119
129
  end
120
130
 
121
- it { MySubject.accessible_by(ability, :read).to_a.wont_include my_subject }
122
- it { MySubject1.accessible_by(ability, :read).to_a.must_include my_subject1 }
123
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include my_subject2 }
131
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include my_subject }
132
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include my_subject1 }
133
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include my_subject2 }
124
134
  end
125
135
 
126
136
  describe 'closed types & open ids' do
@@ -130,8 +140,8 @@ module CanCan
130
140
 
131
141
  let(:owner) { MyOwner.new(my_locks: [lock_1, lock_2, lock_3]) }
132
142
 
133
- it { MySubject.accessible_by(ability, :read).must_include my_subject }
134
- it { MySubject.accessible_by(ability, :read).must_include my_subject1 }
143
+ it { _(MySubject.accessible_by(ability, :read)).must_include my_subject }
144
+ it { _(MySubject.accessible_by(ability, :read)).must_include my_subject1 }
135
145
  end
136
146
  end
137
147
 
@@ -139,19 +149,21 @@ module CanCan
139
149
  describe 'positive' do
140
150
  let(:my_subject1) { MySubject1.new(override: true) }
141
151
 
142
- before(:all) { MySubject.default_lock MyLock, :read, true, override: true }
152
+ before(:all) do
153
+ MySubject.default_lock MyLock, :read, true, override: true
154
+ end
143
155
 
144
- it { MySubject.accessible_by(ability, :read).to_a.wont_include(my_subject) }
145
- it { MySubject.accessible_by(ability, :read).to_a.must_include(my_subject1) }
146
- it { MySubject.accessible_by(ability, :read).to_a.wont_include(my_subject2) }
156
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include(my_subject) }
157
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include(my_subject1) }
158
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include(my_subject2) }
147
159
 
148
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include(my_subject) }
149
- it { MySubject1.accessible_by(ability, :read).to_a.must_include(my_subject1) }
150
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include(my_subject2) }
160
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include(my_subject) }
161
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include(my_subject1) }
162
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include(my_subject2) }
151
163
 
152
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include(my_subject) }
153
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include(my_subject1) }
154
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include(my_subject2) }
164
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include(my_subject) }
165
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include(my_subject1) }
166
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include(my_subject2) }
155
167
  end
156
168
 
157
169
  describe 'negative' do
@@ -162,17 +174,17 @@ module CanCan
162
174
  MySubject.default_lock MyLock, :read, false, override: true
163
175
  end
164
176
 
165
- it { MySubject.accessible_by(ability, :read).to_a.must_include(my_subject) }
166
- it { MySubject.accessible_by(ability, :read).to_a.wont_include(my_subject1) }
167
- it { MySubject.accessible_by(ability, :read).to_a.must_include(my_subject2) }
177
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include(my_subject) }
178
+ it { _(MySubject.accessible_by(ability, :read).to_a).wont_include(my_subject1) }
179
+ it { _(MySubject.accessible_by(ability, :read).to_a).must_include(my_subject2) }
168
180
 
169
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include(my_subject) }
170
- it { MySubject1.accessible_by(ability, :read).to_a.wont_include(my_subject1) }
171
- it { MySubject1.accessible_by(ability, :read).to_a.must_include(my_subject2) }
181
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include(my_subject) }
182
+ it { _(MySubject1.accessible_by(ability, :read).to_a).wont_include(my_subject1) }
183
+ it { _(MySubject1.accessible_by(ability, :read).to_a).must_include(my_subject2) }
172
184
 
173
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include(my_subject) }
174
- it { MySubject2.accessible_by(ability, :read).to_a.wont_include(my_subject1) }
175
- it { MySubject2.accessible_by(ability, :read).to_a.must_include(my_subject2) }
185
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include(my_subject) }
186
+ it { _(MySubject2.accessible_by(ability, :read).to_a).wont_include(my_subject1) }
187
+ it { _(MySubject2.accessible_by(ability, :read).to_a).must_include(my_subject2) }
176
188
  end
177
189
  end
178
190
  end
@@ -182,22 +194,24 @@ module CanCan
182
194
  let(:lock_2) { MyLock.new(subject: my_subject2, action: :read, outcome: false) }
183
195
  let(:role_1) { MyRole.new(my_locks: [lock_1, lock_2]) }
184
196
 
185
- let(:prefix) { :subject }
186
- let(:selector) { MySubject.accessible_by(ability, :read, prefix: prefix).selector }
187
-
188
197
  before(:all) do
189
198
  MySubject.default_lock MyLock, :read, true
190
199
  end
191
200
 
192
201
  it 'allows to pass prefix' do
193
- selector.must_equal(
194
- '$and' => [
195
- { '$or' => [
202
+ prefix = :subject
203
+ selector = MySubject.accessible_by(ability, :read, prefix: prefix).selector
204
+
205
+ _(selector).must_equal(
206
+ {
207
+ '$or' => [
196
208
  { 'subject_type' => { '$nin' => [] } },
197
- { 'subject_id' => my_subject1.id }
198
- ] },
199
- { 'subject_id' => { '$ne' => my_subject2.id } }
200
- ]
209
+ { 'subject_id' => my_subject1.id },
210
+ ],
211
+ '$and' =>[
212
+ { 'subject_id'=> { '$nin' => [my_subject2.id] } }
213
+ ]
214
+ }
201
215
  )
202
216
  end
203
217
  end
data/test/mongoid_ability/ability_basic_benchmark.rb CHANGED
@@ -11,13 +11,13 @@ module MongoidAbility
11
11
 
12
12
  bench_performance_constant 'can?' do |n|
13
13
  n.times do
14
- ability.can?(:read, MySubject).must_equal false
14
+ _(ability.can?(:read, MySubject)).must_equal false
15
15
  end
16
16
  end
17
17
 
18
18
  bench_performance_constant 'cannot?' do |n|
19
19
  n.times do
20
- ability.cannot?(:read, MySubject).must_equal true
20
+ _(ability.cannot?(:read, MySubject)).must_equal true
21
21
  end
22
22
  end
23
23
 
data/test/mongoid_ability/ability_basic_test.rb CHANGED
@@ -6,15 +6,15 @@ module MongoidAbility
6
6
  let(:ability) { Ability.new(owner) }
7
7
 
8
8
  describe 'default' do
9
- it { ability.can?(:read, MySubject).must_equal false }
10
- it { ability.cannot?(:read, MySubject).must_equal true }
9
+ it { _(ability.can?(:read, MySubject)).must_equal false }
10
+ it { _(ability.cannot?(:read, MySubject)).must_equal true }
11
11
  end
12
12
 
13
13
  describe 'class locks' do
14
14
  before(:all) { MySubject.default_lock MyLock, :read, true }
15
15
 
16
- it { ability.can?(:read, MySubject).must_equal true }
17
- it { ability.cannot?(:read, MySubject).must_equal false }
16
+ it { _(ability.can?(:read, MySubject)).must_equal true }
17
+ it { _(ability.cannot?(:read, MySubject)).must_equal false }
18
18
  end
19
19
 
20
20
  describe 'inherited locks' do
@@ -23,8 +23,8 @@ module MongoidAbility
23
23
  let(:my_role) { MyRole.new(my_locks: [read_lock]) }
24
24
  let(:owner) { MyOwner.new(my_roles: [my_role]) }
25
25
 
26
- it { ability.can?(:read, MySubject).must_equal true }
27
- it { ability.cannot?(:read, MySubject).must_equal false }
26
+ it { _(ability.can?(:read, MySubject)).must_equal true }
27
+ it { _(ability.cannot?(:read, MySubject)).must_equal false }
28
28
  end
29
29
 
30
30
  describe 'subject_id' do
@@ -33,14 +33,14 @@ module MongoidAbility
33
33
  let(:my_role) { MyRole.new(my_locks: [read_lock]) }
34
34
  let(:owner) { MyOwner.new(my_roles: [my_role]) }
35
35
 
36
- it { ability.can?(:read, my_subject).must_equal true }
37
- it { ability.cannot?(:read, my_subject).must_equal false }
36
+ it { _(ability.can?(:read, my_subject)).must_equal true }
37
+ it { _(ability.cannot?(:read, my_subject)).must_equal false }
38
38
 
39
39
  describe 'when id stored as String' do
40
40
  let(:read_lock) { MyLock.new(subject_type: my_subject.model_name.to_s, subject_id: my_subject.id.to_s, action: :read, outcome: true) }
41
41
 
42
- it { ability.can?(:read, my_subject).must_equal true }
43
- it { ability.cannot?(:read, my_subject).must_equal false }
42
+ it { _(ability.can?(:read, my_subject)).must_equal true }
43
+ it { _(ability.cannot?(:read, my_subject)).must_equal false }
44
44
  end
45
45
  end
46
46
  end
@@ -50,8 +50,8 @@ module MongoidAbility
50
50
  let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
51
51
  let(:owner) { MyOwner.new(my_locks: [read_lock]) }
52
52
 
53
- it { ability.can?(:read, MySubject).must_equal true }
54
- it { ability.cannot?(:read, MySubject).must_equal false }
53
+ it { _(ability.can?(:read, MySubject)).must_equal true }
54
+ it { _(ability.cannot?(:read, MySubject)).must_equal false }
55
55
  end
56
56
 
57
57
  describe 'subject_id' do
@@ -59,8 +59,8 @@ module MongoidAbility
59
59
  let(:read_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
60
60
  let(:owner) { MyOwner.new(my_locks: [read_lock]) }
61
61
 
62
- it { ability.can?(:read, my_subject).must_equal true }
63
- it { ability.cannot?(:read, my_subject).must_equal false }
62
+ it { _(ability.can?(:read, my_subject)).must_equal true }
63
+ it { _(ability.cannot?(:read, my_subject)).must_equal false }
64
64
  end
65
65
  end
66
66
  end
data/test/mongoid_ability/ability_marshal_test.rb CHANGED
@@ -15,12 +15,17 @@ module MongoidAbility
15
15
  let(:loaded_rules) { ability_load.send(:rules) }
16
16
 
17
17
  describe 'dump' do
18
- it { ability_dump.must_be :present? }
18
+ it { _(ability_dump).must_be :present? }
19
19
  end
20
20
 
21
21
  describe 'load' do
22
- it { loaded_rules.count.must_equal 2 }
23
- it { loaded_rules.map(&:conditions).must_include({ id: my_subject.id }) }
22
+ it 'loads rules for each lock' do
23
+ _(loaded_rules.count { |rule| rule.subjects == [MySubject] }).must_equal 2
24
+ end
25
+
26
+ it 'builds conditions for the subjects id' do
27
+ _(loaded_rules.map(&:conditions)).must_include({ id: my_subject.id })
28
+ end
24
29
  end
25
30
  end
26
31
  end
data/test/mongoid_ability/ability_options_test.rb CHANGED
@@ -12,8 +12,8 @@ module MongoidAbility
12
12
  describe 'positive' do
13
13
  before(:all) { MySubject.default_lock MyLock, :read, true, override: true }
14
14
 
15
- it { ability.can?(:read, subject1).must_equal false }
16
- it { ability.can?(:read, subject2).must_equal true }
15
+ it { _(ability.can?(:read, subject1)).must_equal false }
16
+ it { _(ability.can?(:read, subject2)).must_equal true }
17
17
  end
18
18
 
19
19
  describe 'negative' do
@@ -22,8 +22,8 @@ module MongoidAbility
22
22
  MySubject.default_lock MyLock, :read, false, override: true
23
23
  end
24
24
 
25
- it { ability.can?(:read, subject1).must_equal true }
26
- it { ability.can?(:read, subject2).must_equal false }
25
+ it { _(ability.can?(:read, subject1)).must_equal true }
26
+ it { _(ability.can?(:read, subject2)).must_equal false }
27
27
  end
28
28
  end
29
29
 
@@ -33,8 +33,8 @@ module MongoidAbility
33
33
  describe 'positive' do
34
34
  before(:all) { MySubject.default_lock MyLock, :read, true, str_val: 'Jan Tschichold' }
35
35
 
36
- it { ability.can?(:read, subject1).must_equal false }
37
- it { ability.can?(:read, subject2).must_equal true }
36
+ it { _(ability.can?(:read, subject1)).must_equal false }
37
+ it { _(ability.can?(:read, subject2)).must_equal true }
38
38
  end
39
39
 
40
40
  describe 'negative' do
@@ -43,8 +43,8 @@ module MongoidAbility
43
43
  MySubject.default_lock MyLock, :read, false, str_val: 'Jan Tschichold'
44
44
  end
45
45
 
46
- it { ability.can?(:read, subject1).must_equal true }
47
- it { ability.can?(:read, subject2).must_equal false }
46
+ it { _(ability.can?(:read, subject1)).must_equal true }
47
+ it { _(ability.can?(:read, subject2)).must_equal false }
48
48
  end
49
49
  end
50
50
 
@@ -54,8 +54,8 @@ module MongoidAbility
54
54
  describe 'positive' do
55
55
  before(:all) { MySubject.default_lock MyLock, :read, true, str_val: /tschichold/i }
56
56
 
57
- it { ability.can?(:read, subject1).must_equal false }
58
- it { ability.can?(:read, subject2).must_equal true }
57
+ it { _(ability.can?(:read, subject1)).must_equal false }
58
+ it { _(ability.can?(:read, subject2)).must_equal true }
59
59
  end
60
60
 
61
61
  describe 'negative' do
@@ -64,8 +64,8 @@ module MongoidAbility
64
64
  MySubject.default_lock MyLock, :read, false, str_val: /tschichold/i
65
65
  end
66
66
 
67
- it { ability.can?(:read, subject1).must_equal true }
68
- it { ability.can?(:read, subject2).must_equal false }
67
+ it { _(ability.can?(:read, subject1)).must_equal true }
68
+ it { _(ability.can?(:read, subject2)).must_equal false }
69
69
  end
70
70
  end
71
71
 
@@ -75,8 +75,8 @@ module MongoidAbility
75
75
  describe 'positive' do
76
76
  before(:all) { MySubject.default_lock MyLock, :read, true, str_val: %w(John Paul George Ringo) }
77
77
 
78
- it { ability.can?(:read, subject1).must_equal false }
79
- it { ability.can?(:read, subject2).must_equal true }
78
+ it { _(ability.can?(:read, subject1)).must_equal false }
79
+ it { _(ability.can?(:read, subject2)).must_equal true }
80
80
  end
81
81
 
82
82
  describe 'negative' do
@@ -85,8 +85,8 @@ module MongoidAbility
85
85
  MySubject.default_lock MyLock, :read, false, str_val: %w(John Paul George Ringo)
86
86
  end
87
87
 
88
- it { ability.can?(:read, subject1).must_equal true }
89
- it { ability.can?(:read, subject2).must_equal false }
88
+ it { _(ability.can?(:read, subject1)).must_equal true }
89
+ it { _(ability.can?(:read, subject2)).must_equal false }
90
90
  end
91
91
  end
92
92
  end