func TestServiceLinkBadChainWithoutChainInDefinition(t *testing.T) {
defer tests.RemoveAllContainers()
if err := tests.FakeServiceDefinition(erisDir, "fake", `
[service]
name = "fake"
image = "quay.io/eris/ipfs"
`); err != nil {
t.Fatalf("can't create a fake service definition: %v", err)
}
do := def.NowDo()
do.Operations.Args = []string{"fake"}
do.Operations.ContainerNumber = 1
do.ChainName = "non-existent-chain"
// [pv]: is this a bug? the service which doesn't have a
// "chain" in its definition file doesn't care about linking at all.
if err := services.StartService(do); err != nil {
t.Fatalf("expect service to start, got %v", err)
}
if n := util.HowManyContainersRunning("fake", def.TypeService); n != 1 {
t.Fatalf("expecting 1 service containers, got %v", n)
}
if n := util.HowManyContainersExisting("fake", def.TypeData); n != 0 {
t.Fatalf("expecting 0 data containers, got %v", n)
}
}
func TestStopDataContainer(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
srv.Operations.SrvContainerName = srv.Operations.DataContainerName
if err := DockerStop(srv.Service, srv.Operations, 5); err == nil {
t.Fatalf("expected stop to fail, got %v", err)
}
tests.RemoveAllContainers()
}
func TestRunServiceNoDataContainer(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
srv.Service.AutoData = false
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 1 {
t.Fatalf("expecting 1 service container running, got %v", n)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 0 {
t.Fatalf("expecting no dependent data containers, got %v", n)
}
tests.RemoveAllContainers()
}
func TestExecServiceAfterRunService(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
srv.Operations.Interactive = true
srv.Operations.Args = []string{"uptime"}
if err := DockerExecService(srv.Service, srv.Operations); err == nil {
t.Fatalf("expected failure due to unpublished ports, got %v", err)
}
tests.RemoveAllContainers()
}
func TestContainerRunningBadName(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
if _, exists := ContainerRunning(srv.Operations); exists == false {
t.Fatalf("expecting service container running, got false")
}
srv.Operations.SrvContainerName = "random-bad-name"
if _, exists := ContainerRunning(srv.Operations); exists == true {
t.Fatalf("expecting data container not running, got true")
}
tests.RemoveAllContainers()
}
func TestExecServiceAfterRunServiceWithPublishedPorts2(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
srv.Operations.PublishAllPorts = true
srv.Operations.Interactive = true
srv.Operations.Args = []string{"uptime"}
if err := DockerExecService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected exec container created, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 1 {
t.Fatalf("expecting 1 service container running, got %v", n)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 1 {
t.Fatalf("expecting 1 dependent data container, got %v", n)
}
tests.RemoveAllContainers()
}
func TestExecServiceBadCommandLine(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
srv.Operations.Interactive = false
srv.Operations.Args = []string{"/bad/command/line"}
if err := DockerExecService(srv.Service, srv.Operations); err == nil {
t.Fatalf("expected failure, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 service container running, got %v", n)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 1 {
t.Fatalf("expecting 1 dependent data container, got %v", n)
}
tests.RemoveAllContainers()
}
func TestCreateDataSimple(t *testing.T) {
const (
name = "testdata"
number = 199
)
if n := util.HowManyContainersExisting(name, def.TypeData); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
ops := loaders.LoadDataDefinition(name, number)
if err := DockerCreateData(ops); err != nil {
t.Fatalf("expected data container created, got %v", err)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 1 {
t.Fatalf("expecting 1 containers, got %v", n)
}
// Try to create a duplicate.
if err := DockerCreateData(ops); err == nil {
t.Fatalf("expected an error, got nil")
}
tests.RemoveAllContainers()
}
func TestServiceLinkKeys(t *testing.T) {
defer tests.RemoveAllContainers()
do := def.NowDo()
do.Name = chainName
do.Operations.ContainerNumber = 1
if err := NewChain(do); err != nil {
t.Fatalf("could not start a new chain, got %v", err)
}
if n := util.HowManyContainersExisting(chainName, def.TypeChain); n != 1 {
t.Fatalf("expecting 1 test chain containers, got %v", n)
}
do = def.NowDo()
do.Operations.Args = []string{"keys"}
do.Operations.ContainerNumber = 1
do.ChainName = chainName
if err := services.StartService(do); err != nil {
t.Fatalf("expecting service to start, got %v", err)
}
if n := util.HowManyContainersExisting("keys", def.TypeService); n != 1 {
t.Fatalf("expecting 1 test chain containers, got %v", n)
}
links := tests.Links("keys", def.TypeService, 1)
if len(links) != 0 {
t.Fatalf("expected service links be empty, got %v", links)
}
}
func TestDataContainerExistsAfterRemove(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
srv.Operations.SrvContainerName = srv.Operations.DataContainerName
if _, exists := DataContainerExists(srv.Operations); exists == false {
t.Fatalf("expecting service container exists, got false")
}
tests.RemoveContainer(name, def.TypeData, number)
if _, exists := DataContainerExists(srv.Operations); exists == true {
t.Fatalf("expecting service container not existing after remove, got true")
}
tests.RemoveAllContainers()
}
func TestServiceLinkWithDataContainer(t *testing.T) {
defer tests.RemoveAllContainers()
do := def.NowDo()
do.Name = chainName
do.Operations.ContainerNumber = 1
if err := NewChain(do); err != nil {
t.Fatalf("could not start a new chain, got %v", err)
}
if err := tests.FakeServiceDefinition(erisDir, "fake", `
chain = "$chain:fake"
[service]
name = "fake"
image = "quay.io/eris/ipfs"
data_container = true
`); err != nil {
t.Fatalf("can't create a fake service definition: %v", err)
}
if n := util.HowManyContainersExisting(chainName, def.TypeChain); n != 1 {
t.Fatalf("expecting 1 test chain containers, got %v", n)
}
if n := util.HowManyContainersExisting("fake", def.TypeService); n != 0 {
t.Fatalf("expecting 0 service containers, got %v", n)
}
if n := util.HowManyContainersExisting("fake", def.TypeData); n != 0 {
t.Fatalf("expecting 0 data containers, got %v", n)
}
do = def.NowDo()
do.Operations.Args = []string{"fake"}
do.Operations.ContainerNumber = 1
do.ChainName = chainName
if err := services.StartService(do); err != nil {
t.Fatalf("expecting service to start, got %v", err)
}
if n := util.HowManyContainersRunning("fake", def.TypeService); n != 1 {
t.Fatalf("expecting 1 service containers, got %v", n)
}
if n := util.HowManyContainersExisting("fake", def.TypeData); n != 1 {
t.Fatalf("expecting 1 data containers, got %v", n)
}
links := tests.Links("fake", def.TypeService, 1)
if len(links) != 1 || !strings.Contains(links[0], chainName) {
t.Fatalf("expected service be linked to a test chain, got %v", links)
}
}
func TestRemoveWithoutData(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
if err := DockerStop(srv.Service, srv.Operations, 5); err != nil {
t.Fatal("expected service container stopped, got %v", err)
}
if n := util.HowManyContainersExisting(name, def.TypeService); n != 1 {
t.Fatalf("expecting 1 service container running (before removal), got %v", n)
}
if err := DockerRemove(srv.Service, srv.Operations, false, true); err != nil {
t.Fatal("expected service container removed, got %v", err)
}
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 service container running (after removal), got %v", n)
}
srv.Operations.SrvContainerName = srv.Operations.DataContainerName
if n := util.HowManyContainersExisting(name, def.TypeData); n != 1 {
t.Fatalf("expecting 1 data container existing (before removal), got %v", n)
}
if err := DockerRemove(srv.Service, srv.Operations, false, true); err != nil {
t.Fatal("expected service container removed, got %v", err)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 0 {
t.Fatalf("expecting 0 data container running (after removal), got %v", n)
}
tests.RemoveAllContainers()
}
func TestStopSimple(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
if err := DockerRunService(srv.Service, srv.Operations); err != nil {
t.Fatalf("expected service container created, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 1 {
t.Fatalf("expecting 1 service containers running, got %v", n)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 1 {
t.Fatalf("expecting 1 service containers existing, got %v", n)
}
if err := DockerStop(srv.Service, srv.Operations, 5); err != nil {
t.Fatalf("expected service container to stop, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 service containers running (after stop), got %v", n)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 0 {
t.Fatalf("expecting 1 service containers existing (after stop), got %v", n)
}
tests.RemoveAllContainers()
}
func TestMain(m *testing.M) {
var logLevel log.LogLevel
logLevel = 0
// logLevel = 1
// logLevel = 3
log.SetLoggers(logLevel, os.Stdout, os.Stderr)
tests.IfExit(tests.TestsInit("perform"))
tests.RemoveAllContainers()
exitCode := m.Run()
if os.Getenv("TEST_IN_CIRCLE") != "true" {
tests.IfExit(tests.TestsTearDown())
}
os.Exit(exitCode)
}
func TestServiceLinkBadChain(t *testing.T) {
defer tests.RemoveAllContainers()
if err := tests.FakeServiceDefinition(erisDir, "fake", `
chain = "$chain:fake"
[service]
name = "fake"
image = "quay.io/eris/ipfs"
`); err != nil {
t.Fatalf("can't create a fake service definition: %v", err)
}
do := def.NowDo()
do.Operations.Args = []string{"fake"}
do.Operations.ContainerNumber = 1
do.ChainName = "non-existent-chain"
if err := services.StartService(do); err == nil {
t.Fatalf("expect start service to fail, got nil")
}
}
func TestServiceLinkBadLiteral(t *testing.T) {
defer tests.RemoveAllContainers()
do := def.NowDo()
do.Name = chainName
do.Operations.ContainerNumber = 1
if err := NewChain(do); err != nil {
t.Fatalf("could not start a new chain, got %v", err)
}
if err := tests.FakeServiceDefinition(erisDir, "fake", `
chain = "blah-blah:blah"
[service]
name = "fake"
image = "quay.io/eris/ipfs"
`); err != nil {
t.Fatalf("can't create a fake service definition: %v", err)
}
if n := util.HowManyContainersExisting(chainName, def.TypeChain); n != 1 {
t.Fatalf("expecting 1 test chain containers, got %v", n)
}
do = def.NowDo()
do.Operations.Args = []string{"fake"}
do.Operations.ContainerNumber = 1
do.ChainName = chainName
// [pv]: probably a bug. Bad literal chain link in a definition
// file doesn't affect the service start. Links is not nil.
if err := services.StartService(do); err != nil {
t.Fatalf("expecting service to start, got %v", err)
}
links := tests.Links("fake", def.TypeService, 1)
if len(links) != 1 || !strings.Contains(links[0], chainName) {
t.Fatalf("expected service be linked to a test chain, got %v", links)
}
}
func TestRunDataSimple(t *testing.T) {
const (
name = "testdata"
number = 199
)
if n := util.HowManyContainersExisting(name, def.TypeData); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
ops := loaders.LoadDataDefinition(name, number)
if err := DockerCreateData(ops); err != nil {
t.Fatalf("expected data container created, got %v", err)
}
ops.Args = []string{"uptime"}
if _, err := DockerRunData(ops, nil); err != nil {
t.Fatalf("expected data successfully run, got %v", err)
}
tests.RemoveAllContainers()
}
func TestDataContainerExistsBadName(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("could not load service definition %v", err)
}
srv.Operations.SrvContainerName = "some-random-name"
if _, exists := DataContainerExists(srv.Operations); exists != false {
t.Fatalf("expecting service container not existing, got true")
}
tests.RemoveAllContainers()
}
func TestRunDataBadCommandLine(t *testing.T) {
const (
name = "testdata"
number = 199
)
if n := util.HowManyContainersExisting(name, def.TypeData); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
ops := loaders.LoadDataDefinition(name, number)
if err := DockerCreateData(ops); err != nil {
t.Fatalf("expected data container created, got %v", err)
}
ops.Args = []string{"/bad/command/line"}
if _, err := DockerRunData(ops, nil); err == nil {
t.Fatalf("expected command line error, got nil")
}
tests.RemoveAllContainers()
}
func TestRunServiceTwoServicesPublishedPorts(t *testing.T) {
const (
name = "ipfs"
number = 99
)
if n := util.HowManyContainersExisting(name, def.TypeService); n != 0 {
t.Fatalf("expecting 0 containers, got %v", n)
}
srv1, err := loaders.LoadServiceDefinition(name, true, number)
if err != nil {
t.Fatalf("1. could not load service definition %v", err)
}
if err := DockerRunService(srv1.Service, srv1.Operations); err != nil {
t.Fatalf("1. expected service container created, got %v", err)
}
srv2, err := loaders.LoadServiceDefinition(name, true, number+1)
if err != nil {
t.Fatalf("2. could not load service definition %v", err)
}
srv2.Operations.PublishAllPorts = true
if err := DockerRunService(srv2.Service, srv2.Operations); err != nil {
t.Fatalf("2. expected service container created, got %v", err)
}
if n := util.HowManyContainersRunning(name, def.TypeService); n != 2 {
t.Fatalf("expecting 2 services running, got %v", n)
}
if n := util.HowManyContainersExisting(name, def.TypeData); n != 2 {
t.Fatalf("expecting 2 dependent data container, got %v", n)
}
tests.RemoveAllContainers()
}
func TestServiceLinkChainedService(t *testing.T) {
defer tests.RemoveAllContainers()
do := def.NowDo()
do.Name = chainName
do.Operations.ContainerNumber = 1
if err := NewChain(do); err != nil {
t.Fatalf("could not start a new chain, got %v", err)
}
if err := tests.FakeServiceDefinition(erisDir, "fake", `
chain = "$chain:fake"
[service]
name = "fake"
image = "quay.io/eris/ipfs"
[dependencies]
services = [ "sham" ]
`); err != nil {
t.Fatalf("can't create a fake service definition: %v", err)
}
if err := tests.FakeServiceDefinition(erisDir, "sham", `
chain = "$chain:sham"
[service]
name = "sham"
image = "quay.io/eris/keys"
data_container = true
`); err != nil {
t.Fatalf("can't create a sham service definition: %v", err)
}
if n := util.HowManyContainersExisting(chainName, def.TypeChain); n != 1 {
t.Fatalf("expecting 1 test chain containers, got %v", n)
}
do = def.NowDo()
do.Operations.Args = []string{"fake"}
do.Operations.ContainerNumber = 1
do.ChainName = chainName
if err := services.StartService(do); err != nil {
t.Fatalf("expecting service to start, got %v", err)
}
if n := util.HowManyContainersRunning("fake", def.TypeService); n != 1 {
t.Fatalf("expecting 1 fake service containers, got %v", n)
}
if n := util.HowManyContainersExisting("fake", def.TypeData); n != 0 {
t.Fatalf("expecting 0 fake data containers, got %v", n)
}
if n := util.HowManyContainersRunning("sham", def.TypeService); n != 1 {
t.Fatalf("expecting 1 sham service containers, got %v", n)
}
if n := util.HowManyContainersExisting("sham", def.TypeData); n != 1 {
t.Fatalf("expecting 1 sham data containers, got %v", n)
}
// [pv]: second service doesn't reference the chain.
links := tests.Links("fake", def.TypeService, 1)
if len(links) != 2 || (!strings.Contains(links[1], chainName) && !strings.Contains(links[0], chainName)) {
t.Fatalf("expected service be linked to a test chain, got %v", links)
}
}