← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-proposed

« back to all changes in this revision

Viewing changes to src/launchpad.net/loggo/writer_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/loggo/writer_test.go
 
1
package loggo_test
 
2
 
 
3
import (
 
4
        "fmt"
 
5
        "time"
 
6
 
 
7
        . "launchpad.net/gocheck"
 
8
        "launchpad.net/loggo"
 
9
)
 
10
 
 
11
type writerBasicsSuite struct{}
 
12
 
 
13
var _ = Suite(&writerBasicsSuite{})
 
14
 
 
15
func (s *writerBasicsSuite) TearDownTest(c *C) {
 
16
        loggo.ResetWriters()
 
17
}
 
18
 
 
19
func (*writerBasicsSuite) TestRemoveDefaultWriter(c *C) {
 
20
        defaultWriter, level, err := loggo.RemoveWriter("default")
 
21
        c.Assert(err, IsNil)
 
22
        c.Assert(level, Equals, loggo.TRACE)
 
23
        c.Assert(defaultWriter, Not(IsNil))
 
24
 
 
25
        // Trying again fails.
 
26
        defaultWriter, level, err = loggo.RemoveWriter("default")
 
27
        c.Assert(err, ErrorMatches, `Writer "default" is not registered`)
 
28
        c.Assert(level, Equals, loggo.UNSPECIFIED)
 
29
        c.Assert(defaultWriter, IsNil)
 
30
}
 
31
 
 
32
func (*writerBasicsSuite) TestRegisterWriterExistingName(c *C) {
 
33
        err := loggo.RegisterWriter("default", &loggo.TestWriter{}, loggo.INFO)
 
34
        c.Assert(err, ErrorMatches, `there is already a Writer registered with the name "default"`)
 
35
}
 
36
 
 
37
func (*writerBasicsSuite) TestRegisterNilWriter(c *C) {
 
38
        err := loggo.RegisterWriter("nil", nil, loggo.INFO)
 
39
        c.Assert(err, ErrorMatches, `Writer cannot be nil`)
 
40
}
 
41
 
 
42
func (*writerBasicsSuite) TestRegisterWriterTypedNil(c *C) {
 
43
        // If the interface is a typed nil, we have to trust the user.
 
44
        var writer *loggo.TestWriter
 
45
        err := loggo.RegisterWriter("nil", writer, loggo.INFO)
 
46
        c.Assert(err, IsNil)
 
47
}
 
48
 
 
49
func (*writerBasicsSuite) TestReplaceDefaultWriter(c *C) {
 
50
        oldWriter, err := loggo.ReplaceDefaultWriter(&loggo.TestWriter{})
 
51
        c.Assert(oldWriter, NotNil)
 
52
        c.Assert(err, IsNil)
 
53
}
 
54
 
 
55
func (*writerBasicsSuite) TestReplaceDefaultWriterWithNil(c *C) {
 
56
        oldWriter, err := loggo.ReplaceDefaultWriter(nil)
 
57
        c.Assert(oldWriter, IsNil)
 
58
        c.Assert(err, ErrorMatches, "Writer cannot be nil")
 
59
}
 
60
 
 
61
func (*writerBasicsSuite) TestReplaceDefaultWriterNoDefault(c *C) {
 
62
        loggo.RemoveWriter("default")
 
63
        oldWriter, err := loggo.ReplaceDefaultWriter(&loggo.TestWriter{})
 
64
        c.Assert(oldWriter, IsNil)
 
65
        c.Assert(err, ErrorMatches, `there is no "default" writer`)
 
66
}
 
67
 
 
68
func (s *writerBasicsSuite) TestWillWrite(c *C) {
 
69
        // By default, the root logger watches TRACE messages
 
70
        c.Assert(loggo.WillWrite(loggo.TRACE), Equals, true)
 
71
        // Note: ReplaceDefaultWriter doesn't let us change the default log
 
72
        //       level :(
 
73
        writer, _, err := loggo.RemoveWriter("default")
 
74
        c.Assert(err, IsNil)
 
75
        c.Assert(writer, NotNil)
 
76
        err = loggo.RegisterWriter("default", writer, loggo.CRITICAL)
 
77
        c.Assert(err, IsNil)
 
78
        c.Assert(loggo.WillWrite(loggo.TRACE), Equals, false)
 
79
        c.Assert(loggo.WillWrite(loggo.DEBUG), Equals, false)
 
80
        c.Assert(loggo.WillWrite(loggo.INFO), Equals, false)
 
81
        c.Assert(loggo.WillWrite(loggo.WARNING), Equals, false)
 
82
        c.Assert(loggo.WillWrite(loggo.CRITICAL), Equals, true)
 
83
}
 
