← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/logger/logger_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/worker/logger/logger_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package logger_test
 
5
 
 
6
import (
 
7
        "time"
 
8
 
 
9
        "github.com/juju/loggo"
 
10
        jc "github.com/juju/testing/checkers"
 
11
        gc "gopkg.in/check.v1"
 
12
        "gopkg.in/juju/names.v2"
 
13
 
 
14
        "github.com/juju/juju/agent"
 
15
        apilogger "github.com/juju/juju/api/logger"
 
16
        "github.com/juju/juju/juju/testing"
 
17
        "github.com/juju/juju/state"
 
18
        "github.com/juju/juju/worker"
 
19
        "github.com/juju/juju/worker/logger"
 
20
)
 
21
 
 
22
// worstCase is used for timeouts when timing out
 
23
// will fail the test. Raising this value should
 
24
// not affect the overall running time of the tests
 
25
// unless they fail.
 
26
const worstCase = 5 * time.Second
 
27
 
 
28
type LoggerSuite struct {
 
29
        testing.JujuConnSuite
 
30
 
 
31
        loggerApi *apilogger.State
 
32
        machine   *state.Machine
 
33
}
 
34
 
 
35
var _ = gc.Suite(&LoggerSuite{})
 
36
 
 
37
func (s *LoggerSuite) SetUpTest(c *gc.C) {
 
38
        s.JujuConnSuite.SetUpTest(c)
 
39
        apiConn, machine := s.OpenAPIAsNewMachine(c)
 
40
        // Create the machiner API facade.
 
41
        s.loggerApi = apilogger.NewState(apiConn)
 
42
        c.Assert(s.loggerApi, gc.NotNil)
 
43
        s.machine = machine
 
44
}
 
45
 
 
46
func (s *LoggerSuite) waitLoggingInfo(c *gc.C, expected string) {
 
47
        timeout := time.After(worstCase)
 
48
        for {
 
49
                select {
 
50
                case <-timeout:
 
51
                        c.Fatalf("timeout while waiting for logging info to change")
 
52
                case <-time.After(10 * time.Millisecond):
 
53
                        loggerInfo := loggo.LoggerInfo()
 
54
                        if loggerInfo != expected {
 
55
                                c.Logf("logging is %q, still waiting", loggerInfo)
 
56
                                continue
 
57
                        }
 
58
                        return
 
59
                }
 
60
        }
 
61
}
 
62
 
 
63
type mockConfig struct {
 
64
        agent.Config
 
65
        c   *gc.C
 
66
        tag names.Tag
 
67
}
 
68
 
 
69
func (mock *mockConfig) Tag() names.Tag {
 
70
        return mock.tag
 
71
}
 
72
 
 
73
func agentConfig(c *gc.C, tag names.Tag) *mockConfig {
 
74
        return &mockConfig{c: c, tag: tag}
 
75
}
 
76
 
 
77
func (s *LoggerSuite) makeLogger(c *gc.C) (worker.Worker, *mockConfig) {
 
78
        config := agentConfig(c, s.machine.Tag())
 
79
        w, err := logger.NewLogger(s.loggerApi, config)
 
80
        c.Assert(err, jc.ErrorIsNil)
 
81
        return w, config
 
82
}
 
83
 
 
84
func (s *LoggerSuite) TestRunStop(c *gc.C) {
 
85
        loggingWorker, _ := s.makeLogger(c)
 
86
        c.Assert(worker.Stop(loggingWorker), gc.IsNil)
 
87
}
 
88
 
 
89
func (s *LoggerSuite) TestInitialState(c *gc.C) {
 
90
        config, err := s.State.ModelConfig()
 
91
        c.Assert(err, jc.ErrorIsNil)
 
92
        expected := config.LoggingConfig()
 
93
 
 
94
        initial := "<root>=DEBUG;wibble=ERROR"
 
95
        c.Assert(expected, gc.Not(gc.Equals), initial)
 
96
 
 
97
        loggo.DefaultContext().ResetLoggerLevels()
 
98
        err = loggo.ConfigureLoggers(initial)
 
99
        c.Assert(err, jc.ErrorIsNil)
 
100
 
 
101
        loggingWorker, _ := s.makeLogger(c)
 
102
        defer worker.Stop(loggingWorker)
 
103
 
 
104
        s.waitLoggingInfo(c, expected)
 
105
}