How to use

first

method

in

com.thoughtworks.go.config.materials.MaterialConfigs

public String getMaterialOptions() {
  return first() == null ? "" : first().getType();
}

@Test
public void shouldSetSvnConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  Map<String, Object> svnAttrMap = new HashMap<>();
  svnAttrMap.put(SvnMaterialConfig.URL, "foo");
  svnAttrMap.put(SvnMaterialConfig.USERNAME, "bar");
  svnAttrMap.put(SvnMaterialConfig.PASSWORD, "baz");
  svnAttrMap.put(SvnMaterialConfig.CHECK_EXTERNALS, false);
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, SvnMaterialConfig.TYPE);
  attributeMap.put(SvnMaterialConfig.TYPE, svnAttrMap);
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.first(), is(new SvnMaterialConfig("foo", "bar", "baz", false)));
}

@Test
public void shouldSetPluggableSCMMaterialConfigAttributesForMaterial() {
  String scmId = "scm-id";
  Map<String, String> hashMap = new HashMap<>();
  hashMap.put(PluggableSCMMaterialConfig.SCM_ID, scmId);
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, PluggableSCMMaterialConfig.TYPE);
  attributeMap.put(PluggableSCMMaterialConfig.TYPE, hashMap);
  MaterialConfigs materialConfigs = new MaterialConfigs();
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  assertThat(((PluggableSCMMaterialConfig) materialConfigs.first()).getScmId(), is(scmId));
}

@Test
public void shouldSetPackageMaterialConfigAttributesForMaterial() {
  Map<String, String> hashMap = new HashMap<>();
  String packageId = "some-id";
  hashMap.put(PackageMaterialConfig.PACKAGE_ID, packageId);
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, PackageMaterialConfig.TYPE);
  attributeMap.put(PackageMaterialConfig.TYPE, hashMap);
  MaterialConfigs materialConfigs = new MaterialConfigs();
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  assertThat(((PackageMaterialConfig) materialConfigs.first()).getPackageId(), is(packageId));
}

@Test
public void shouldSetGitConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  Map<String, String> hashMap = new HashMap<>();
  hashMap.put(GitMaterialConfig.URL, "foo");
  hashMap.put(GitMaterialConfig.BRANCH, "master");
  HashMap<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, GitMaterialConfig.TYPE);
  attributeMap.put(GitMaterialConfig.TYPE, hashMap);
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  GitMaterialConfig expected = new GitMaterialConfig("foo");
  expected.setConfigAttributes(Collections.singletonMap(GitMaterialConfig.BRANCH, "master"));
  assertThat(materialConfigs.first(), is(expected));
}

@Test
public void shouldSetP4ConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  Map<String, String> hashMap = new HashMap<>();
  hashMap.put(P4MaterialConfig.SERVER_AND_PORT, "localhost:1666");
  hashMap.put(P4MaterialConfig.USERNAME, "username");
  hashMap.put(P4MaterialConfig.PASSWORD, "password");
  hashMap.put(P4MaterialConfig.VIEW, "foo");
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, P4MaterialConfig.TYPE);
  attributeMap.put(P4MaterialConfig.TYPE, hashMap);
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  P4MaterialConfig expected = new P4MaterialConfig("localhost:1666", "foo", "username");
  expected.setPassword("password");
  assertThat(materialConfigs.first(), is(expected));
}

@Test
public void shouldSetDependencyMaterialConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  Map<String, String> hashMap = new HashMap<>();
  hashMap.put(DependencyMaterialConfig.PIPELINE_STAGE_NAME, "blah [foo]");
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, DependencyMaterialConfig.TYPE);
  attributeMap.put(DependencyMaterialConfig.TYPE, hashMap);
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  DependencyMaterialConfig expected = new DependencyMaterialConfig(new CaseInsensitiveString("blah"), new CaseInsensitiveString("foo"));
  assertThat(materialConfigs.first(), is(expected));
}

@Test
public void shouldSetTfsConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  Map<String, String> tfsAttrMap = new HashMap<>();
  tfsAttrMap.put(TfsMaterialConfig.URL, "foo");
  tfsAttrMap.put(TfsMaterialConfig.USERNAME, "bar");
  tfsAttrMap.put(TfsMaterialConfig.PASSWORD, "baz");
  tfsAttrMap.put(TfsMaterialConfig.PROJECT_PATH, "to_hell");
  tfsAttrMap.put(TfsMaterialConfig.MATERIAL_NAME, "crapy_material");
  tfsAttrMap.put(TfsMaterialConfig.DOMAIN, "CORPORATE");
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, TfsMaterialConfig.TYPE);
  attributeMap.put(TfsMaterialConfig.TYPE, tfsAttrMap);
  materialConfigs.setConfigAttributes(attributeMap);
  TfsMaterialConfig tfsMaterialConfig = new TfsMaterialConfig(new GoCipher(), new UrlArgument("foo"), "bar", "CORPORATE", "baz", "to_hell");
  tfsMaterialConfig.setName(new CaseInsensitiveString("crapy_material"));
  assertThat(materialConfigs.first(), is(tfsMaterialConfig));
  assertThat(tfsMaterialConfig.getPassword(), is("baz"));
}

