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

     1  package com.sap.piper
     2  
     3  
     4  import hudson.plugins.sidebar_link.LinkAction
     5  import hudson.AbortException
     6  
     7  import org.jenkinsci.plugins.workflow.steps.MissingContextVariableException
     8  import org.junit.Before
     9  import org.junit.Rule
    10  import org.junit.Test
    11  import org.junit.rules.ExpectedException
    12  import org.junit.rules.RuleChain
    13  import util.BasePiperTest
    14  import util.JenkinsLoggingRule
    15  import util.JenkinsShellCallRule
    16  import util.LibraryLoadingTestExecutionListener
    17  import util.Rules
    18  
    19  import static org.hamcrest.Matchers.*
    20  import static org.junit.Assert.assertThat
    21  import static org.junit.Assert.assertEquals
    22  
    23  class JenkinsUtilsTest extends BasePiperTest {
    24      public ExpectedException exception = ExpectedException.none()
    25  
    26      private JenkinsLoggingRule loggingRule = new JenkinsLoggingRule(this)
    27      private JenkinsShellCallRule shellRule = new JenkinsShellCallRule(this)
    28  
    29      @Rule
    30      public RuleChain rules = Rules
    31          .getCommonRules(this)
    32          .around(exception)
    33          .around(shellRule)
    34          .around(loggingRule)
    35  
    36      JenkinsUtils jenkinsUtils
    37      Object currentBuildMock
    38      Object rawBuildMock
    39      Object jenkinsInstanceMock
    40      Object parentMock
    41  
    42      Map triggerCause
    43  
    44      String userId
    45  
    46      Map results
    47  
    48  
    49      @Before
    50      void init() throws Exception {
    51          results = [:]
    52          results.runlinkCalled = false
    53          results.joblinkCalled = false
    54          results.removejoblinkCalled = false
    55  
    56          jenkinsUtils = new JenkinsUtils() {
    57              def getCurrentBuildInstance() {
    58                  return currentBuildMock
    59              }
    60  
    61              def getActiveJenkinsInstance() {
    62                  return jenkinsInstanceMock
    63              }
    64          }
    65          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(jenkinsUtils)
    66  
    67          jenkinsInstanceMock = new Object()
    68          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(jenkinsInstanceMock)
    69  
    70          parentMock = new Object() {
    71  
    72          }
    73          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(parentMock)
    74  
    75          rawBuildMock = new Object() {
    76              def getParent() {
    77                  return parentMock
    78              }
    79              def getCause(type) {
    80                  if (type == hudson.model.Cause.UserIdCause.class){
    81                      def userIdCause = new hudson.model.Cause.UserIdCause()
    82                      userIdCause.metaClass.getUserId =  {
    83                          return userId
    84                      }
    85                      return userIdCause
    86                  } else {
    87                      return triggerCause
    88                  }
    89              }
    90              def getAction(type) {
    91                  return new Object() {
    92                      def getLibraries() {
    93                          return [
    94                              [name: 'lib1', version: '1', trusted: true],
    95                              [name: 'lib2', version: '2', trusted: false],
    96                          ]
    97                      }
    98                  }
    99              }
   100  
   101          }
   102          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(rawBuildMock)
   103  
   104          currentBuildMock = new Object() {
   105              def number
   106              def getRawBuild() {
   107                  return rawBuildMock
   108              }
   109          }
   110          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(currentBuildMock)
   111      }
   112  
   113      def initializeNewUtil() {
   114          jenkinsUtils = new JenkinsUtils() {
   115              def getCurrentBuildInstance() {
   116                  return currentBuildMock
   117              }
   118  
   119              def getActiveJenkinsInstance() {
   120                  return jenkinsInstanceMock
   121              }
   122  
   123              void addRunSideBarLink(String relativeUrl, String displayName, String relativeIconPath) {
   124                  results.runlinkCalled = true
   125                  assertThat(relativeUrl, is('https://server.com/1234.pdf'))
   126                  assertThat(displayName, is('Test link'))
   127                  assertThat(relativeIconPath, is('images/24x24/graph.png'))
   128              }
   129  
   130              void addJobSideBarLink(String relativeUrl, String displayName, String relativeIconPath) {
   131                  results.joblinkCalled = true
   132                  assertThat(relativeUrl, is('https://server.com/1234.pdf'))
   133                  assertThat(displayName, is('Test link'))
   134                  assertThat(relativeIconPath, is('images/24x24/graph.png'))
   135              }
   136              void removeJobSideBarLinks(String relativeUrl) {
   137                  results.removejoblinkCalled = true
   138                  assertThat(relativeUrl, is('https://server.com/1234.pdf'))
   139              }
   140          }
   141          LibraryLoadingTestExecutionListener.prepareObjectInterceptors(jenkinsUtils)
   142      }
   143  
   144      @Test
   145      void testHandleStepResultsJobLink() {
   146          initializeNewUtil()
   147          helper.registerAllowedMethod("fileExists", [Map], { m ->
   148              return true
   149          })
   150          helper.registerAllowedMethod("readJSON", [Map], { m ->
   151              if(m.file == 'someStep_reports.json')
   152                  return []
   153              if(m.file == 'someStep_links.json')
   154                  return [[target: "https://server.com/1234.pdf", name: "Test link", mandatory: true, scope: 'job']]
   155          })
   156  
   157          jenkinsUtils.handleStepResults("someStep", true, true)
   158  
   159          assertThat(results.removejoblinkCalled, is(true))
   160          assertThat(results.runlinkCalled, is(true))
   161          assertThat(results.joblinkCalled, is(true))
   162      }
   163      @Test
   164      void testHandleStepResults() {
   165          initializeNewUtil()
   166          helper.registerAllowedMethod("fileExists", [Map], { m ->
   167              return true
   168          })
   169          helper.registerAllowedMethod("readJSON", [Map], { m ->
   170              if(m.file == 'someStep_reports.json')
   171                  return [[target: "1234.pdf", mandatory: true]]
   172              if(m.file == 'someStep_links.json')
   173                  return [[target: "https://server.com/1234.pdf", name: "Test link", mandatory: true]]
   174          })
   175  
   176          jenkinsUtils.handleStepResults("someStep", true, true)
   177  
   178          assertThat(results.removejoblinkCalled, is(false))
   179          assertThat(results.runlinkCalled, is(true))
   180          assertThat(results.joblinkCalled, is(false))
   181      }
   182      @Test
   183      void testHandleStepResultsEmptyReports() {
   184          initializeNewUtil()
   185          helper.registerAllowedMethod("fileExists", [Map], { m ->
   186              return true
   187          })
   188          helper.registerAllowedMethod("readJSON", [Map], { m ->
   189              if(m.file == 'someStep_reports.json')
   190                  return []
   191              if(m.file == 'someStep_links.json')
   192                  return [[target: "https://server.com/1234.pdf", name: "Test link", mandatory: true]]
   193          })
   194  
   195          jenkinsUtils.handleStepResults("someStep", true, true)
   196      }
   197      @Test
   198      void testHandleStepResultsEmptyLinks() {
   199          initializeNewUtil()
   200          helper.registerAllowedMethod("fileExists", [Map], { m ->
   201              return true
   202          })
   203          helper.registerAllowedMethod("readJSON", [Map], { m ->
   204              if(m.file == 'someStep_reports.json')
   205                  return [[target: "1234.pdf", mandatory: true]]
   206              if(m.file == 'someStep_links.json')
   207                  return []
   208          })
   209  
   210          jenkinsUtils.handleStepResults("someStep", true, true)
   211      }
   212      @Test
   213      void testHandleStepResultsNoErrorReportsLinks() {
   214          initializeNewUtil()
   215          helper.registerAllowedMethod("fileExists", [Map], { m ->
   216              return true
   217          })
   218          helper.registerAllowedMethod("readJSON", [Map], { m ->
   219              if(m.file == 'someStep_reports.json')
   220                  return []
   221              if(m.file == 'someStep_links.json')
   222                  return []
   223          })
   224          jenkinsUtils.handleStepResults("someStep", false, false)
   225      }
   226      @Test
   227      void testHandleStepResultsReportsNoFile() {
   228          initializeNewUtil()
   229          helper.registerAllowedMethod("fileExists", [Map], { m ->
   230              return false
   231          })
   232          helper.registerAllowedMethod("readJSON", [Map], { m ->
   233              if(m.file == 'someStep_reports.json')
   234                  return [[target: "1234.pdf", mandatory: true]]
   235              if(m.file == 'someStep_links.json')
   236                  return [[target: "https://server.com/1234.pdf", name: "Test link", mandatory: true]]
   237          })
   238  
   239          exception.expect(AbortException)
   240          exception.expectMessage("Expected to find someStep_reports.json in workspace but it is not there")
   241  
   242          jenkinsUtils.handleStepResults("someStep", true, false)
   243      }
   244      @Test
   245      void testHandleStepResultsLinksNoFile() {
   246          initializeNewUtil()
   247          helper.registerAllowedMethod("fileExists", [Map], { m ->
   248              return false
   249          })
   250          helper.registerAllowedMethod("readJSON", [Map], { m ->
   251              if(m.file == 'someStep_reports.json')
   252                  return [[target: "1234.pdf", mandatory: true]]
   253              if(m.file == 'someStep_links.json')
   254                  return [[target: "https://server.com/1234.pdf", name: "Test link", mandatory: true]]
   255          })
   256          helper.registerAllowedMethod('addRunSideBarLink', [String, String, String], { u, n, i ->
   257              assertThat(u, is('https://server.com/1234.pdf'))
   258              assertThat(n, is('Test link'))
   259              assertThat(i, is('images/24x24/graph.png'))
   260          })
   261  
   262          exception.expect(AbortException)
   263          exception.expectMessage("Expected to find someStep_links.json in workspace but it is not there")
   264  
   265          jenkinsUtils.handleStepResults("someStep", false, true)
   266      }
   267      @Test
   268      void testNodeAvailable() {
   269          def result = jenkinsUtils.nodeAvailable()
   270          assertThat(shellRule.shell, contains("echo 'Node is available!'"))
   271          assertThat(result, is(true))
   272      }
   273  
   274      @Test
   275      void testNoNodeAvailable() {
   276          helper.registerAllowedMethod('sh', [String.class], {s ->
   277              throw new MissingContextVariableException(String.class)
   278          })
   279  
   280          def result = jenkinsUtils.nodeAvailable()
   281          assertThat(loggingRule.log, containsString('No node context available.'))
   282          assertThat(result, is(false))
   283      }
   284  
   285      @Test
   286      void testGetIssueCommentTriggerAction() {
   287          triggerCause = [
   288              comment: 'this is my test comment /n /piper test whatever',
   289              triggerPattern: '.*/piper ([a-z]*).*'
   290          ]
   291          assertThat(jenkinsUtils.getIssueCommentTriggerAction(), is('test'))
   292      }
   293  
   294      @Test
   295      void testGetIssueCommentTriggerActionNoAction() {
   296          triggerCause = [
   297              comment: 'this is my test comment /n whatever',
   298              triggerPattern: '.*/piper ([a-z]*).*'
   299          ]
   300          assertThat(jenkinsUtils.getIssueCommentTriggerAction(), isEmptyOrNullString())
   301      }
   302  
   303      @Test
   304      void testGetUserId() {
   305          userId = 'Test User'
   306          assertThat(jenkinsUtils.getJobStartedByUserId(), is('Test User'))
   307      }
   308  
   309      @Test
   310      void testGetUserIdNoUser() {
   311          userId = null
   312          assertThat(jenkinsUtils.getJobStartedByUserId(), isEmptyOrNullString())
   313      }
   314  
   315      @Test
   316      void testGetLibrariesInfo() {
   317          def libs
   318          libs = jenkinsUtils.getLibrariesInfo()
   319          assertThat(libs[0], is([name: 'lib1', version: '1', trusted: true]))
   320          assertThat(libs[1], is([name: 'lib2', version: '2', trusted: false]))
   321      }
   322  
   323      @Test
   324      void testAddJobSideBarLink() {
   325          def actions = new ArrayList()
   326  
   327          helper.registerAllowedMethod("getActions", [], {
   328              return actions
   329          })
   330  
   331          currentBuildMock.number = 15
   332  
   333          jenkinsUtils.addJobSideBarLink("abcd/1234", "Some report link", "images/24x24/report.png")
   334  
   335          assertEquals(1, actions.size())
   336          assertEquals(LinkAction.class, actions.get(0).getClass())
   337          assertEquals("15/abcd/1234", actions.get(0).getUrlName())
   338          assertEquals("Some report link", actions.get(0).getDisplayName())
   339          assertEquals("/images/24x24/report.png", actions.get(0).getIconFileName())
   340      }
   341  
   342      @Test
   343      void testRemoveJobSideBarLinks() {
   344          def actions = new ArrayList()
   345          actions.add(new LinkAction("abcd/1234", "Some report link", "images/24x24/report.png"))
   346  
   347          helper.registerAllowedMethod("getActions", [], {
   348              return actions
   349          })
   350  
   351          jenkinsUtils.removeJobSideBarLinks("abcd/1234")
   352  
   353          assertEquals(0, actions.size())
   354      }
   355  
   356      @Test
   357      void testAddRunSideBarLink() {
   358          def actions = new ArrayList()
   359  
   360          helper.registerAllowedMethod("getActions", [], {
   361              return actions
   362          })
   363  
   364          jenkinsUtils.addRunSideBarLink("abcd/1234", "Some report link", "images/24x24/report.png")
   365  
   366          assertEquals(1, actions.size())
   367          assertEquals(LinkAction.class, actions.get(0).getClass())
   368          assertEquals("abcd/1234", actions.get(0).getUrlName())
   369          assertEquals("Some report link", actions.get(0).getDisplayName())
   370          assertEquals("/images/24x24/report.png", actions.get(0).getIconFileName())
   371      }
   372  
   373  }