yell 2.2.0 → 2.2.1

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,21 +0,0 @@
1
- require 'spec_helper'
2
-
3
- class LoggableFactory
4
- include Yell::Loggable
5
- end
6
-
7
- describe Yell::Loggable do
8
- let(:factory) { LoggableFactory.new }
9
-
10
- it "responds with logger" do
11
- expect(factory).to respond_to(:logger)
12
- end
13
-
14
- it "should make a lookup in the Yell::Repository" do
15
- expect(Yell::Repository).to(
16
- receive(:[]).with(LoggableFactory)
17
- )
18
-
19
- factory.logger
20
- end
21
- end
@@ -1,290 +0,0 @@
1
- require 'spec_helper'
2
-
3
- class LoggerFactory
4
- attr_accessor :logger
5
-
6
- def info
7
- logger.info :foo
8
- end
9
-
10
- def add
11
- logger.add 1, :bar
12
- end
13
- end
14
-
15
- describe Yell::Logger do
16
- let(:filename) { fixture_path + '/logger.log' }
17
-
18
- describe "a Logger instance" do
19
- let(:logger) { Yell::Logger.new }
20
- subject { logger }
21
-
22
- context "log methods" do
23
- it { should respond_to(:debug) }
24
- it { should respond_to(:debug?) }
25
-
26
- it { should respond_to(:info) }
27
- it { should respond_to(:info?) }
28
-
29
- it { should respond_to(:warn) }
30
- it { should respond_to(:warn?) }
31
-
32
- it { should respond_to(:error) }
33
- it { should respond_to(:error?) }
34
-
35
- it { should respond_to(:fatal) }
36
- it { should respond_to(:fatal?) }
37
-
38
- it { should respond_to(:unknown) }
39
- it { should respond_to(:unknown?) }
40
- end
41
-
42
- context "default #name" do
43
- its(:name) { should eq("<Yell::Logger##{logger.object_id}>") }
44
-
45
- it "should not be added to the repository" do
46
- expect { Yell::Repository[logger.name] }.to raise_error(Yell::LoggerNotFound)
47
- end
48
- end
49
-
50
- context "default #adapter" do
51
- subject { logger.adapters.instance_variable_get(:@collection) }
52
-
53
- its(:size) { should == 1 }
54
- its(:first) { should be_kind_of(Yell::Adapters::File) }
55
- end
56
-
57
- context "default #level" do
58
- subject { logger.level }
59
-
60
- it { should be_instance_of(Yell::Level) }
61
- its(:severities) { should eq([true, true, true, true, true, true]) }
62
- end
63
-
64
- context "default #trace" do
65
- subject { logger.trace }
66
-
67
- it { should be_instance_of(Yell::Level) }
68
- its(:severities) { should eq([false, false, false, true, true, true]) } # from error onwards
69
- end
70
- end
71
-
72
- describe "initialize with #name" do
73
- let(:name) { 'test' }
74
- let!(:logger) { Yell.new(name: name) }
75
-
76
- it "should set the name correctly" do
77
- expect(logger.name).to eq(name)
78
- end
79
-
80
- it "should be added to the repository" do
81
- expect(Yell::Repository[name]).to eq(logger)
82
- end
83
- end
84
-
85
- context "initialize with #level" do
86
- let(:level) { :error }
87
- let(:logger) { Yell.new(level: level) }
88
- subject { logger.level }
89
-
90
- it { should be_instance_of(Yell::Level) }
91
- its(:severities) { should eq([false, false, false, true, true, true]) }
92
- end
93
-
94
- context "initialize with #trace" do
95
- let(:trace) { :info }
96
- let(:logger) { Yell.new(trace: trace) }
97
- subject { logger.trace }
98
-
99
- it { should be_instance_of(Yell::Level) }
100
- its(:severities) { should eq([false, true, true, true, true, true]) }
101
- end
102
-
103
- context "initialize with #silence" do
104
- let(:silence) { "test" }
105
- let(:logger) { Yell.new(silence: silence) }
106
- subject { logger.silencer }
107
-
108
- it { should be_instance_of(Yell::Silencer) }
109
- its(:patterns) { should eq([silence]) }
110
- end
111
-
112
- context "initialize with a #filename" do
113
- it "should call adapter with :file" do
114
- expect(Yell::Adapters::File).to(
115
- receive(:new).with(filename: filename).and_call_original
116
- )
117
-
118
- Yell::Logger.new(filename)
119
- end
120
- end
121
-
122
- context "initialize with a #filename of Pathname type" do
123
- let(:pathname) { Pathname.new(filename) }
124
-
125
- it "should call adapter with :file" do
126
- expect(Yell::Adapters::File).to(
127
- receive(:new).with(filename: pathname).and_call_original
128
- )
129
-
130
- Yell::Logger.new(pathname)
131
- end
132
- end
133
-
134
- context "initialize with a :stdout adapter" do
135
- before do
136
- expect(Yell::Adapters::Stdout).to receive(:new)
137
- end
138
-
139
- it "should call adapter with STDOUT" do
140
- Yell::Logger.new(STDOUT)
141
- end
142
-
143
- it "should call adapter with :stdout" do
144
- Yell::Logger.new(:stdout)
145
- end
146
- end
147
-
148
- context "initialize with a :stderr adapter" do
149
- before do
150
- expect(Yell::Adapters::Stderr).to receive(:new)
151
- end
152
-
153
- it "should call adapter with STDERR" do
154
- Yell::Logger.new(STDERR)
155
- end
156
-
157
- it "should call adapter with :stderr" do
158
- Yell::Logger.new(:stderr)
159
- end
160
- end
161
-
162
- context "initialize with a block" do
163
- let(:level) { Yell::Level.new :error }
164
- let(:adapters) { logger.adapters.instance_variable_get(:@collection) }
165
-
166
- context "with arity" do
167
- let(:logger) do
168
- Yell::Logger.new(level: level) { |l| l.adapter(:stdout) }
169
- end
170
-
171
- it "should pass the level correctly" do
172
- expect(logger.level).to eq(level)
173
- end
174
-
175
- it "should pass the adapter correctly" do
176
- expect(adapters.first).to be_instance_of(Yell::Adapters::Stdout)
177
- end
178
- end
179
-
180
- context "without arity" do
181
- let(:logger) do
182
- Yell::Logger.new(level: level) { adapter(:stdout) }
183
- end
184
-
185
- it "should pass the level correctly" do
186
- expect(logger.level).to eq(level)
187
- end
188
-
189
- it "should pass the adapter correctly" do
190
- expect(adapters.first).to be_instance_of(Yell::Adapters::Stdout)
191
- end
192
- end
193
- end
194
-
195
- context "initialize with #adapters option" do
196
- it "should set adapters in logger correctly" do
197
- expect(Yell::Adapters::Stdout).to(
198
- receive(:new).
199
- and_call_original
200
- )
201
- expect(Yell::Adapters::Stderr).to(
202
- receive(:new).
203
- with(hash_including(level: :error)).
204
- and_call_original
205
- )
206
-
207
- Yell::Logger.new(
208
- adapters: [
209
- :stdout,
210
- {stderr: {level: :error}}
211
- ]
212
- )
213
- end
214
- end
215
-
216
- context "caller's :file, :line and :method" do
217
- let(:stdout) { Yell::Adapters::Stdout.new(format: "%F, %n: %M") }
218
- let(:logger) { Yell::Logger.new(trace: true) { |l| l.adapter(stdout) } }
219
-
220
- it "should write correctly" do
221
- factory = LoggerFactory.new
222
- factory.logger = logger
223
-
224
- expect(stdout.send(:stream)).to(
225
- receive(:syswrite).with("#{__FILE__}, 7: info\n")
226
- )
227
- expect(stdout.send(:stream)).to(
228
- receive(:syswrite).with("#{__FILE__}, 11: add\n")
229
- )
230
-
231
- factory.info
232
- factory.add
233
- end
234
- end
235
-
236
- context "logging in general" do
237
- let(:logger) { Yell::Logger.new(filename, format: "%m") }
238
- let(:line) { File.open(filename, &:readline) }
239
-
240
- it "should output a single message" do
241
- logger.info "Hello World"
242
-
243
- expect(line).to eq("Hello World\n")
244
- end
245
-
246
- it "should output multiple messages" do
247
- # logger.info ["Hello", "W", "o", "r", "l", "d"]
248
- logger.info %w[Hello W o r l d]
249
- expect(line).to eq("Hello W o r l d\n")
250
- end
251
-
252
- it "should output a hash and message" do
253
- logger.info ["Hello World", {test: :message}]
254
-
255
- expect(line).to eq("Hello World test: message\n")
256
- end
257
-
258
- it "should output a hash and message" do
259
- logger.info [{test: :message}, "Hello World"]
260
-
261
- expect(line).to eq("test: message Hello World\n")
262
- end
263
-
264
- it "should output a hash and block" do
265
- logger.info(:test => :message) { "Hello World" }
266
-
267
- expect(line).to eq("test: message Hello World\n")
268
- end
269
- end
270
-
271
- context "logging with a silencer" do
272
- let(:silence) { "this" }
273
- let(:stdout) { Yell::Adapters::Stdout.new }
274
- let(:logger) { Yell::Logger.new(stdout, silence: silence) }
275
-
276
- it "should not pass a matching message to any adapter" do
277
- expect(stdout).to_not receive(:write)
278
-
279
- logger.info "this should not be logged"
280
- end
281
-
282
- it "should pass a non-matching message to any adapter" do
283
- expect(stdout).to receive(:write).with(kind_of(Yell::Event))
284
-
285
- logger.info "that should be logged"
286
- end
287
- end
288
-
289
- end
290
-
@@ -1,83 +0,0 @@
1
- require 'spec_helper'
2
-
3
- describe Yell::Repository do
4
- let(:name) { 'test' }
5
- let(:logger) { Yell.new(:stdout) }
6
-
7
- subject { Yell::Repository[name] }
8
-
9
- context ".[]" do
10
- it "should raise when not set" do
11
- expect { subject }.to raise_error(Yell::LoggerNotFound)
12
- end
13
-
14
- context "when logger with :name exists" do
15
- let!(:logger) { Yell.new(:stdout, name: name) }
16
-
17
- it "should eq(logger)" do
18
- expect(subject).to eq(logger)
19
- end
20
- end
21
-
22
- context "given a Class" do
23
- let!(:logger) { Yell.new(:stdout, name: "Numeric") }
24
-
25
- it "should raise with the correct :name when logger not found" do
26
- expect(Yell::LoggerNotFound).to(
27
- receive(:new).with(String).and_call_original
28
- )
29
-
30
- expect {
31
- Yell::Repository[String]
32
- }.to raise_error(Yell::LoggerNotFound)
33
- end
34
-
35
- it "should return the logger" do
36
- expect(Yell::Repository[Numeric]).to eq(logger)
37
- end
38
-
39
- it "should return the logger when superclass has it defined" do
40
- expect(Yell::Repository[Integer]).to eq(logger)
41
- end
42
- end
43
- end
44
-
45
- context ".[]=" do
46
- before { Yell::Repository[name] = logger }
47
- it "should eq(logger)" do
48
- expect(subject).to eq(logger)
49
- end
50
- end
51
-
52
- context ".[]= with a named logger" do
53
- let!(:logger) { Yell.new(:stdout, name: name) }
54
- before { Yell::Repository[name] = logger }
55
-
56
- it "should eq(logger)" do
57
- expect(subject).to eq(logger)
58
- end
59
- end
60
-
61
- context ".[]= with a named logger of a different name" do
62
- let(:other) { 'other' }
63
- let(:logger) { Yell.new(:stdout, name: other) }
64
- before { Yell::Repository[name] = logger }
65
-
66
- it "should add logger to both repositories" do
67
- expect(Yell::Repository[name]).to eq(logger)
68
- expect(Yell::Repository[other]).to eq(logger)
69
- end
70
- end
71
-
72
- context "loggers" do
73
- let(:loggers) { { name => logger } }
74
- subject { Yell::Repository.loggers }
75
- before { Yell::Repository[name] = logger }
76
-
77
- it "should eq(loggers)" do
78
- expect(subject).to eq(loggers)
79
- end
80
- end
81
-
82
- end
83
-
@@ -1,38 +0,0 @@
1
- require 'spec_helper'
2
-
3
- describe Yell::Silencer do
4
-
5
- context "initialize with #patterns" do
6
- subject { Yell::Silencer.new(/this/) }
7
-
8
- its(:patterns) { should eq([/this/]) }
9
- end
10
-
11
- context "#add" do
12
- let(:silencer) { Yell::Silencer.new }
13
-
14
- it "should add patterns" do
15
- silencer.add /this/, /that/
16
-
17
- expect(silencer.patterns).to eq([/this/, /that/])
18
- end
19
-
20
- it "should ignore duplicate patterns" do
21
- silencer.add /this/, /that/, /this/
22
-
23
- expect(silencer.patterns).to eq([/this/, /that/])
24
- end
25
- end
26
-
27
- context "#call" do
28
- let(:silencer) { Yell::Silencer.new(/this/) }
29
-
30
- it "should reject messages that match any pattern" do
31
- expect(silencer.call("this")).to eq([])
32
- expect(silencer.call("that")).to eq(["that"])
33
- expect(silencer.call("this", "that")).to eq(["that"])
34
- end
35
- end
36
-
37
- end
38
-
@@ -1,120 +0,0 @@
1
- require 'spec_helper'
2
-
3
- describe Yell do
4
- let( :logger ) { Yell.new }
5
-
6
- subject { logger }
7
-
8
- it "should be_kind_of Yell::Logger" do
9
- expect(subject).to be_a_kind_of(Yell::Logger)
10
- end
11
-
12
- it "should raise AdapterNotFound when adapter cant be loaded" do
13
- expect {
14
- Yell.new :unknownadapter
15
- }.to raise_error(Yell::AdapterNotFound)
16
- end
17
-
18
- context ".level" do
19
- subject { Yell.level }
20
- it "should be_kind_of Yell::Level" do
21
- expect(subject).to be_a_kind_of(Yell::Level)
22
- end
23
- end
24
-
25
- context ".format" do
26
- subject { Yell.format( "%m" ) }
27
- it "should be_kind_of Yell::Formatter" do
28
- expect(subject).to be_a_kind_of(Yell::Formatter)
29
- end
30
- end
31
-
32
- context ".load!" do
33
- subject { Yell.load!('yell.yml') }
34
-
35
- before do
36
- expect(Yell::Configuration).to(
37
- receive(:load!).with('yell.yml') { {} }
38
- )
39
- end
40
-
41
- it "should be_kind_of Yell::Logger" do
42
- expect(subject).to be_a_kind_of(Yell::Logger)
43
- end
44
- end
45
-
46
- context ".[]" do
47
- let(:name) { 'test' }
48
-
49
- it "should delegate to the repository" do
50
- expect(Yell::Repository).to receive(:[]).with(name)
51
-
52
- Yell[name]
53
- end
54
- end
55
-
56
- context ".[]=" do
57
- let(:name) { 'test' }
58
-
59
- it "should delegate to the repository" do
60
- expect(Yell::Repository).to(
61
- receive(:[]=).with(name, logger).and_call_original
62
- )
63
-
64
- Yell[name] = logger
65
- end
66
- end
67
-
68
- context ".env" do
69
- subject { Yell.env }
70
-
71
- it "should default to YELL_ENV" do
72
- expect(subject).to eq('test')
73
- end
74
-
75
- context "fallback to RACK_ENV" do
76
- before do
77
- expect(ENV).to receive(:key?).with('YELL_ENV') { false }
78
- expect(ENV).to receive(:key?).with('RACK_ENV') { true }
79
-
80
- ENV['RACK_ENV'] = 'rack'
81
- end
82
-
83
- after { ENV.delete 'RACK_ENV' }
84
-
85
- it "should == 'rack'" do
86
- expect(subject).to eq('rack')
87
- end
88
- end
89
-
90
- context "fallback to RAILS_ENV" do
91
- before do
92
- expect(ENV).to receive(:key?).with('YELL_ENV') { false }
93
- expect(ENV).to receive(:key?).with('RACK_ENV') { false }
94
- expect(ENV).to receive(:key?).with('RAILS_ENV') { true }
95
-
96
- ENV['RAILS_ENV'] = 'rails'
97
- end
98
-
99
- after { ENV.delete 'RAILS_ENV' }
100
-
101
- it "should == 'rails'" do
102
- expect(subject).to eq('rails')
103
- end
104
- end
105
-
106
- context "fallback to development" do
107
- before do
108
- expect(ENV).to receive(:key?).with('YELL_ENV') { false }
109
- expect(ENV).to receive(:key?).with('RACK_ENV') { false }
110
- expect(ENV).to receive(:key?).with('RAILS_ENV') { false }
111
- end
112
-
113
- it "should == 'development'" do
114
- expect(subject).to eq('development')
115
- end
116
- end
117
- end
118
-
119
- end
120
-