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,
"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)
}
// 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) 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 := testing.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) TestBundleTo(c *gc.C) {
baseDir := c.MkDir()
charmDir := testing.Charms.ClonedDirPath(baseDir, "dummy")
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))
}