github.com/ouraigua/jenkins-library@v0.0.0-20231028010029-fbeaf2f3aa9b/test/groovy/CfManifestSubstituteVariablesTest.groovy

github.com/ouraigua/jenkins-library@v0.0.0-20231028010029-fbeaf2f3aa9b/test/groovy/CfManifestSubstituteVariablesTest.groovy (about)

     1  import org.junit.Before
     2  import org.junit.Rule
     3  import org.junit.Test
     4  import org.junit.rules.ExpectedException
     5  import org.junit.rules.RuleChain
     6  import util.*
     7  
     8  import static org.junit.Assert.*
     9  import static util.JenkinsWriteYamlRule.DATA
    10  import static util.JenkinsWriteYamlRule.SERIALIZED_YAML
    11  
    12  public class CfManifestSubstituteVariablesTest extends BasePiperTest {
    13  
    14      private JenkinsStepRule script = new JenkinsStepRule(this)
    15      private JenkinsReadYamlRule readYamlRule = new JenkinsReadYamlRule(this)
    16      private JenkinsWriteYamlRule writeYamlRule = new JenkinsWriteYamlRule(this)
    17      private JenkinsErrorRule errorRule = new JenkinsErrorRule(this)
    18      private JenkinsEnvironmentRule environmentRule = new JenkinsEnvironmentRule(this)
    19      private JenkinsLoggingRule loggingRule = new JenkinsLoggingRule(this)
    20      private ExpectedException expectedExceptionRule = ExpectedException.none()
    21      private JenkinsFileExistsRule fileExistsRule = new JenkinsFileExistsRule(this, [])
    22  
    23      @Rule
    24      public RuleChain rules = Rules
    25          .getCommonRules(this)
    26          .around(fileExistsRule)
    27          .around(readYamlRule)
    28          .around(writeYamlRule)
    29          .around(errorRule)
    30          .around(environmentRule)
    31          .around(loggingRule)
    32          .around(script)
    33          .around(expectedExceptionRule)
    34  
    35      @Before
    36      public void setup() {
    37          readYamlRule.registerYaml("manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/manifest.yml")))
    38                      .registerYaml("manifest-variables.yml", new FileInputStream(new File("test/resources/variableSubstitution/manifest-variables.yml")))
    39                      .registerYaml("test/resources/variableSubstitution/manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/manifest.yml")))
    40                      .registerYaml("test/resources/variableSubstitution/manifest-variables.yml", new FileInputStream(new File("test/resources/variableSubstitution/manifest-variables.yml")))
    41                      .registerYaml("test/resources/variableSubstitution/invalid_manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/invalid_manifest.yml")))
    42                      .registerYaml("test/resources/variableSubstitution/novars_manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/novars_manifest.yml")))
    43                      .registerYaml("test/resources/variableSubstitution/multi_manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/multi_manifest.yml")))
    44                      .registerYaml("test/resources/variableSubstitution/datatypes_manifest.yml", new FileInputStream(new File("test/resources/variableSubstitution/datatypes_manifest.yml")))
    45                      .registerYaml("test/resources/variableSubstitution/datatypes_manifest-variables.yml", new FileInputStream(new File("test/resources/variableSubstitution/datatypes_manifest-variables.yml")))
    46                      .registerYaml("test/resources/variableSubstitution/manifest-variables-conflicting.yml", new FileInputStream(new File("test/resources/variableSubstitution/manifest-variables-conflicting.yml")))
    47      }
    48  
    49      @Test
    50      public void substituteVariables_SkipsExecution_If_ManifestNotPresent() throws Exception {
    51          String manifestFileName = "nonexistent/manifest.yml"
    52          String variablesFileName = "nonexistent/manifest-variables.yml"
    53          List<String> variablesFiles = [ variablesFileName ]
    54  
    55          // check that a proper log is written.
    56          loggingRule.expect("[CFManifestSubstituteVariables] Could not find YAML file at ${manifestFileName}. Skipping variable substitution.")
    57  
    58          // execute step
    59          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
    60  
    61          //Check that nothing was written
    62          assertNull(writeYamlRule.files[manifestFileName])
    63  
    64          // check that the step was marked as a success (even if it did do nothing).
    65          assertJobStatusSuccess()
    66      }
    67  
    68      @Test
    69      public void substituteVariables_SkipsExecution_If_VariablesFileNotPresent() throws Exception {
    70          String manifestFileName = "test/resources/variableSubstitution/manifest.yml"
    71          String variablesFileName = "nonexistent/manifest-variables.yml"
    72          List<String> variablesFiles = [ variablesFileName ]
    73  
    74          fileExistsRule.registerExistingFile(manifestFileName)
    75  
    76          // check that a proper log is written.
    77          loggingRule.expect("[CFManifestSubstituteVariables] Did not find manifest variable substitution file at ${variablesFileName}.")
    78          expectedExceptionRule.expect(hudson.AbortException)
    79          expectedExceptionRule.expectMessage("[CFManifestSubstituteVariables] Could not find all given manifest variable substitution files. Make sure all files given as manifestVariablesFiles exist.")
    80  
    81          // execute step
    82          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
    83  
    84          //Check that nothing was written
    85          assertNull(writeYamlRule.files[manifestFileName])
    86  
    87          // check that the step was marked as a success (even if it did do nothing).
    88          assertJobStatusSuccess()
    89      }
    90  
    91      @Test
    92      public void substituteVariables_Throws_If_manifestInvalid() throws Exception {
    93          String manifestFileName = "test/resources/variableSubstitution/invalid_manifest.yml"
    94          String variablesFileName = "test/resources/variableSubstitution/invalid_manifest.yml"
    95          List<String> variablesFiles = [ variablesFileName ]
    96  
    97          fileExistsRule.registerExistingFile(manifestFileName)
    98          fileExistsRule.registerExistingFile(variablesFileName)
    99  
   100          //check that exception is thrown and that it has the correct message.
   101          expectedExceptionRule.expect(org.yaml.snakeyaml.scanner.ScannerException)
   102          expectedExceptionRule.expectMessage("found character '%' that cannot start any token. (Do not use % for indentation)")
   103  
   104          loggingRule.expect("[CFManifestSubstituteVariables] Could not load manifest file at ${manifestFileName}.")
   105  
   106          // execute step
   107          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   108  
   109          //Check that nothing was written
   110          assertNull(writeYamlRule.files[manifestFileName])
   111  
   112          // check that the step was marked as a success (even if it did do nothing).
   113          assertJobStatusSuccess()
   114      }
   115  
   116      @Test
   117      public void substituteVariables_Throws_If_manifestVariablesInvalid() throws Exception {
   118          String manifestFileName = "test/resources/variableSubstitution/manifest.yml"
   119          String variablesFileName = "test/resources/variableSubstitution/invalid_manifest.yml"
   120          List<String> variablesFiles = [ variablesFileName ]
   121  
   122          fileExistsRule.registerExistingFile(manifestFileName)
   123          fileExistsRule.registerExistingFile(variablesFileName)
   124  
   125          //check that exception is thrown and that it has the correct message.
   126          expectedExceptionRule.expect(org.yaml.snakeyaml.scanner.ScannerException)
   127          expectedExceptionRule.expectMessage("found character '%' that cannot start any token. (Do not use % for indentation)")
   128  
   129          loggingRule.expect("[CFManifestSubstituteVariables] Could not load manifest variables file at ${variablesFileName}")
   130  
   131          // execute step
   132          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   133  
   134          //Check that nothing was written
   135          assertNull(writeYamlRule.files[manifestFileName])
   136  
   137          // check that the step was marked as a success (even if it did do nothing).
   138          assertJobStatusSuccess()
   139      }
   140  
   141      @Test
   142      public void substituteVariables_UsesDefaultFileName_If_NoManifestSpecified() throws Exception {
   143          // In this test, we check that the implementation will resort to the default manifest file name.
   144          // Since the file is not present, the implementation should stop, but the log should indicate that the
   145          // the default file name was used.
   146  
   147          String manifestFileName = "manifest.yml" // default name should be chosen.
   148  
   149          // check that a proper log is written.
   150          loggingRule.expect("[CFManifestSubstituteVariables] Could not find YAML file at ${manifestFileName}. Skipping variable substitution.")
   151  
   152          // execute step
   153          script.step.cfManifestSubstituteVariables script: nullScript
   154  
   155          //Check that nothing was written
   156          assertNull(writeYamlRule.files[manifestFileName])
   157  
   158          // check that the step was marked as a success (even if it did do nothing).
   159          assertJobStatusSuccess()
   160      }
   161  
   162      @Test
   163      public void substituteVariables_UsesDefaultFileName_If_NoVariablesFileSpecified() throws Exception {
   164          // In this test, we check that the implementation will resort to the default manifest _variables_ file name.
   165          // Since the file is not present, the implementation should stop, but the log should indicate that the
   166          // the default file name was used.
   167  
   168          String manifestFileName = "test/resources/variableSubstitution/manifest.yml"
   169          String variablesFileName = "manifest-variables.yml" // default file name that should be chosen.
   170  
   171          fileExistsRule.registerExistingFile(manifestFileName)
   172  
   173          // check that a proper log is written.
   174          loggingRule.expect("[CFManifestSubstituteVariables] Did not find manifest variable substitution file at ${variablesFileName}.")
   175                     .expect("[CFManifestSubstituteVariables] Could not find any default manifest variable substitution file at ${variablesFileName}, and no manifest variables list was specified. Skipping variable substitution.")
   176  
   177          // execute step
   178          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, script: nullScript
   179  
   180          //Check that nothing was written
   181          assertNull(writeYamlRule.files[manifestFileName])
   182  
   183          // check that the step was marked as a success (even if it did do nothing).
   184          assertJobStatusSuccess()
   185      }
   186  
   187      @Test
   188      public void substituteVariables_ReplacesVariablesProperly_InSingleYamlFiles() throws Exception {
   189          String manifestFileName = "test/resources/variableSubstitution/manifest.yml"
   190          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   191          List<String> variablesFiles = [ variablesFileName ]
   192  
   193          fileExistsRule.registerExistingFile(manifestFileName)
   194          fileExistsRule.registerExistingFile(variablesFileName)
   195  
   196          // check that a proper log is written.
   197          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   198                     .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   199                     .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   200                     .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   201  
   202          // execute step
   203          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   204  
   205  
   206          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   207          Map<String, Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   208  
   209          //Check that something was written
   210          assertNotNull(manifestDataAfterReplacement)
   211  
   212          // check that there are no unresolved variables left.
   213          assertAllVariablesReplaced(yamlStringAfterReplacement)
   214  
   215          // check that resolved variables have expected values
   216          assertCorrectVariableResolution(manifestDataAfterReplacement)
   217  
   218          // check that the step was marked as a success (even if it did do nothing).
   219          assertJobStatusSuccess()
   220      }
   221  
   222      private void assertAllVariablesReplaced(String yamlStringAfterReplacement) {
   223          assertFalse(yamlStringAfterReplacement.contains("(("))
   224          assertFalse(yamlStringAfterReplacement.contains("))"))
   225      }
   226  
   227      private void assertCorrectVariableResolution(Map<String, Object> manifestDataAfterReplacement) {
   228          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("name").equals("uniquePrefix-catalog-service-odatav2-0.0.1"))
   229          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("routes").get(0).get("route").equals("uniquePrefix-catalog-service-odatav2-001.cfapps.eu10.hana.ondemand.com"))
   230          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("services").get(0).equals("uniquePrefix-catalog-service-odatav2-xsuaa"))
   231          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("services").get(1).equals("uniquePrefix-catalog-service-odatav2-hana"))
   232          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("xsuaa-instance-name").equals("uniquePrefix-catalog-service-odatav2-xsuaa"))
   233          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("db_service_instance_name").equals("uniquePrefix-catalog-service-odatav2-hana"))
   234      }
   235  
   236      @Test
   237      public void substituteVariables_ReplacesVariablesProperly_InMultiYamlFiles() throws Exception {
   238          String manifestFileName = "test/resources/variableSubstitution/multi_manifest.yml"
   239          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   240          List<String> variablesFiles = [ variablesFileName ]
   241  
   242          fileExistsRule.registerExistingFile(manifestFileName)
   243          fileExistsRule.registerExistingFile(variablesFileName)
   244  
   245          // check that a proper log is written.
   246          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   247                     .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   248                     .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   249                     .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   250  
   251          // execute step
   252          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   253  
   254  
   255          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   256          List<Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   257  
   258          //Check that something was written
   259          assertNotNull(manifestDataAfterReplacement)
   260  
   261          // check that there are no unresolved variables left.
   262          assertAllVariablesReplaced(yamlStringAfterReplacement)
   263  
   264          //check that result still is a multi-YAML file.
   265          assertEquals("Dumped YAML after replacement should still be a multi-YAML file.",2, manifestDataAfterReplacement.size())
   266  
   267          // check that resolved variables have expected values
   268          manifestDataAfterReplacement.each { yaml ->
   269              assertCorrectVariableResolution(yaml as Map<String, Object>)
   270          }
   271  
   272          // check that the step was marked as a success (even if it did do nothing).
   273          assertJobStatusSuccess()
   274      }
   275  
   276      @Test
   277      public void substituteVariables_ReplacesVariablesFromListProperly_whenNoManifestVariablesFilesGiven_InMultiYamlFiles() throws Exception {
   278          // This test replaces variables in multi-yaml files from a list of specified variables
   279          // the the user has not specified any variable substitution files list.
   280  
   281          String manifestFileName = "test/resources/variableSubstitution/multi_manifest.yml"
   282          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   283  
   284          List<Map<String, Object>> variablesList = [
   285                                                      ["unique-prefix" : "uniquePrefix"],
   286                                                      ["xsuaa-instance-name" : "uniquePrefix-catalog-service-odatav2-xsuaa"],
   287                                                      ["hana-instance-name" : "uniquePrefix-catalog-service-odatav2-hana"]
   288                                                    ]
   289  
   290          fileExistsRule.registerExistingFile(manifestFileName)
   291          fileExistsRule.registerExistingFile(variablesFileName)
   292  
   293          // check that a proper log is written.
   294          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   295              //.expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   296              .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   297              .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   298  
   299          // execute step
   300          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariables: variablesList, script: nullScript
   301  
   302          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   303          List<Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   304  
   305          //Check that something was written
   306          assertNotNull(manifestDataAfterReplacement)
   307  
   308          // check that there are no unresolved variables left.
   309          assertAllVariablesReplaced(yamlStringAfterReplacement)
   310  
   311          //check that result still is a multi-YAML file.
   312          assertEquals("Dumped YAML after replacement should still be a multi-YAML file.",2, manifestDataAfterReplacement.size())
   313  
   314          // check that resolved variables have expected values
   315          manifestDataAfterReplacement.each { yaml ->
   316              assertCorrectVariableResolution(yaml as Map<String, Object>)
   317          }
   318  
   319          // check that the step was marked as a success (even if it did do nothing).
   320          assertJobStatusSuccess()
   321      }
   322  
   323      @Test
   324      public void substituteVariables_ReplacesVariablesFromListProperly_whenEmptyManifestVariablesFilesGiven_InMultiYamlFiles() throws Exception {
   325          // This test replaces variables in multi-yaml files from a list of specified variables
   326          // the the user has specified an empty list of variable substitution files.
   327  
   328          String manifestFileName = "test/resources/variableSubstitution/multi_manifest.yml"
   329          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   330          List<String> variablesFiles = []
   331  
   332          List<Map<String, Object>> variablesList = [
   333              ["unique-prefix" : "uniquePrefix"],
   334              ["xsuaa-instance-name" : "uniquePrefix-catalog-service-odatav2-xsuaa"],
   335              ["hana-instance-name" : "uniquePrefix-catalog-service-odatav2-hana"]
   336          ]
   337  
   338          fileExistsRule.registerExistingFile(manifestFileName)
   339          fileExistsRule.registerExistingFile(variablesFileName)
   340  
   341          // check that a proper log is written.
   342          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   343          //.expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   344              .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   345              .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   346  
   347          // execute step
   348          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, manifestVariables: variablesList, script: nullScript
   349  
   350          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   351          List<Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   352  
   353          //Check that something was written
   354          assertNotNull(manifestDataAfterReplacement)
   355  
   356          // check that there are no unresolved variables left.
   357          assertAllVariablesReplaced(yamlStringAfterReplacement)
   358  
   359          //check that result still is a multi-YAML file.
   360          assertEquals("Dumped YAML after replacement should still be a multi-YAML file.",2, manifestDataAfterReplacement.size())
   361  
   362          // check that resolved variables have expected values
   363          manifestDataAfterReplacement.each { yaml ->
   364              assertCorrectVariableResolution(yaml as Map<String, Object>)
   365          }
   366  
   367          // check that the step was marked as a success (even if it did do nothing).
   368          assertJobStatusSuccess()
   369      }
   370  
   371      @Test
   372      public void substituteVariables_SkipsExecution_If_NoVariablesInManifest() throws Exception {
   373          // This test makes sure that, if no variables are found in a manifest that need
   374          // to be replaced, the execution is eventually skipped and the manifest remains
   375          // untouched.
   376  
   377          String manifestFileName = "test/resources/variableSubstitution/novars_manifest.yml"
   378          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   379          List<String> variablesFiles = [ variablesFileName ]
   380  
   381          fileExistsRule.registerExistingFile(manifestFileName)
   382          fileExistsRule.registerExistingFile(variablesFileName)
   383  
   384          // check that a proper log is written.
   385          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   386                     .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   387                     .expect("[CFManifestSubstituteVariables] No variables were found or could be replaced in ${manifestFileName}. Skipping variable substitution.")
   388  
   389          // execute step
   390          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   391  
   392          //Check that nothing was written
   393          assertNull(writeYamlRule.files[manifestFileName])
   394  
   395          // check that the step was marked as a success (even if it did do nothing).
   396          assertJobStatusSuccess()
   397      }
   398  
   399      @Test
   400      public void substituteVariables_SupportsAllDataTypes() throws Exception {
   401          // This test makes sure that, all datatypes supported by YAML are also
   402          // properly substituted by the substituteVariables step.
   403          // In particular this includes variables of type:
   404          // Integer, Boolean, String, Float and inline JSON documents (which are parsed as multi-line strings)
   405          // and complex types (like other YAML objects).
   406          // The test also checks the differing behaviour when substituting nodes that only consist of a
   407          // variable reference and nodes that contains several variable references or additional string constants.
   408  
   409          String manifestFileName = "test/resources/variableSubstitution/datatypes_manifest.yml"
   410          String variablesFileName = "test/resources/variableSubstitution/datatypes_manifest-variables.yml"
   411          List<String> variablesFiles = [ variablesFileName ]
   412  
   413          fileExistsRule.registerExistingFile(manifestFileName)
   414          fileExistsRule.registerExistingFile(variablesFileName)
   415  
   416          // check that a proper log is written.
   417          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   418                     .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   419  
   420          // execute step
   421          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   422  
   423          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   424          Map<String, Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   425  
   426          //Check that something was written
   427          assertNotNull(manifestDataAfterReplacement)
   428  
   429          assertAllVariablesReplaced(yamlStringAfterReplacement)
   430          assertCorrectVariableResolution(manifestDataAfterReplacement)
   431  
   432          assertDataTypeAndSubstitutionCorrectness(manifestDataAfterReplacement)
   433  
   434          // check that the step was marked as a success (even if it did do nothing).
   435          assertJobStatusSuccess()
   436      }
   437  
   438      private void assertDataTypeAndSubstitutionCorrectness(Map<String, Object> manifestDataAfterReplacement) {
   439          // See datatypes_manifest.yml and datatypes_manifest-variables.yml.
   440          // Note: For debugging consider turning on YAML writing to a file in JenkinsWriteYamlRule to see the
   441          // actual outcome of replacing variables (for visual inspection).
   442  
   443          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("instances").equals(1))
   444          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("instances") instanceof Integer)
   445  
   446          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("services").get(0) instanceof String)
   447  
   448          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("booleanVariableTrue").equals(true))
   449          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("booleanVariableTrue") instanceof Boolean)
   450  
   451          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("floatVariable") == 0.25)
   452          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("floatVariable") instanceof Double)
   453  
   454          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("json-variable") instanceof String)
   455  
   456          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("object-variable") instanceof Map)
   457  
   458          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("string-variable").startsWith("true-0.25-1-"))
   459          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("string-variable") instanceof String)
   460  
   461          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("single-var-with-string-constants").equals("true-with-some-more-text"))
   462          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("single-var-with-string-constants") instanceof String)
   463      }
   464  
   465      @Test
   466      public void substituteVariables_replacesManifestIfNoOutputGiven() throws Exception {
   467          // Test that makes sure that the original input manifest file is replaced with
   468          // a version that has variables replaced (by deleting the original file and
   469          // dumping a new one with the same name).
   470  
   471          String manifestFileName = "test/resources/variableSubstitution/datatypes_manifest.yml"
   472          String variablesFileName = "test/resources/variableSubstitution/datatypes_manifest-variables.yml"
   473          List<String> variablesFiles = [ variablesFileName ]
   474  
   475          fileExistsRule.registerExistingFile(manifestFileName)
   476          fileExistsRule.registerExistingFile(variablesFileName)
   477  
   478          // check that a proper log is written.
   479          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   480                     .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   481                     .expect("[CFManifestSubstituteVariables] Successfully deleted file '${manifestFileName}'.")
   482                     .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   483                     .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   484  
   485          // execute step
   486          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, script: nullScript
   487  
   488          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   489          Map<String, Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   490  
   491          //Check that something was written
   492          assertNotNull(manifestDataAfterReplacement)
   493  
   494          assertAllVariablesReplaced(yamlStringAfterReplacement)
   495          assertCorrectVariableResolution(manifestDataAfterReplacement)
   496  
   497          assertDataTypeAndSubstitutionCorrectness(manifestDataAfterReplacement)
   498  
   499          // check that the step was marked as a success (even if it did do nothing).
   500          assertJobStatusSuccess()
   501      }
   502  
   503      @Test
   504      public void substituteVariables_writesToOutputFileIfGiven() throws Exception {
   505          // Test that makes sure that the output is written to the specified file and that the original input manifest
   506          // file is NOT deleted / replaced.
   507  
   508          String manifestFileName = "test/resources/variableSubstitution/datatypes_manifest.yml"
   509          String variablesFileName = "test/resources/variableSubstitution/datatypes_manifest-variables.yml"
   510          List<String> variablesFiles = [ variablesFileName ]
   511          String outputFileName = "output.yml"
   512  
   513          fileExistsRule.registerExistingFile(manifestFileName)
   514          fileExistsRule.registerExistingFile(variablesFileName)
   515  
   516          // check that a proper log is written.
   517          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   518              .expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   519              .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   520              .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${outputFileName}.")
   521  
   522          // execute step
   523          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, outputManifestFile: outputFileName,  script: nullScript
   524  
   525          String yamlStringAfterReplacement = writeYamlRule.files[outputFileName].get(SERIALIZED_YAML) as String
   526          Map<String, Object> manifestDataAfterReplacement = writeYamlRule.files[outputFileName].get(DATA)
   527  
   528          //Check that something was written
   529          assertNotNull(manifestDataAfterReplacement)
   530  
   531          // make sure the input file was NOT deleted.
   532          assertFalse(loggingRule.expected.contains("[CFManifestSubstituteVariables] Successfully deleted file '${manifestFileName}'."))
   533  
   534          assertAllVariablesReplaced(yamlStringAfterReplacement)
   535          assertCorrectVariableResolution(manifestDataAfterReplacement)
   536  
   537          assertDataTypeAndSubstitutionCorrectness(manifestDataAfterReplacement)
   538  
   539          // check that the step was marked as a success (even if it did do nothing).
   540          assertJobStatusSuccess()
   541      }
   542  
   543      @Test
   544      public void substituteVariables_resolvesConflictsProperly_InMultiYamlFiles() throws Exception {
   545          // This test checks if the resolution and of conflicting variables and the
   546          // overriding nature of variable lists vs. variable files lists is working properly.
   547  
   548          String manifestFileName = "test/resources/variableSubstitution/multi_manifest.yml"
   549          String variablesFileName = "test/resources/variableSubstitution/manifest-variables.yml"
   550          String conflictingVariablesFileName = "test/resources/variableSubstitution/manifest-variables-conflicting.yml"
   551          List<String> variablesFiles = [ variablesFileName, conflictingVariablesFileName ] //introducing a conflicting file whose entries should win, since it is last in the list
   552  
   553          List<Map<String, Object>> variablesList = [
   554              ["unique-prefix" : "uniquePrefix-from-vars-list"],
   555              ["unique-prefix" : "uniquePrefix-from-vars-list-conflicting"] // introduce a conflict that should win, since it is last in the list.
   556          ]
   557  
   558          fileExistsRule.registerExistingFile(manifestFileName)
   559          fileExistsRule.registerExistingFile(variablesFileName)
   560          fileExistsRule.registerExistingFile(conflictingVariablesFileName)
   561  
   562          // check that a proper log is written.
   563          loggingRule.expect("[CFManifestSubstituteVariables] Loaded manifest at ${manifestFileName}!")
   564          //.expect("[CFManifestSubstituteVariables] Loaded variables file at ${variablesFileName}!")
   565              .expect("[CFManifestSubstituteVariables] Replaced variables in ${manifestFileName}.")
   566              .expect("[CFManifestSubstituteVariables] Wrote output file (with variables replaced) at ${manifestFileName}.")
   567  
   568          // execute step
   569          script.step.cfManifestSubstituteVariables manifestFile: manifestFileName, manifestVariablesFiles: variablesFiles, manifestVariables: variablesList, script: nullScript
   570  
   571          String yamlStringAfterReplacement = writeYamlRule.files[manifestFileName].get(SERIALIZED_YAML) as String
   572          List<Object> manifestDataAfterReplacement = writeYamlRule.files[manifestFileName].get(DATA)
   573  
   574          //Check that something was written
   575          assertNotNull(manifestDataAfterReplacement)
   576  
   577          // check that there are no unresolved variables left.
   578          assertAllVariablesReplaced(yamlStringAfterReplacement)
   579  
   580          //check that result still is a multi-YAML file.
   581          assertEquals("Dumped YAML after replacement should still be a multi-YAML file.",2, manifestDataAfterReplacement.size())
   582  
   583          // check that resolved variables have expected values
   584          manifestDataAfterReplacement.each { yaml ->
   585              assertCorrectVariableSubstitutionUnderConflictAndWithOverriding(yaml as Map<String, Object>)
   586          }
   587  
   588          // check that the step was marked as a success (even if it did do nothing).
   589          assertJobStatusSuccess()
   590      }
   591  
   592      private void assertCorrectVariableSubstitutionUnderConflictAndWithOverriding(Map<String, Object> manifestDataAfterReplacement) {
   593          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("name").equals("uniquePrefix-from-vars-list-conflicting-catalog-service-odatav2-0.0.1"))
   594          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("routes").get(0).get("route").equals("uniquePrefix-from-vars-list-conflicting-catalog-service-odatav2-001.cfapps.eu10.hana.ondemand.com"))
   595          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("services").get(0).equals("uniquePrefix-catalog-service-odatav2-xsuaa-conflicting-from-file"))
   596          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("services").get(1).equals("uniquePrefix-catalog-service-odatav2-hana"))
   597          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("xsuaa-instance-name").equals("uniquePrefix-catalog-service-odatav2-xsuaa-conflicting-from-file"))
   598          assertTrue(manifestDataAfterReplacement.get("applications").get(0).get("env").get("db_service_instance_name").equals("uniquePrefix-catalog-service-odatav2-hana"))
   599      }
   600  }