func WorkflowMockGenHook()

in codegen/post_gen_hooks.go [350:479]
114 lines of code
15 McCabe index (conditional complexity)

func WorkflowMockGenHook(h *PackageHelper, t *Template) PostGenHook {
	return func(instances map[string][]*ModuleInstance) error {
		errChanSize := 0
		shouldGenMap := map[*ModuleInstance][]*EndpointSpec{}
		for _, instance := range instances["endpoint"] {
			if instance.GeneratedSpec() == nil {
				continue
			}
			endpointSpecs := instance.GeneratedSpec().([]*EndpointSpec)
			for _, endpointSpec := range endpointSpecs {
				if endpointSpec.WorkflowType == "custom" {
					shouldGenMap[instance] = endpointSpecs
					errChanSize += len(endpointSpecs)
					break
				}
			}
		}

		genEndpointCount := len(shouldGenMap)
		if genEndpointCount == 0 {
			return nil
		}
		errChanSize += genEndpointCount

		fmt.Printf("Generating %d endpoint mocks:\n", genEndpointCount)
		ec := make(chan error, errChanSize)
		var idx int32 = 1
		var files sync.Map
		var wg sync.WaitGroup
		for instance, endpointSpecs := range shouldGenMap {
			wg.Add(1)
			go func(instance *ModuleInstance, endpointSpecs []*EndpointSpec) {
				defer wg.Done()

				buildDir := h.CodeGenTargetPath()
				genDir := filepath.Join(buildDir, instance.Directory, "mock-workflow")

				cwf, err := FindClientsWithFixture(instance)
				if err != nil {
					ec <- errors.Wrapf(
						err,
						"Error generating mock endpoint %s",
						instance.InstanceName,
					)
					return
				}

				var subWg sync.WaitGroup

				subWg.Add(1)
				go func() {
					defer subWg.Done()

					mockClientsType, err := generateEndpointMockClientsType(instance, cwf, h, t)
					if err != nil {
						ec <- errors.Wrapf(
							err,
							"Error generating mock clients type.go for endpoint %s",
							instance.InstanceName,
						)
						return
					}
					files.Store(filepath.Join(genDir, "type.go"), mockClientsType)
				}()

				for _, endpointSpec := range endpointSpecs {
					if endpointSpec.WorkflowType != "custom" {
						continue
					}

					subWg.Add(1)

					go func(espec *EndpointSpec) {
						defer subWg.Done()

						mockWorkflow, err := generateMockWorkflow(espec, instance, cwf, h, t)
						if err != nil {
							ec <- errors.Wrapf(
								err,
								"Error generating mock workflow for %s",
								instance.InstanceName,
							)
							return
						}
						filename := strings.ToLower(espec.ThriftServiceName) + "_" +
							strings.ToLower(espec.ThriftMethodName) + "_workflow_mock.go"
						files.Store(filepath.Join(genDir, filename), mockWorkflow)
					}(endpointSpec)
				}

				subWg.Wait()
				PrintGenLine(
					"mock",
					instance.ClassName,
					instance.InstanceName,
					path.Join(path.Base(buildDir), instance.Directory, "mock-workflow"),
					int(atomic.LoadInt32(&idx)), genEndpointCount,
				)
				atomic.AddInt32(&idx, 1)
			}(instance, endpointSpecs)
		}
		wg.Wait()

		select {
		case err := <-ec:
			close(ec)
			errs := []string{err.Error()}
			for e := range ec {
				errs = append(errs, e.Error())
			}
			return errors.Errorf(
				"encountered %d errors when generating mock endpoint workflows:\n%s",
				len(errs),
				strings.Join(errs, "\n"),
			)
		default:
		}

		var err error

		files.Range(func(p, data interface{}) bool {
			if err = WriteAndFormat(p.(string), data.([]byte)); err != nil {
				return false
			}
			return true
		})

		return err
	}
}