func makeResultSet(t *testing.T) resultset {
temp, err := runtime.NewTemporaryStorage(os.TempDir())
if err != nil {
t.Fatal(err)
}
context, _, err := runtime.NewTaskContext(temp.NewFilePath(), runtime.TaskInfo{}, nil)
if err != nil {
t.Fatal(err)
}
config := configType{
CreateUser: false,
}
e := engine{
config: &config,
log: logrus.New().WithField("component", "test"),
}
return resultset{
ResultSetBase: engines.ResultSetBase{},
taskUser: user{},
context: context,
success: true,
engine: &e,
}
}
func newTaskRun(
config *configType,
claim *taskClaim,
environment *runtime.Environment,
engine engines.Engine,
plugin plugins.Plugin,
log *logrus.Entry,
) (*TaskRun, error) {
tp := environment.TemporaryStorage.NewFilePath()
info := runtime.TaskInfo{
TaskID: claim.taskClaim.Status.TaskID,
RunID: claim.taskClaim.RunID,
Created: claim.taskClaim.Task.Created,
Deadline: claim.taskClaim.Task.Deadline,
Expires: claim.taskClaim.Task.Expires,
}
ctxt, ctxtctl, err := runtime.NewTaskContext(tp, info, environment.WebHookServer)
queueClient := queue.New(&tcclient.Credentials{
ClientID: claim.taskClaim.Credentials.ClientID,
AccessToken: claim.taskClaim.Credentials.AccessToken,
Certificate: claim.taskClaim.Credentials.Certificate,
})
if config.QueueBaseURL != "" {
queueClient.BaseURL = config.QueueBaseURL
}
ctxtctl.SetQueueClient(queueClient)
if err != nil {
return nil, err
}
t := &TaskRun{
TaskID: claim.taskID,
RunID: claim.runID,
definition: claim.definition,
log: log,
context: ctxt,
controller: ctxtctl,
engine: engine,
plugin: plugin,
queueURL: config.QueueBaseURL,
stopReclaims: make(chan struct{}),
reclaimsDone: make(chan struct{}),
}
go t.reclaim(time.Time(claim.taskClaim.TakenUntil))
return t, nil
}
func newTestSandbox(taskPayload *payloadType, env []string) (*sandbox, error) {
temp, err := runtime.NewTemporaryStorage(os.TempDir())
if err != nil {
return nil, err
}
context, _, err := runtime.NewTaskContext(temp.NewFilePath(), runtime.TaskInfo{}, nil)
if err != nil {
return nil, err
}
config := configType{
CreateUser: false,
}
e := engine{
EngineBase: engines.EngineBase{},
config: &config,
log: logrus.New().WithField("component", "test"),
}
return newSandbox(context, taskPayload, env, &e), nil
}
func (p *EngineProvider) newTestTaskContext() (*runtime.TaskContext, *runtime.TaskContextController) {
ctx, control, err := runtime.NewTaskContext(p.environment.TemporaryStorage.NewFilePath(), runtime.TaskInfo{}, nil)
nilOrPanic(err, "Failed to create new TaskContext")
return ctx, control
}
// Test is called to trigger a plugintest.Case to run
func (c Case) Test() {
runtimeEnvironment := newTestEnvironment()
testServer, err := webhookserver.NewTestServer()
nilOrPanic(err)
defer testServer.Stop()
runtimeEnvironment.WebHookServer = testServer
engineProvider := engines.Engines()["mock"]
engine, err := engineProvider.NewEngine(engines.EngineOptions{
Environment: runtimeEnvironment,
Log: runtimeEnvironment.Log.WithField("engine", "mock"),
// TODO: Add engine config
})
nilOrPanic(err, "engineProvider.NewEngine failed")
taskID := c.TaskID
if taskID == "" {
taskID = slugid.Nice()
}
context, controller, err := runtime.NewTaskContext(runtimeEnvironment.TemporaryStorage.NewFilePath(), runtime.TaskInfo{
TaskID: taskID,
RunID: c.RunID,
}, testServer)
nilOrPanic(err)
if c.QueueMock != nil {
controller.SetQueueClient(c.QueueMock)
}
sandboxBuilder, err := engine.NewSandboxBuilder(engines.SandboxOptions{
TaskContext: context,
Payload: parseEnginePayload(engine, c.Payload),
})
nilOrPanic(err, "engine.NewSandboxBuilder failed")
provider := plugins.Plugins()[c.Plugin]
assert(provider != nil, "Plugin does not exist! You tried to load: ", c.Plugin)
p, err := provider.NewPlugin(plugins.PluginOptions{
Environment: runtimeEnvironment,
Engine: engine,
Log: runtimeEnvironment.Log.WithField("plugin", c.Plugin),
Config: parsePluginConfig(provider, c.PluginConfig),
})
nilOrPanic(err, "pluginProvider.NewPlugin failed")
tp, err := p.NewTaskPlugin(plugins.TaskPluginOptions{
TaskInfo: &context.TaskInfo,
Payload: parsePluginPayload(p, c.Payload),
Log: runtimeEnvironment.Log.WithField("plugin", c.Plugin).WithField("taskId", taskID),
})
nilOrPanic(err, "plugin.NewTaskPlugin failed")
// taskPlugin can be nil, if the plugin doesn't want any hooks
if tp == nil {
tp = plugins.TaskPluginBase{}
}
options := Options{
Environment: runtimeEnvironment,
SandboxBuilder: sandboxBuilder,
Engine: engine,
Plugin: p,
TaskPlugin: tp,
}
err = tp.Prepare(context)
nilOrPanic(err, "taskPlugin.Prepare failed")
// Set environment variables and proxies
for key, val := range c.Env {
nilOrPanic(err, sandboxBuilder.SetEnvironmentVariable(key, val),
"Error setting env var: %s = %s", key, val)
}
for hostname, handler := range c.Proxies {
nilOrPanic(err, sandboxBuilder.AttachProxy(hostname, handler),
"Error attaching proxy for hostname: %s", hostname)
}
c.maybeRun(c.BeforeBuildSandbox, options)
err = tp.BuildSandbox(sandboxBuilder)
nilOrPanic(err, "taskPlugin.BuildSandbox failed")
c.maybeRun(c.AfterBuildSandbox, options)
c.maybeRun(c.BeforeStarted, options)
sandbox, err := sandboxBuilder.StartSandbox()
nilOrPanic(err, "sandboxBuilder.StartSandbox failed")
err = tp.Started(sandbox)
nilOrPanic(err, "taskPlugin.Started failed")
c.maybeRun(c.AfterStarted, options)
c.maybeRun(c.BeforeStopped, options)
resultSet, err := sandbox.WaitForResult()
nilOrPanic(err, "sandbox.WaitForResult failed")
assert(resultSet.Success() == c.EngineSuccess)
success, err := tp.Stopped(resultSet)
nilOrPanic(err, "taskPlugin.Stopped failed")
assert(success == c.PluginSuccess)
c.maybeRun(c.AfterStopped, options)
c.maybeRun(c.BeforeFinished, options)
controller.CloseLog()
err = tp.Finished(success)
nilOrPanic(err, "taskPlugin.Finished failed")
c.grepLog(context)
c.maybeRun(c.AfterFinished, options)
c.maybeRun(c.BeforeDisposed, options)
controller.Dispose()
err = tp.Dispose()
nilOrPanic(err, "taskPlugin.Dispose failed")
c.maybeRun(c.AfterDisposed, options)
}