func (s *BundleDeployCharmStoreSuite) TestDeployBundleWithAnnotations_OutputIsCorrect(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/django-42", "dummy")
testcharms.UploadCharm(c, s.client, "xenial/mem-47", "dummy")
output, err := s.DeployBundleYAML(c, `
applications:
django:
charm: cs:django
num_units: 1
annotations:
key1: value1
key2: value2
to: [1]
memcached:
charm: xenial/mem-47
num_units: 1
machines:
1:
annotations: {foo: bar}
`)
c.Assert(err, jc.ErrorIsNil)
c.Check(output, gc.Equals, ""+
`Deploying charm "cs:xenial/django-42"`+"\n"+
`Deploying charm "cs:xenial/mem-47"`+"\n"+
`Deploy of bundle completed.`,
)
}
func (s *UpgradeCharmCharmStoreStateSuite) TestSwitch(c *gc.C) {
testcharms.UploadCharm(c, s.client, "cs:~other/trusty/riak-0", "riak")
testcharms.UploadCharm(c, s.client, "cs:~other/trusty/anotherriak-7", "riak")
err := runDeploy(c, "cs:~other/trusty/riak-0")
c.Assert(err, jc.ErrorIsNil)
riak, err := s.State.Application("riak")
c.Assert(err, jc.ErrorIsNil)
ch, forced, err := riak.Charm()
c.Assert(err, jc.ErrorIsNil)
c.Assert(ch.Revision(), gc.Equals, 0)
c.Assert(forced, jc.IsFalse)
err = runUpgradeCharm(c, "riak", "--switch=cs:~other/trusty/anotherriak")
c.Assert(err, jc.ErrorIsNil)
curl := s.assertUpgraded(c, riak, 7, false)
c.Assert(curl.String(), gc.Equals, "cs:~other/trusty/anotherriak-7")
// Now try the same with explicit revision - should fail.
err = runUpgradeCharm(c, "riak", "--switch=cs:~other/trusty/anotherriak-7")
c.Assert(err, gc.ErrorMatches, `already running specified charm "cs:~other/trusty/anotherriak-7"`)
// Change the revision to 42 and upgrade to it with explicit revision.
testcharms.UploadCharm(c, s.client, "cs:~other/trusty/anotherriak-42", "riak")
err = runUpgradeCharm(c, "riak", "--switch=cs:~other/trusty/anotherriak-42")
c.Assert(err, jc.ErrorIsNil)
curl = s.assertUpgraded(c, riak, 42, false)
c.Assert(curl.String(), gc.Equals, "cs:~other/trusty/anotherriak-42")
}
func (s *DeployCharmStoreSuite) TestDeployAuthorization(c *gc.C) {
// Upload the two charms required to upload the bundle.
testcharms.UploadCharm(c, s.client, "trusty/mysql-0", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-1", "wordpress")
// Run the tests.
for i, test := range deployAuthorizationTests {
c.Logf("test %d: %s", i, test.about)
// Upload the charm or bundle under test.
url := charm.MustParseURL(test.uploadURL)
if url.Series == "bundle" {
url, _ = testcharms.UploadBundle(c, s.client, test.uploadURL, "wordpress-simple")
} else {
url, _ = testcharms.UploadCharm(c, s.client, test.uploadURL, "wordpress")
}
// Change the ACL of the uploaded entity if required in this case.
if test.readPermUser != "" {
s.changeReadPerm(c, url, test.readPermUser)
}
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&deployCommand{}), test.deployURL, fmt.Sprintf("wordpress%d", i))
if test.expectError != "" {
c.Assert(err, gc.ErrorMatches, test.expectError)
continue
}
c.Assert(err, jc.ErrorIsNil)
output := strings.Trim(coretesting.Stderr(ctx), "\n")
c.Assert(output, gc.Equals, strings.TrimSpace(test.expectOutput))
}
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleApplicationConstrants(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/wordpress-42", "wordpress")
testcharms.UploadCharm(c, s.client, "precise/dummy-0", "dummy")
_, err := s.DeployBundleYAML(c, `
applications:
wordpress:
charm: wordpress
constraints: mem=4G cores=2
customized:
charm: precise/dummy-0
num_units: 1
constraints: arch=i386
`)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:precise/dummy-0", "cs:xenial/wordpress-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"customized": {
charm: "cs:precise/dummy-0",
constraints: constraints.MustParse("arch=i386"),
},
"wordpress": {
charm: "cs:xenial/wordpress-42",
constraints: constraints.MustParse("mem=4G cores=2"),
},
})
s.assertUnitsCreated(c, map[string]string{
"customized/0": "0",
})
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleUnitPlacedInService(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/django-42", "dummy")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-0", "wordpress")
output, err := s.deployBundleYAML(c, `
services:
wordpress:
charm: wordpress
num_units: 3
django:
charm: cs:trusty/django-42
num_units: 2
to: [wordpress]
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/django-42
service django deployed (charm: cs:trusty/django-42)
added charm cs:trusty/wordpress-0
service wordpress deployed (charm: cs:trusty/wordpress-0)
added wordpress/0 unit to new machine
added wordpress/1 unit to new machine
added wordpress/2 unit to new machine
added django/0 unit to machine 0
added django/1 unit to machine 1
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertUnitsCreated(c, map[string]string{
"django/0": "0",
"django/1": "1",
"wordpress/0": "0",
"wordpress/1": "1",
"wordpress/2": "2",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleApplicationOptions(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/wordpress-42", "wordpress")
testcharms.UploadCharm(c, s.client, "precise/dummy-0", "dummy")
_, err := s.DeployBundleYAML(c, `
applications:
wordpress:
charm: wordpress
num_units: 1
options:
blog-title: these are the voyages
customized:
charm: precise/dummy-0
num_units: 1
options:
username: who
skill-level: 47
`)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:precise/dummy-0", "cs:xenial/wordpress-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"customized": {
charm: "cs:precise/dummy-0",
config: charm.Settings{"username": "******", "skill-level": int64(47)},
},
"wordpress": {
charm: "cs:xenial/wordpress-42",
config: charm.Settings{"blog-title": "these are the voyages"},
},
})
s.assertUnitsCreated(c, map[string]string{
"wordpress/0": "1",
"customized/0": "0",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleStorage(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/mysql-42", "mysql-storage")
testcharms.UploadCharm(c, s.client, "xenial/wordpress-47", "wordpress")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-with-mysql-storage-1", "wordpress-with-mysql-storage")
_, err := runDeployCommand(
c, "bundle/wordpress-with-mysql-storage",
"--storage", "mysql:logs=tmpfs,10G", // override logs
)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:xenial/mysql-42", "cs:xenial/wordpress-47")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"mysql": {
charm: "cs:xenial/mysql-42",
storage: map[string]state.StorageConstraints{
"data": state.StorageConstraints{Pool: "rootfs", Size: 50 * 1024, Count: 1},
"logs": state.StorageConstraints{Pool: "tmpfs", Size: 10 * 1024, Count: 1},
},
},
"wordpress": {charm: "cs:xenial/wordpress-47"},
})
s.assertRelationsEstablished(c, "wordpress:db mysql:server")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"wordpress/0": "1",
})
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleWatcherTimeout(c *gc.C) {
// Inject an "AllWatcher" that never delivers a result.
ch := make(chan struct{})
defer close(ch)
watcher := mockAllWatcher{
next: func() []multiwatcher.Delta {
<-ch
return nil
},
}
s.PatchValue(&watchAll, func(*api.Client) (allWatcher, error) {
return watcher, nil
})
testcharms.UploadCharm(c, s.client, "trusty/django-0", "dummy")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-0", "wordpress")
s.PatchValue(&updateUnitStatusPeriod, 0*time.Second)
_, err := s.deployBundleYAML(c, `
services:
django:
charm: django
num_units: 1
wordpress:
charm: wordpress
num_units: 1
to: [django]
`)
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: cannot retrieve placement for "wordpress" unit: cannot resolve machine: timeout while trying to get new changes from the watcher`)
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleServiceUpgradeFailure(c *gc.C) {
s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress"))
// Try upgrading to a different charm name.
testcharms.UploadCharm(c, s.client, "trusty/incompatible-42", "wordpress")
_, err := s.deployBundleYAML(c, `
services:
wordpress:
charm: trusty/incompatible-42
num_units: 1
`)
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: cannot upgrade service "wordpress": bundle charm "cs:trusty/incompatible-42" is incompatible with existing charm "local:quantal/wordpress-3"`)
// Try upgrading to a different user.
testcharms.UploadCharm(c, s.client, "~who/trusty/wordpress-42", "wordpress")
_, err = s.deployBundleYAML(c, `
services:
wordpress:
charm: cs:~who/trusty/wordpress-42
num_units: 1
`)
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: cannot upgrade service "wordpress": bundle charm "cs:~who/trusty/wordpress-42" is incompatible with existing charm "local:quantal/wordpress-3"`)
// Try upgrading to a different series.
testcharms.UploadCharm(c, s.client, "vivid/wordpress-42", "wordpress")
_, err = s.deployBundleYAML(c, `
services:
wordpress:
charm: vivid/wordpress
num_units: 1
`)
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: cannot upgrade service "wordpress": bundle charm "cs:vivid/wordpress-42" is incompatible with existing charm "local:quantal/wordpress-3"`)
}
func (s *DeployCharmStoreSuite) TestDeployBundleWithTermsSuccess(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/terms1-17", "terms1")
testcharms.UploadCharm(c, s.client, "trusty/terms2-42", "terms2")
testcharms.UploadBundle(c, s.client, "bundle/terms-simple-1", "terms-simple")
output, err := runDeployCommand(c, "bundle/terms-simple")
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/terms1-17
service terms1 deployed (charm: cs:trusty/terms1-17)
added charm cs:trusty/terms2-42
service terms2 deployed (charm: cs:trusty/terms2-42)
added terms1/0 unit to new machine
added terms2/0 unit to new machine
deployment of bundle "cs:bundle/terms-simple-1" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertCharmsUplodaded(c, "cs:trusty/terms1-17", "cs:trusty/terms2-42")
s.assertServicesDeployed(c, map[string]serviceInfo{
"terms1": {charm: "cs:trusty/terms1-17"},
"terms2": {charm: "cs:trusty/terms2-42"},
})
s.assertUnitsCreated(c, map[string]string{
"terms1/0": "0",
"terms2/0": "1",
})
c.Assert(s.termsString, gc.Not(gc.Equals), "")
}
func (s *DeployCharmStoreSuite) TestDeployBundleSuccess(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/mysql-42", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-47", "wordpress")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-simple-1", "wordpress-simple")
output, err := runDeployCommand(c, "bundle/wordpress-simple")
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/mysql-42
service mysql deployed (charm: cs:trusty/mysql-42)
added charm cs:trusty/wordpress-47
service wordpress deployed (charm: cs:trusty/wordpress-47)
related wordpress:db and mysql:server
added mysql/0 unit to new machine
added wordpress/0 unit to new machine
deployment of bundle "cs:bundle/wordpress-simple-1" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertCharmsUplodaded(c, "cs:trusty/mysql-42", "cs:trusty/wordpress-47")
s.assertServicesDeployed(c, map[string]serviceInfo{
"mysql": {charm: "cs:trusty/mysql-42"},
"wordpress": {charm: "cs:trusty/wordpress-47"},
})
s.assertRelationsEstablished(c, "wordpress:db mysql:server")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"wordpress/0": "1",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleMultipleRelations(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/wordpress-0", "wordpress")
testcharms.UploadCharm(c, s.client, "xenial/mysql-1", "mysql")
testcharms.UploadCharm(c, s.client, "xenial/postgres-2", "mysql")
testcharms.UploadCharm(c, s.client, "xenial/varnish-3", "varnish")
_, err := s.DeployBundleYAML(c, `
applications:
wp:
charm: wordpress
num_units: 1
mysql:
charm: mysql
num_units: 1
pgres:
charm: xenial/postgres-2
num_units: 1
varnish:
charm: xenial/varnish
num_units: 1
relations:
- ["wp:db", "mysql:server"]
- ["wp:db", "pgres:server"]
- ["varnish:webcache", "wp:cache"]
`)
c.Assert(err, jc.ErrorIsNil)
s.assertRelationsEstablished(c, "wp:db mysql:server", "wp:db pgres:server", "wp:cache varnish:webcache")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"pgres/0": "1",
"varnish/0": "2",
"wp/0": "3",
})
}
func (s *DeployCharmStoreSuite) TestDeployBundleGatedCharmUnauthorized(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/mysql-42", "mysql")
url, _ := testcharms.UploadCharm(c, s.client, "trusty/wordpress-47", "wordpress")
s.changeReadPerm(c, url, "who")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-simple-1", "wordpress-simple")
_, err := runDeployCommand(c, "bundle/wordpress-simple")
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: .*: unauthorized: access denied for user "client-username"`)
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleNewRelations(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/wordpress-0", "wordpress")
testcharms.UploadCharm(c, s.client, "trusty/mysql-1", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/postgres-2", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/varnish-3", "varnish")
_, err := s.deployBundleYAML(c, `
services:
wp:
charm: wordpress
num_units: 1
mysql:
charm: mysql
num_units: 1
varnish:
charm: trusty/varnish
num_units: 1
relations:
- ["wp:db", "mysql:server"]
`)
c.Assert(err, jc.ErrorIsNil)
output, err := s.deployBundleYAML(c, `
services:
wp:
charm: wordpress
num_units: 1
mysql:
charm: mysql
num_units: 1
varnish:
charm: trusty/varnish
num_units: 1
relations:
- ["wp:db", "mysql:server"]
- ["varnish:webcache", "wp:cache"]
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/mysql-1
reusing service mysql (charm: cs:trusty/mysql-1)
added charm cs:trusty/varnish-3
reusing service varnish (charm: cs:trusty/varnish-3)
added charm cs:trusty/wordpress-0
reusing service wp (charm: cs:trusty/wordpress-0)
wp:db and mysql:server are already related
related varnish:webcache and wp:cache
avoid adding new units to service mysql: 1 unit already present
avoid adding new units to service varnish: 1 unit already present
avoid adding new units to service wp: 1 unit already present
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertRelationsEstablished(c, "wp:db mysql:server", "wp:cache varnish:webcache")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"varnish/0": "1",
"wp/0": "2",
})
}
func (s *DeployCharmStoreSuite) TestDeployBundleInvalidFlags(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/mysql-42", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-47", "wordpress")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-simple-1", "wordpress-simple")
_, err := runDeployCommand(c, "bundle/wordpress-simple", "--config", "config.yaml")
c.Assert(err, gc.ErrorMatches, "Flags provided but not supported when deploying a bundle: --config.")
_, err = runDeployCommand(c, "bundle/wordpress-simple", "-n", "2")
c.Assert(err, gc.ErrorMatches, "Flags provided but not supported when deploying a bundle: -n.")
_, err = runDeployCommand(c, "bundle/wordpress-simple", "--series", "trusty", "--force")
c.Assert(err, gc.ErrorMatches, "Flags provided but not supported when deploying a bundle: --force, --series.")
}
func (s *DeployCharmStoreSuite) TestDeployBundleGatedCharm(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/mysql-42", "mysql")
url, _ := testcharms.UploadCharm(c, s.client, "trusty/wordpress-47", "wordpress")
s.changeReadPerm(c, url, clientUserName)
testcharms.UploadBundle(c, s.client, "bundle/wordpress-simple-1", "wordpress-simple")
_, err := runDeployCommand(c, "bundle/wordpress-simple")
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUplodaded(c, "cs:trusty/mysql-42", "cs:trusty/wordpress-47")
s.assertServicesDeployed(c, map[string]serviceInfo{
"mysql": {charm: "cs:trusty/mysql-42"},
"wordpress": {charm: "cs:trusty/wordpress-47"},
})
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleMultipleRelations(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/wordpress-0", "wordpress")
testcharms.UploadCharm(c, s.client, "trusty/mysql-1", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/postgres-2", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/varnish-3", "varnish")
output, err := s.deployBundleYAML(c, `
services:
wp:
charm: wordpress
num_units: 1
mysql:
charm: mysql
num_units: 1
pgres:
charm: trusty/postgres-2
num_units: 1
varnish:
charm: trusty/varnish
num_units: 1
relations:
- ["wp:db", "mysql:server"]
- ["wp:db", "pgres:server"]
- ["varnish:webcache", "wp:cache"]
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/mysql-1
service mysql deployed (charm: cs:trusty/mysql-1)
added charm cs:trusty/postgres-2
service pgres deployed (charm: cs:trusty/postgres-2)
added charm cs:trusty/varnish-3
service varnish deployed (charm: cs:trusty/varnish-3)
added charm cs:trusty/wordpress-0
service wp deployed (charm: cs:trusty/wordpress-0)
related wp:db and mysql:server
related wp:db and pgres:server
related varnish:webcache and wp:cache
added mysql/0 unit to new machine
added pgres/0 unit to new machine
added varnish/0 unit to new machine
added wp/0 unit to new machine
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertRelationsEstablished(c, "wp:db mysql:server", "wp:db pgres:server", "wp:cache varnish:webcache")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"pgres/0": "1",
"varnish/0": "2",
"wp/0": "3",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleApplicationUpgrade(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/wordpress-42", "wordpress")
testcharms.UploadCharm(c, s.client, "vivid/upgrade-1", "upgrade1")
testcharms.UploadCharm(c, s.client, "vivid/upgrade-2", "upgrade2")
// First deploy the bundle.
_, err := s.DeployBundleYAML(c, `
applications:
wordpress:
charm: wordpress
num_units: 1
options:
blog-title: these are the voyages
constraints: spaces=final,frontiers mem=8000M
up:
charm: vivid/upgrade-1
num_units: 1
`)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:vivid/upgrade-1", "cs:xenial/wordpress-42")
// Then deploy a new bundle with modified charm revision and options.
_, err = s.DeployBundleYAML(c, `
applications:
wordpress:
charm: wordpress
num_units: 1
options:
blog-title: new title
constraints: spaces=new cores=8
up:
charm: vivid/upgrade-2
num_units: 1
`)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:vivid/upgrade-1", "cs:vivid/upgrade-2", "cs:xenial/wordpress-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"up": {charm: "cs:vivid/upgrade-2"},
"wordpress": {
charm: "cs:xenial/wordpress-42",
config: charm.Settings{"blog-title": "new title"},
constraints: constraints.MustParse("spaces=new cores=8"),
},
})
s.assertUnitsCreated(c, map[string]string{
"up/0": "0",
"wordpress/0": "1",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleLocalAndCharmStoreCharms(c *gc.C) {
charmsPath := c.MkDir()
testcharms.UploadCharm(c, s.client, "xenial/wordpress-42", "wordpress")
mysqlPath := testcharms.Repo.ClonedDirPath(charmsPath, "mysql")
_, err := s.DeployBundleYAML(c, fmt.Sprintf(`
series: xenial
applications:
wordpress:
charm: xenial/wordpress-42
series: xenial
num_units: 1
mysql:
charm: %s
num_units: 1
relations:
- ["wordpress:db", "mysql:server"]
`, mysqlPath))
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "local:xenial/mysql-1", "cs:xenial/wordpress-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"mysql": {charm: "local:xenial/mysql-1"},
"wordpress": {charm: "cs:xenial/wordpress-42"},
})
s.assertRelationsEstablished(c, "wordpress:db mysql:server")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"wordpress/0": "1",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleUnitPlacedToMachines(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/django-42", "dummy")
_, err := s.DeployBundleYAML(c, `
applications:
django:
charm: cs:django
num_units: 7
to:
- new
- 4
- kvm:8
- lxd:4
- lxd:4
- lxd:new
machines:
4:
8:
`)
c.Assert(err, jc.ErrorIsNil)
s.assertUnitsCreated(c, map[string]string{
"django/0": "0", // Machine "4" in the bundle.
"django/1": "2", // Machine "new" in the bundle.
"django/2": "1/kvm/0", // The KVM container in bundle machine "8".
"django/3": "0/lxd/0", // First lxd container in bundle machine "4".
"django/4": "0/lxd/1", // Second lxd container in bundle machine "4".
"django/5": "3/lxd/0", // First lxd in new machine.
"django/6": "4/lxd/0", // Second lxd in new machine.
})
}
func (s *CharmSuite) SetUpTest(c *gc.C) {
db := s.jcSuite.Session.DB("juju-testing")
params := charmstore.ServerParams{
AuthUsername: "******",
AuthPassword: "******",
}
handler, err := charmstore.NewServer(db, nil, "", params, charmstore.V4)
c.Assert(err, jc.ErrorIsNil)
s.Handler = handler
s.Server = httptest.NewServer(handler)
s.Client = csclient.New(csclient.Params{
URL: s.Server.URL,
User: params.AuthUsername,
Password: params.AuthPassword,
})
urls := map[string]string{
"mysql": "quantal/mysql-23",
"dummy": "quantal/dummy-24",
"riak": "quantal/riak-25",
"wordpress": "quantal/wordpress-26",
"logging": "quantal/logging-27",
}
for name, url := range urls {
testcharms.UploadCharm(c, s.Client, url, name)
}
s.jcSuite.PatchValue(&charmrepo.CacheDir, c.MkDir())
// Patch the charm repo initializer function: it is replaced with a charm
// store repo pointing to the testing server.
s.jcSuite.PatchValue(&charmrevisionupdater.NewCharmStore, func(p charmrepo.NewCharmStoreParams) charmrepo.Interface {
p.URL = s.Server.URL
return charmrepo.NewCharmStore(p)
})
s.charms = make(map[string]*state.Charm)
}
func (s *DeployCharmStoreSuite) TestDeployCharmWithSomeEndpointBindingsSpecifiedSuccess(c *gc.C) {
_, err := s.State.AddSpace("db", "", nil, false)
c.Assert(err, jc.ErrorIsNil)
_, err = s.State.AddSpace("public", "", nil, false)
c.Assert(err, jc.ErrorIsNil)
testcharms.UploadCharm(c, s.client, "cs:quantal/wordpress-extra-bindings-1", "wordpress-extra-bindings")
err = runDeploy(c, "cs:quantal/wordpress-extra-bindings-1", "--bind", "db=db db-client=db public admin-api=public")
c.Assert(err, jc.ErrorIsNil)
s.assertServicesDeployed(c, map[string]serviceInfo{
"wordpress-extra-bindings": {charm: "cs:quantal/wordpress-extra-bindings-1"},
})
s.assertDeployedServiceBindings(c, map[string]serviceInfo{
"wordpress-extra-bindings": {
endpointBindings: map[string]string{
"cache": "public",
"url": "public",
"logging-dir": "public",
"monitoring-port": "public",
"db": "db",
"db-client": "db",
"admin-api": "public",
"foo-bar": "public",
"cluster": "public",
},
},
})
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleWatcherTimeout(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/django-0", "dummy")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-0", "wordpress")
s.PatchValue(&updateUnitStatusPeriod, 0*time.Second)
_, err := s.deployBundleYAML(c, `
services:
django:
charm: django
num_units: 1
wordpress:
charm: wordpress
num_units: 1
to: [django]
`)
c.Assert(err, gc.ErrorMatches, `cannot deploy bundle: cannot retrieve placement for "wordpress" unit: cannot resolve machine: timeout while trying to get new changes from the watcher`)
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleTwiceScaleUp(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/django-42", "dummy")
_, err := s.deployBundleYAML(c, `
services:
django:
charm: cs:trusty/django-42
num_units: 2
`)
c.Assert(err, jc.ErrorIsNil)
output, err := s.deployBundleYAML(c, `
services:
django:
charm: cs:trusty/django-42
num_units: 5
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/django-42
reusing service django (charm: cs:trusty/django-42)
added django/2 unit to new machine
added django/3 unit to new machine
added django/4 unit to new machine
avoid adding new units to service django: 5 units already present
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertUnitsCreated(c, map[string]string{
"django/0": "0",
"django/1": "1",
"django/2": "2",
"django/3": "3",
"django/4": "4",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleEndpointBindingsSpaceMissing(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/mysql-42", "mysql")
testcharms.UploadCharm(c, s.client, "xenial/wordpress-extra-bindings-47", "wordpress-extra-bindings")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-with-endpoint-bindings-1", "wordpress-with-endpoint-bindings")
output, err := runDeployCommand(c, "bundle/wordpress-with-endpoint-bindings")
c.Assert(err, gc.ErrorMatches, ""+
"cannot deploy bundle: cannot deploy application \"mysql\": "+
"cannot add application \"mysql\": unknown space \"db\" not valid")
c.Assert(output, gc.Equals, ""+
`Located bundle "cs:bundle/wordpress-with-endpoint-bindings-1"`+"\n"+
`Deploying charm "cs:xenial/mysql-42"`,
)
s.assertCharmsUploaded(c, "cs:xenial/mysql-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{})
s.assertUnitsCreated(c, map[string]string{})
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleExpose(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/wordpress-42", "wordpress")
content := `
services:
wordpress:
charm: wordpress
num_units: 1
expose: true
`
expectedServices := map[string]serviceInfo{
"wordpress": {
charm: "cs:trusty/wordpress-42",
exposed: true,
},
}
// First deploy the bundle.
output, err := s.deployBundleYAML(c, content)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:trusty/wordpress-42
service wordpress deployed (charm: cs:trusty/wordpress-42)
service wordpress exposed
added wordpress/0 unit to new machine
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertServicesDeployed(c, expectedServices)
// Then deploy the same bundle again: no error is produced when the service
// is exposed again.
output, err = s.deployBundleYAML(c, content)
c.Assert(err, jc.ErrorIsNil)
expectedOutput = `
added charm cs:trusty/wordpress-42
reusing service wordpress (charm: cs:trusty/wordpress-42)
service wordpress exposed
avoid adding new units to service wordpress: 1 unit already present
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertServicesDeployed(c, expectedServices)
// Then deploy a bundle with the service unexposed, and check that the
// service is not unexposed.
output, err = s.deployBundleYAML(c, `
services:
wordpress:
charm: wordpress
num_units: 1
expose: false
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput = `
added charm cs:trusty/wordpress-42
reusing service wordpress (charm: cs:trusty/wordpress-42)
avoid adding new units to service wordpress: 1 unit already present
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertServicesDeployed(c, expectedServices)
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleSuccess(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/mysql-42", "mysql")
testcharms.UploadCharm(c, s.client, "xenial/wordpress-47", "wordpress")
testcharms.UploadBundle(c, s.client, "bundle/wordpress-simple-1", "wordpress-simple")
_, err := runDeployCommand(c, "bundle/wordpress-simple")
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:xenial/mysql-42", "cs:xenial/wordpress-47")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"mysql": {charm: "cs:xenial/mysql-42"},
"wordpress": {charm: "cs:xenial/wordpress-47"},
})
s.assertRelationsEstablished(c, "wordpress:db mysql:server")
s.assertUnitsCreated(c, map[string]string{
"mysql/0": "0",
"wordpress/0": "1",
})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleWithTermsSuccess(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/terms1-17", "terms1")
testcharms.UploadCharm(c, s.client, "xenial/terms2-42", "terms2")
testcharms.UploadBundle(c, s.client, "bundle/terms-simple-1", "terms-simple")
_, err := runDeployCommand(c, "bundle/terms-simple")
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:xenial/terms1-17", "cs:xenial/terms2-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"terms1": {charm: "cs:xenial/terms1-17"},
"terms2": {charm: "cs:xenial/terms2-42"},
})
s.assertUnitsCreated(c, map[string]string{
"terms1/0": "0",
"terms2/0": "1",
})
c.Assert(s.termsString, gc.Not(gc.Equals), "")
}
func (s *UpgradeCharmCharmStoreStateSuite) TestUpgradeCharmAuthorization(c *gc.C) {
testcharms.UploadCharm(c, s.client, "cs:~other/trusty/wordpress-0", "wordpress")
err := runDeploy(c, "cs:~other/trusty/wordpress-0")
c.Assert(err, jc.ErrorIsNil)
for i, test := range upgradeCharmAuthorizationTests {
c.Logf("test %d: %s", i, test.about)
url, _ := testcharms.UploadCharm(c, s.client, test.uploadURL, "wordpress")
if test.readPermUser != "" {
s.changeReadPerm(c, url, test.readPermUser)
}
err := runUpgradeCharm(c, "wordpress", "--switch", test.switchURL)
if test.expectError != "" {
c.Assert(err, gc.ErrorMatches, test.expectError)
continue
}
c.Assert(err, jc.ErrorIsNil)
}
}
func (s *deployRepoCharmStoreSuite) TestDeployBundleServiceOptions(c *gc.C) {
testcharms.UploadCharm(c, s.client, "trusty/wordpress-42", "wordpress")
testcharms.UploadCharm(c, s.client, "precise/dummy-0", "dummy")
output, err := s.deployBundleYAML(c, `
services:
wordpress:
charm: wordpress
num_units: 1
options:
blog-title: these are the voyages
customized:
charm: precise/dummy-0
num_units: 1
options:
username: who
skill-level: 47
`)
c.Assert(err, jc.ErrorIsNil)
expectedOutput := `
added charm cs:precise/dummy-0
service customized deployed (charm: cs:precise/dummy-0)
added charm cs:trusty/wordpress-42
service wordpress deployed (charm: cs:trusty/wordpress-42)
added customized/0 unit to new machine
added wordpress/0 unit to new machine
deployment of bundle "local:bundle/example-0" completed`
c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))
s.assertCharmsUplodaded(c, "cs:precise/dummy-0", "cs:trusty/wordpress-42")
s.assertServicesDeployed(c, map[string]serviceInfo{
"customized": {
charm: "cs:precise/dummy-0",
config: charm.Settings{"username": "******", "skill-level": int64(47)},
},
"wordpress": {
charm: "cs:trusty/wordpress-42",
config: charm.Settings{"blog-title": "these are the voyages"},
},
})
s.assertUnitsCreated(c, map[string]string{
"wordpress/0": "1",
"customized/0": "0",
})
}