~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

        "net/url"

        "os"

        "path"

        "sort"

        "strings"

 

        "gopkg.in/juju/charm.v6-unstable"

        "gopkg.in/juju/charmrepo.v2-unstable"

        "gopkg.in/juju/charmrepo.v2-unstable/csclient"

        "gopkg.in/juju/charmstore.v5-unstable"

        "gopkg.in/macaroon-bakery.v1/bakery"

        "gopkg.in/macaroon-bakery.v1/bakery/checkers"

        "github.com/juju/juju/environs/config"

        "github.com/juju/juju/instance"

        "github.com/juju/juju/juju/testing"

        "github.com/juju/juju/state"

        "github.com/juju/juju/storage/poolmanager"

        "github.com/juju/juju/storage/provider"

        c.Assert(err, gc.ErrorMatches, `charm or bundle URL has invalid form: "/home/nowhere"`)

}

 

func (s *DeploySuite) TestPathWithNoCharm(c *gc.C) {

        err := runDeploy(c, c.MkDir())

        c.Assert(err, gc.ErrorMatches, `no charm or bundle found at .*`)

        })

}

 

func (s *DeploySuite) TestNetworksIsDeprecated(c *gc.C) {

        testcharms.Repo.CharmArchivePath(s.SeriesPath, "dummy")

        err := runDeploy(c, "local:dummy", "--networks", ", net1, net2 , ", "--constraints", "mem=2G cpu-cores=2 networks=net1,net0,^net3,^net4")

 

        for i, test := range deploySeriesTests {

                c.Logf("test %d", i)

                c.Assert(err, jc.ErrorIsNil)

                series, msg, err := charmSeries(test.requestedSeries, test.seriesFromCharm, test.supportedSeries, test.force, cfg)

                if test.err != "" {

Deployment under prior agreement to terms: term1/1 term3/1

`

        c.Assert(output, gc.Equals, strings.TrimSpace(expectedOutput))

        s.assertServicesDeployed(c, map[string]serviceInfo{

                "terms1": {charm: "cs:trusty/terms1-1"},

        })

        c.Assert(err, gc.ErrorMatches, expectedError)

}

 

const (

        // clientUserCookie is the name of the cookie which is

        // used to signal to the charmStoreSuite macaroon discharger

                PublicKeyLocator: keyring,

                TermsLocation:    s.termsDischarger.Location(),

        }

        c.Assert(err, jc.ErrorIsNil)

        s.handler = handler

        s.srv = httptest.NewServer(handler)

        s.client = csclient.New(csclient.Params{

                URL:      s.srv.URL,

                User:     params.AuthUsername,

        s.PatchValue(&charmrepo.CacheDir, c.MkDir())

 

        // Point the CLI to the charm store testing server.

                // Add a cookie so that the discharger can detect whether the

                // HTTP client is the juju environment or the juju client.

                lurl, err := url.Parse(s.discharger.Location())

                c.Assert(err, jc.ErrorIsNil)

                        Name:  clientUserCookie,

                        Value: clientUserName,

                }})

        })

 

        // Point the Juju API server to the charm store testing server.

        s.PatchValue(&csclient.ServerURL, s.srv.URL)

 

}

 

func (s *charmStoreSuite) TearDownTest(c *gc.C) {

        c.Assert(err, jc.ErrorIsNil)

}

 

        charms, err := s.State.AllCharms()

        c.Assert(err, jc.ErrorIsNil)

        uploaded := make([]string, len(charms))

        c.Assert(err, jc.ErrorIsNil)

        c.Assert(ch.URL(), gc.DeepEquals, curl)

        c.Assert(called, jc.IsTrue)

        stub.CheckCalls(c, []jujutesting.StubCall{{

                "Authorize", []interface{}{metricRegistrationPost{

                        ModelUUID:   modelUUID,

        c.Assert(err, jc.ErrorIsNil)

        c.Assert(ch.URL(), gc.DeepEquals, curl)

        c.Assert(called, jc.IsTrue)

        stub.CheckCalls(c, []jujutesting.StubCall{{

                "DefaultPlan", []interface{}{"cs:quantal/metered-1"},

        }, {

        c.Assert(command.flagSet, jc.DeepEquals, flagSet)

        // Add to the slice below if a new flag is introduced which is valid for

        // both charms and bundles.

        var allFlags []string

        flagSet.VisitAll(func(flag *gnuflag.Flag) {

                allFlags = append(allFlags, flag.Name)

        _, err = s.State.AddSpace("public", "", nil, false)

        c.Assert(err, jc.ErrorIsNil)

 

        c.Assert(err, jc.ErrorIsNil)

        s.assertServicesDeployed(c, map[string]serviceInfo{

        })

        s.assertDeployedServiceBindings(c, map[string]serviceInfo{

                        endpointBindings: map[string]string{

                                "cache":           "public",

                                "url":             "public",

                                "logging-dir":     "public",

                                "monitoring-port": "public",

                                "db":              "db",

                        },

                },

        })

 

var _ = gc.Suite(&ParseBindSuite{})

 

}