84
 
 
85
type writerSuite struct {
 
86
        logger loggo.Logger
 
87
}
 
88
 
 
89
var _ = Suite(&writerSuite{})
 
90
 
 
91
func (s *writerSuite) SetUpTest(c *C) {
 
92
        loggo.ResetLoggers()
 
93
        loggo.RemoveWriter("default")
 
94
        s.logger = loggo.GetLogger("test.writer")
 
95
        // Make it so the logger itself writes all messages.
 
96
        s.logger.SetLogLevel(loggo.TRACE)
 
97
}
 
98
 
 
99
func (s *writerSuite) TearDownTest(c *C) {
 
100
        loggo.ResetWriters()
 
101
}
 
102
 
 
103
func (s *writerSuite) TearDownSuite(c *C) {
 
104
        loggo.ResetLoggers()
 
105
}
 
106
 
 
107
func (s *writerSuite) TestWritingCapturesFileAndLineAndModule(c *C) {
 
108
        writer := &loggo.TestWriter{}
 
109
        err := loggo.RegisterWriter("test", writer, loggo.INFO)
 
110
        c.Assert(err, IsNil)
 
111
 
 
112
        s.logger.Infof("Info message")
 
113
 
 
114
        // WARNING: test checks the line number of the above logger lines, this
 
115
        // will mean that if the above line moves, the test will fail unless
 
116
        // updated.
 
117
        c.Assert(writer.Log, HasLen, 1)
 
118
        c.Assert(writer.Log[0].Filename, Equals, "writer_test.go")
 
119
        c.Assert(writer.Log[0].Line, Equals, 112)
 
120
        c.Assert(writer.Log[0].Module, Equals, "test.writer")
 
121
}
 
122
 
 
123
func (s *writerSuite) TestWritingLimitWarning(c *C) {
 
124
        writer := &loggo.TestWriter{}
 
125
        err := loggo.RegisterWriter("test", writer, loggo.WARNING)
 
126
        c.Assert(err, IsNil)
 
127
 
 
128
        start := time.Now()
 
129
        s.logger.Criticalf("Something critical.")
 
130
        s.logger.Errorf("An error.")
 
131
        s.logger.Warningf("A warning message")
 
132
        s.logger.Infof("Info message")
 
133
        s.logger.Tracef("Trace the function")
 
134
        end := time.Now()
 
135
 
 
136
        c.Assert(writer.Log, HasLen, 3)
 
137
        c.Assert(writer.Log[0].Level, Equals, loggo.CRITICAL)
 
138
        c.Assert(writer.Log[0].Message, Equals, "Something critical.")
 
139
        c.Assert(writer.Log[0].Timestamp, Between(start, end))
 
140
 
 
141
        c.Assert(writer.Log[1].Level, Equals, loggo.ERROR)
 
142
        c.Assert(writer.Log[1].Message, Equals, "An error.")
 
143
        c.Assert(writer.Log[1].Timestamp, Between(start, end))
 
144
 
 
145
        c.Assert(writer.Log[2].Level, Equals, loggo.WARNING)
 
146
        c.Assert(writer.Log[2].Message, Equals, "A warning message")
 
147
        c.Assert(writer.Log[2].Timestamp, Between(start, end))
 
148
}
 
