refactor: test on test deploy job specification when success

Author: deryrahman

api/handler/v1beta1/job_test.go

@@ -6,138 +6,146 @@ import (
 	"testing"
 	"time"
 
+	"github.com/google/uuid"
 	v1 "github.com/odpf/optimus/api/handler/v1beta1"
 	pb "github.com/odpf/optimus/api/proto/odpf/optimus/core/v1beta1"
+	"github.com/odpf/optimus/core/progress"
 
-	"github.com/google/uuid"
 	"github.com/odpf/optimus/mock"
 	"github.com/odpf/optimus/models"
 	"github.com/odpf/salt/log"
 	"github.com/stretchr/testify/assert"
 	mock2 "github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
 )
 
-func TestJobSpecificationOnServer(t *testing.T) {
-	log := log.NewNoop()
-	ctx := context.Background()
-
-	t.Run("DeployJobSpecification", func(t *testing.T) {
-		t.Run("should deploy the job", func(t *testing.T) {
-			Version := "1.0.1"
-
-			projectName := "a-data-project"
-			jobName1 := "a-data-job"
-			taskName := "a-data-task"
-
-			projectSpec := models.ProjectSpec{
-				ID:   uuid.Must(uuid.NewRandom()),
-				Name: projectName,
-				Config: map[string]string{
-					"bucket": "gs://some_folder",
-				},
-			}
-
-			namespaceSpec := models.NamespaceSpec{
-				ID:   uuid.Must(uuid.NewRandom()),
-				Name: "dev-test-namespace-1",
-				Config: map[string]string{
-					"bucket": "gs://some_folder",
-				},
-				ProjectSpec: projectSpec,
-			}
-
-			execUnit1 := new(mock.BasePlugin)
-			execUnit1.On("PluginInfo").Return(&models.PluginInfoResponse{
-				Name: taskName,
-			}, nil)
-			defer execUnit1.AssertExpectations(t)
-
-			jobSpecs := []models.JobSpec{
-				{
-					Name: jobName1,
-					Task: models.JobSpecTask{
-						Unit: &models.Plugin{
-							Base: execUnit1,
-						},
-						Config: models.JobSpecConfigs{
-							{
-								Name:  "do",
-								Value: "this",
-							},
-						},
-					},
-					Assets: *models.JobAssets{}.New(
-						[]models.JobSpecAsset{
-							{
-								Name:  "query.sql",
-								Value: "select * from 1",
-							},
-						}),
-				},
-			}
-
-			jobSpecRepository := new(mock.JobSpecRepository)
-			defer jobSpecRepository.AssertExpectations(t)
-
-			jobSpecRepoFactory := new(mock.JobSpecRepoFactory)
-			defer jobSpecRepoFactory.AssertExpectations(t)
-
-			pluginRepo := new(mock.SupportedPluginRepo)
-			pluginRepo.On("GetByName", taskName).Return(&models.Plugin{
-				Base: execUnit1,
-			}, nil)
-			adapter := v1.NewAdapter(pluginRepo, nil)
-
-			nsService := new(mock.NamespaceService)
-			nsService.On("Get", ctx, projectSpec.Name, namespaceSpec.Name).Return(namespaceSpec, nil)
-			defer nsService.AssertExpectations(t)
-
-			projectJobSpecRepository := new(mock.ProjectJobSpecRepository)
-			defer projectJobSpecRepository.AssertExpectations(t)
-
-			projectJobSpecRepoFactory := new(mock.ProjectJobSpecRepoFactory)
-			defer projectJobSpecRepoFactory.AssertExpectations(t)
-
-			jobService := new(mock.JobService)
-			jobService.On("Create", ctx, mock2.Anything, namespaceSpec).Return(nil)
-			jobService.On("KeepOnly", ctx, namespaceSpec, mock2.Anything, mock2.Anything).Return(nil)
-			jobService.On("Sync", mock2.Anything, namespaceSpec, mock2.Anything).Return(nil)
-			defer jobService.AssertExpectations(t)
+type RuntimeServiceServerTestSuite struct {
+	suite.Suite
+	version          string
+	ctx              context.Context
+	namespaceService *mock.NamespaceService
+	projectService   *mock.ProjectService
+	secretService    *mock.SecretService
+	runService       *mock.RunService        // TODO: refactor to service package
+	jobService       *mock.JobService        // TODO: refactor to service package
+	resourceService  models.DatastoreService // TODO: refactor to service package
+	jobEventService  v1.JobEventService      // TODO: refactor to service package
+	adapter          *mock.ProtoAdapter
+	scheduler        models.SchedulerUnit
+	log              log.Logger
+	progressObserver progress.Observer
+
+	req           *pb.DeployJobSpecificationRequest
+	projectSpec   models.ProjectSpec
+	namespaceSpec models.NamespaceSpec
+}
 
-			jobSpecsAdapted := []*pb.JobSpecification{}
-			for _, jobSpec := range jobSpecs {
-				jobSpecAdapted, _ := adapter.ToJobProto(jobSpec)
-				jobSpecsAdapted = append(jobSpecsAdapted, jobSpecAdapted)
-			}
+func (s *RuntimeServiceServerTestSuite) SetupTest() {
+	s.version = "v1.0.0"
+	s.ctx = context.Background()
+	s.namespaceService = new(mock.NamespaceService)
+	s.adapter = new(mock.ProtoAdapter)
+	s.jobService = new(mock.JobService)
+	s.log = log.NewNoop()
+	// ... etdc
+
+	s.projectSpec = models.ProjectSpec{}
+	s.projectSpec.Name = "project-a"
+	s.projectSpec.ID = uuid.MustParse("26a0d6a0-13c6-4b30-ae6f-29233df70f31")
+
+	s.namespaceSpec = models.NamespaceSpec{}
+	s.namespaceSpec.Name = "ns1"
+	s.namespaceSpec.ID = uuid.MustParse("ceba7919-e07d-48b4-a4ce-141d79a3b59d")
+
+	s.req = &pb.DeployJobSpecificationRequest{}
+	s.req.ProjectName = s.projectSpec.Name
+	s.req.NamespaceName = s.namespaceSpec.Name
+}
 
-			grpcRespStream := new(mock.DeployJobSpecificationServer)
-			grpcRespStream.On("Context").Return(context.Background())
-			recv := &pb.DeployJobSpecificationRequest{ProjectName: projectName, Jobs: jobSpecsAdapted, NamespaceName: namespaceSpec.Name}
-			grpcRespStream.On("Recv").Return(recv, nil).Once()
-			grpcRespStream.On("Recv").Return(nil, io.EOF).Once()
-			grpcRespStream.On("Send", mock2.Anything).Return(nil)
-			defer grpcRespStream.AssertExpectations(t)
+func TestRuntimeServiceServerTestSuite(t *testing.T) {
+	s := new(RuntimeServiceServerTestSuite)
+	suite.Run(t, s)
+}
 
-			runtimeServiceServer := v1.NewRuntimeServiceServer(
-				log,
-				Version,
-				jobService,
-				nil, nil,
-				nil,
-				nsService,
-				nil,
-				adapter,
-				nil,
-				nil,
-				nil,
-			)
+func (s *RuntimeServiceServerTestSuite) newRuntimeServiceServer() *v1.RuntimeServiceServer {
+	return v1.NewRuntimeServiceServer(
+		s.log,
+		s.version,
+		s.jobService,
+		s.jobEventService,
+		s.resourceService,
+		s.projectService,
+		s.namespaceService,
+		s.secretService,
+		s.adapter,
+		s.progressObserver,
+		s.runService,
+		s.scheduler,
+	)
+}
 
-			err := runtimeServiceServer.DeployJobSpecification(grpcRespStream)
+func (s *RuntimeServiceServerTestSuite) TestDeployJobSpecification_Success() {
+	s.Run("NoJobSpec", func() {
+		stream := new(mock.DeployJobSpecificationServer)
+		stream.On("Context").Return(s.ctx)
+		stream.On("Recv").Return(s.req, nil).Once()
+		stream.On("Recv").Return(nil, io.EOF).Once()
+
+		s.namespaceService.On("Get", s.ctx, s.req.GetProjectName(), s.req.GetNamespaceName()).Return(s.namespaceSpec, nil).Once()
+		s.jobService.On("KeepOnly", s.ctx, s.namespaceSpec, mock2.Anything, mock2.Anything).Return(nil).Once()
+		s.jobService.On("Sync", s.ctx, s.namespaceSpec, mock2.Anything).Return(nil).Once()
+		stream.On("Send", mock2.Anything).Return(nil).Once()
+
+		runtimeServiceServer := s.newRuntimeServiceServer()
+		err := runtimeServiceServer.DeployJobSpecification(stream)
+
+		s.Assert().NoError(err)
+		stream.AssertExpectations(s.T())
+		s.namespaceService.AssertExpectations(s.T())
+		s.jobService.AssertExpectations(s.T())
+	})
 
-			assert.NoError(t, err)
-		})
+	s.Run("TwoJobSpec", func() {
+		jobSpecs := []*pb.JobSpecification{}
+		jobSpecs = append(jobSpecs, &pb.JobSpecification{Name: "job-1"})
+		jobSpecs = append(jobSpecs, &pb.JobSpecification{Name: "job-2"})
+		s.req.Jobs = jobSpecs
+		adaptedJobs := []models.JobSpec{}
+		adaptedJobs = append(adaptedJobs, models.JobSpec{Name: "job-1"})
+		adaptedJobs = append(adaptedJobs, models.JobSpec{Name: "job-2"})
+
+		stream := new(mock.DeployJobSpecificationServer)
+		stream.On("Context").Return(s.ctx)
+		stream.On("Recv").Return(s.req, nil).Once()
+		stream.On("Recv").Return(nil, io.EOF).Once()
+
+		s.namespaceService.On("Get", s.ctx, s.req.GetProjectName(), s.req.GetNamespaceName()).Return(s.namespaceSpec, nil).Once()
+		for i := range jobSpecs {
+			s.adapter.On("FromJobProto", jobSpecs[i]).Return(adaptedJobs[i], nil).Once()
+			s.jobService.On("Create", s.ctx, s.namespaceSpec, adaptedJobs[i]).Return(nil).Once()
+		}
+		s.jobService.On("KeepOnly", s.ctx, s.namespaceSpec, adaptedJobs, mock2.Anything).Return(nil).Once()
+		s.jobService.On("Sync", s.ctx, s.namespaceSpec, mock2.Anything).Return(nil).Once()
+		stream.On("Send", mock2.Anything).Return(nil).Once()
+
+		runtimeServiceServer := s.newRuntimeServiceServer()
+		err := runtimeServiceServer.DeployJobSpecification(stream)
+
+		s.Assert().NoError(err)
+		stream.AssertExpectations(s.T())
+		s.adapter.AssertExpectations(s.T())
+		s.namespaceService.AssertExpectations(s.T())
+		s.jobService.AssertExpectations(s.T())
 	})
+}
+
+func (s *RuntimeServiceServerTestSuite) TestDeployJobSpecification_Fail() {
+}
 
+// TODO: refactor to test suite
+func TestJobSpecificationOnServer(t *testing.T) {
+	log := log.NewNoop()
+	ctx := context.Background()
 	t.Run("GetJobSpecification", func(t *testing.T) {
 		t.Run("should read a job spec", func(t *testing.T) {
 			Version := "1.0.1"
@@ -287,7 +295,7 @@ func TestJobSpecificationOnServer(t *testing.T) {
 			}
 
 			jobSvc := new(mock.JobService)
-			jobSvc.On("Create", ctx, jobSpec, namespaceSpec).Return(nil)
+			jobSvc.On("Create", ctx, namespaceSpec, jobSpec).Return(nil)
 			jobSvc.On("Check", ctx, namespaceSpec, []models.JobSpec{jobSpec}, mock2.Anything).Return(nil)
 			jobSvc.On("Sync", mock2.Anything, namespaceSpec, mock2.Anything).Return(nil)
 			defer jobSvc.AssertExpectations(t)

mock/job.go

@@ -128,7 +128,7 @@ type JobService struct {
 }
 
 func (srv *JobService) Create(ctx context.Context, spec2 models.NamespaceSpec, spec models.JobSpec) error {
-	args := srv.Called(ctx, spec, spec2)
+	args := srv.Called(ctx, spec2, spec)
 	return args.Error(0)
 }