github.com/ouraigua/jenkins-library@v0.0.0-20231028010029-fbeaf2f3aa9b/test/groovy/NpmExecuteEndToEndTestsTest.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.JenkinsMockStepRule
    10  import util.JenkinsReadYamlRule
    11  import util.JenkinsStepRule
    12  import util.Rules
    13  
    14  import com.sap.piper.Utils
    15  
    16  import static org.junit.Assert.assertFalse
    17  import static org.junit.Assert.assertTrue
    18  import static org.junit.Assert.assertTrue
    19  
    20  class NpmExecuteEndToEndTestsTest extends BasePiperTest {
    21  
    22      private JenkinsStepRule stepRule = new JenkinsStepRule(this)
    23      private ExpectedException thrown = ExpectedException.none()
    24      private JenkinsMockStepRule npmExecuteScriptsRule = new JenkinsMockStepRule(this, 'npmExecuteScripts')
    25      private JenkinsCredentialsRule credentialsRule = new JenkinsCredentialsRule(this)
    26      private JenkinsReadYamlRule readYamlRule = new JenkinsReadYamlRule(this)
    27  
    28      private boolean executedOnKubernetes = false
    29      private boolean executedOnNode = false
    30      private boolean executedInParallel = false
    31  
    32      @Rule
    33      public RuleChain ruleChain = Rules
    34          .getCommonRules(this)
    35          .around(thrown)
    36          .around(readYamlRule)
    37          .around(credentialsRule)
    38          .around(stepRule)
    39          .around(npmExecuteScriptsRule)
    40  
    41      @Before
    42      void init() {
    43          helper.registerAllowedMethod("deleteDir", [], null)
    44  
    45          helper.registerAllowedMethod('dockerExecuteOnKubernetes', [Map.class, Closure.class], {params, body ->
    46              executedOnKubernetes = true
    47              body()
    48          })
    49          helper.registerAllowedMethod('node', [String.class, Closure.class], {s, body ->
    50              executedOnNode = true
    51              body()
    52          })
    53          helper.registerAllowedMethod("parallel", [Map.class], { map ->
    54              map.each {key, value ->
    55                  value()
    56              }
    57              executedInParallel = true
    58          })
    59          helper.registerAllowedMethod('findFiles', [Map.class], {return []})
    60  
    61          credentialsRule.reset()
    62              .withCredentials('testCred', 'test_cf', '********')
    63              .withCredentials('testCred2', 'test_other', '**')
    64  
    65          Utils.metaClass.echo = { def m -> }
    66      }
    67  
    68      @After
    69      public void tearDown() {
    70          Utils.metaClass = null
    71      }
    72  
    73      @Test
    74      void appUrlsNoList() {
    75          def appUrl = "http://my-url.com"
    76  
    77          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
    78              appUrls: appUrl
    79          ]]]
    80  
    81          thrown.expect(hudson.AbortException)
    82          thrown.expectMessage("[npmExecuteEndToEndTests] The execution failed, since appUrls is not a list. Please provide appUrls as a list of maps.")
    83  
    84          stepRule.step.npmExecuteEndToEndTests(
    85              script: nullScript,
    86              stageName: "myStage"
    87          )
    88      }
    89  
    90      @Test
    91      void appUrlsNoMap() {
    92          def appUrl = "http://my-url.com"
    93  
    94          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
    95              appUrls: [appUrl]
    96          ]]]
    97  
    98          thrown.expect(hudson.AbortException)
    99          thrown.expectMessage("[npmExecuteEndToEndTests] The element ${appUrl} is not of type map. Please provide appUrls as a list of maps.")
   100  
   101          stepRule.step.npmExecuteEndToEndTests(
   102              script: nullScript,
   103              stageName: "myStage"
   104          )
   105      }
   106  
   107      @Test
   108      void appUrlParametersNoList() {
   109          def appUrl = [url: "http://my-url.com", credentialId: 'testCred', parameters: '--tag scenario1']
   110  
   111          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   112              appUrls: [appUrl]
   113          ]]]
   114  
   115          thrown.expect(hudson.AbortException)
   116          thrown.expectMessage("[npmExecuteEndToEndTests] The parameters property is not of type list. Please provide parameters as a list of strings.")
   117  
   118          stepRule.step.npmExecuteEndToEndTests(
   119              script: nullScript,
   120              stageName: "myStage"
   121          )
   122      }
   123  
   124      @Test
   125      void oneAppUrl() {
   126          def appUrl = [url: "http://my-url.com"]
   127  
   128          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   129              appUrls: [appUrl]
   130          ]]]
   131  
   132          stepRule.step.npmExecuteEndToEndTests(
   133              script: nullScript,
   134              stageName: "myStage"
   135          )
   136  
   137          assertFalse(executedInParallel)
   138          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   139          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   140          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   141          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   142          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"])
   143      }
   144  
   145      @Test
   146      void baseUrl() {
   147  
   148          nullScript.commonPipelineEnvironment.configuration = [
   149                  stages: [
   150                          myStage: [
   151                              baseUrl: "http://my-url.com"
   152                          ]
   153                  ]
   154          ]
   155  
   156          stepRule.step.npmExecuteEndToEndTests(
   157                  script: nullScript,
   158                  stageName: "myStage"
   159          )
   160  
   161          assertFalse(executedInParallel)
   162          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   163          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   164          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   165          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   166          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--baseUrl=http://my-url.com"])
   167      }
   168  
   169      @Test
   170      void oneAppUrl__whenWdi5IsTrue__wdi5CredentialIsProvided() {
   171          def appUrl = [url: "http://my-url.com", credentialId: "testCred"]
   172  
   173          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   174              appUrls: [appUrl],
   175              wdi5: true
   176          ]]]
   177  
   178          stepRule.step.npmExecuteEndToEndTests(
   179              script: nullScript,
   180              stageName: "myStage"
   181          )
   182  
   183          assertFalse(executedInParallel)
   184          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   185          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   186          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   187          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   188          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"])
   189          assert binding.hasVariable('e2e_username')
   190          assert binding.hasVariable('e2e_password')
   191          assert binding.hasVariable('wdi5_username')
   192          assert binding.hasVariable('wdi5_password')
   193      }
   194  
   195      @Test
   196      void oneAppUrl__whenWdi5IsNotSet__noWdi5CredentialIsProvided() {
   197          def appUrl = [url: "http://my-url.com", credentialId: "testCred"]
   198  
   199          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   200              appUrls: [appUrl]
   201          ]]]
   202  
   203          stepRule.step.npmExecuteEndToEndTests(
   204              script: nullScript,
   205              stageName: "myStage"
   206          )
   207  
   208          assertFalse(executedInParallel)
   209          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   210          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   211          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   212          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   213          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"])
   214          assert binding.hasVariable('e2e_username')
   215          assert binding.hasVariable('e2e_password')
   216          assertFalse binding.hasVariable('wdi5_username')
   217          assertFalse binding.hasVariable('wdi5_password')
   218      }
   219  
   220      @Test
   221      void whenWdi5IsTrue__wdi5CredentialIsProvided() {
   222  
   223          nullScript.commonPipelineEnvironment.configuration = [
   224                  stages: [
   225                          myStage: [
   226                              wdi5: true,
   227                              credentialsId: "testCred"
   228                          ]
   229                  ]
   230          ]
   231  
   232          stepRule.step.npmExecuteEndToEndTests(
   233                  script: nullScript,
   234                  stageName: "myStage"
   235          )
   236  
   237          assertFalse(executedInParallel)
   238          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   239          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   240          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   241          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   242          assert binding.hasVariable('e2e_username')
   243          assert binding.hasVariable('e2e_password')
   244          assert binding.hasVariable('wdi5_username')
   245          assert binding.hasVariable('wdi5_password')
   246  
   247      }
   248  
   249      @Test
   250      void whenWdi5IsNotSet__noWdi5CredentialIsProvided() {
   251  
   252          nullScript.commonPipelineEnvironment.configuration = [
   253                  stages: [
   254                          myStage: [
   255                              credentialsId: "testCred"
   256                          ]
   257                  ]
   258          ]
   259  
   260          stepRule.step.npmExecuteEndToEndTests(
   261                  script: nullScript,
   262                  stageName: "myStage"
   263          )
   264  
   265          assertFalse(executedInParallel)
   266          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   267          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   268          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   269          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   270          assert binding.hasVariable('e2e_username')
   271          assert binding.hasVariable('e2e_password')
   272          assertFalse binding.hasVariable('wdi5_username')
   273          assertFalse binding.hasVariable('wdi5_password')
   274  
   275      }
   276  
   277      @Test
   278      void chooseScript() {
   279  
   280          nullScript.commonPipelineEnvironment.configuration = [
   281                  stages: [
   282                          myStage: [
   283                                  runScript: "wdio"
   284                          ]
   285                  ]
   286          ]
   287  
   288          stepRule.step.npmExecuteEndToEndTests(
   289                  script: nullScript,
   290                  stageName: "myStage"
   291          )
   292  
   293          assertFalse(executedInParallel)
   294          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   295          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   296          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   297          assert npmExecuteScriptsRule.hasParameter('runScripts', ["wdio"])
   298          assert npmExecuteScriptsRule.hasParameter('scriptOptions', [])
   299      }
   300  
   301      @Test
   302      void oneAppUrlWithCredentials() {
   303          def appUrl = [url: "http://my-url.com", credentialId: 'testCred']
   304  
   305          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   306              appUrls: [appUrl]
   307          ]]]
   308  
   309          stepRule.step.npmExecuteEndToEndTests(
   310              script: nullScript,
   311              stageName: "myStage"
   312          )
   313  
   314          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   315          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   316          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   317          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   318          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"])
   319      }
   320  
   321      @Test
   322      void twoAppUrlsWithCredentials() {
   323          def appUrl = [url: "http://my-url.com", credentialId: 'testCred']
   324          def appUrl2 = [url: "http://my-second-url.com", credentialId: 'testCred2']
   325  
   326          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   327              appUrls: [appUrl, appUrl2]
   328          ]]]
   329  
   330          stepRule.step.npmExecuteEndToEndTests(
   331              script: nullScript,
   332              stageName: "myStage"
   333          )
   334  
   335          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   336          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   337          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   338          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   339          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"])
   340          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl2.url}"])
   341      }
   342  
   343      @Test
   344      void oneAppUrlWithCredentialsAndParameters() {
   345          def appUrl = [url: "http://my-url.com", credentialId: 'testCred', parameters: ['--tag','scenario1', '--NIGHTWATCH_ENV=chrome']]
   346  
   347          nullScript.commonPipelineEnvironment.configuration = [stages: [myStage:[
   348              appUrls: [appUrl]
   349          ]]]
   350  
   351          stepRule.step.npmExecuteEndToEndTests(
   352              script: nullScript,
   353              stageName: "myStage",
   354              buildDescriptorExcludeList: ["path/to/package.json"],
   355          )
   356  
   357          assert npmExecuteScriptsRule.hasParameter('script', nullScript)
   358          assert npmExecuteScriptsRule.hasParameter('parameters', [dockerOptions: ['--shm-size 512MB']])
   359          assert npmExecuteScriptsRule.hasParameter('virtualFrameBuffer', true)
   360          assert npmExecuteScriptsRule.hasParameter('runScripts', ["ci-e2e"])
   361          assert npmExecuteScriptsRule.hasParameter('scriptOptions', ["--launchUrl=${appUrl.url}"] + appUrl.parameters)
   362          assert npmExecuteScriptsRule.hasParameter('buildDescriptorExcludeList', ["path/to/package.json"])
   363      }
   364  
   365      @Test
   366      void parallelE2eTest() {
   367          def appUrl = [url: "http://my-url.com", credentialId: 'testCred']
   368  
   369          nullScript.commonPipelineEnvironment.configuration = [
   370              general: [parallelExecution: true],
   371              stages: [
   372                  myStage:[
   373                      appUrls: [appUrl]
   374                  ]]]
   375  
   376          stepRule.step.npmExecuteEndToEndTests(
   377              script: nullScript,
   378              stageName: "myStage"
   379          )
   380  
   381          assertTrue(executedInParallel)
   382          assertTrue(executedOnNode)
   383          assertFalse(executedOnKubernetes)
   384      }
   385  
   386      @Test
   387      void parallelE2eTestOnKubernetes_setWith_POD_NAME_EnvVariable() {
   388          def appUrl = [url: "http://my-url.com", credentialId: 'testCred']
   389          binding.variables.env.POD_NAME = "name"
   390  
   391          nullScript.commonPipelineEnvironment.configuration = [
   392              general: [parallelExecution: true],
   393              stages: [
   394                  myStage:[
   395                      appUrls: [appUrl]
   396                  ]]]
   397  
   398          stepRule.step.npmExecuteEndToEndTests(
   399              script: nullScript,
   400              stageName: "myStage"
   401          )
   402  
   403          assertTrue(executedInParallel)
   404          assertFalse(executedOnNode)
   405          assertTrue(executedOnKubernetes)
   406      }
   407  
   408      @Test
   409      void parallelE2eTestOnKubernetes_setWith_ON_K8S_EnvVariable() {
   410          def appUrl = [url: "http://my-url.com", credentialId: 'testCred']
   411          binding.variables.env.ON_K8S = "true"
   412  
   413          nullScript.commonPipelineEnvironment.configuration = [
   414              general: [parallelExecution: true],
   415              stages: [
   416                  myStage:[
   417                      appUrls: [appUrl]
   418                  ]]]
   419  
   420          stepRule.step.npmExecuteEndToEndTests(
   421              script: nullScript,
   422              stageName: "myStage",
   423              runScript: "ci-e2e"
   424          )
   425  
   426          assertTrue(executedInParallel)
   427          assertFalse(executedOnNode)
   428          assertTrue(executedOnKubernetes)
   429      }
   430  }