// TestSeries ensures that valid series values are parsed correctly when specified // in the charm metadata. func (s *MetaSuite) TestSeries(c *gc.C) { // series not specified meta, err := charm.ReadMeta(strings.NewReader(dummyMetadata)) c.Assert(err, gc.IsNil) c.Check(meta.Series, gc.Equals, "") for _, seriesName := range []string{"precise", "trusty", "plan9"} { meta, err := charm.ReadMeta(strings.NewReader( fmt.Sprintf("%s\nseries: %s\n", dummyMetadata, seriesName))) c.Assert(err, gc.IsNil) c.Check(meta.Series, gc.Equals, seriesName) } }
func (s *MetaSuite) TestScopeConstraint(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("logging")) c.Assert(err, gc.IsNil) c.Assert(meta.Provides["logging-client"].Scope, gc.Equals, charm.ScopeGlobal) c.Assert(meta.Requires["logging-directory"].Scope, gc.Equals, charm.ScopeContainer) c.Assert(meta.Subordinate, gc.Equals, true) }
func (s *MetaSuite) TestSubordinateWithoutContainerRelation(c *gc.C) { r := repoMeta("dummy") hackYaml := ReadYaml(r) hackYaml["subordinate"] = true _, err := charm.ReadMeta(hackYaml.Reader()) c.Assert(err, gc.ErrorMatches, "subordinate charm \"dummy\" lacks \"requires\" relation with container scope") }
func (s *MetaSuite) TestReadMetaVersion2(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("format2")) c.Assert(err, gc.IsNil) c.Assert(meta.Name, gc.Equals, "format2") c.Assert(meta.Format, gc.Equals, 2) c.Assert(meta.Categories, gc.HasLen, 0) }
func (s *MetaSuite) TestMetaHooks(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("wordpress")) c.Assert(err, gc.IsNil) hooks := meta.Hooks() expectedHooks := map[string]bool{ "install": true, "start": true, "config-changed": true, "action-requested": true, "upgrade-charm": true, "stop": true, "cache-relation-joined": true, "cache-relation-changed": true, "cache-relation-departed": true, "cache-relation-broken": true, "db-relation-joined": true, "db-relation-changed": true, "db-relation-departed": true, "db-relation-broken": true, "logging-dir-relation-joined": true, "logging-dir-relation-changed": true, "logging-dir-relation-departed": true, "logging-dir-relation-broken": true, "monitoring-port-relation-joined": true, "monitoring-port-relation-changed": true, "monitoring-port-relation-departed": true, "monitoring-port-relation-broken": true, "url-relation-joined": true, "url-relation-changed": true, "url-relation-departed": true, "url-relation-broken": true, } c.Assert(hooks, gc.DeepEquals, expectedHooks) }
func (s *MetaSuite) TestRelationsConstraints(c *gc.C) { check := func(s, e string) { meta, err := charm.ReadMeta(strings.NewReader(s)) if e != "" { c.Assert(err, gc.ErrorMatches, e) c.Assert(meta, gc.IsNil) } else { c.Assert(err, gc.IsNil) c.Assert(meta, gc.NotNil) } } prefix := "name: a\nsummary: b\ndescription: c\n" for i, t := range relationsConstraintsTests { c.Logf("test %d", i) check(prefix+t.rels, t.err) check(prefix+"subordinate: true\n"+t.rels, t.err) } // The juju-* namespace is accessible to container-scoped require // relations on subordinate charms. check(prefix+` subordinate: true requires: juju-info: interface: juju-info scope: container`, "") // The juju-* interfaces are allowed on any require relation. check(prefix+` requires: innocuous: juju-info`, "") }
// TestInvalidSeries ensures that invalid series values cause a parse error // when specified in the charm metadata. func (s *MetaSuite) TestInvalidSeries(c *gc.C) { for _, seriesName := range []string{"pre-c1se", "pre^cise", "cp/m", "OpenVMS"} { _, err := charm.ReadMeta(strings.NewReader( fmt.Sprintf("%s\nseries: %s\n", dummyMetadata, seriesName))) c.Assert(err, gc.NotNil) c.Check(err, gc.ErrorMatches, `charm "a" declares invalid series: .*`) } }
func (s *MetaSuite) TestReadMetaVersion1(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("dummy")) c.Assert(err, gc.IsNil) c.Assert(meta.Name, gc.Equals, "dummy") c.Assert(meta.Summary, gc.Equals, "That's a dummy charm.") c.Assert(meta.Description, gc.Equals, "This is a longer description which\npotentially contains multiple lines.\n") c.Assert(meta.Format, gc.Equals, 1) c.Assert(meta.OldRevision, gc.Equals, 0) c.Assert(meta.Subordinate, gc.Equals, false) }
func (s *CharmTestHelperSuite) TestMetaCharm(c *gc.C) { forEachStandardCharm(c, func(name string) { chd := charmtesting.Charms.Dir(name) config := chd.Config() metaYaml := "name: " + name + metaYamlSnippet meta, err := charm.ReadMeta(bytes.NewBuffer([]byte(metaYaml))) c.Assert(err, gc.IsNil) ch := s.AddMetaCharm(c, name, metaYaml, 123) assertCustomCharm(c, ch, "quantal", meta, config, 123) }) }
func (s *MetaSuite) TestParseMetaRelations(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("mysql")) c.Assert(err, gc.IsNil) c.Assert(meta.Provides["server"], gc.Equals, charm.Relation{ Name: "server", Role: charm.RoleProvider, Interface: "mysql", Scope: charm.ScopeGlobal, }) c.Assert(meta.Requires, gc.IsNil) c.Assert(meta.Peers, gc.IsNil) meta, err = charm.ReadMeta(repoMeta("riak")) c.Assert(err, gc.IsNil) c.Assert(meta.Provides["endpoint"], gc.Equals, charm.Relation{ Name: "endpoint", Role: charm.RoleProvider, Interface: "http", Scope: charm.ScopeGlobal, }) c.Assert(meta.Provides["admin"], gc.Equals, charm.Relation{ Name: "admin", Role: charm.RoleProvider, Interface: "http", Scope: charm.ScopeGlobal, }) c.Assert(meta.Peers["ring"], gc.Equals, charm.Relation{ Name: "ring", Role: charm.RolePeer, Interface: "riak", Limit: 1, Scope: charm.ScopeGlobal, }) c.Assert(meta.Requires, gc.IsNil) meta, err = charm.ReadMeta(repoMeta("terracotta")) c.Assert(err, gc.IsNil) c.Assert(meta.Provides["dso"], gc.Equals, charm.Relation{ Name: "dso", Role: charm.RoleProvider, Interface: "terracotta", Optional: true, Scope: charm.ScopeGlobal, }) c.Assert(meta.Peers["server-array"], gc.Equals, charm.Relation{ Name: "server-array", Role: charm.RolePeer, Interface: "terracotta-server", Limit: 1, Scope: charm.ScopeGlobal, }) c.Assert(meta.Requires, gc.IsNil) meta, err = charm.ReadMeta(repoMeta("wordpress")) c.Assert(err, gc.IsNil) c.Assert(meta.Provides["url"], gc.Equals, charm.Relation{ Name: "url", Role: charm.RoleProvider, Interface: "http", Scope: charm.ScopeGlobal, }) c.Assert(meta.Requires["db"], gc.Equals, charm.Relation{ Name: "db", Role: charm.RoleRequirer, Interface: "mysql", Limit: 1, Scope: charm.ScopeGlobal, }) c.Assert(meta.Requires["cache"], gc.Equals, charm.Relation{ Name: "cache", Role: charm.RoleRequirer, Interface: "varnish", Limit: 2, Optional: true, Scope: charm.ScopeGlobal, }) c.Assert(meta.Peers, gc.IsNil) }
func (s *MetaSuite) TestSubordinate(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("logging")) c.Assert(err, gc.IsNil) c.Assert(meta.Subordinate, gc.Equals, true) }
func (s *MetaSuite) TestReadCategory(c *gc.C) { meta, err := charm.ReadMeta(repoMeta("category")) c.Assert(err, gc.IsNil) c.Assert(meta.Categories, gc.DeepEquals, []string{"database"}) }
func (s *DirSuite) assertBundleTo(c *gc.C, baseDir, charmDir string) { var haveSymlinks = true if err := os.Symlink("../target", filepath.Join(charmDir, "hooks/symlink")); err != nil { haveSymlinks = false } dir, err := charm.ReadDir(charmDir) c.Assert(err, gc.IsNil) path := filepath.Join(baseDir, "bundle.charm") file, err := os.Create(path) c.Assert(err, gc.IsNil) err = dir.BundleTo(file) file.Close() c.Assert(err, gc.IsNil) zipr, err := zip.OpenReader(path) c.Assert(err, gc.IsNil) defer zipr.Close() var metaf, instf, emptyf, revf, symf *zip.File for _, f := range zipr.File { c.Logf("Bundled file: %s", f.Name) switch f.Name { case "revision": revf = f case "metadata.yaml": metaf = f case "hooks/install": instf = f case "hooks/symlink": symf = f case "empty/": emptyf = f case "build/ignored": c.Errorf("bundle includes build/*: %s", f.Name) case ".ignored", ".dir/ignored": c.Errorf("bundle includes .* entries: %s", f.Name) } } c.Assert(revf, gc.NotNil) reader, err := revf.Open() c.Assert(err, gc.IsNil) data, err := ioutil.ReadAll(reader) reader.Close() c.Assert(err, gc.IsNil) c.Assert(string(data), gc.Equals, "1") c.Assert(metaf, gc.NotNil) reader, err = metaf.Open() c.Assert(err, gc.IsNil) meta, err := charm.ReadMeta(reader) reader.Close() c.Assert(err, gc.IsNil) c.Assert(meta.Name, gc.Equals, "dummy") c.Assert(instf, gc.NotNil) // Despite it being 0751, we pack and unpack it as 0755. c.Assert(instf.Mode()&0777, gc.Equals, os.FileMode(0755)) if haveSymlinks { c.Assert(symf, gc.NotNil) c.Assert(symf.Mode()&0777, gc.Equals, os.FileMode(0777)) reader, err = symf.Open() c.Assert(err, gc.IsNil) data, err = ioutil.ReadAll(reader) reader.Close() c.Assert(err, gc.IsNil) c.Assert(string(data), gc.Equals, "../target") } else { c.Assert(symf, gc.IsNil) } c.Assert(emptyf, gc.NotNil) c.Assert(emptyf.Mode()&os.ModeType, gc.Equals, os.ModeDir) // Despite it being 0750, we pack and unpack it as 0755. c.Assert(emptyf.Mode()&0777, gc.Equals, os.FileMode(0755)) }