berater 0.6.0 → 0.8.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.
@@ -1,35 +1,20 @@
1
- describe Berater::TestMode, order: :defined do
2
- let(:reset_test_mode) { true }
3
-
4
- after do
5
- Berater.test_mode = nil if reset_test_mode
6
- end
7
-
8
- context 'after test_mode.rb was required, but not used' do
9
- let(:reset_test_mode) { false }
10
-
11
- it 'has already been loaded by "berater/rspec", unfortunately' do
12
- expect {
13
- expect { Berater.test_mode }.to raise_error(NoMethodError)
14
- }.to fail
1
+ describe Berater::TestMode do
2
+ context 'after test_mode.rb has been loaded' do
3
+ it 'monkey patches Berater' do
4
+ expect(Berater).to respond_to(:test_mode)
15
5
  end
16
6
 
17
7
  it 'defaults to off' do
18
8
  expect(Berater.test_mode).to be nil
19
9
  end
20
10
 
21
- it 'did not prepend .new yet' do
22
- expect(Berater::Limiter.singleton_class.ancestors).not_to include(described_class)
23
- end
24
-
25
- it 'prepends when first turned on' do
26
- Berater.test_mode = :pass
27
-
28
- expect(Berater::Limiter.singleton_class.ancestors).to include(described_class)
11
+ it 'prepends Limiter subclasses' do
12
+ expect(Berater::Unlimiter.ancestors).to include(Berater::Limiter::TestMode)
13
+ expect(Berater::Inhibitor.ancestors).to include(Berater::Limiter::TestMode)
29
14
  end
30
15
 
31
16
  it 'preserves the original functionality via super' do
32
- expect { Berater::Limiter.new }.to raise_error(NotImplementedError)
17
+ expect { Berater::Limiter.new }.to raise_error(NoMethodError)
33
18
  end
34
19
  end
35
20
 
@@ -50,31 +35,53 @@ describe Berater::TestMode, order: :defined do
50
35
  it 'validates input' do
51
36
  expect { Berater.test_mode = :foo }.to raise_error(ArgumentError)
52
37
  end
53
- end
54
38
 
55
- shared_examples 'it always works, without redis' do
56
- before do
57
- Berater.redis = nil
58
- expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
39
+ it 'works no matter when limiter was created' do
40
+ limiter = Berater::Unlimiter.new
41
+ expect(limiter).not_to be_overloaded
42
+
43
+ Berater.test_mode = :fail
44
+ expect(limiter).to be_overloaded
45
+ end
46
+
47
+ it 'supports a generic expectation' do
48
+ Berater.test_mode = :pass
49
+ expect_any_instance_of(Berater::Limiter).to receive(:limit)
50
+ Berater::Unlimiter.new.limit
59
51
  end
52
+ end
60
53
 
61
- it_behaves_like 'it is not overloaded'
54
+ describe '.reset' do
55
+ before { Berater.test_mode = :pass }
62
56
 
63
- it 'always works' do
64
- 10.times { subject.limit }
57
+ it 'resets test_mode' do
58
+ expect(Berater.test_mode).to be :pass
59
+ Berater.reset
60
+ expect(Berater.test_mode).to be nil
65
61
  end
66
62
  end
67
63
 
68
- shared_examples 'it never works, without redis' do
64
+ shared_examples 'it supports test_mode' do
69
65
  before do
66
+ # without hitting Redis
70
67
  Berater.redis = nil
71
68
  expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
72
69
  end
73
70
 
74
- it_behaves_like 'it is overloaded'
71
+ context 'with test_mode = :pass' do
72
+ before { Berater.test_mode = :pass }
73
+
74
+ it_behaves_like 'it is not overloaded'
75
+
76
+ it 'always works' do
77
+ 10.times { subject.limit }
78
+ end
79
+ end
80
+
81
+ context 'with test_mode = :fail' do
82
+ before { Berater.test_mode = :fail }
75
83
 
76
- it 'never works' do
77
- expect { subject }.to be_overloaded
84
+ it_behaves_like 'it is overloaded'
78
85
  end
79
86
  end
80
87
 
@@ -84,23 +91,10 @@ describe Berater::TestMode, order: :defined do
84
91
  context 'when test_mode = nil' do
85
92
  before { Berater.test_mode = nil }
86
93
 
87
- it { is_expected.to be_a Berater::Unlimiter }
88
- it_behaves_like 'it always works, without redis'
89
- end
90
-
91
- context 'when test_mode = :pass' do
92
- before { Berater.test_mode = :pass }
93
-
94
- it { is_expected.to be_a Berater::Unlimiter }
95
- it_behaves_like 'it always works, without redis'
94
+ it_behaves_like 'it is not overloaded'
96
95
  end
97
96
 
98
- context 'when test_mode = :fail' do
99
- before { Berater.test_mode = :fail }
100
-
101
- it { is_expected.to be_a Berater::Unlimiter }
102
- it_behaves_like 'it never works, without redis'
103
- end
97
+ it_behaves_like 'it supports test_mode'
104
98
  end
105
99
 
106
100
  describe 'Inhibitor' do
@@ -109,42 +103,18 @@ describe Berater::TestMode, order: :defined do
109
103
  context 'when test_mode = nil' do
110
104
  before { Berater.test_mode = nil }
111
105
 
112
- it { is_expected.to be_a Berater::Inhibitor }
113
- it_behaves_like 'it never works, without redis'
114
- end
115
-
116
- context 'when test_mode = :pass' do
117
- before { Berater.test_mode = :pass }
118
-
119
- it { is_expected.to be_a Berater::Inhibitor }
120
- it_behaves_like 'it always works, without redis'
106
+ it_behaves_like 'it is overloaded'
121
107
  end
