func (s *baseDeclSuite) TestConnection(c *C) {
all := builtin.Interfaces()
// connecting with these interfaces needs to be allowed on
// case-by-case basis
noconnect := map[string]bool{
"bluez": true,
"boot-config": true,
"docker": true,
"fwupd": true,
"location-control": true,
"location-observe": true,
"lxd": true,
"mir": true,
"udisks2": true,
}
for _, iface := range all {
expected := !noconnect[iface.Name()]
comm := Commentf(iface.Name())
// check base declaration
cand := s.connectCand(c, iface.Name(), "", "")
err := cand.Check()
if expected {
c.Check(err, IsNil, comm)
} else {
c.Check(err, NotNil, comm)
}
}
}
func (s *baseDeclSuite) TestSanity(c *C) {
all := builtin.Interfaces()
// these interfaces have rules both for the slots and plugs side
// given how the rules work this can be delicate,
// listed here to make sure that was a conscious decision
bothSides := map[string]bool{
"docker-support": true,
"kernel-module-control": true,
"lxd-support": true,
"snapd-control": true,
}
for _, iface := range all {
plugRule := s.baseDecl.PlugRule(iface.Name())
slotRule := s.baseDecl.SlotRule(iface.Name())
if plugRule == nil && slotRule == nil {
c.Logf("%s is not considered in the base declaration", iface.Name())
c.Fail()
}
if plugRule != nil && slotRule != nil {
if !bothSides[iface.Name()] {
c.Logf("%s have both a base declaration slot rule and plug rule, make sure that's intended and correct", iface.Name())
c.Fail()
}
}
}
}
func (s *AllSuite) TestInterfaces(c *C) {
all := builtin.Interfaces()
c.Check(all, Contains, &builtin.BluezInterface{})
c.Check(all, Contains, &builtin.BoolFileInterface{})
c.Check(all, Contains, &builtin.BrowserSupportInterface{})
c.Check(all, Contains, &builtin.DbusInterface{})
c.Check(all, Contains, &builtin.DockerInterface{})
c.Check(all, Contains, &builtin.DockerSupportInterface{})
c.Check(all, Contains, &builtin.FwupdInterface{})
c.Check(all, Contains, &builtin.FwupdInterface{})
c.Check(all, Contains, &builtin.GpioInterface{})
c.Check(all, Contains, &builtin.HidrawInterface{})
c.Check(all, Contains, &builtin.I2cInterface{})
c.Check(all, Contains, &builtin.IioInterface{})
c.Check(all, Contains, &builtin.LocationControlInterface{})
c.Check(all, Contains, &builtin.LocationObserveInterface{})
c.Check(all, Contains, &builtin.LxdSupportInterface{})
c.Check(all, Contains, &builtin.MirInterface{})
c.Check(all, Contains, &builtin.MprisInterface{})
c.Check(all, Contains, &builtin.PulseAudioInterface{})
c.Check(all, Contains, &builtin.SerialPortInterface{})
c.Check(all, Contains, &builtin.UDisks2Interface{})
c.Check(all, DeepContains, builtin.NewAlsaInterface())
c.Check(all, DeepContains, builtin.NewAvahiObserveInterface())
c.Check(all, DeepContains, builtin.NewBluetoothControlInterface())
c.Check(all, DeepContains, builtin.NewCameraInterface())
c.Check(all, DeepContains, builtin.NewCupsControlInterface())
c.Check(all, DeepContains, builtin.NewFirewallControlInterface())
c.Check(all, DeepContains, builtin.NewFuseSupportInterface())
c.Check(all, DeepContains, builtin.NewGsettingsInterface())
c.Check(all, DeepContains, builtin.NewHomeInterface())
c.Check(all, DeepContains, builtin.NewKernelModuleControlInterface())
c.Check(all, DeepContains, builtin.NewLocaleControlInterface())
c.Check(all, DeepContains, builtin.NewLogObserveInterface())
c.Check(all, DeepContains, builtin.NewMountObserveInterface())
c.Check(all, DeepContains, builtin.NewNetworkBindInterface())
c.Check(all, DeepContains, builtin.NewNetworkControlInterface())
c.Check(all, DeepContains, builtin.NewNetworkInterface())
c.Check(all, DeepContains, builtin.NewNetworkObserveInterface())
c.Check(all, DeepContains, builtin.NewOpenglInterface())
c.Check(all, DeepContains, builtin.NewOpenvSwitchInterface())
c.Check(all, DeepContains, builtin.NewOpenvSwitchSupportInterface())
c.Check(all, DeepContains, builtin.NewOpticalDriveInterface())
c.Check(all, DeepContains, builtin.NewProcessControlInterface())
c.Check(all, DeepContains, builtin.NewRawUsbInterface())
c.Check(all, DeepContains, builtin.NewRemovableMediaInterface())
c.Check(all, DeepContains, builtin.NewScreenInhibitControlInterface())
c.Check(all, DeepContains, builtin.NewSnapdControlInterface())
c.Check(all, DeepContains, builtin.NewSystemObserveInterface())
c.Check(all, DeepContains, builtin.NewSystemTraceInterface())
c.Check(all, DeepContains, builtin.NewTimeControlInterface())
c.Check(all, DeepContains, builtin.NewTimeserverControlInterface())
c.Check(all, DeepContains, builtin.NewTimezoneControlInterface())
c.Check(all, DeepContains, builtin.NewTpmInterface())
c.Check(all, DeepContains, builtin.NewUPowerObserveInterface())
c.Check(all, DeepContains, builtin.NewUnity7Interface())
c.Check(all, DeepContains, builtin.NewX11Interface())
}
func (s *baseDeclSuite) TestSlotInstallation(c *C) {
typMap := map[string]snap.Type{
"core": snap.TypeOS,
"app": snap.TypeApp,
"kernel": snap.TypeKernel,
"gadget": snap.TypeGadget,
}
all := builtin.Interfaces()
for _, iface := range all {
types, ok := slotInstallation[iface.Name()]
compareWithSanitize := false
if !ok { // common ones, only core can install them,
// their plain SanitizeSlot checked for that
types = []string{"core"}
compareWithSanitize = true
}
if types == nil {
// snowflake needs to be tested specially
continue
}
for name, snapType := range typMap {
ok := contains(types, name)
ic := s.installSlotCand(c, iface.Name(), snapType, ``)
slotInfo := ic.Snap.Slots[iface.Name()]
err := ic.Check()
comm := Commentf("%s by %s snap", iface.Name(), name)
if ok {
c.Check(err, IsNil, comm)
} else {
c.Check(err, NotNil, comm)
}
if compareWithSanitize {
sanitizeErr := iface.SanitizeSlot(&interfaces.Slot{SlotInfo: slotInfo})
if err == nil {
c.Check(sanitizeErr, IsNil, comm)
} else {
c.Check(sanitizeErr, NotNil, comm)
}
}
}
}
// test docker specially
ic := s.installSlotCand(c, "docker", snap.TypeApp, ``)
err := ic.Check()
c.Assert(err, Not(IsNil))
c.Assert(err, ErrorMatches, "installation not allowed by \"docker\" slot rule of interface \"docker\"")
// test lxd specially
ic = s.installSlotCand(c, "lxd", snap.TypeApp, ``)
err = ic.Check()
c.Assert(err, Not(IsNil))
c.Assert(err, ErrorMatches, "installation not allowed by \"lxd\" slot rule of interface \"lxd\"")
}
func (s *InfoSnapYamlTestSuite) TestImplicitSlotsAreRealInterfaces(c *C) {
known := make(map[string]bool)
for _, iface := range builtin.Interfaces() {
known[iface.Name()] = true
}
for _, ifaceName := range snap.ImplicitSlotsForTests {
c.Check(known[ifaceName], Equals, true)
}
for _, ifaceName := range snap.ImplicitClassicSlotsForTests {
c.Check(known[ifaceName], Equals, true)
}
}
func (m *InterfaceManager) addInterfaces(extra []interfaces.Interface) error {
for _, iface := range builtin.Interfaces() {
if err := m.repo.AddInterface(iface); err != nil {
return err
}
}
for _, iface := range extra {
if err := m.repo.AddInterface(iface); err != nil {
return err
}
}
return nil
}
func (s *baseDeclSuite) TestAutoConnection(c *C) {
all := builtin.Interfaces()
// these have more complex or in flux policies and have their
// own separate tests
snowflakes := map[string]bool{
"content": true,
"home": true,
"lxd-support": true,
"snapd-control": true,
}
// these simply auto-connect, anything else doesn't
autoconnect := map[string]bool{
"browser-support": true,
"gsettings": true,
"mir": true,
"network": true,
"network-bind": true,
"opengl": true,
"optical-drive": true,
"pulseaudio": true,
"screen-inhibit-control": true,
"unity7": true,
"upower-observe": true,
"x11": true,
}
for _, iface := range all {
if snowflakes[iface.Name()] {
continue
}
expected := autoconnect[iface.Name()]
comm := Commentf(iface.Name())
// cross-check with past behavior
c.Check(expected, Equals, iface.LegacyAutoConnect(), comm)
// check base declaration
cand := s.connectCand(c, iface.Name(), "", "")
err := cand.CheckAutoConnect()
if expected {
c.Check(err, IsNil, comm)
} else {
c.Check(err, NotNil, comm)
}
}
}
func (s *baseDeclSuite) TestAutoConnectPlugSlot(c *C) {
all := builtin.Interfaces()
// these have more complex or in flux policies and have their
// own separate tests
snowflakes := map[string]bool{
"content": true,
"home": true,
"lxd-support": true,
}
for _, iface := range all {
if snowflakes[iface.Name()] {
continue
}
c.Check(iface.AutoConnect(nil, nil), Equals, true)
}
}
func (s *baseDeclSuite) TestPlugInstallation(c *C) {
all := builtin.Interfaces()
restricted := map[string]bool{
"docker-support": true,
"kernel-module-control": true,
"lxd-support": true,
"snapd-control": true,
}
for _, iface := range all {
ic := s.installPlugCand(c, iface.Name(), snap.TypeApp, ``)
err := ic.Check()
comm := Commentf("%s", iface.Name())
if restricted[iface.Name()] {
c.Check(err, NotNil, comm)
} else {
c.Check(err, IsNil, comm)
}
}
}
func (s *baseDeclSuite) TestAutoConnectionOverrideMultiple(c *C) {
plugsSlots := `
plugs:
network-bind:
allow-auto-connection: true
network-control:
allow-auto-connection: true
kernel-module-control:
allow-auto-connection: true
system-observe:
allow-auto-connection: true
hardware-observe:
allow-auto-connection: true
`
snapDecl := s.mockSnapDecl(c, "some-snap", "J60k4JY0HppjwOjW8dZdYc8obXKxujRu", "canonical", plugsSlots)
all := builtin.Interfaces()
// these are a mixture interfaces that the snap plugs
plugged := map[string]bool{
"network-bind": true,
"network-control": true,
"kernel-module-control": true,
"system-observe": true,
"hardware-observe": true,
}
for _, iface := range all {
if !plugged[iface.Name()] {
continue
}
cand := s.connectCand(c, iface.Name(), "", "")
cand.PlugSnapDeclaration = snapDecl
err := cand.CheckAutoConnect()
c.Check(err, IsNil)
}
}
func (s *baseDeclSuite) TestConnectionOnClassic(c *C) {
restore := release.MockOnClassic(false)
defer restore()
all := builtin.Interfaces()
// connecting with these interfaces needs to be allowed on
// case-by-case basis when not on classic
noconnect := map[string]bool{
"modem-manager": true,
"network-manager": true,
"ofono": true,
"pulseaudio": true,
}
for _, onClassic := range []bool{true, false} {
release.OnClassic = onClassic
for _, iface := range all {
if !noconnect[iface.Name()] {
continue
}
expected := onClassic
comm := Commentf(iface.Name())
// check base declaration
cand := s.connectCand(c, iface.Name(), "", "")
err := cand.Check()
if expected {
c.Check(err, IsNil, comm)
} else {
c.Check(err, NotNil, comm)
}
}
}
}