mongoid_ability 0.3.12 → 0.4.3
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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +19 -0
- data/lib/mongoid_ability.rb +1 -0
- data/lib/mongoid_ability/ability.rb +17 -19
- data/lib/mongoid_ability/lock.rb +5 -6
- data/lib/mongoid_ability/owner.rb +6 -12
- data/lib/mongoid_ability/resolve_default_locks.rb +7 -4
- data/lib/mongoid_ability/resolve_inherited_locks.rb +19 -14
- data/lib/mongoid_ability/resolve_locks.rb +7 -27
- data/lib/mongoid_ability/resolve_owner_locks.rb +15 -7
- data/lib/mongoid_ability/resolver.rb +24 -0
- data/lib/mongoid_ability/values_for_accessible_query.rb +4 -0
- data/lib/mongoid_ability/version.rb +1 -1
- data/test/mongoid_ability/ability_basic_test.rb +29 -0
- data/test/mongoid_ability/ability_syntactic_sugar_test.rb +32 -0
- data/test/mongoid_ability/ability_test.rb +83 -39
- data/test/mongoid_ability/accessible_query_builder_test.rb +56 -14
- data/test/mongoid_ability/can_options_test.rb +5 -5
- data/test/mongoid_ability/lock_test.rb +27 -11
- data/test/mongoid_ability/owner_locks_test.rb +9 -13
- data/test/mongoid_ability/resolve_default_locks_test.rb +24 -10
- data/test/mongoid_ability/resolve_inherited_locks_test.rb +20 -19
- data/test/mongoid_ability/resolve_owner_locks_test.rb +27 -21
- data/test/mongoid_ability/{resolve_locks_test.rb → resolver_test.rb} +4 -6
- data/test/mongoid_ability/subject_accessible_by_test.rb +97 -98
- data/test/mongoid_ability/subject_test.rb +57 -26
- data/test/support/test_classes/my_subject.rb +0 -4
- metadata +10 -6
- data/test/mongoid_ability/ability_role_test.rb +0 -31
|
@@ -1,49 +1,50 @@
|
|
|
1
|
-
require
|
|
1
|
+
require 'test_helper'
|
|
2
2
|
|
|
3
3
|
module MongoidAbility
|
|
4
4
|
describe ResolveInheritedLocks do
|
|
5
|
-
|
|
6
5
|
describe 'when defined on class' do
|
|
7
6
|
let(:owner) { MyOwner.new }
|
|
8
7
|
let(:my_subject) { MySubject.new }
|
|
9
8
|
|
|
10
|
-
|
|
9
|
+
let(:default_locks) { [MyLock.new(subject_type: MySubject, action: :my_read, outcome: true)] }
|
|
11
10
|
|
|
12
|
-
# ---------------------------------------------------------------------
|
|
13
|
-
|
|
14
11
|
it 'returns it' do
|
|
15
|
-
|
|
16
|
-
|
|
12
|
+
MySubject.stub :default_locks, default_locks do
|
|
13
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).calculated_outcome.must_equal true
|
|
14
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject).calculated_outcome.must_equal true
|
|
15
|
+
end
|
|
17
16
|
end
|
|
18
17
|
|
|
19
|
-
# ---------------------------------------------------------------------
|
|
20
|
-
|
|
21
18
|
describe 'when defined on one of the inherited owners' do
|
|
22
19
|
let(:inherited_owner_1) { MyOwner.new }
|
|
23
20
|
let(:inherited_owner_2) { MyOwner.new }
|
|
24
21
|
let(:owner) { MyOwner.new(my_roles: [inherited_owner_1, inherited_owner_2]) }
|
|
25
22
|
let(:my_subject) { MySubject.new }
|
|
26
23
|
|
|
27
|
-
|
|
24
|
+
let(:lock) { MyLock.new(action: :my_read, subject_type: MySubject, outcome: false) }
|
|
25
|
+
|
|
26
|
+
before { inherited_owner_1.my_locks = [lock] }
|
|
28
27
|
|
|
29
28
|
it 'returns it' do
|
|
30
|
-
|
|
31
|
-
|
|
29
|
+
MySubject.stub :default_locks, default_locks do
|
|
30
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).must_equal lock
|
|
31
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject.id).must_equal lock
|
|
32
|
+
end
|
|
32
33
|
end
|
|
33
34
|
|
|
34
|
-
# ---------------------------------------------------------------------
|
|
35
|
-
|
|
36
35
|
describe 'when defined on user' do
|
|
37
|
-
|
|
36
|
+
let(:lock) { MyLock.new(action: :my_read, subject_type: MySubject, outcome: false) }
|
|
37
|
+
|
|
38
|
+
before { owner.my_locks = [lock] }
|
|
38
39
|
|
|
39
40
|
it 'returns it' do
|
|
40
|
-
|
|
41
|
-
|
|
41
|
+
MySubject.stub :default_locks, default_locks do
|
|
42
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, nil).must_equal lock
|
|
43
|
+
ResolveInheritedLocks.call(owner, :my_read, MySubject, my_subject.id).must_equal lock
|
|
44
|
+
end
|
|
42
45
|
end
|
|
43
46
|
end
|
|
44
|
-
|
|
45
47
|
end
|
|
46
48
|
end
|
|
47
|
-
|
|
48
49
|
end
|
|
49
50
|
end
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
require
|
|
1
|
+
require 'test_helper'
|
|
2
2
|
|
|
3
3
|
module MongoidAbility
|
|
4
4
|
describe ResolveOwnerLocks do
|
|
@@ -6,45 +6,51 @@ module MongoidAbility
|
|
|
6
6
|
let(:my_subject) { MySubject.new }
|
|
7
7
|
|
|
8
8
|
subject { ResolveOwnerLocks.call(owner, :read, MySubject, nil) }
|
|
9
|
-
let(:resolver_for_subject_id) { ResolveOwnerLocks.call(owner, :read, MySubject, my_subject) }
|
|
10
|
-
|
|
11
|
-
# =====================================================================
|
|
12
|
-
|
|
13
|
-
describe '#outcome' do
|
|
14
|
-
before do
|
|
15
|
-
MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :read, outcome: false) ]
|
|
16
|
-
end
|
|
9
|
+
let(:resolver_for_subject_id) { ResolveOwnerLocks.call(owner, :read, MySubject, my_subject.id) }
|
|
10
|
+
let(:default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: false)] }
|
|
17
11
|
|
|
12
|
+
describe '#lock' do
|
|
18
13
|
describe 'no locks' do
|
|
19
|
-
it
|
|
14
|
+
it 'must be nil' do
|
|
15
|
+
MySubject.stub :default_locks, default_locks do
|
|
16
|
+
subject.must_be_nil
|
|
17
|
+
end
|
|
18
|
+
end
|
|
20
19
|
end
|
|
21
20
|
|
|
22
21
|
describe 'id locks' do
|
|
23
22
|
it 'returns outcome' do
|
|
24
|
-
|
|
25
|
-
|
|
23
|
+
MySubject.stub :default_locks, default_locks do
|
|
24
|
+
owner.my_locks = [MyLock.new(action: :read, subject: my_subject, outcome: true)]
|
|
25
|
+
resolver_for_subject_id.calculated_outcome.must_equal true
|
|
26
|
+
end
|
|
26
27
|
end
|
|
27
28
|
|
|
28
29
|
it 'prefers negative outcome' do
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
30
|
+
MySubject.stub :default_locks, default_locks do
|
|
31
|
+
owner.my_locks = [MyLock.new(action: :read, subject: my_subject, outcome: true),
|
|
32
|
+
MyLock.new(action: :read, subject: my_subject, outcome: false)]
|
|
33
|
+
resolver_for_subject_id.calculated_outcome.must_equal false
|
|
34
|
+
end
|
|
32
35
|
end
|
|
33
36
|
end
|
|
34
37
|
|
|
35
38
|
describe 'class locks' do
|
|
36
39
|
it 'returns outcome' do
|
|
37
|
-
|
|
38
|
-
|
|
40
|
+
MySubject.stub :default_locks, default_locks do
|
|
41
|
+
owner.my_locks = [MyLock.new(action: :read, subject_type: MySubject, outcome: true)]
|
|
42
|
+
subject.calculated_outcome.must_equal true
|
|
43
|
+
end
|
|
39
44
|
end
|
|
40
45
|
|
|
41
46
|
it 'prefers negative outcome' do
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
47
|
+
MySubject.stub :default_locks, default_locks do
|
|
48
|
+
owner.my_locks = [MyLock.new(action: :read, subject_type: MySubject, outcome: true),
|
|
49
|
+
MyLock.new(action: :read, subject_type: MySubject, outcome: false)]
|
|
50
|
+
subject.calculated_outcome.must_equal false
|
|
51
|
+
end
|
|
45
52
|
end
|
|
46
53
|
end
|
|
47
54
|
end
|
|
48
|
-
|
|
49
55
|
end
|
|
50
56
|
end
|
|
@@ -1,25 +1,23 @@
|
|
|
1
1
|
require 'test_helper'
|
|
2
2
|
|
|
3
3
|
module MongoidAbility
|
|
4
|
-
describe
|
|
5
|
-
|
|
4
|
+
describe Resolver do
|
|
6
5
|
let(:owner) { MyOwner.new }
|
|
7
6
|
|
|
8
7
|
describe 'errors' do
|
|
9
8
|
it 'raises NameError for invalid subject_type' do
|
|
10
|
-
-> {
|
|
9
|
+
-> { Resolver.call(owner, :read, 'Foo') }.must_raise NameError
|
|
11
10
|
end
|
|
12
11
|
|
|
13
12
|
it 'raises StandardError when subject_type does not have default_locks' do
|
|
14
|
-
-> {
|
|
13
|
+
-> { Resolver.call(owner, :read, Object) }.must_raise StandardError
|
|
15
14
|
end
|
|
16
15
|
|
|
17
16
|
it 'raises StandardError when subject_type class or its ancestors does not have default_lock' do
|
|
18
17
|
MySubject.stub(:default_locks, []) do
|
|
19
|
-
-> {
|
|
18
|
+
-> { Resolver.call(owner, :read, MySubject) }.must_raise StandardError
|
|
20
19
|
end
|
|
21
20
|
end
|
|
22
21
|
end
|
|
23
|
-
|
|
24
22
|
end
|
|
25
23
|
end
|
|
@@ -11,137 +11,136 @@ module MongoidAbility
|
|
|
11
11
|
let(:owner) { MyOwner.new(my_roles: [role_1, role_2]) }
|
|
12
12
|
let(:ability) { Ability.new(owner) }
|
|
13
13
|
|
|
14
|
-
|
|
14
|
+
let(:my_subject_default_locks) { [] }
|
|
15
|
+
let(:my_subject_1_default_locks) { [] }
|
|
16
|
+
let(:my_subject_2_default_locks) { [] }
|
|
17
|
+
|
|
18
|
+
before { my_subject; my_subject1; my_subject2 }
|
|
15
19
|
|
|
16
20
|
describe 'default open locks' do
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :update, outcome: true) ]
|
|
20
|
-
MySubject1.default_locks = []
|
|
21
|
-
MySubject2.default_locks = []
|
|
22
|
-
|
|
23
|
-
my_subject
|
|
24
|
-
my_subject1
|
|
25
|
-
my_subject2
|
|
26
|
-
end
|
|
21
|
+
# NOTE: we might need to use the .default_lock macro in case we propagate down directly
|
|
22
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: true)] }
|
|
27
23
|
|
|
28
24
|
it 'propagates from superclass to all subclasses' do
|
|
29
|
-
MySubject.
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
25
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
26
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
27
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
28
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject
|
|
29
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
30
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject2
|
|
31
|
+
|
|
32
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
33
|
+
MySubject1.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
34
|
+
MySubject1.accessible_by(ability, :update).to_a.must_include my_subject2
|
|
35
|
+
|
|
36
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
37
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject1
|
|
38
|
+
MySubject2.accessible_by(ability, :update).to_a.must_include my_subject2
|
|
39
|
+
end
|
|
40
|
+
end
|
|
41
|
+
end
|
|
40
42
|
end
|
|
41
43
|
end
|
|
42
44
|
|
|
43
45
|
describe 'default closed locks' do
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :update, outcome: false) ]
|
|
47
|
-
MySubject1.default_locks = []
|
|
48
|
-
MySubject2.default_locks = []
|
|
49
|
-
|
|
50
|
-
my_subject
|
|
51
|
-
my_subject1
|
|
52
|
-
my_subject2
|
|
53
|
-
end
|
|
46
|
+
# NOTE: we might need to use the .default_lock macro in case we propagate down directly
|
|
47
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: false)] }
|
|
54
48
|
|
|
55
49
|
it 'propagates from superclass to all subclasses' do
|
|
56
|
-
MySubject.
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
50
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
51
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
52
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
53
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
54
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject1
|
|
55
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
56
|
+
|
|
57
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
58
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject1
|
|
59
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
60
|
+
|
|
61
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
62
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject1
|
|
63
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
64
|
+
end
|
|
65
|
+
end
|
|
66
|
+
end
|
|
67
67
|
end
|
|
68
68
|
end
|
|
69
69
|
|
|
70
70
|
describe 'default combined locks' do
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
MySubject2.default_locks = [ MyLock.new(subject_type: MySubject, action: :update, outcome: false) ]
|
|
76
|
-
|
|
77
|
-
my_subject
|
|
78
|
-
my_subject1
|
|
79
|
-
my_subject2
|
|
80
|
-
end
|
|
71
|
+
# NOTE: we might need to use the .default_lock macro in case we propagate down directly
|
|
72
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: false)] }
|
|
73
|
+
let(:my_subject_1_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: true)] }
|
|
74
|
+
let(:my_subject_2_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: false)] }
|
|
81
75
|
|
|
82
76
|
it 'propagates from superclass to all subclasses' do
|
|
83
|
-
MySubject.
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
77
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
78
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
79
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
80
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
81
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
82
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
83
|
+
|
|
84
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
85
|
+
MySubject1.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
86
|
+
MySubject1.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
87
|
+
|
|
88
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
89
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject1
|
|
90
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
91
|
+
end
|
|
92
|
+
end
|
|
93
|
+
end
|
|
94
94
|
end
|
|
95
95
|
end
|
|
96
96
|
|
|
97
|
-
# ---------------------------------------------------------------------
|
|
98
|
-
|
|
99
97
|
describe 'closed id locks' do
|
|
100
|
-
let(:role_1) { MyRole.new(my_locks: [
|
|
101
|
-
|
|
102
|
-
before do
|
|
103
|
-
MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :update, outcome: true) ]
|
|
104
|
-
MySubject1.default_locks = []
|
|
105
|
-
MySubject2.default_locks = []
|
|
106
|
-
|
|
107
|
-
my_subject
|
|
108
|
-
my_subject1
|
|
109
|
-
my_subject2
|
|
110
|
-
end
|
|
98
|
+
let(:role_1) { MyRole.new(my_locks: [MyLock.new(subject: my_subject, action: :update, outcome: false)]) }
|
|
99
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: true)] }
|
|
111
100
|
|
|
112
101
|
it 'applies id locks' do
|
|
113
|
-
MySubject.
|
|
114
|
-
|
|
115
|
-
|
|
102
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
103
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
104
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
105
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
106
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
107
|
+
MySubject.accessible_by(ability, :update).to_a.must_include my_subject2
|
|
108
|
+
end
|
|
109
|
+
end
|
|
110
|
+
end
|
|
116
111
|
end
|
|
117
112
|
end
|
|
118
113
|
|
|
119
114
|
describe 'open id locks' do
|
|
120
|
-
let(:role_1) { MyRole.new(my_locks: [
|
|
121
|
-
|
|
122
|
-
before do
|
|
123
|
-
MySubject.default_locks = [ MyLock.new(subject_type: MySubject, action: :update, outcome: false) ]
|
|
124
|
-
MySubject1.default_locks = []
|
|
125
|
-
MySubject2.default_locks = []
|
|
126
|
-
|
|
127
|
-
my_subject
|
|
128
|
-
my_subject1
|
|
129
|
-
my_subject2
|
|
130
|
-
end
|
|
115
|
+
let(:role_1) { MyRole.new(my_locks: [MyLock.new(subject: my_subject1, action: :update, outcome: true)]) }
|
|
116
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: false)] }
|
|
131
117
|
|
|
132
118
|
it 'applies id locks' do
|
|
133
|
-
MySubject.
|
|
134
|
-
|
|
135
|
-
|
|
119
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
120
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
121
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
122
|
+
MySubject.accessible_by(ability, :update).to_a.wont_include my_subject
|
|
123
|
+
MySubject1.accessible_by(ability, :update).to_a.must_include my_subject1
|
|
124
|
+
MySubject2.accessible_by(ability, :update).to_a.wont_include my_subject2
|
|
125
|
+
end
|
|
126
|
+
end
|
|
127
|
+
end
|
|
136
128
|
end
|
|
137
129
|
end
|
|
138
130
|
|
|
139
|
-
# =====================================================================
|
|
140
|
-
|
|
141
131
|
describe 'prefix' do
|
|
132
|
+
let(:prefix) { :subject }
|
|
133
|
+
let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :update, outcome: true)] }
|
|
134
|
+
|
|
142
135
|
it 'allows to pass prefix' do
|
|
143
|
-
|
|
144
|
-
|
|
136
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
137
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
138
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
139
|
+
selector = MySubject.accessible_by(ability, :update, prefix: prefix).selector
|
|
140
|
+
selector.must_equal('$and' => [{ '$or' => [{ "#{prefix}_type" => { '$nin' => [] } }, { "#{prefix}_type" => { '$in' => [] }, "#{prefix}_id" => { '$in' => [] } }] }, { "#{prefix}_id" => { '$nin' => [] } }])
|
|
141
|
+
end
|
|
142
|
+
end
|
|
143
|
+
end
|
|
145
144
|
end
|
|
146
145
|
end
|
|
147
146
|
end
|
|
@@ -2,48 +2,79 @@ require 'test_helper'
|
|
|
2
2
|
|
|
3
3
|
module MongoidAbility
|
|
4
4
|
describe Subject do
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
MySubject1.default_locks = []
|
|
9
|
-
MySubject2.default_locks = []
|
|
10
|
-
|
|
11
|
-
MySubject.default_lock MyLock, :read, true
|
|
12
|
-
MySubject.default_lock MyLock, :update, true
|
|
13
|
-
MySubject1.default_lock MyLock1, :update, false
|
|
14
|
-
end
|
|
5
|
+
let(:my_subject_default_locks) { [] }
|
|
6
|
+
let(:my_subject_1_default_locks) { [] }
|
|
7
|
+
let(:my_subject_2_default_locks) { [] }
|
|
15
8
|
|
|
9
|
+
describe '.default_lock' do
|
|
16
10
|
it 'stores them' do
|
|
17
|
-
MySubject.default_locks
|
|
18
|
-
|
|
11
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
12
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
13
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
14
|
+
MySubject.default_lock MyLock, :read, true
|
|
15
|
+
MySubject.default_lock MyLock, :update, true
|
|
16
|
+
MySubject1.default_lock MyLock1, :update, false
|
|
17
|
+
|
|
18
|
+
MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read update)
|
|
19
|
+
MySubject1.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(update)
|
|
20
|
+
end
|
|
21
|
+
end
|
|
22
|
+
end
|
|
19
23
|
end
|
|
20
24
|
end
|
|
21
25
|
|
|
22
26
|
describe 'prevents conflicts' do
|
|
23
|
-
before do
|
|
24
|
-
MySubject.default_locks = []
|
|
25
|
-
MySubject.default_lock MyLock, :read, false
|
|
26
|
-
MySubject.default_lock MyLock1, :read, false
|
|
27
|
-
|
|
28
|
-
MySubject1.default_locks = []
|
|
29
|
-
MySubject1.default_lock MyLock, :read, true
|
|
30
|
-
end
|
|
31
|
-
|
|
32
27
|
it 'does not allow multiple locks for same action' do
|
|
33
|
-
MySubject.
|
|
28
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
29
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
30
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
31
|
+
MySubject.default_lock MyLock1, :read, false
|
|
32
|
+
MySubject1.default_lock MyLock, :read, true
|
|
33
|
+
|
|
34
|
+
MySubject.default_locks.count { |l| l.action == :read }.must_equal 1
|
|
35
|
+
end
|
|
36
|
+
end
|
|
37
|
+
end
|
|
34
38
|
end
|
|
35
39
|
|
|
36
40
|
it 'replace existing locks with new attributes' do
|
|
37
|
-
MySubject.
|
|
41
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
42
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
43
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
44
|
+
MySubject.default_lock MyLock1, :read, false
|
|
45
|
+
MySubject1.default_lock MyLock, :read, true
|
|
46
|
+
|
|
47
|
+
MySubject.default_locks.detect { |l| l.action == :read }.outcome.must_equal false
|
|
48
|
+
end
|
|
49
|
+
end
|
|
50
|
+
end
|
|
38
51
|
end
|
|
39
52
|
|
|
40
53
|
it 'replaces existing locks with new one' do
|
|
41
|
-
MySubject.
|
|
54
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
55
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
56
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
57
|
+
MySubject.default_lock MyLock1, :read, false
|
|
58
|
+
MySubject1.default_lock MyLock, :read, true
|
|
59
|
+
|
|
60
|
+
MySubject.default_locks.detect { |l| l.action == :read }.class.must_equal MyLock1
|
|
61
|
+
end
|
|
62
|
+
end
|
|
63
|
+
end
|
|
42
64
|
end
|
|
43
65
|
|
|
44
66
|
it 'replaces superclass locks' do
|
|
45
|
-
|
|
46
|
-
|
|
67
|
+
MySubject.stub :default_locks, my_subject_default_locks do
|
|
68
|
+
MySubject1.stub :default_locks, my_subject_1_default_locks do
|
|
69
|
+
MySubject2.stub :default_locks, my_subject_2_default_locks do
|
|
70
|
+
MySubject.default_lock MyLock1, :read, false
|
|
71
|
+
MySubject1.default_lock MyLock, :read, true
|
|
72
|
+
|
|
73
|
+
MySubject1.default_locks.count.must_equal 1
|
|
74
|
+
MySubject1.default_locks.detect { |l| l.action == :read }.outcome.must_equal true
|
|
75
|
+
end
|
|
76
|
+
end
|
|
77
|
+
end
|
|
47
78
|
end
|
|
48
79
|
end
|
|
49
80
|
|