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

     1  import org.junit.After
     2  import org.junit.Before
     3  import org.junit.Rule
     4  import org.junit.Test
     5  import org.junit.rules.ExpectedException
     6  import org.junit.rules.RuleChain
     7  import util.BasePiperTest
     8  import util.JenkinsCredentialsRule
     9  import util.JenkinsFileExistsRule
    10  import util.JenkinsReadFileRule
    11  import util.JenkinsReadYamlRule
    12  import util.JenkinsShellCallRule
    13  import util.JenkinsStepRule
    14  import util.JenkinsWriteFileRule
    15  import util.Rules
    16  import static org.junit.Assert.assertThat
    17  import static org.hamcrest.Matchers.*
    18  import static org.junit.Assert.assertTrue
    19  import static org.junit.Assert.assertFalse
    20  import com.sap.piper.Utils
    21  
    22  class WriteTemporaryCredentialsTest extends BasePiperTest {
    23      private JenkinsStepRule stepRule = new JenkinsStepRule(this)
    24      private ExpectedException thrown = ExpectedException.none()
    25      private JenkinsCredentialsRule credentialsRule = new JenkinsCredentialsRule(this)
    26      private JenkinsWriteFileRule writeFileRule = new JenkinsWriteFileRule(this)
    27      private JenkinsFileExistsRule fileExistsRule = new JenkinsFileExistsRule(this, [])
    28      private JenkinsReadFileRule readFileRule = new JenkinsReadFileRule(this, null)
    29      private JenkinsReadYamlRule readYamlRule = new JenkinsReadYamlRule(this)
    30      private JenkinsShellCallRule shellRule = new JenkinsShellCallRule(this)
    31  
    32      def bodyExecuted
    33  
    34      @Rule
    35      public RuleChain ruleChain = Rules
    36          .getCommonRules(this)
    37          .around(thrown)
    38          .around(readYamlRule)
    39          .around(credentialsRule)
    40          .around(stepRule)
    41          .around(writeFileRule)
    42          .around(fileExistsRule)
    43          .around(readFileRule)
    44          .around(shellRule)
    45  
    46      @Before
    47      void init() {
    48          bodyExecuted = false
    49  
    50          helper.registerAllowedMethod("deleteDir", [], null)
    51  
    52          credentialsRule.reset()
    53              .withCredentials('erp-credentials', 'test_user', '********')
    54              .withCredentials('testCred2', 'test_other', '**')
    55  
    56          Utils.metaClass.echo = { def m -> }
    57      }
    58  
    59      @After
    60      public void tearDown() {
    61          Utils.metaClass = null
    62      }
    63  
    64      @Test
    65      void noCredentials() {
    66          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
    67              credentialsDirectories: ['./', 'integration-test/'],
    68          ]]]
    69          stepRule.step.writeTemporaryCredentials(
    70              script: nullScript,
    71              stageName: "myStage",
    72          ){
    73              bodyExecuted = true
    74          }
    75          assertTrue(bodyExecuted)
    76          assertThat(writeFileRule.files.keySet(), hasSize(0))
    77          assertThat(shellRule.shell, hasSize(0))
    78      }
    79  
    80      @Test
    81      void credentialsNoList() {
    82          def credential = "id"
    83  
    84          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
    85              credentials: credential
    86          ]]]
    87  
    88          thrown.expect(hudson.AbortException)
    89          thrown.expectMessage('[writeTemporaryCredentials] The execution failed, since credentials is not a list. Please provide credentials as a list of maps.')
    90  
    91          stepRule.step.writeTemporaryCredentials(
    92              script: nullScript,
    93              stageName: "myStage",
    94          ){
    95              bodyExecuted = true
    96          }
    97          assertFalse(bodyExecuted)
    98      }
    99  
   100      @Test
   101      void noCredentialsDirectories() {
   102          def credential = [alias: 'ERP', credentialId: 'erp-credentials']
   103  
   104          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   105              credentials: [credential],
   106              credentialsDirectories: []
   107          ]]]
   108  
   109          thrown.expect(hudson.AbortException)
   110          thrown.expectMessage("[writeTemporaryCredentials] The execution failed, since no credentialsDirectories are defined. Please provide a list of paths for the credentials files.")
   111  
   112          stepRule.step.writeTemporaryCredentials(
   113              script: nullScript,
   114              stageName: "myStage",
   115          ){
   116              bodyExecuted = true
   117          }
   118          assertFalse(bodyExecuted)
   119      }
   120  
   121      @Test
   122      void credentialsDirectoriesNoList() {
   123          def credential = [alias: 'ERP', credentialId: 'erp-credentials']
   124  
   125          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   126              credentials: [credential],
   127              credentialsDirectories: './',
   128          ]]]
   129  
   130          thrown.expect(hudson.AbortException)
   131          thrown.expectMessage("[writeTemporaryCredentials] The execution failed, since credentialsDirectories is not a list. Please provide credentialsDirectories as a list of paths.")
   132  
   133          stepRule.step.writeTemporaryCredentials(
   134              script: nullScript,
   135              stageName: "myStage",
   136          ){
   137              bodyExecuted = true
   138          }
   139          assertFalse(bodyExecuted)
   140      }
   141  
   142      @Test
   143      void credentialsFileWrittenAndRemoved() {
   144          def credential = [alias: 'ERP', credentialId: 'erp-credentials']
   145          fileExistsRule.registerExistingFile('./systems.yml')
   146          fileExistsRule.registerExistingFile('./credentials.json')
   147  
   148          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   149              credentials: [credential],
   150              credentialsDirectories: ['./', 'integration-test/'],
   151          ]]]
   152  
   153          stepRule.step.writeTemporaryCredentials(
   154              script: nullScript,
   155              stageName: "myStage",
   156          ){
   157              bodyExecuted = true
   158          }
   159  
   160          assertTrue(bodyExecuted)
   161          assertThat(writeFileRule.files['./credentials.json'], containsString('"alias":"ERP","username":"test_user","password":"********"'))
   162          assertThat(shellRule.shell, hasItem('rm -f ./credentials.json'))
   163          assertThat(writeFileRule.files.size(), is(1))
   164      }
   165  }