configSource.FetchConfigReturns(fetchedConfig, nil)
})
Context("when creating the task's container works", func() {
var (
fakeContainer *wfakes.FakeContainer
fakeProcess *gfakes.FakeProcess
)
BeforeEach(func() {
fakeContainer = new(wfakes.FakeContainer)
fakeContainer.HandleReturns("some-handle")
fakeWorkerClient.CreateContainerReturns(fakeContainer, nil)
fakeProcess = new(gfakes.FakeProcess)
fakeProcess.IDReturns(42)
fakeContainer.RunReturns(fakeProcess, nil)
fakeContainer.StreamInReturns(nil)
})
Describe("before having created the container", func() {
BeforeEach(func() {
taskDelegate.InitializingStub = func(atc.TaskConfig) {
defer GinkgoRecover()
Ω(fakeWorkerClient.CreateContainerCallCount()).Should(BeZero())
}
})
It("invokes the delegate's Initializing callback", func() {
Ω(taskDelegate.InitializingCallCount()).Should(Equal(1))
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
params = atc.Params{"some": "params"}
fakeArtifactSource = new(fakes.FakeArtifactSource)
outScriptStdout = "{}"
outScriptStderr = ""
outScriptExitStatus = 0
runOutError = nil
outScriptProcess = new(gfakes.FakeProcess)
outScriptProcess.IDReturns(42)
outScriptProcess.WaitStub = func() (int, error) {
return outScriptExitStatus, nil
}
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
ioConfig = IOConfig{
Stdout: stdoutBuf,
Stderr: stderrBuf,
}
})
JustBeforeEach(func() {
fakeContainer.RunStub = func(spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
_, _, err = container.NetIn(1235, 5679)
Expect(err).ToNot(HaveOccurred())
info, err := container.Info()
Expect(err).ToNot(HaveOccurred())
Expect(info.MappedPorts).To(Equal([]garden.PortMapping{
{HostPort: 1234, ContainerPort: 5678},
{HostPort: 1235, ContainerPort: 5679},
}))
})
Context("with running processes", func() {
JustBeforeEach(func() {
p1 := new(wfakes.FakeProcess)
p1.IDReturns(1)
p2 := new(wfakes.FakeProcess)
p2.IDReturns(2)
p3 := new(wfakes.FakeProcess)
p3.IDReturns(3)
fakeProcessTracker.ActiveProcessesReturns([]garden.Process{p1, p2, p3})
})
It("returns their process IDs", func() {
info, err := container.Info()
Expect(err).ToNot(HaveOccurred())
Expect(info.ProcessIDs).To(Equal([]uint32{1, 2, 3}))
})
fakeConnection.CurrentMemoryLimitsReturns(garden.MemoryLimits{}, disaster)
})
It("returns the error", func() {
_, err := container.CurrentMemoryLimits()
Ω(err).Should(Equal(disaster))
})
})
})
Describe("Run", func() {
It("sends a run request and returns the process id and a stream", func() {
fakeConnection.RunStub = func(handle string, spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
process := new(wfakes.FakeProcess)
process.IDReturns(42)
process.WaitReturns(123, nil)
go func() {
defer GinkgoRecover()
_, err := fmt.Fprintf(io.Stdout, "stdout data")
Ω(err).ShouldNot(HaveOccurred())
_, err = fmt.Fprintf(io.Stderr, "stderr data")
Ω(err).ShouldNot(HaveOccurred())
}()
return process, nil
}
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
params = atc.Params{"some": "params"}
fakeArtifactSource = new(fakes.FakeArtifactSource)
outScriptStdout = "{}"
outScriptStderr = ""
outScriptExitStatus = 0
runOutError = nil
outScriptProcess = new(gfakes.FakeProcess)
outScriptProcess.IDReturns("process-id")
outScriptProcess.WaitStub = func() (int, error) {
return outScriptExitStatus, nil
}
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
ioConfig = IOConfig{
Stdout: stdoutBuf,
Stderr: stderrBuf,
}
})
JustBeforeEach(func() {
fakeContainer.RunStub = func(spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
version = atc.Version{"some": "version"}
params = atc.Params{"some": "params"}
inScriptStdout = "{}"
inScriptStderr = ""
inScriptExitStatus = 0
runInError = nil
inScriptProcess = new(gfakes.FakeProcess)
inScriptProcess.IDReturns("process-id")
inScriptProcess.WaitStub = func() (int, error) {
return inScriptExitStatus, nil
}
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
ioConfig = IOConfig{
Stdout: stdoutBuf,
Stderr: stderrBuf,
}
})
itCanStreamOut := func() {
Describe("streaming bits out", func() {
fakeConnection.CurrentMemoryLimitsReturns(garden.MemoryLimits{}, disaster)
})
It("returns the error", func() {
_, err := container.CurrentMemoryLimits()
Ω(err).Should(Equal(disaster))
})
})
})
Describe("Run", func() {
It("sends a run request and returns the process id and a stream", func() {
fakeConnection.RunStub = func(handle string, spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
process := new(wfakes.FakeProcess)
process.IDReturns("process-handle")
process.WaitReturns(123, nil)
go func() {
defer GinkgoRecover()
_, err := fmt.Fprintf(io.Stdout, "stdout data")
Ω(err).ShouldNot(HaveOccurred())
_, err = fmt.Fprintf(io.Stderr, "stderr data")
Ω(err).ShouldNot(HaveOccurred())
}()
return process, nil
}
stdoutBuf *gbytes.Buffer
stderrBuf *gbytes.Buffer
)
BeforeEach(func() {
source = atc.Source{"some": "source"}
version = atc.Version{"some": "version"}
params = atc.Params{"some": "params"}
inScriptStdout = "{}"
inScriptStderr = ""
inScriptExitStatus = 0
runInError = nil
inScriptProcess = new(gfakes.FakeProcess)
inScriptProcess.IDReturns(42)
inScriptProcess.WaitStub = func() (int, error) {
return inScriptExitStatus, nil
}
stdoutBuf = gbytes.NewBuffer()
stderrBuf = gbytes.NewBuffer()
ioConfig = IOConfig{
Stdout: stdoutBuf,
Stderr: stderrBuf,
}
})
JustBeforeEach(func() {
fakeContainer.RunStub = func(spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
}))
})
It("should log before and after", func() {
_, err := container.Info()
Expect(err).ToNot(HaveOccurred())
Expect(logger.LogMessages()).To(ContainElement(ContainSubstring("info-starting")))
Expect(logger.LogMessages()).To(ContainElement(ContainSubstring("info-ended")))
})
Context("with running processes", func() {
JustBeforeEach(func() {
p1 := new(wfakes.FakeProcess)
p1.IDReturns("1")
p2 := new(wfakes.FakeProcess)
p2.IDReturns("2")
p3 := new(wfakes.FakeProcess)
p3.IDReturns("3")
fakeProcessTracker.ActiveProcessesReturns([]garden.Process{p1, p2, p3})
})
It("returns their process IDs", func() {
info, err := container.Info()
Expect(err).ToNot(HaveOccurred())
Expect(info.ProcessIDs).To(Equal([]string{"1", "2", "3"}))
})
writing.Add(1)
go func() {
defer writing.Done()
defer GinkgoRecover()
_, err := fmt.Fprintf(io.Stdout, "hi out\n")
Expect(err).ToNot(HaveOccurred())
_, err = fmt.Fprintf(io.Stderr, "hi err\n")
Expect(err).ToNot(HaveOccurred())
}()
process := new(wfakes.FakeProcess)
process.IDReturns(processID)
process.WaitStub = func() (int, error) {
writing.Wait()
return 123, nil
}
return process, nil
}
})
It("streams stderr and stdout and exit status", func() {
stdout := gbytes.NewBuffer()
stderr := gbytes.NewBuffer()
process, err := container.Run(garden.ProcessSpec{
})
})
Describe("Attach", func() {
var (
fakeProcess *gfakes.FakeProcess
process garden.Process
)
processIO := garden.ProcessIO{
Stdout: gbytes.NewBuffer(),
}
BeforeEach(func() {
fakeProcess = new(gfakes.FakeProcess)
fakeProcess.IDReturns(6)
})
itRetries(func() error {
var err error
process, err = conn.Attach("la-contineur", 6, processIO)
return err
}, func(err error) {
innerConnection.AttachReturns(fakeProcess, err)
}, func() int {
return innerConnection.AttachCallCount()
}, func() {
It("calls through to garden", func() {
Ω(innerConnection.AttachCallCount()).Should(Equal(1))
handle, processID, calledProcessIO := innerConnection.AttachArgsForCall(0)
})
})
Describe("Attach", func() {
var (
fakeProcess *gfakes.FakeProcess
process garden.Process
)
processIO := garden.ProcessIO{
Stdout: gbytes.NewBuffer(),
}
BeforeEach(func() {
fakeProcess = new(gfakes.FakeProcess)
fakeProcess.IDReturns("process-id")
})
itRetries(func() error {
var err error
process, err = conn.Attach("la-contineur", "process-id", processIO)
return err
}, func(err error) {
innerConnection.AttachReturns(fakeProcess, err)
}, func() int {
return innerConnection.AttachCallCount()
}, func() {
It("calls through to garden", func() {
Expect(innerConnection.AttachCallCount()).To(Equal(1))
handle, processID, calledProcessIO := innerConnection.AttachArgsForCall(0)
writing.Add(1)
go func() {
defer writing.Done()
defer GinkgoRecover()
_, err := fmt.Fprintf(io.Stdout, "hi out\n")
Expect(err).ToNot(HaveOccurred())
_, err = fmt.Fprintf(io.Stderr, "hi err\n")
Expect(err).ToNot(HaveOccurred())
}()
process := new(wfakes.FakeProcess)
process.IDReturns(processID)
process.WaitStub = func() (int, error) {
writing.Wait()
return 123, nil
}
return process, nil
}
})
It("streams stderr and stdout and exit status", func() {
stdout := gbytes.NewBuffer()
stderr := gbytes.NewBuffer()
process, err := container.Run(garden.ProcessSpec{
