1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright 2012, 2013 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package testing
import (
"fmt"
gc "launchpad.net/gocheck"
"launchpad.net/juju-core/constraints"
"launchpad.net/juju-core/environs"
"launchpad.net/juju-core/environs/tools"
"launchpad.net/juju-core/instance"
"launchpad.net/juju-core/names"
"launchpad.net/juju-core/state"
"launchpad.net/juju-core/state/api"
"launchpad.net/juju-core/testing"
)
// FakeStateInfo holds information about no state - it will always
// give an error when connected to. The machine id gives the machine id
// of the machine to be started.
func FakeStateInfo(machineId string) *state.Info {
return &state.Info{
Addrs: []string{"0.1.2.3:1234"},
Tag: names.MachineTag(machineId),
Password: "unimportant",
CACert: []byte(testing.CACert),
}
}
// FakeAPIInfo holds information about no state - it will always
// give an error when connected to. The machine id gives the machine id
// of the machine to be started.
func FakeAPIInfo(machineId string) *api.Info {
return &api.Info{
Addrs: []string{"0.1.2.3:1234"},
Tag: names.MachineTag(machineId),
Password: "unimportant",
CACert: []byte(testing.CACert),
}
}
// AssertStartInstance is a test helper function that starts an instance with a
// plausible but invalid configuration, and checks that it succeeds.
func AssertStartInstance(
c *gc.C, env environs.Environ, machineId string,
) (
instance.Instance, *instance.HardwareCharacteristics,
) {
inst, hc, err := StartInstance(env, machineId)
c.Assert(err, gc.IsNil)
return inst, hc
}
// StartInstance is a test helper function that starts an instance with a plausible
// but invalid configuration, and returns the result of Environ.StartInstance.
func StartInstance(
env environs.Environ, machineId string,
) (
instance.Instance, *instance.HardwareCharacteristics, error,
) {
return StartInstanceWithConstraints(env, machineId, constraints.Value{})
}
// AssertStartInstanceWithConstraints is a test helper function that starts an instance
// with the given constraints, and a plausible but invalid configuration, and returns
// the result of Environ.StartInstance.
func AssertStartInstanceWithConstraints(
c *gc.C, env environs.Environ, machineId string, cons constraints.Value,
) (
instance.Instance, *instance.HardwareCharacteristics,
) {
inst, hc, err := StartInstanceWithConstraints(env, machineId, cons)
c.Assert(err, gc.IsNil)
return inst, hc
}
// StartInstanceWithConstraints is a test helper function that starts an instance
// with the given constraints, and a plausible but invalid configuration, and returns
// the result of Environ.StartInstance.
func StartInstanceWithConstraints(
env environs.Environ, machineId string, cons constraints.Value,
) (
instance.Instance, *instance.HardwareCharacteristics, error,
) {
return StartInstanceWithConstraintsAndNetworks(env, machineId, cons, environs.Networks{})
}
// AssertStartInstanceWithNetworks is a test helper function that starts an
// instance with the given networks, and a plausible but invalid
// configuration, and returns the result of Environ.StartInstance.
func AssertStartInstanceWithNetworks(
c *gc.C, env environs.Environ, machineId string, cons constraints.Value, nets environs.Networks,
) (
instance.Instance, *instance.HardwareCharacteristics,
) {
inst, hc, err := StartInstanceWithConstraintsAndNetworks(env, machineId, cons, nets)
c.Assert(err, gc.IsNil)
return inst, hc
}
// StartInstanceWithNetworks is a test helper function that starts an instance
// with the given networks, and a plausible but invalid configuration, and
// returns the result of Environ.StartInstance.
func StartInstanceWithConstraintsAndNetworks(
env environs.Environ, machineId string, cons constraints.Value,
nets environs.Networks,
) (
instance.Instance, *instance.HardwareCharacteristics, error,
) {
series := env.Config().DefaultSeries()
agentVersion, ok := env.Config().AgentVersion()
if !ok {
return nil, nil, fmt.Errorf("missing agent version in environment config")
}
possibleTools, err := tools.FindInstanceTools(env, agentVersion, series, cons.Arch)
if err != nil {
return nil, nil, err
}
machineNonce := "fake_nonce"
stateInfo := FakeStateInfo(machineId)
apiInfo := FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(machineId, machineNonce, stateInfo, apiInfo)
return env.StartInstance(environs.StartInstanceParams{
Constraints: cons,
Networks: nets,
Tools: possibleTools,
MachineConfig: machineConfig,
})
}
|