beckermj/vaguerent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up service runner tests

Browse Source
This commit is contained in:
sophia 2021-07-20 14:17:34 -05:00 committed by Paul Hinze
parent cdb77936fa
commit bb83e4aa46
No known key found for this signature in database
GPG Key ID: B69DEDF2D55501C0
1 changed files with 206 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

450
internal/server/singleprocess/service_runner_test.go
View File

@ -1,286 +1,248 @@
package singleprocess
// import (
// "context"
// "io"
// "testing"
import (
"context"
"io"
"testing"
// "github.com/stretchr/testify/require"
// "google.golang.org/grpc/codes"
// "google.golang.org/grpc/status"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
// "github.com/hashicorp/vagrant/internal/server"
// "github.com/hashicorp/vagrant/internal/server/proto/vagrant_server"
// serverptypes "github.com/hashicorp/vagrant/internal/server/ptypes"
// )
"github.com/hashicorp/vagrant/internal/server"
"github.com/hashicorp/vagrant/internal/server/proto/vagrant_server"
serverptypes "github.com/hashicorp/vagrant/internal/server/ptypes"
)
// // Complete happy path job stream
// func TestServiceRunnerJobStream_complete(t *testing.T) {
// ctx := context.Background()
// require := require.New(t)
// Complete happy path job stream
func TestServiceRunnerJobStream_complete(t *testing.T) {
ctx := context.Background()
require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// Create our server
impl, err := New(WithDB(testDB(t)))
require.NoError(err)
client := server.TestServer(t, impl)
// // Initialize our app
// TestApp(t, client, serverptypes.TestJobNew(t, nil).Application)
// Initialize our basis
TestBasis(t, client, serverptypes.TestBasis(t, nil))
// // Create a job
// queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
// require.NoError(err)
// require.NotNil(queueResp)
// require.NotEmpty(queueResp.JobId)
// Create a job
queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
require.NoError(err)
require.NotNil(queueResp)
require.NotEmpty(queueResp.JobId)
// // Register our runner
// id, _ := TestRunner(t, client, nil)
// Register our runner
id, _ := TestRunner(t, client, nil)
// // Start a job request
// stream, err := client.RunnerJobStream(ctx)
// require.NoError(err)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Request_{
// Request: &vagrant_server.RunnerJobStreamRequest_Request{
// RunnerId: id,
// },
// },
// }))
// Start a job request
stream, err := client.RunnerJobStream(ctx)
require.NoError(err)
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Request_{
Request: &vagrant_server.RunnerJobStreamRequest_Request{
RunnerId: id,
},
},
}))
// // Wait for assignment and ack
// {
// resp, err := stream.Recv()
// require.NoError(err)
// assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
// require.True(ok, "should be an assignment")
// require.NotNil(assignment)
// require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// Wait for assignment and ack
{
resp, err := stream.Recv()
require.NoError(err)
assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
require.True(ok, "should be an assignment")
require.NotNil(assignment)
require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
// Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
// },
// }))
// }
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
},
}))
}
// // Complete the job
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Complete_{
// Complete: &vagrant_server.RunnerJobStreamRequest_Complete{},
// },
// }))
// Complete the job
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Complete_{
Complete: &vagrant_server.RunnerJobStreamRequest_Complete{},
},
}))
// // Should be done
// _, err = stream.Recv()
// require.Error(err)
// require.Equal(io.EOF, err)
// Should be done
_, err = stream.Recv()
require.Error(err)
require.Equal(io.EOF, err)
// // Query our job and it should be done
// job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
// require.NoError(err)
// require.Equal(vagrant_server.Job_SUCCESS, job.State)
// }
// Query our job and it should be done
job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
require.NoError(err)
require.Equal(vagrant_server.Job_SUCCESS, job.State)
}
// func TestServiceRunnerJobStream_badOpen(t *testing.T) {
// ctx := context.Background()
// require := require.New(t)
func TestServiceRunnerJobStream_badOpen(t *testing.T) {
ctx := context.Background()
require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// Create our server
impl, err := New(WithDB(testDB(t)))
require.NoError(err)
client := server.TestServer(t, impl)
// // Start exec with a bad starting message
// stream, err := client.RunnerJobStream(ctx)
// require.NoError(err)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
// Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
// },
// }))
// Start exec with a bad starting message
stream, err := client.RunnerJobStream(ctx)
require.NoError(err)
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
},
}))
// // Wait for data
// resp, err := stream.Recv()
// require.Error(err)
// require.Equal(codes.FailedPrecondition, status.Code(err))
// require.Nil(resp)
// }
// Wait for data
resp, err := stream.Recv()
require.Error(err)
require.Equal(codes.FailedPrecondition, status.Code(err))
require.Nil(resp)
}
// func TestServiceRunnerJobStream_errorBeforeAck(t *testing.T) {
// ctx := context.Background()
// require := require.New(t)
func TestServiceRunnerJobStream_errorBeforeAck(t *testing.T) {
ctx := context.Background()
require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// Create our server
impl, err := New(WithDB(testDB(t)))
require.NoError(err)
client := server.TestServer(t, impl)
// // Initialize our app
// TestApp(t, client, serverptypes.TestJobNew(t, nil).Application)
// Initialize our basis
TestBasis(t, client, serverptypes.TestBasis(t, nil))
// // Create a job
// queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
// require.NoError(err)
// require.NotNil(queueResp)
// require.NotEmpty(queueResp.JobId)
// Create a job
queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
require.NoError(err)
require.NotNil(queueResp)
require.NotEmpty(queueResp.JobId)
// // Register our runner
// id, _ := TestRunner(t, client, nil)
// Register our runner
id, _ := TestRunner(t, client, nil)
// // Start a job request
// stream, err := client.RunnerJobStream(ctx)
// require.NoError(err)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Request_{
// Request: &vagrant_server.RunnerJobStreamRequest_Request{
// RunnerId: id,
// },
// },
// }))
// Start a job request
stream, err := client.RunnerJobStream(ctx)
require.NoError(err)
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Request_{
Request: &vagrant_server.RunnerJobStreamRequest_Request{
RunnerId: id,
},
},
}))
// // Wait for assignment and DONT ack, send an error instead
// {
// resp, err := stream.Recv()
// require.NoError(err)
// assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
// require.True(ok, "should be an assignment")
// require.NotNil(assignment)
// require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// Wait for assignment and DONT ack, send an error instead
{
resp, err := stream.Recv()
require.NoError(err)
assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
require.True(ok, "should be an assignment")
require.NotNil(assignment)
require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Error_{
// Error: &vagrant_server.RunnerJobStreamRequest_Error{
// Error: status.Newf(codes.Unknown, "error").Proto(),
// },
// },
// }))
// }
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Error_{
Error: &vagrant_server.RunnerJobStreamRequest_Error{
Error: status.Newf(codes.Unknown, "error").Proto(),
},
},
}))
}
// // Should be done
// _, err = stream.Recv()
// require.Error(err)
// require.Equal(io.EOF, err)
// Should be done
_, err = stream.Recv()
require.Error(err)
require.Equal(io.EOF, err)
// // Query our job and it should be queued again
// job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
// require.NoError(err)
// require.Equal(vagrant_server.Job_QUEUED, job.State)
// }
// Query our job and it should be queued again
job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
require.NoError(err)
require.Equal(vagrant_server.Job_QUEUED, job.State)
}
// // Complete happy path job stream
// func TestServiceRunnerJobStream_cancel(t *testing.T) {
// ctx := context.Background()
// require := require.New(t)
// Complete happy path job stream
func TestServiceRunnerJobStream_cancel(t *testing.T) {
ctx := context.Background()
require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// Create our server
impl, err := New(WithDB(testDB(t)))
require.NoError(err)
client := server.TestServer(t, impl)
// // Initialize our app
// TestApp(t, client, serverptypes.TestJobNew(t, nil).Application)
// Initialize our basis
TestBasis(t, client, serverptypes.TestBasis(t, nil))
// // Create a job
// queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
// require.NoError(err)
// require.NotNil(queueResp)
// require.NotEmpty(queueResp.JobId)
// Create a job
queueResp, err := client.QueueJob(ctx, &vagrant_server.QueueJobRequest{Job: serverptypes.TestJobNew(t, nil)})
require.NoError(err)
require.NotNil(queueResp)
require.NotEmpty(queueResp.JobId)
// // Register our runner
// id, _ := TestRunner(t, client, nil)
// Register our runner
id, _ := TestRunner(t, client, nil)
// // Start a job request
// stream, err := client.RunnerJobStream(ctx)
// require.NoError(err)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Request_{
// Request: &vagrant_server.RunnerJobStreamRequest_Request{
// RunnerId: id,
// },
// },
// }))
// Start a job request
stream, err := client.RunnerJobStream(ctx)
require.NoError(err)
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Request_{
Request: &vagrant_server.RunnerJobStreamRequest_Request{
RunnerId: id,
},
},
}))
// // Wait for assignment and ack
// {
// resp, err := stream.Recv()
// require.NoError(err)
// assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
// require.True(ok, "should be an assignment")
// require.NotNil(assignment)
// require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// Wait for assignment and ack
{
resp, err := stream.Recv()
require.NoError(err)
assignment, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Assignment)
require.True(ok, "should be an assignment")
require.NotNil(assignment)
require.Equal(queueResp.JobId, assignment.Assignment.Job.Id)
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
// Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
// },
// }))
// }
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Ack_{
Ack: &vagrant_server.RunnerJobStreamRequest_Ack{},
},
}))
}
// // Cancel the job
// _, err = client.CancelJob(ctx, &vagrant_server.CancelJobRequest{JobId: queueResp.JobId})
// require.NoError(err)
// Cancel the job
_, err = client.CancelJob(ctx, &vagrant_server.CancelJobRequest{JobId: queueResp.JobId})
require.NoError(err)
// // Wait for the cancel event
// {
// resp, err := stream.Recv()
// require.NoError(err)
// _, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Cancel)
// require.True(ok, "should be an assignment")
// }
// Wait for the cancel event
{
resp, err := stream.Recv()
require.NoError(err)
_, ok := resp.Event.(*vagrant_server.RunnerJobStreamResponse_Cancel)
require.True(ok, "should be an assignment")
}
// // Complete the job
// require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
// Event: &vagrant_server.RunnerJobStreamRequest_Complete_{
// Complete: &vagrant_server.RunnerJobStreamRequest_Complete{},
// },
// }))
// Complete the job
require.NoError(stream.Send(&vagrant_server.RunnerJobStreamRequest{
Event: &vagrant_server.RunnerJobStreamRequest_Complete_{
Complete: &vagrant_server.RunnerJobStreamRequest_Complete{},
},
}))
// // Should be done
// _, err = stream.Recv()
// require.Error(err)
// require.Equal(io.EOF, err, err.Error())
// Should be done
_, err = stream.Recv()
require.Error(err)
require.Equal(io.EOF, err, err.Error())
// // Query our job and it should be done
// job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
// require.NoError(err)
// require.Equal(vagrant_server.Job_SUCCESS, job.State)
// require.NotEmpty(job.CancelTime)
// }
// func TestServiceRunnerGetDeploymentConfig(t *testing.T) {
// ctx := context.Background()
// t.Run("with no server config", func(t *testing.T) {
// require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// // Request deployment config
// resp, err := client.RunnerGetDeploymentConfig(ctx, &vagrant_server.RunnerGetDeploymentConfigRequest{})
// require.NoError(err)
// require.Empty(resp.ServerAddr)
// })
// t.Run("with server config", func(t *testing.T) {
// require := require.New(t)
// // Create our server
// impl, err := New(WithDB(testDB(t)))
// require.NoError(err)
// client := server.TestServer(t, impl)
// // Set some config
// _, err = client.SetServerConfig(ctx, &vagrant_server.SetServerConfigRequest{
// Config: serverptypes.TestServerConfig(t, nil),
// })
// require.NoError(err)
// // Request deployment config
// resp, err := client.RunnerGetDeploymentConfig(ctx, &vagrant_server.RunnerGetDeploymentConfigRequest{})
// require.NoError(err)
// require.NotEmpty(resp.ServerAddr)
// })
// }
// Query our job and it should be done
job, err := testServiceImpl(impl).state.JobById(queueResp.JobId, nil)
require.NoError(err)
require.Equal(vagrant_server.Job_SUCCESS, job.State)
require.NotEmpty(job.CancelTime)
}