@Test
public void shouldClearExistingAndSetHgConfigAttributesForMaterial() {
  MaterialConfigs materialConfigs = new MaterialConfigs();
  materialConfigs.add(new HgMaterialConfig("", null));
  materialConfigs.add(new SvnMaterialConfig("", "", "", false));
  Map<String, String> hashMap = new HashMap<>();
  hashMap.put(HgMaterialConfig.URL, "foo");
  Map<String, Object> attributeMap = new HashMap<>();
  attributeMap.put(AbstractMaterialConfig.MATERIAL_TYPE, HgMaterialConfig.TYPE);
  attributeMap.put(HgMaterialConfig.TYPE, hashMap);
  materialConfigs.setConfigAttributes(attributeMap);
  assertThat(materialConfigs.size(), is(1));
  assertThat(materialConfigs.first(), is(new HgMaterialConfig("foo", null)));
}

@Test
public void shouldLoadPipelineWithP4MaterialFromXmlPartial() throws Exception {
  String pipelineWithP4MaterialXmlPartial =
      "<pipeline name=\"pipeline\">\n"
          + "  <materials>\n"
          + "    <p4 port=\"10.18.3.241:9999\" username=\"cruise\" password=\"password\" "
          + "        useTickets=\"true\">\n"
          + "          <view><![CDATA[//depot/dev/... //lumberjack/...]]></view>\n"
          + "    </p4>"
          + "  </materials>\n"
          + "  <stage name=\"mingle\">\n"
          + "    <jobs>\n"
          + "      <job name=\"functional\">\n"
          + "        <artifacts>\n"
          + "          <log src=\"artifact1.xml\" dest=\"cruise-output\" />\n"
          + "        </artifacts>\n"
          + "      </job>\n"
          + "    </jobs>\n"
          + "  </stage>\n"
          + "</pipeline>\n";
  PipelineConfig pipeline = xmlLoader.fromXmlPartial(pipelineWithP4MaterialXmlPartial, PipelineConfig.class);
  assertThat(pipeline.name(), is(new CaseInsensitiveString("pipeline")));
  MaterialConfig material = pipeline.materialConfigs().first();
  assertThat(material, is(instanceOf(P4MaterialConfig.class)));
  assertThat(((P4MaterialConfig) material).getUseTickets(), is(true));
}

@Test
public void shouldRemoveDuplicatedIgnoreTag() throws Exception {
  CruiseConfig cruiseConfig = ConfigMigrator.load(ConfigFileFixture.TWO_DUPLICATED_FILTER);
  int size = cruiseConfig.pipelineConfigByName(new CaseInsensitiveString("pipeline1")).materialConfigs().first().filter().size();
  assertThat(size, is(1));
}

@Test
public void shouldGetAllMaterialsByFingerPrint() throws Exception {
  CruiseConfig cruiseConfig = new GoConfigMother().cruiseConfigWithPipelineUsingTwoMaterials();
  MaterialConfig expectedMaterial = MaterialConfigsMother.multipleMaterialConfigs().get(1);
  PipelineConfigSaveValidationContext context = PipelineConfigSaveValidationContext.forChain(true, "group", cruiseConfig);
  MaterialConfigs allMaterialsByFingerPrint = context.getAllMaterialsByFingerPrint(expectedMaterial.getFingerprint());
  assertThat(allMaterialsByFingerPrint.size(), is(1));
  assertThat(allMaterialsByFingerPrint.first(), is(expectedMaterial));
}
@Test

@Test
public void shouldReturnTrueWhenConfigRevisionIsEqualToQuery() {
  PipelineConfig pipelineConfig = PipelineConfigMother.createPipelineConfig("pipeline", "stage", "build");
  MaterialConfig material = pipelineConfig.materialConfigs().first();
  pipelineConfig.setOrigin(new RepoConfigOrigin(new ConfigRepoConfig(material, "plugin"), "1233"));
  assertThat(pipelineConfig.isConfigOriginFromRevision("1233"), is(true));
}

@Test
public void shouldReturnFalseWhenConfigRevisionIsNotEqualToQuery() {
  PipelineConfig pipelineConfig = PipelineConfigMother.createPipelineConfig("pipeline", "stage", "build");
  MaterialConfig material = pipelineConfig.materialConfigs().first();
  pipelineConfig.setOrigin(new RepoConfigOrigin(new ConfigRepoConfig(material, "plugin"), "1233"));
  assertThat(pipelineConfig.isConfigOriginFromRevision("32"), is(false));
}

