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", }) }