matcher

Documentation

Overview

Package matcher implements Gomega matchers for lxkns information model artifacts, such as containers and container groups (pods in particular). These matchers can be used in unit tests of applications using the lxkns API and information model.

While these matchers almost always can be easily written using the existing Gomega matchers these new matchers offer to spell expectations out in a domain-specific language.

For instance, instead of:

Expect(actual).To(ContainElement(And(HaveField("Name", "foo"), HaveField("Type", "docker.com"))))

more succinctly:

Expect(actual).To(ContainElement(BeADockerContainer(WithName("foo"))))

Index

• func BeAContainer(options ...types.GomegaMatcher) types.GomegaMatcher
• func BeADockerContainer(options ...types.GomegaMatcher) types.GomegaMatcher
• func BeAPod(options ...types.GomegaMatcher) types.GomegaMatcher
• func BeInAGroup(opts ...types.GomegaMatcher) types.GomegaMatcher
• func BeInAPod(opts ...types.GomegaMatcher) types.GomegaMatcher
• func BePaused() types.GomegaMatcher
• func HaveLabel(name string, value ...string) types.GomegaMatcher
• func WithFlavor(flavor string) types.GomegaMatcher
• func WithName(nameid string) types.GomegaMatcher
• func WithStrictType(typ string) types.GomegaMatcher
• func WithType(typeflavor string) types.GomegaMatcher

Examples

• BeAContainer
• BeAContainer (Slice)
• BeADockerContainer
• BeAPod
• BeInAGroup
• BeInAPod
• BePaused
• HaveLabel
• WithFlavor
• WithName
• WithStrictType
• WithType

Functions

func BeAContainer

func BeAContainer(options ...types.GomegaMatcher) types.GomegaMatcher

BeAContainer succeeds if actual is a model.Container or *model.Container and also satisfies all its option matchers. A typical use is to use BeAContainer in combination with the "WithX" matchers, such as WithName and WithType. Of course, any other matcher can be specified as an option matcher to BeAContainer as needed.

Example

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   "ducker.io",
	Flavor: "fluffy",
	Groups: []*model.Group{
		{Name: "fluffy", Type: "group.io", Flavor: "fluffy.io"},
	},
	Paused: true,
}

Expect(container).To(BeAContainer())
Expect(container).To(BeAContainer(HaveField("ID", container.ID)))

Example (Slice)

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   "ducker.io",
	Flavor: "fluffy",
	Groups: []*model.Group{
		{Name: "fluffy", Type: "group.io", Flavor: "fluffy.io"},
	},
	Paused: true,
}
containers := []*model.Container{&container}

Expect(containers).To(ContainElement(BeAContainer(WithName("foo_bar"))))
Expect(containers).NotTo(ContainElement(BeAContainer(WithName("baz"))))

func BeADockerContainer

func BeADockerContainer(options ...types.GomegaMatcher) types.GomegaMatcher

BeADockerContainer succeeds if actual is a Docker container and also satisfy all its option matchers.

Example

var dockerC = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   moby.Type,
	Flavor: "fluffy",
}
otherC := dockerC
otherC.Type = "cry-oh.io"

Expect(dockerC).To(BeADockerContainer())
Expect(otherC).NotTo(BeADockerContainer())

func BeAPod

func BeAPod(options ...types.GomegaMatcher) types.GomegaMatcher

BeAPod succeeds if actual is a model.Group or a *model.Group with the Kubernetes pod type, and also satisfies all specified option matchers.

Example

group := model.Group{
	Name: "test/foopod",
	Type: kuhbernetes.PodGroupType,
}
composergroup := model.Group{
	Name: "foobar-project",
	Type: composer.ComposerGroupType,
}
Expect(group).To(BeAPod())
Expect(composergroup).NotTo(BeAPod())

func BeInAGroup

func BeInAGroup(opts ...types.GomegaMatcher) types.GomegaMatcher

BeInAGroup succeeds if actual is a model.Container or *model.Container and the specified option matchers all succeed on a group the actual container belongs to.

Expect(c).To(BeInAGroup(WithName("my_project")))

