public EnvironmentVariablesTransformTest() { parser = new EnvironmentVariablesTransform(); }
public JsonArray transform(Object all) { Map<String, Object> map = (Map<String, Object>) all; return transform(map.get(YAML_ENV_VAR_FIELD), map.get(YAML_SEC_VAR_FIELD)); } }
public Map<String, Object> inverseTransform(List<Map<String, Object>> vars) { if (vars == null) return null; return inverseTransformPlainAndSecureOptions(vars, YAML_ENV_VAR_FIELD, YAML_SEC_VAR_FIELD); }
public Map<String, Object> inverseTransform(Map<String, Object> stage) { if (stage == null) { return stage; } String stageName = (String) stage.get(JSON_STAGE_NAME_FIELD); Map<String, Object> inverseStage = new LinkedTreeMap<>(); Map<String, Object> stageData = new LinkedTreeMap<>(); addOptionalValue(stageData, stage, JSON_STAGE_FETCH_FIELD, YAML_STAGE_FETCH_FIELD); addOptionalValue(stageData, stage, JSON_STAGE_NEVER_CLEAN_FIELD, YAML_STAGE_KEEP_ARTIFACTS_FIELD); addOptionalValue(stageData, stage, JSON_STAGE_CLEAN_WORK_FIELD, YAML_STAGE_CLEAN_WORK_FIELD); addInverseApproval(stageData, stage); Map<String, Object> yamlEnvVariables = environmentTransform.inverseTransform((List<Map<String, Object>>) stage.get(JSON_ENV_VAR_FIELD)); if (yamlEnvVariables != null && yamlEnvVariables.size() > 0) stageData.putAll(yamlEnvVariables); addInverseJobs(stageData, (List<Map<String, Object>>) stage.get(JSON_STAGE_JOBS_FIELD)); inverseStage.put(stageName, stageData); return inverseStage; }
public JsonArray transform(Object variables, Object secureVariables) { JsonArray array = new JsonArray(); transformPlainAndSecureOptions(array, variables, secureVariables, JSON_ENV_NAME_FIELD); return array; }
public Map<String, Object> inverseTransform(Map<String, Object> pipeline) { Map<String, Object> result = new LinkedTreeMap<>(); Map<String, Object> pipelineMap = new LinkedTreeMap<>(); String name = (String) pipeline.get(JSON_PIPELINE_NAME_FIELD); pipelineMap.put(YAML_PIPELINE_GROUP_FIELD, pipeline.get(JSON_PIPELINE_GROUP_FIELD)); addOptionalValue(pipelineMap, pipeline, JSON_PIPELINE_TEMPLATE_FIELD, YAML_PIPELINE_TEMPLATE_FIELD); addOptionalValue(pipelineMap, pipeline, JSON_PIPELINE_LABEL_TEMPLATE_FIELD, YAML_PIPELINE_LABEL_TEMPLATE_FIELD); addOptionalValue(pipelineMap, pipeline, JSON_PIPELINE_PIPE_LOCKING_FIELD, YAML_PIPELINE_PIPE_LOCKING_FIELD); addOptionalValue(pipelineMap, pipeline, JSON_PIPELINE_LOCK_BEHAVIOR_FIELD, YAML_PIPELINE_LOCK_BEHAVIOR_FIELD); addOptionalValue(pipelineMap, pipeline, JSON_PIPELINE_TRACKING_TOOL_FIELD, YAML_PIPELINE_TRACKING_TOOL_FIELD); addInverseTimer(pipelineMap, pipeline); Map<String, Object> yamlEnvVariables = variablesTransform.inverseTransform((List<Map<String, Object>>) pipeline.get(JSON_ENV_VAR_FIELD)); if (yamlEnvVariables != null && yamlEnvVariables.size() > 0) pipelineMap.putAll(yamlEnvVariables); addInverseMaterials(pipelineMap, (List<Map<String, Object>>) pipeline.get(JSON_PIPELINE_MATERIALS_FIELD)); if (!pipelineMap.containsKey(YAML_PIPELINE_TEMPLATE_FIELD)) { addInverseStages(pipelineMap, (List<Map<String, Object>>) pipeline.get(JSON_PIPELINE_STAGES_FIELD)); } Map<String, Object> params = parameterTransform.inverseTransform((List<Map<String, Object>>) pipeline.get("parameters")); if (params != null && !params.isEmpty()) { pipelineMap.putAll(params); } result.put(name, pipelineMap); return result; }
public EnvironmentsTransformTest() { parser = new EnvironmentsTransform(new EnvironmentVariablesTransform()); }
public JsonObject transform(Map.Entry<String, Object> env) { String envName = env.getKey(); JsonObject envJson = new JsonObject(); envJson.addProperty(JSON_ENV_NAME_FIELD, envName); Object envObj = env.getValue(); if (envObj == null) return envJson; if (!(envObj instanceof Map)) throw new YamlConfigException("Expected environment to be a hash"); Map<String, Object> envMap = (Map<String, Object>) envObj; addOptionalStringList(envJson, envMap, "agents", "agents"); addOptionalStringList(envJson, envMap, "pipelines", "pipelines"); JsonArray jsonEnvVariables = environmentVariablesTransform.transform(envMap); if (jsonEnvVariables != null && jsonEnvVariables.size() > 0) envJson.add(JSON_ENV_VAR_FIELD, jsonEnvVariables); return envJson; } }
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; }
@Before public void SetUp() { environmentTransform = new EnvironmentVariablesTransform(); taskTransform = mock(TaskTransform.class); parser = new JobTransform(environmentTransform, taskTransform); }
public JsonObject transform(Map.Entry<String, Object> entry) { String stageName = entry.getKey(); JsonObject stage = new JsonObject(); stage.addProperty(JSON_STAGE_NAME_FIELD, stageName); Map<String, Object> stageMap = (Map<String, Object>) entry.getValue(); addOptionalBoolean(stage, stageMap, JSON_STAGE_FETCH_FIELD, YAML_STAGE_FETCH_FIELD); addOptionalBoolean(stage, stageMap, JSON_STAGE_NEVER_CLEAN_FIELD, YAML_STAGE_KEEP_ARTIFACTS_FIELD); addOptionalBoolean(stage, stageMap, JSON_STAGE_CLEAN_WORK_FIELD, YAML_STAGE_CLEAN_WORK_FIELD); addApproval(stage, stageMap); JsonArray jsonEnvVariables = environmentTransform.transform(stageMap); if (jsonEnvVariables != null && jsonEnvVariables.size() > 0) stage.add(JSON_ENV_VAR_FIELD, jsonEnvVariables); addJobs(stage, stageMap); return stage; }
private void testInverseTransform(String caseFile, String expectedFile) throws IOException { String expectedObject = loadString("parts/env_vars/" + expectedFile + ".yaml"); Map<String, Object> actual = parser.inverseTransform(readJsonArrayGson("parts/env_vars/" + caseFile + ".json")); assertYamlEquivalent(expectedObject, YamlUtils.dump(actual)); } }
@Before public void SetUp() { environmentTransform = new EnvironmentVariablesTransform(); jobTransform = mock(JobTransform.class); parser = new StageTransform(environmentTransform, jobTransform); }
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 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); }
public JsonObject transform(Map.Entry<String, Object> entry) { String pipelineName = entry.getKey(); JsonObject pipeline = new JsonObject(); pipeline.addProperty(JSON_PIPELINE_NAME_FIELD, pipelineName); Map<String, Object> pipeMap = (Map<String, Object>) entry.getValue(); addOptionalString(pipeline, pipeMap, JSON_PIPELINE_GROUP_FIELD, YAML_PIPELINE_GROUP_FIELD); addOptionalString(pipeline, pipeMap, JSON_PIPELINE_TEMPLATE_FIELD, YAML_PIPELINE_TEMPLATE_FIELD); addOptionalString(pipeline, pipeMap, JSON_PIPELINE_LABEL_TEMPLATE_FIELD, YAML_PIPELINE_LABEL_TEMPLATE_FIELD); addOptionalBoolean(pipeline, pipeMap, JSON_PIPELINE_PIPE_LOCKING_FIELD, YAML_PIPELINE_PIPE_LOCKING_FIELD); addOptionalString(pipeline, pipeMap, JSON_PIPELINE_LOCK_BEHAVIOR_FIELD, YAML_PIPELINE_LOCK_BEHAVIOR_FIELD); addOptionalObject(pipeline, pipeMap, JSON_PIPELINE_TRACKING_TOOL_FIELD, YAML_PIPELINE_TRACKING_TOOL_FIELD); addOptionalObject(pipeline, pipeMap, JSON_PIPELINE_MINGLE_FIELD, YAML_PIPELINE_MINGLE_FIELD); addTimer(pipeline, pipeMap); JsonArray jsonEnvVariables = variablesTransform.transform(pipeMap); if (jsonEnvVariables != null && jsonEnvVariables.size() > 0) pipeline.add(JSON_ENV_VAR_FIELD, jsonEnvVariables); addMaterials(pipeline, pipeMap); if (!pipeline.has(JSON_PIPELINE_TEMPLATE_FIELD)) { addStages(pipeline, pipeMap); } JsonArray params = parameterTransform.transform(pipeMap); if (params != null && params.size() > 0) { pipeline.add(YAML_PIPELINE_PARAMETERS_FIELD, params); } return pipeline; }
@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 void testTransform(String caseFile, String expectedFile) throws IOException { JsonArray expected = (JsonArray) readJsonObject("parts/env_vars/" + expectedFile + ".json"); JsonArray actual = parser.transform(readYamlObject("parts/env_vars/" + caseFile + ".yaml")); assertThat(actual, is(expected)); }