func init() {
check.Suite(&SimpleSuite{})
check.Suite(&FileSuite{})
check.Suite(&DockerSuite{})
check.Suite(&ConsulSuite{})
check.Suite(&MarathonSuite{})
}
func registerLocalTests() {
// N.B. Make sure the region we use here
// has entries in the images/query txt files.
aws.Regions["test"] = aws.Region{
Name: "test",
}
gc.Suite(&localServerSuite{})
gc.Suite(&localLiveSuite{})
gc.Suite(&localNonUSEastSuite{})
}
func init() {
gc.Suite(&liveSuite{
LiveTests: jujutest.LiveTests{
TestConfig: dummy.SampleConfig(),
CanOpenState: true,
HasProvisioner: false,
},
})
gc.Suite(&suite{
Tests: jujutest.Tests{
TestConfig: dummy.SampleConfig(),
},
})
}
func registerAmazonTests() {
// The following attributes hold the environment configuration
// for running the amazon EC2 integration tests.
//
// This is missing keys for security reasons; set the following
// environment variables to make the Amazon testing work:
// access-key: $AWS_ACCESS_KEY_ID
// secret-key: $AWS_SECRET_ACCESS_KEY
attrs := coretesting.FakeConfig().Merge(map[string]interface{}{
"name": "sample-" + uniqueName,
"type": "ec2",
"control-bucket": "juju-test-" + uniqueName,
"admin-secret": "for real",
"firewall-mode": config.FwInstance,
"agent-version": coretesting.FakeVersionNumber.String(),
})
gc.Suite(&LiveTests{
LiveTests: jujutest.LiveTests{
TestConfig: attrs,
Attempt: *ec2.ShortAttempt,
CanOpenState: true,
HasProvisioner: true,
},
})
}
// RegisterSuite registers a new suite for a provided box
func RegisterSuite(boxConstructor BoxConstructor, opts isolate.Profile, skipCheck SkipCheck) {
check.Suite(&BoxSuite{
Constructor: boxConstructor,
SkipCheck: skipCheck,
opts: opts,
ctx: context.Background(),
})
}
func registerLiveSimpleStreamsTests(baseURL string, validImageConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, requireSigned),
RequireSigned: requireSigned,
DataType: imagemetadata.ImageIds,
ValidConstraint: validImageConstraint,
})
}
func init() {
check.Suite(&SimpleSuite{})
check.Suite(&HTTPSSuite{})
check.Suite(&FileSuite{})
check.Suite(&DockerSuite{})
check.Suite(&ConsulSuite{})
check.Suite(&ConsulCatalogSuite{})
check.Suite(&EtcdSuite{})
check.Suite(&MarathonSuite{})
}
func registerLiveSimpleStreamsTests(baseURL string, validToolsConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, requireSigned),
RequireSigned: requireSigned,
DataType: tools.ContentDownload,
StreamsVersion: tools.CurrentStreamsVersion,
ValidConstraint: validToolsConstraint,
})
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource(
"test roundtripper", "test:", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false),
RequireSigned: false,
DataType: imagemetadata.ImageIds,
StreamsVersion: imagemetadata.CurrentStreamsVersion,
ValidConstraint: imagemetadata.NewImageConstraint(simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"amd64", "arm"},
}),
},
})
gc.Suite(&signedSuite{})
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false),
RequireSigned: false,
DataType: tools.ContentDownload,
StreamsVersion: tools.CurrentStreamsVersion,
ValidConstraint: tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"amd64", "arm"},
Stream: "released",
}),
},
})
gc.Suite(&signedSuite{})
}
// Register tests to run against a real Openstack instance.
func registerLiveTests(cred *identity.Credentials) {
config := makeTestConfig(cred)
gc.Suite(&LiveTests{
cred: cred,
LiveTests: jujutest.LiveTests{
TestConfig: config,
Attempt: *openstack.ShortAttempt,
CanOpenState: true,
HasProvisioner: true,
},
})
}
func init() {
flag.Parse()
if *runFeatureTests == false {
return
}
// Initialize all suites here.
gc.Suite(&cmdJujuSuite{})
gc.Suite(&leadershipSuite{})
gc.Suite(&uniterLeadershipSuite{})
gc.Suite(&annotationsSuite{})
gc.Suite(&apiEnvironmentSuite{})
gc.Suite(&blockSuite{})
gc.Suite(&apiCharmsSuite{})
gc.Suite(&cmdEnvironmentSuite{})
gc.Suite(&cmdStorageSuite{})
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames),
RequireSigned: false,
DataType: "image-ids",
StreamsVersion: "v1",
ValidConstraint: sstesting.NewTestConstraint(simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: []string{"precise"},
Arches: []string{"amd64", "arm"},
}),
},
})
}
"github.com/juju/juju/cloudconfig/instancecfg"
"github.com/juju/juju/constraints"
"github.com/juju/juju/environs"
"github.com/juju/juju/environs/imagemetadata"
"github.com/juju/juju/instance"
"github.com/juju/juju/testing"
"github.com/juju/juju/tools"
"github.com/juju/juju/version"
)
type clientSuite struct {
testing.BaseSuite
}
var _ = gc.Suite(&clientSuite{})
func (s *clientSuite) SetUpSuite(c *gc.C) {
s.BaseSuite.SetUpSuite(c)
mock.Start()
}
func (s *clientSuite) TearDownSuite(c *gc.C) {
mock.Stop()
s.BaseSuite.TearDownSuite(c)
}
func (s *clientSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
ll := logger.LogLevel()
"fmt"
"time"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
coretesting "github.com/juju/juju/testing"
"github.com/juju/juju/worker"
"github.com/juju/juju/worker/dependency"
)
type SelfSuite struct {
engineFixture
}
var _ = gc.Suite(&SelfSuite{})
func (s *SelfSuite) TestInputs(c *gc.C) {
manifold := dependency.SelfManifold(s.engine)
c.Check(manifold.Inputs, gc.HasLen, 0)
}
func (s *SelfSuite) TestStart(c *gc.C) {
manifold := dependency.SelfManifold(s.engine)
engine, err := manifold.Start(nil)
c.Check(err, jc.ErrorIsNil)
c.Check(engine, gc.Equals, s.engine)
}
func (s *SelfSuite) TestOutputBadInput(c *gc.C) {
manifold := dependency.SelfManifold(s.engine)
gc "gopkg.in/check.v1"
"github.com/juju/juju/environs"
"github.com/juju/juju/environs/config"
envtesting "github.com/juju/juju/environs/testing"
"github.com/juju/juju/testing"
)
// Use local suite since this file lives in the ec2 package
// for testing internals.
type ConfigSuite struct {
testing.BaseSuite
savedHome, savedAccessKey, savedSecretKey string
}
var _ = gc.Suite(&ConfigSuite{})
var configTestRegion = aws.Region{
Name: "configtest",
EC2Endpoint: "testregion.nowhere:1234",
}
var testAuth = aws.Auth{"gopher", "long teeth"}
// configTest specifies a config parsing test, checking that env when
// parsed as the ec2 section of a config file matches baseConfigResult
// when mutated by the mutate function, or that the parse matches the
// given error.
type configTest struct {
config map[string]interface{}
change map[string]interface{}
"time"
"github.com/juju/errors"
"github.com/juju/testing"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
charmresource "gopkg.in/juju/charm.v6-unstable/resource"
"github.com/juju/juju/resource"
)
type ResourceSuite struct {
testing.IsolationSuite
}
var _ = gc.Suite(&ResourceSuite{})
func (ResourceSuite) TestValidateUploadUsed(c *gc.C) {
res := resource.Resource{
Resource: newFullCharmResource(c, "spam"),
ID: "a-service/spam",
ServiceID: "a-service",
Username: "******",
Timestamp: time.Now(),
}
err := res.Validate()
c.Check(err, jc.ErrorIsNil)
}
"github.com/juju/errors"
"github.com/juju/testing"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
"gopkg.in/juju/charm.v5/hooks"
"github.com/juju/juju/worker/uniter/hook"
"github.com/juju/juju/worker/uniter/operation"
"github.com/juju/juju/worker/uniter/runner"
)
type RunActionSuite struct {
testing.IsolationSuite
}
var _ = gc.Suite(&RunActionSuite{})
func (s *RunActionSuite) TestPrepareErrorBadActionAndFailSucceeds(c *gc.C) {
errBadAction := runner.NewBadActionError("some-action-id", "splat")
runnerFactory := &MockRunnerFactory{
MockNewActionRunner: &MockNewActionRunner{err: errBadAction},
}
callbacks := &RunActionCallbacks{
MockFailAction: &MockFailAction{err: errors.New("squelch")},
}
factory := operation.NewFactory(operation.FactoryParams{
RunnerFactory: runnerFactory,
Callbacks: callbacks,
})
op, err := factory.NewAction(someActionId)
c.Assert(err, jc.ErrorIsNil)
"github.com/juju/utils"
gc "gopkg.in/check.v1"
"gopkg.in/juju/charm.v6-unstable"
apihttp "github.com/juju/juju/apiserver/http"
"github.com/juju/juju/apiserver/params"
"github.com/juju/juju/state"
"github.com/juju/juju/state/storage"
"github.com/juju/juju/testcharms"
)
type charmsSuite struct {
userAuthHttpSuite
}
var _ = gc.Suite(&charmsSuite{})
func (s *charmsSuite) SetUpSuite(c *gc.C) {
// TODO(bogdanteleaga): Fix this on windows
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Skipping this on windows for now")
}
s.userAuthHttpSuite.SetUpSuite(c)
s.archiveContentType = "application/zip"
}
func (s *charmsSuite) TestCharmsServedSecurely(c *gc.C) {
info := s.APIInfo(c)
uri := "http://" + info.Addrs[0] + "/charms"
_, err := s.sendRequest(c, "", "", "GET", uri, "", nil)
c.Assert(err, gc.ErrorMatches, `.*malformed HTTP response.*`)
gc "gopkg.in/check.v1"
"github.com/juju/juju/apiserver/params"
"github.com/juju/juju/status"
"github.com/juju/juju/worker"
"github.com/juju/juju/worker/workertest"
)
// UndertakerSuite is *not* complete. But it's a lot more so
// than it was before, and should be much easier to extend.
type UndertakerSuite struct {
testing.IsolationSuite
fix fixture
}
var _ = gc.Suite(&UndertakerSuite{})
func (s *UndertakerSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
s.fix = fixture{
info: params.UndertakerModelInfoResult{
Result: params.UndertakerModelInfo{
Life: "dying",
},
},
}
}
func (s *UndertakerSuite) TestAliveError(c *gc.C) {
s.fix.info.Result.Life = "alive"
s.fix.dirty = true
gc "gopkg.in/check.v1"
"github.com/juju/juju/constraints"
"github.com/juju/juju/environs/config"
"github.com/juju/juju/state"
statetesting "github.com/juju/juju/state/testing"
"github.com/juju/juju/testing"
)
type InitializeSuite struct {
gitjujutesting.MgoSuite
testing.BaseSuite
State *state.State
}
var _ = gc.Suite(&InitializeSuite{})
func (s *InitializeSuite) SetUpSuite(c *gc.C) {
s.BaseSuite.SetUpSuite(c)
s.MgoSuite.SetUpSuite(c)
}
func (s *InitializeSuite) TearDownSuite(c *gc.C) {
s.MgoSuite.TearDownSuite(c)
s.BaseSuite.TearDownSuite(c)
}
func (s *InitializeSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
}
"github.com/juju/errors"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
"github.com/juju/juju/cmd/juju/system"
"github.com/juju/juju/environs/configstore"
"github.com/juju/juju/feature"
"github.com/juju/juju/testing"
)
type ListSuite struct {
testing.FakeJujuHomeSuite
store configstore.Storage
}
var _ = gc.Suite(&ListSuite{})
type errorStore struct {
err error
}
func (errorStore) CreateInfo(envName string) configstore.EnvironInfo {
panic("CreateInfo not implemented")
}
func (errorStore) List() ([]string, error) {
panic("List not implemented")
}
func (e errorStore) ListSystems() ([]string, error) {
return nil, e.err
"github.com/juju/juju/provider/azure"
"github.com/juju/juju/provider/azure/internal/azuretesting"
"github.com/juju/juju/storage"
"github.com/juju/juju/testing"
)
type storageSuite struct {
testing.BaseSuite
storageClient azuretesting.MockStorageClient
provider storage.Provider
requests []*http.Request
sender azuretesting.Senders
}
var _ = gc.Suite(&storageSuite{})
func (s *storageSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.storageClient = azuretesting.MockStorageClient{}
s.requests = nil
_, s.provider = newProviders(c, azure.ProviderConfig{
Sender: &s.sender,
NewStorageClient: s.storageClient.NewClient,
RequestInspector: requestRecorder(&s.requests),
})
s.sender = nil
}
func (s *storageSuite) volumeSource(c *gc.C, attrs ...testing.Attrs) storage.VolumeSource {
storageConfig, err := storage.NewConfig("azure", "azure", nil)
"github.com/juju/errors"
"github.com/juju/names"
jc "github.com/juju/testing/checkers"
"github.com/juju/utils"
gc "gopkg.in/check.v1"
"github.com/juju/juju/state"
"github.com/juju/juju/testing"
)
type blockSuite struct {
ConnSuite
}
var _ = gc.Suite(&blockSuite{})
func (s *blockSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
}
func assertNoEnvBlock(c *gc.C, st *state.State) {
all, err := st.AllBlocks()
c.Assert(err, jc.ErrorIsNil)
c.Assert(all, gc.HasLen, 0)
}
func (s *blockSuite) assertNoTypedBlock(c *gc.C, t state.BlockType) {
one, found, err := s.State.GetBlockForType(t)
c.Assert(err, jc.ErrorIsNil)
c.Assert(found, jc.IsFalse)
"github.com/juju/juju/state"
"github.com/juju/juju/testing"
)
// Ensure that Backend remains compatible with *state.State
var _ migrationminion.Backend = (*state.State)(nil)
type Suite struct {
testing.BaseSuite
backend *stubBackend
resources *common.Resources
authorizer apiservertesting.FakeAuthorizer
}
var _ = gc.Suite(&Suite{})
func (s *Suite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.backend = &stubBackend{}
migrationminion.PatchState(s, s.backend)
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: names.NewMachineTag("99"),
}
}
// Licensed under the AGPLv3, see LICENCE file for details.
package simplestreams_test
import (
"bytes"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
"github.com/juju/juju/environs/simplestreams"
)
type decodeSuite struct{}
var _ = gc.Suite(&decodeSuite{})
func (s *decodeSuite) TestDecodeCheckValidSignature(c *gc.C) {
r := bytes.NewReader([]byte(signedData))
txt, err := simplestreams.DecodeCheckSignature(r, testSigningKey)
c.Assert(err, jc.ErrorIsNil)
c.Assert(txt, gc.DeepEquals, []byte(unsignedData[1:]))
}
func (s *decodeSuite) TestDecodeCheckInvalidSignature(c *gc.C) {
r := bytes.NewReader([]byte(invalidClearsignInput + signSuffix))
_, err := simplestreams.DecodeCheckSignature(r, testSigningKey)
c.Assert(err, gc.Not(gc.IsNil))
_, ok := err.(*simplestreams.NotPGPSignedError)
c.Assert(ok, jc.IsFalse)
}
package lxdclient_test
import (
"bytes"
"crypto/tls"
"encoding/pem"
"github.com/juju/errors"
jc "github.com/juju/testing/checkers"
gc "gopkg.in/check.v1"
"github.com/juju/juju/tools/lxdclient"
)
var (
_ = gc.Suite(&certSuite{})
_ = gc.Suite(&certFunctionalSuite{})
)
type certSuite struct {
lxdclient.BaseSuite
certPEM []byte
keyPEM []byte
}
func (s *certSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.certPEM = []byte("<a valid PEM-encoded x.509 cert>")
s.keyPEM = []byte("<a valid PEM-encoded x.509 key>")
import (
"bytes"
"testing"
gc "gopkg.in/check.v1"
)
func Test(t *testing.T) {
gc.TestingT(t)
}
type ColumnSuite struct {
}
var _ = gc.Suite(&ColumnSuite{})
//
// tests for baseColumn and columns that extends baseColumn
//
func (s *ColumnSuite) TestRealColumnName(c *gc.C) {
col := IntColumn("col", Nullable)
c.Assert(col.Name(), gc.Equals, "col")
}
func (s *ColumnSuite) TestRealColumnSerializeSqlForColumnList(c *gc.C) {
col := IntColumn("col", Nullable)
// Without table name
"github.com/juju/juju/api"
"github.com/juju/juju/apiserver"
"github.com/juju/juju/rpc"
coretesting "github.com/juju/juju/testing"
)
// pingerSuite exercises the apiserver's ping timeout functionality
// from the outside. Ping API requests are made (or not) to a running
// API server to ensure that the server shuts down the API connection
// as expected once there's been no pings within the timeout period.
type pingerSuite struct {
apiserverBaseSuite
}
var _ = gc.Suite(&pingerSuite{})
func (s *pingerSuite) newServerWithTestClock(c *gc.C) (*apiserver.Server, *testing.Clock) {
clock := testing.NewClock(time.Now())
config := s.sampleConfig(c)
config.PingClock = clock
server := s.newServer(c, config)
return server, clock
}
func (s *pingerSuite) TestConnectionBrokenDetection(c *gc.C) {
server, clock := s.newServerWithTestClock(c)
conn, _ := s.OpenAPIAsNewMachine(c, server)
clock.Advance(api.PingPeriod)
// Connection still alive
// Copyright 2015 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package state
import (
"github.com/juju/names"
gc "gopkg.in/check.v1"
)
type internalUserSuite struct {
internalStateSuite
}
var _ = gc.Suite(&internalUserSuite{})
func (s *internalUserSuite) TestCreateInitialUserOp(c *gc.C) {
tag := names.NewUserTag("AdMiN")
op := createInitialUserOp(nil, tag, "abc")
c.Assert(op.Id, gc.Equals, "admin")
doc := op.Insert.(*userDoc)
c.Assert(doc.DocID, gc.Equals, "admin")
c.Assert(doc.Name, gc.Equals, "AdMiN")
}
func (s *internalUserSuite) TestCaseNameVsId(c *gc.C) {
user, err := s.state.AddUser(
"boB", "ignored", "ignored", "ignored")
c.Assert(err, gc.IsNil)
c.Assert(user.Name(), gc.Equals, "boB")