Example

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   "ducker.io",
	Flavor: "fluffy",
	Groups: []*model.Group{
		{Name: "fluffy", Type: "group.io", Flavor: "fluffy.io"},
	},
}

Expect(container).To(BeInAGroup(WithName("fluffy")))
Expect(container).NotTo(BeInAGroup(WithType(kuhbernetes.PodGroupType)))

func BeInAPod

func BeInAPod(opts ...types.GomegaMatcher) types.GomegaMatcher

BeInAPod succeeds if actual is a model.Container or *model.Container and the container is grouped by a Kubernetes/k8s pod for which all the option matchers also succeed.

Expect(c).To(BeInAPod(WithName("default/mypod")))

Example

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   moby.Type,
	Flavor: moby.Type,
	Groups: []*model.Group{
		{
			Name:   "space/pod",
			Type:   kuhbernetes.PodGroupType,
			Flavor: kuhbernetes.PodGroupType,
		},
	},
}
container.Groups[0].Containers = []*model.Container{&container}
pod := container.Groups[0]

Expect(container).To(BeInAPod())
Expect(container).To(BeInAPod(WithName(pod.Name)))
Expect(container).NotTo(BeInAPod(WithName("Bielefeld")))

func BePaused

func BePaused() types.GomegaMatcher

BePaused succeeds if actual is a model.Container or *model.Container and the container is paused.

Expect(c).To(BePaused())

Example

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   "ducker.io",
	Flavor: "fluffy",
	Groups: []*model.Group{
		{Name: "fluffy", Type: "group.io", Flavor: "fluffy.io"},
	},
	Paused: true,
}
cp := container
cp.Paused = false

Expect(container).To(BePaused())
Expect(cp).NotTo(BePaused())

func HaveLabel

func HaveLabel(name string, value ...string) types.GomegaMatcher

HaveLabel succeeds if actual has a "Labels" field that contains a map key with the specified name and the optionally specified value.

Expect(container).To(HaveLabel("foobar"))
Expect(container).To(HaveLabel("foo", "bar"))

Example

var container = model.Container{
	ID:     "1234567890",
	Name:   "foo_bar",
	Type:   "ducker.io",
	Flavor: "fluffy",
	Labels: model.Labels{
		"foo": "FOO",
	},
}

Expect(container).To(HaveLabel("foo"))        // any value
Expect(container).To(HaveLabel("foo", "FOO")) // specific value

Expect(container).NotTo(HaveLabel("bar"))        // not at all
Expect(container).NotTo(HaveLabel("foo", "BAR")) // not this value

func WithFlavor

func WithFlavor(flavor string) types.GomegaMatcher

WithFlavor succeeds if actual has a Flavor field and the specified flavor matches this field.

Example

var container = model.Container{
	Type:   moby.Type,
	Flavor: "moby",
}

Expect(container).To(WithFlavor("moby"))
Expect(container).NotTo(WithFlavor(moby.Type))

func WithName

func WithName(nameid string) types.GomegaMatcher

WithName succeeds if actual has a Name field and optionally an ID field, and the specified nameid matches at least one of these fields.

Example

var container = model.Container{
	ID:   "1234abcde",
	Name: "morbid_moby",
}

Expect(container).To(WithName("1234abcde"))
Expect(container).To(WithName("morbid_moby"))

func WithStrictType

func WithStrictType(typ string) types.GomegaMatcher

WithStrictType succeeds if actual has a Type field and the specified type matches it.

Example

var container = model.Container{
	Type:   moby.Type,
	Flavor: "moby",
}

Expect(container).To(WithStrictType(container.Type))
Expect(container).NotTo(WithStrictType(container.Flavor))

func WithType

func WithType(typeflavor string) types.GomegaMatcher

WithType succeeds if actual has a Type field and optionally a Flavor field, and the specified typeflavor matches at least one of these fields. If you want to check only for the specific Type but not accept it as a Flavor, then use the WithStrictType matcher instead.

Example

var container = model.Container{
	Type:   moby.Type,
	Flavor: "moby",
}

Expect(container).To(WithType(container.Type))
Expect(container).To(WithType(container.Flavor))