149
 
 
150
func (s *writerSuite) TestWritingLimitTrace(c *C) {
 
151
        writer := &loggo.TestWriter{}
 
152
        err := loggo.RegisterWriter("test", writer, loggo.TRACE)
 
153
        c.Assert(err, IsNil)
 
154
 
 
155
        start := time.Now()
 
156
        s.logger.Criticalf("Something critical.")
 
157
        s.logger.Errorf("An error.")
 
158
        s.logger.Warningf("A warning message")
 
159
        s.logger.Infof("Info message")
 
160
        s.logger.Tracef("Trace the function")
 
161
        end := time.Now()
 
162
 
 
163
        c.Assert(writer.Log, HasLen, 5)
 
164
        c.Assert(writer.Log[0].Level, Equals, loggo.CRITICAL)
 
165
        c.Assert(writer.Log[0].Message, Equals, "Something critical.")
 
166
        c.Assert(writer.Log[0].Timestamp, Between(start, end))
 
167
 
 
168
        c.Assert(writer.Log[1].Level, Equals, loggo.ERROR)
 
169
        c.Assert(writer.Log[1].Message, Equals, "An error.")
 
170
        c.Assert(writer.Log[1].Timestamp, Between(start, end))
 
171
 
 
172
        c.Assert(writer.Log[2].Level, Equals, loggo.WARNING)
 
173
        c.Assert(writer.Log[2].Message, Equals, "A warning message")
 
174
        c.Assert(writer.Log[2].Timestamp, Between(start, end))
 
175
 
 
176
        c.Assert(writer.Log[3].Level, Equals, loggo.INFO)
 
177
        c.Assert(writer.Log[3].Message, Equals, "Info message")
 
178
        c.Assert(writer.Log[3].Timestamp, Between(start, end))
 
179
 
 
180
        c.Assert(writer.Log[4].Level, Equals, loggo.TRACE)
 
181
        c.Assert(writer.Log[4].Message, Equals, "Trace the function")
 
182
        c.Assert(writer.Log[4].Timestamp, Between(start, end))
 
183
}
 
184
 
 
185
func (s *writerSuite) TestMultipleWriters(c *C) {
 
186
        errorWriter := &loggo.TestWriter{}
 
187
        err := loggo.RegisterWriter("error", errorWriter, loggo.ERROR)
 
188
        c.Assert(err, IsNil)
 
189
        warningWriter := &loggo.TestWriter{}
 
190
        err = loggo.RegisterWriter("warning", warningWriter, loggo.WARNING)
 
191
        c.Assert(err, IsNil)
 
192
        infoWriter := &loggo.TestWriter{}
 
193
        err = loggo.RegisterWriter("info", infoWriter, loggo.INFO)
 
194
        c.Assert(err, IsNil)
 
195
        traceWriter := &loggo.TestWriter{}
 
196
        err = loggo.RegisterWriter("trace", traceWriter, loggo.TRACE)
 
197
        c.Assert(err, IsNil)
 
198
 
 
199
        s.logger.Errorf("An error.")
 
200
        s.logger.Warningf("A warning message")
 
201
        s.logger.Infof("Info message")
 
202
        s.logger.Tracef("Trace the function")
 
203
 
 
204
        c.Assert(errorWriter.Log, HasLen, 1)
 
205
        c.Assert(warningWriter.Log, HasLen, 2)
 
206
        c.Assert(infoWriter.Log, HasLen, 3)
 
207
        c.Assert(traceWriter.Log, HasLen, 4)
 
208
}
 
209
 
 
210
func Between(start, end time.Time) Checker {
 
211
        if end.Before(start) {
 
212
                return &betweenChecker{end, start}
 
213
        }
 
214
        return &betweenChecker{start, end}
 
215
}
 
216
 
 
217
type betweenChecker struct {
 
218
        start, end time.Time
 
219
}
 
220
 
 
221
func (checker *betweenChecker) Info() *CheckerInfo {
 
222
        info := CheckerInfo{
 
223
                Name:   "Between",
 
224
                Params: []string{"obtained"},
 
225
        }
 
226
        return &info
 
227
}
 
228
 
 
229
func (checker *betweenChecker) Check(params []interface{}, names []string) (result bool, error string) {
 
230
        when, ok := params[0].(time.Time)
 
231
        if !ok {
 
232
                return false, "obtained value type must be time.Time"
 
233
        }
 
234
        if when.Before(checker.start) {
 
235
                return false, fmt.Sprintf("obtained value %#v type must before start value of %#v", when, checker.start)
 
236
        }
 
237
        if when.After(checker.end) {
 
238
                return false, fmt.Sprintf("obtained value %#v type must after end value of %#v", when, checker.end)
 
239
        }
 
240
        return true, ""
 
241
}