122
108
 
123
- context 'when test_mode = :fail' do
124
- before { Berater.test_mode = :fail }
125
-
126
- it { is_expected.to be_a Berater::Inhibitor }
127
- it_behaves_like 'it never works, without redis'
128
- end
109
+ it_behaves_like 'it supports test_mode'
129
110
  end
130
111
 
131
112
  describe 'RateLimiter' do
132
113
  subject { Berater::RateLimiter.new(:key, 1, :second) }
133
114
 
134
- shared_examples 'a RateLimiter' do
135
- it { is_expected.to be_a Berater::RateLimiter }
136
-
137
- it 'checks arguments' do
138
- expect {
139
- Berater::RateLimiter.new(:key, 1)
140
- }.to raise_error(ArgumentError)
141
- end
142
- end
143
-
144
115
  context 'when test_mode = nil' do
145
116
  before { Berater.test_mode = nil }
146
117
 
147
- it_behaves_like 'a RateLimiter'
148
118
  it_behaves_like 'it is not overloaded'
149
119
 
150
120
  it 'works per usual' do
@@ -154,19 +124,7 @@ describe Berater::TestMode, order: :defined do
154
124
  end
155
125
  end
156
126
 
157
- context 'when test_mode = :pass' do
158
- before { Berater.test_mode = :pass }
159
-
160
- it_behaves_like 'a RateLimiter'
161
- it_behaves_like 'it always works, without redis'
162
- end
163
-
164
- context 'when test_mode = :fail' do
165
- before { Berater.test_mode = :fail }
166
-
167
- it_behaves_like 'a RateLimiter'
168
- it_behaves_like 'it never works, without redis'
169
- end
127
+ it_behaves_like 'it supports test_mode'
170
128
  end
171
129
 
172
130
  describe 'ConcurrencyLimiter' do
@@ -175,8 +133,6 @@ describe Berater::TestMode, order: :defined do
175
133
  context 'when test_mode = nil' do
176
134
  before { Berater.test_mode = nil }
177
135
 
178
- it { is_expected.to be_a Berater::ConcurrencyLimiter }
179
-
180
136
  it_behaves_like 'it is not overloaded'
181
137
 
182
138
  it 'works per usual' do
@@ -186,21 +142,7 @@ describe Berater::TestMode, order: :defined do
186
142
  end
187
143
  end
188
144
 
189
- context 'when test_mode = :pass' do
190
- before { Berater.test_mode = :pass }
191
-
192
- it { is_expected.to be_a Berater::ConcurrencyLimiter }
193
-
194
- it_behaves_like 'it always works, without redis'
195
- end
196
-
197
- context 'when test_mode = :fail' do
198
- before { Berater.test_mode = :fail }
199
-
200
- it { is_expected.to be_a Berater::ConcurrencyLimiter }
201
-
202
- it_behaves_like 'it never works, without redis'
203
- end
145
+ it_behaves_like 'it supports test_mode'
204
146
  end
205
147
 
206
148
  end
@@ -1,9 +1,11 @@
1
1
  describe Berater::Unlimiter do
2
+ subject { described_class.new }
3
+
2
4
  it_behaves_like 'a limiter', described_class.new
3
5
 
4
6
  describe '.new' do
5
7
  it 'initializes without any arguments or options' do
6
- expect(described_class.new).to be_a described_class
8
+ is_expected.to be_a described_class
7
9
  end
8
10
 
9
11
  it 'initializes with any arguments and options' do
@@ -11,14 +13,12 @@ describe Berater::Unlimiter do
11
13
  end
12
14
 
13
15
  it 'has default values' do
14
- expect(described_class.new.key).to be :unlimiter
15
- expect(described_class.new.redis).to be Berater.redis
16
+ expect(subject.key).to be :unlimiter
17
+ expect(subject.redis).to be Berater.redis
16
18
  end
17
19
  end
18
20
 
19
21
  describe '#limit' do
20
- subject { described_class.new }
21
-
22
22
  it_behaves_like 'it is not overloaded'
23
23
 
24
24
  it 'is never overloaded' do
@@ -27,4 +27,10 @@ describe Berater::Unlimiter do
27
27
  end
28
28
  end
29
29
  end
30
+
31
+ describe '#to_s' do
32
+ it do
33
+ expect(subject.to_s).to include described_class.to_s
34
+ end
35
+ end
30
36
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: berater
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.6.0
4
+ version: 0.8.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Daniel Pepper
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2021-03-07 00:00:00.000000000 Z
11
+ date: 2021-03-22 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: redis
@@ -138,6 +138,7 @@ files:
138
138
  - lib/berater/rate_limiter.rb
139
139
  - lib/berater/rspec.rb
140
140
  - lib/berater/rspec/matchers.rb
141
+ - lib/berater/static_limiter.rb
141
142
  - lib/berater/test_mode.rb
142
143
  - lib/berater/unlimiter.rb
143
144
  - lib/berater/utils.rb
@@ -152,6 +153,7 @@ files:
152
153
  - spec/matchers_spec.rb
153
154
  - spec/rate_limiter_spec.rb
154
155
  - spec/riddle_spec.rb
156
+ - spec/static_limiter_spec.rb
155
157
  - spec/test_mode_spec.rb
156
158
  - spec/unlimiter_spec.rb
157
159
  - spec/utils_spec.rb
@@ -190,5 +192,6 @@ test_files:
190
192
  - spec/utils_spec.rb
191
193
  - spec/berater_spec.rb
192
194
  - spec/limiter_spec.rb
195
+ - spec/static_limiter_spec.rb
193
196
  - spec/inhibitor_spec.rb
194
197
  - spec/unlimiter_spec.rb