private void addInverseJobs(Map<String, Object> stageData, List<Map<String, Object>> jobs) { Map<String, Object> inverseJobs = new LinkedTreeMap<>(); for (Map<String, Object> job : jobs) { Map<String, Object> inverseJob = jobTransform.inverseTransform(job); if (inverseJob != null) inverseJobs.putAll(inverseJob); } stageData.put("jobs", inverseJobs); }
public JsonObject transform(Object yamlObject) { Map<String, Object> map = (Map<String, Object>) yamlObject; for (Map.Entry<String, Object> entry : map.entrySet()) { return transform(entry); } throw new RuntimeException("expected job hash to have 1 item"); }
public JsonObject transform(String jobName, Map<String, Object> jobMap) { JsonObject jobJson = new JsonObject(); jobJson.addProperty(JSON_JOB_NAME_FIELD, jobName); addOptionalInteger(jobJson, jobMap, JSON_JOB_TIMEOUT_FIELD, YAML_JOB_TIMEOUT_FIELD); addRunInstances(jobMap, jobJson); JsonArray jsonEnvVariables = environmentTransform.transform(jobMap); if (jsonEnvVariables != null && jsonEnvVariables.size() > 0) jobJson.add(JSON_ENV_VAR_FIELD, jsonEnvVariables); addTabs(jobJson, jobMap); addOptionalStringList(jobJson, jobMap, JSON_JOB_RESOURCES_FIELD, YAML_JOB_RESOURCES_FIELD); addOptionalString(jobJson, jobMap, JSON_JOB_ELASTIC_PROFILE_FIELD, YAML_JOB_ELASTIC_PROFILE_FIELD); addArtifacts(jobJson, jobMap); addProperties(jobJson, jobMap); addTasks(jobJson, jobMap); return jobJson; }
public Map<String, Object> inverseTransform(Map<String, Object> job) { if (job == null) return null; String jobName = (String) job.get(JSON_JOB_NAME_FIELD); Map<String, Object> inverseJob = new LinkedTreeMap<>(); Map<String, Object> jobData = new LinkedTreeMap<>(); addOptionalInt(jobData, job, JSON_JOB_TIMEOUT_FIELD, YAML_JOB_TIMEOUT_FIELD); addInverseRunInstances(jobData, job); Map<String, Object> yamlEnvVariables = environmentTransform.inverseTransform((List<Map<String, Object>>) job.get(JSON_ENV_VAR_FIELD)); if (yamlEnvVariables != null && yamlEnvVariables.size() > 0) jobData.putAll(yamlEnvVariables); addInverseTabs(jobData, job); addOptionalList(jobData, job, JSON_JOB_RESOURCES_FIELD, YAML_JOB_RESOURCES_FIELD); addOptionalValue(jobData, job, JSON_JOB_ELASTIC_PROFILE_FIELD, YAML_JOB_ELASTIC_PROFILE_FIELD); addInverseArtifacts(jobData, job); addInverseProperties(jobData, job); addInverseTasks(jobData, job); inverseJob.put(jobName, jobData); return inverseJob; }
@Test public void shouldInverseTransformSingleJobStage() throws IOException { parser = new StageTransform(environmentTransform, new JobTransform(environmentTransform, mock(TaskTransform.class))); testTransform("stage-job"); }
@Test public void shouldTransformSingleJobStage() throws IOException { parser = new StageTransform(environmentTransform, new JobTransform(environmentTransform, mock(TaskTransform.class))); testTransform("stage-job"); }
@Before public void SetUp() { environmentTransform = new EnvironmentVariablesTransform(); taskTransform = mock(TaskTransform.class); parser = new JobTransform(environmentTransform, taskTransform); }
public JsonObject transform(Map.Entry<String, Object> entry) { return transform(entry.getKey(), (Map<String, Object>) entry.getValue()); }
@Test public void shouldInverseTransformCompleteStage() throws IOException { Map<String, Object> jobs = new LinkedTreeMap<>(); jobs.put("one", null); jobs.put("two", null); when(jobTransform.inverseTransform(any(LinkedTreeMap.class))).thenReturn(jobs); testInverseTransform("complete"); }
public RootTransform() { EnvironmentVariablesTransform environmentVarsTransform = new EnvironmentVariablesTransform(); MaterialTransform material = new MaterialTransform(); ParameterTransform parameterTransform = new ParameterTransform(); JobTransform job = new JobTransform(environmentVarsTransform, new TaskTransform()); StageTransform stage = new StageTransform(environmentVarsTransform, job); this.pipelineTransform = new PipelineTransform(material, stage, environmentVarsTransform, parameterTransform); this.environmentsTransform = new EnvironmentsTransform(environmentVarsTransform); }
private void addJobs(JsonObject stage, Map<String, Object> stageMap) { JsonArray jsonJobs = new JsonArray(); Object jobsObj = stageMap.get("jobs"); if (jobsObj == null) { //there are no jobs, then it might be a single-job stage Object tasks = stageMap.get("tasks"); if (tasks == null) throw new YamlConfigException("Stage must have jobs defined, or tasks if only one job should exist"); // single-job stage - expect to find job definition in the stage definition JsonObject job = jobTransform.transform(stage.get(JSON_STAGE_NAME_FIELD).getAsString(), stageMap); jsonJobs.add(job); } else { // standard definition Map<String, Object> jobsMap = (Map<String, Object>) jobsObj; for (Map.Entry<String, Object> entry : jobsMap.entrySet()) { JsonObject job = jobTransform.transform(entry); jsonJobs.add(job); } } stage.add(JSON_STAGE_JOBS_FIELD, jsonJobs); } }
private void testInverseTransform(String caseFile, String expectedFile) throws IOException { Map<String, Object> inverse = parser.inverseTransform(readJsonGson("parts/jobs/" + caseFile + ".json")); assertYamlEquivalent(loadString("parts/jobs/" + expectedFile + ".yaml"), YamlUtils.dump(inverse)); } }
@Test public void shouldTransformJobWithListOfListsTasks() throws IOException { environmentTransform = new EnvironmentVariablesTransform(); taskTransform = new TaskTransform(); parser = new JobTransform(environmentTransform, taskTransform); JsonObject job = testTransform("list_of_lists_tasks"); }
private JsonObject testTransform(String caseFile, String expectedFile) throws IOException { JsonObject expectedObject = (JsonObject) readJsonObject("parts/jobs/" + expectedFile + ".json"); JsonObject jsonObject = parser.transform(readYamlObject("parts/jobs/" + caseFile + ".yaml")); assertThat(jsonObject, is(new JsonObjectMatcher(expectedObject))); return jsonObject; }