@Test
public void shouldReturnTrueWhenOneOfPipelineMaterialsIsTheSameAsConfigOrigin() {
  PipelineConfig pipelineConfig = PipelineConfigMother.createPipelineConfig("pipeline", "stage", "build");
  MaterialConfig material = pipelineConfig.materialConfigs().first();
  pipelineConfig.setOrigin(new RepoConfigOrigin(new ConfigRepoConfig(material, "plugin"), "1233"));
  assertThat(pipelineConfig.isConfigOriginSameAsOneOfMaterials(), is(true));
}

@Test
public void shouldFailValidateWhenUpstreamPipelineForDependencyMaterialDoesNotExist() {
  String upstreamPipeline = "non-existant";
  PipelineConfig pipelineConfig = GoConfigMother.createPipelineConfigWithMaterialConfig(
      new DependencyMaterialConfig(new CaseInsensitiveString(upstreamPipeline), new CaseInsensitiveString("non-existant")));
  BasicCruiseConfig cruiseConfig = new BasicCruiseConfig(new BasicPipelineConfigs(pipelineConfig));
  boolean isValid = pipelineConfig.validateTree(PipelineConfigSaveValidationContext.forChain(true, cruiseConfig.getGroups().first().getGroup(), cruiseConfig, pipelineConfig));
  assertThat(isValid, is(false));
  ConfigErrors materialErrors = pipelineConfig.materialConfigs().first().errors();
  assertThat(materialErrors.isEmpty(), is(false));
  assertThat(materialErrors.firstError(), is("Pipeline with name 'non-existant' does not exist, it is defined as a dependency for pipeline 'pipeline' (cruise-config.xml)"));
}

assertThat(plan.getTabs().first().getPath(), is("logs/emma/index.html"));
assertThat(pipelineConfig1.materialConfigs().size(), is(1));
shouldBeSvnMaterial(pipelineConfig1.materialConfigs().first());
shouldBeHgMaterial(pipelineConfig2.materialConfigs().first());
MaterialConfig p4Material = pipelineConfig3.materialConfigs().first();
shouldBeP4Material(p4Material);
shouldBeGitMaterial(pipelineConfig4.materialConfigs().first());

@Test
public void shouldFailValidateWhenUpstreamStageForDependencyMaterialDoesNotExist() {
  String upstreamPipeline = "upstream";
  String upstreamStage = "non-existant";
  PipelineConfig upstream = GoConfigMother.createPipelineConfigWithMaterialConfig(upstreamPipeline, new GitMaterialConfig("url"));
  PipelineConfig pipelineConfig = GoConfigMother.createPipelineConfigWithMaterialConfig("downstream",
      new DependencyMaterialConfig(new CaseInsensitiveString(upstreamPipeline), new CaseInsensitiveString(upstreamStage)));
  BasicCruiseConfig cruiseConfig = new BasicCruiseConfig(new BasicPipelineConfigs(pipelineConfig, upstream));
  boolean isValid = pipelineConfig.validateTree(PipelineConfigSaveValidationContext.forChain(true, cruiseConfig.getGroups().first().getGroup(), cruiseConfig, pipelineConfig));
  assertThat(isValid, is(false));
  ConfigErrors materialErrors = pipelineConfig.materialConfigs().first().errors();
  assertThat(materialErrors.isEmpty(), is(false));
  assertThat(materialErrors.firstError(), is("Stage with name 'non-existant' does not exist on pipeline 'upstream', it is being referred to from pipeline 'downstream' (cruise-config.xml)"));
}

public static PipelineInstanceModels pipelineHistory(PipelineConfig pipelineConfig, Date scheduleDate, Date modificationDate, String revision, String committer, String commitMessage,
                           String commiterEmail, String commitedFileName, String dirModified, String label) {
  PipelineInstanceModels history = PipelineInstanceModels.createPipelineInstanceModels();
  Modification modification = new Modification(committer, commitMessage, commiterEmail, modificationDate, revision);
  modification.createModifiedFile(commitedFileName, dirModified, ModifiedAction.added);
  MaterialRevisions revisions = new MaterialRevisions();
  Material material = new MaterialConfigConverter().toMaterial(pipelineConfig.materialConfigs().first());
  material.setId(10);
  revisions.addRevision(material, modification);
  BuildCause buildCause = BuildCause.createManualForced(revisions, Username.ANONYMOUS);
  PipelineInstanceModel item = PipelineInstanceModel.createPipeline(CaseInsensitiveString.str(pipelineConfig.name()), -1, label, buildCause, stageHistory(pipelineConfig, scheduleDate));
  item.setCounter(1);
  item.setId(1);
  item.setComment("build comment");
  history.add(item);
  return history;
}