// Register tests to run against a test Openstack instance (service doubles).
func registerLocalTests() {
cred := &identity.Credentials{
User: "******",
Secrets: "secret",
Region: "some-region",
TenantName: "some tenant",
}
config := makeTestConfig(cred)
config["agent-version"] = version.Current.Number.String()
config["authorized-keys"] = "fakekey"
gc.Suite(&localLiveSuite{
LiveTests: LiveTests{
cred: cred,
LiveTests: jujutest.LiveTests{
TestConfig: config,
},
},
})
gc.Suite(&localServerSuite{
cred: cred,
Tests: jujutest.Tests{
TestConfig: config,
},
})
}
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(&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": version.Current.Number.String(),
})
gc.Suite(&LiveTests{
LiveTests: jujutest.LiveTests{
TestConfig: attrs,
Attempt: *ec2.ShortAttempt,
CanOpenState: true,
HasProvisioner: true,
},
})
}
func init() {
if logger == nil {
logger = log.NewLogger("com.deepin.daemon.Power")
}
C.Suite(&DBusInterfaceTest{})
}
func registerLiveSimpleStreamsTests(baseURL string, validImageConstraint ImageConstraint, requireSigned bool) {
gc.Suite(&liveSimplestreamsSuite{
baseURL: baseURL,
requireSigned: requireSigned,
validImageConstraint: validImageConstraint,
})
}
func registerLocalTests(keyName string) {
if keyName == "" {
localKeyFile = os.Getenv("HOME") + "/.ssh/id_rsa"
} else {
localKeyFile = keyName
}
gc.Suite(&LocalTests{})
}
func registerLiveSimpleStreamsTests(baseURL string, validToolsConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames),
RequireSigned: requireSigned,
DataType: tools.ContentDownload,
ValidConstraint: validToolsConstraint,
})
}
func registerLiveSimpleStreamsTests(baseURL string, validImageConstraint simplestreams.LookupConstraint, requireSigned bool) {
gc.Suite(&sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", baseURL, utils.VerifySSLHostnames),
RequireSigned: requireSigned,
DataType: imagemetadata.ImageIds,
ValidConstraint: validImageConstraint,
})
}
func Test(t *testing.T) {
creds, err := jpc.CompleteCredentialsFromEnv(*keyName)
if err != nil {
t.Fatalf("Error setting up test suite: %v", err)
}
gc.Suite(&ClientSuite{creds: creds})
gc.TestingT(t)
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource("test", "test:", utils.VerifySSLHostnames),
RequireSigned: false,
DataType: tools.ContentDownload,
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"},
}),
},
})
gc.Suite(&signedSuite{})
}
func registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
LocalLiveSimplestreamsSuite: sstesting.LocalLiveSimplestreamsSuite{
Source: simplestreams.NewURLDataSource(
"test roundtripper", "test:", utils.VerifySSLHostnames),
RequireSigned: false,
DataType: imagemetadata.ImageIds,
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 registerLocalTests(keyName string) {
var localKeyFile string
if keyName == "" {
localKeyFile = os.Getenv("HOME") + "/.ssh/id_rsa"
} else {
localKeyFile = keyName
}
privateKey, _ = ioutil.ReadFile(localKeyFile)
gc.Suite(&LocalTests{})
}
// 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 registerSimpleStreamsTests() {
gc.Suite(&simplestreamsSuite{
liveSimplestreamsSuite: liveSimplestreamsSuite{
baseURL: "test:",
requireSigned: false,
validImageConstraint: ImageConstraint{
CloudSpec: CloudSpec{
Region: "us-east-1",
Endpoint: "https://ec2.us-east-1.amazonaws.com",
},
Series: "precise",
Arches: []string{"amd64", "arm"},
},
},
})
}
func Test(t *testing.T) {
if *live {
if *vendor == "" {
t.Fatal("missing vendor")
}
var ok bool
var testData liveTestData
if testData, ok = liveUrls[*vendor]; !ok {
keys := reflect.ValueOf(liveUrls).MapKeys()
t.Fatalf("Unknown vendor %s. Must be one of %s", *vendor, keys)
}
registerLiveSimpleStreamsTests(testData.baseURL, ImageConstraint{
CloudSpec: testData.validCloudSpec,
Series: "quantal",
Arches: []string{"amd64"},
}, testData.requireSigned)
}
registerSimpleStreamsTests()
gc.Suite(&signingSuite{})
gc.TestingT(t)
}
func registerLiveTests() {
attrs := coretesting.FakeConfig().Merge(map[string]interface{}{
"name": "sample-" + uniqueName,
"type": "joyent",
"sdc-user": os.Getenv("SDC_ACCOUNT"),
"sdc-key-id": os.Getenv("SDC_KEY_ID"),
"manta-user": os.Getenv("MANTA_USER"),
"manta-key-id": os.Getenv("MANTA_KEY_ID"),
"control-dir": "juju-test-" + uniqueName,
"admin-secret": "for real",
"firewall-mode": config.FwInstance,
"agent-version": version.Current.Number.String(),
})
gc.Suite(&LiveTests{
LiveTests: jujutest.LiveTests{
TestConfig: attrs,
CanOpenState: true,
HasProvisioner: true,
},
})
}
package sdb_test
import (
"github.com/qpingu/goamz/aws"
"github.com/qpingu/goamz/exp/sdb"
"github.com/qpingu/goamz/testutil"
"launchpad.net/gocheck"
"testing"
)
func Test(t *testing.T) {
gocheck.TestingT(t)
}
var _ = gocheck.Suite(&S{})
type S struct {
sdb *sdb.SDB
}
var testServer = testutil.NewHTTPServer()
func (s *S) SetUpSuite(c *gocheck.C) {
testServer.Start()
auth := aws.Auth{AccessKey: "abc", SecretKey: "123"}
s.sdb = sdb.New(auth, aws.Region{SDBEndpoint: testServer.URL})
}
func (s *S) TearDownTest(c *gocheck.C) {
testServer.Flush()
}
/*
*
* gocommon - Go library to interact with the JoyentCloud
*
*
* Copyright (c) 2016 Joyent Inc.
*
* Written by Daniele Stroppa <*****@*****.**>
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
package gocommon
import (
gc "launchpad.net/gocheck"
"testing"
)
func Test(t *testing.T) {
gc.TestingT(t)
}
type GoCommonTestSuite struct {
}
var _ = gc.Suite(&GoCommonTestSuite{})
goyaml "gopkg.in/yaml.v1"
gc "launchpad.net/gocheck"
"github.com/juju/juju/cmd/envcmd"
"github.com/juju/juju/environs/configstore"
"github.com/juju/juju/testing"
)
// All of the functionality of the AddUser api call is contained elsewhere.
// This suite provides basic tests for the "user add" command
type UserAddCommandSuite struct {
testing.FakeJujuHomeSuite
mockAPI *mockAddUserAPI
}
var _ = gc.Suite(&UserAddCommandSuite{})
func (s *UserAddCommandSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.mockAPI = &mockAddUserAPI{}
s.PatchValue(&getAddUserAPI, func(c *UserAddCommand) (addUserAPI, error) {
return s.mockAPI, nil
})
}
func newUserAddCommand() cmd.Command {
return envcmd.Wrap(&UserAddCommand{})
}
func (s *UserAddCommandSuite) TestAddUserJustUsername(c *gc.C) {
context, err := testing.RunCommand(c, newUserAddCommand(), "foobar")
package app
import (
"bytes"
"github.com/globocom/tsuru/db"
"github.com/tsuru/config"
"labix.org/v2/mgo/bson"
"launchpad.net/gocheck"
)
type WriterSuite struct {
conn *db.Storage
}
var _ = gocheck.Suite(&WriterSuite{})
func (s *WriterSuite) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_writer_test")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
}
func (s *WriterSuite) TearDownSuite(c *gocheck.C) {
s.conn.Apps().Database.DropDatabase()
}
func (s *WriterSuite) TestLogWriter(c *gocheck.C) {
var b bytes.Buffer
"github.com/globocom/tsuru/queue"
"github.com/globocom/tsuru/testing"
"labix.org/v2/mgo/bson"
"launchpad.net/gocheck"
"sort"
)
type ELBSuite struct {
server *elbtest.Server
client *elb.ELB
conn *db.Storage
cName string
provisioner *testing.FakeProvisioner
}
var _ = gocheck.Suite(&ELBSuite{})
func (s *ELBSuite) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "juju_elb_tests")
s.conn, err = db.Conn()
s.server, err = elbtest.NewServer()
c.Assert(err, gocheck.IsNil)
config.Set("juju:elb-endpoint", s.server.URL())
config.Set("juju:use-elb", true)
region := aws.SAEast
region.ELBEndpoint = s.server.URL()
s.client = elb.New(aws.Auth{AccessKey: "some", SecretKey: "thing"}, region)
c.Assert(err, gocheck.IsNil)
s.cName = "juju_test_elbs"
import (
"fmt"
"launchpad.net/gocheck"
"log"
"os"
"regexp"
"strings"
)
// -----------------------------------------------------------------------
// Foundation test suite.
type FoundationS struct{}
var foundationS = gocheck.Suite(&FoundationS{})
func (s *FoundationS) TestCountSuite(c *gocheck.C) {
suitesRun += 1
}
func (s *FoundationS) TestErrorf(c *gocheck.C) {
// Do not use checkState() here. It depends on Errorf() working.
expectedLog := fmt.Sprintf("foundation_test.go:%d:\n"+
" c.Errorf(\"Error %%v!\", \"message\")\n"+
"... Error: Error message!\n\n",
getMyLine()+1)
c.Errorf("Error %v!", "message")
failed := c.Failed()
c.Succeed()
if log := c.GetTestLog(); log != expectedLog {
"launchpad.net/juju-core/agent/tools"
"launchpad.net/juju-core/environs"
"launchpad.net/juju-core/environs/dummy"
envtesting "launchpad.net/juju-core/environs/testing"
"launchpad.net/juju-core/testing"
"launchpad.net/juju-core/version"
)
type StorageSuite struct {
env environs.Environ
testing.LoggingSuite
dataDir string
}
var _ = gc.Suite(&StorageSuite{})
func (s *StorageSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
env, err := environs.NewFromAttrs(map[string]interface{}{
"name": "test",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
"ca-private-key": "",
})
c.Assert(err, gc.IsNil)
s.env = env
s.dataDir = c.MkDir()
}
gc "launchpad.net/gocheck"
"github.com/juju/juju/apiserver/params"
envtesting "github.com/juju/juju/environs/testing"
"github.com/juju/juju/environs/tools"
toolstesting "github.com/juju/juju/environs/tools/testing"
"github.com/juju/juju/state"
coretools "github.com/juju/juju/tools"
"github.com/juju/juju/version"
)
type toolsSuite struct {
authHttpSuite
}
var _ = gc.Suite(&toolsSuite{})
func (s *toolsSuite) SetUpSuite(c *gc.C) {
s.authHttpSuite.SetUpSuite(c)
s.archiveContentType = "application/x-tar-gz"
}
func (s *toolsSuite) TestToolsUploadedSecurely(c *gc.C) {
info := s.APIInfo(c)
uri := "http://" + info.Addrs[0] + "/tools"
_, err := s.sendRequest(c, "", "", "PUT", uri, "", nil)
c.Assert(err, gc.ErrorMatches, `.*malformed HTTP response.*`)
}
func (s *toolsSuite) TestRequiresAuth(c *gc.C) {
resp, err := s.sendRequest(c, "", "", "GET", s.toolsURI(c, ""), "", nil)
package main
import (
gc "launchpad.net/gocheck"
"github.com/juju/core/charm"
"github.com/juju/core/cmd/envcmd"
jujutesting "github.com/juju/core/juju/testing"
"github.com/juju/core/testing"
)
type UnexposeSuite struct {
jujutesting.RepoSuite
}
var _ = gc.Suite(&UnexposeSuite{})
func runUnexpose(c *gc.C, args ...string) error {
_, err := testing.RunCommand(c, envcmd.Wrap(&UnexposeCommand{}), args...)
return err
}
func (s *UnexposeSuite) assertExposed(c *gc.C, service string, expected bool) {
svc, err := s.State.Service(service)
c.Assert(err, gc.IsNil)
actual := svc.IsExposed()
c.Assert(actual, gc.Equals, expected)
}
func (s *UnexposeSuite) TestUnexpose(c *gc.C) {
testing.Charms.BundlePath(s.SeriesPath, "dummy")
)
type RelationerSuite struct {
jujutesting.JujuConnSuite
hooks chan hook.Info
svc *state.Service
rel *state.Relation
dir *relation.StateDir
dirPath string
st *api.State
uniter *apiuniter.State
apiRelUnit *apiuniter.RelationUnit
}
var _ = gc.Suite(&RelationerSuite{})
func (s *RelationerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
var err error
s.svc = s.AddTestingService(c, "u", s.AddTestingCharm(c, "riak"))
c.Assert(err, gc.IsNil)
rels, err := s.svc.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 1)
s.rel = rels[0]
_, unit := s.AddRelationUnit(c, "u/0")
s.dirPath = c.MkDir()
s.dir, err = relation.ReadStateDir(s.dirPath, s.rel.Id())
c.Assert(err, gc.IsNil)
s.hooks = make(chan hook.Info)
authorizer apiservertesting.FakeAuthorizer
resources *common.Resources
machine0 *state.Machine
machine1 *state.Machine
wordpress *state.Service
wpCharm *state.Charm
mysql *state.Service
wordpressUnit *state.Unit
mysqlUnit *state.Unit
uniter *uniter.UniterAPI
}
var _ = gc.Suite(&uniterSuite{})
func (s *uniterSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.wpCharm = s.AddTestingCharm(c, "wordpress")
// Create two machines, two services and add a unit to each service.
var err error
s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageEnviron)
c.Assert(err, gc.IsNil)
s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
s.wordpress = s.AddTestingService(c, "wordpress", s.wpCharm)
s.mysql = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
s.wordpressUnit, err = s.wordpress.AddUnit()
c.Assert(err, gc.IsNil)
package network_test
import (
jc "github.com/juju/testing/checkers"
gc "launchpad.net/gocheck"
"github.com/juju/juju/network"
"github.com/juju/juju/testing"
)
type AddressSuite struct {
testing.BaseSuite
}
var _ = gc.Suite(&AddressSuite{})
func (s *AddressSuite) TestNewAddressIPv4(c *gc.C) {
type test struct {
value string
scope network.Scope
expectedScope network.Scope
}
tests := []test{{
value: "127.0.0.1",
scope: network.ScopeUnknown,
expectedScope: network.ScopeMachineLocal,
}, {
value: "127.0.0.1",
scope: network.ScopePublic,
package aws_test
import (
"fmt"
"github.com/crowdmob/goamz/aws"
"launchpad.net/gocheck"
"net/http"
"strings"
"time"
)
var _ = gocheck.Suite(&V4SignerSuite{})
type V4SignerSuite struct {
auth aws.Auth
region aws.Region
cases []V4SignerSuiteCase
}
type V4SignerSuiteCase struct {
label string
request V4SignerSuiteCaseRequest
canonicalRequest string
stringToSign string
signature string
authorization string
}
type V4SignerSuiteCaseRequest struct {
method string
host string