options are not supported for dockerExecuteOnKubernetes, but
environment variables are. Hence we switch to environment variables
which works on both, plain docker and on kubernetes.
Using env vars is the cleaner approach anyway.
Nobody will have a look at println statements emitted by tests. Proper way is to assert.
* log is empty, not sure if it makes sense to assert that the log is empty.
* result is already asserted, so everything is fine there ...
We should try to avoid promting statements to the log during tests. This is basically
some kind of manual/visual checking of conditions. This does not work since in most cases
nobody scans test logs manually/visually. I think this is often a smell for missing assertions.
* Provide flag for skipping docker image pulls
Usefull for testing while developing images. Without pulling images it is possible to
use images available in the local registry only.
* Project "Piper" Template: framework and structure
This is the first in a series of Pull-Requests to provide a fully functional Pipeline template into the library.
This PR contains:
* general Pipeline structure incl. tests
* Pipeline initialization incl. tests
* Hollow pipeline stages incl. tests
* first set of default values
* add gitUrls to commonPipelineEnvironment
* set correct git information on commonPipelineEnvironment
If there was no instance deployed in CF and blue-green deployment was activated stopping the old instance caused a failure of the pipeline, even if the application was deployed successfully.
With that change the failure of the pipeline will be avoided in case of no old application is available.
The following features were added:
Lock resources for deployment
New parameters: environment, vmArguments
Assert password does not start with @
Link to cloud cockpit
Only execute rolling update if app is running
Show logs if deployment failed
Restart app after normal deployment
Use neo namespace for parameters
Align parameter names with neo sdk: size, application, source
Remove vmSize check as done by the tool itself
command `which` requires a dedicated OS package to be installed.
In case a Jenkins Master or Jenkins Slave Image does not contain `which`, although `docker` command is available the step took a wrong turn.
This removes the check using `which` since checking `docker ps` is sufficient.
mta deploy plugin has flag:
` --no-confirm` which is described as _"Do not require confirmation for deleting the previously deployed MTA apps"_
This flag is essentials for performing fully automated blue-green deployments.
Add reporting of operations-related data to Influx (if configured), like:
* Version of deployed artifact
* Deployment time
* Target infrastructure for deployment
* influxWriteData - support Influx tags
In order to better query data in Influx, tags needs to be written.
This change allows filling tag data via the Influx plugin.
influxWriteData requires a node to be executed.
In a declarative pipeline the POST section by default does not provide a node/agent.
This adds a parameter to force creation of a node/agent.
a lot of code can be replaced by configuring the JenkinsShellCallRule accordingly. At the time when
this test was provided there was not JenkinsShellCallRule ...
* add wrapper for stages contained in library
`piperStageWrapper` provides a wrapper for stages which we may include into the library.
It will take care about extension capabilities, locking, node handling, ... which should be a capability of every stage contained in the library.
* toString is helpful for troubleshooting during developing tests
* equals/hashCode are required in case somebody would like to register
some responses again (e.g. register something valid almost all the time, and
register something more specific for a certain test).
- don't log a message and continue when it is clear that we cannot succeed
together with error raised later during attempt not parse a non-existing
file
- More log output in order to clarify what happens with mta.yaml
* cloudFoundryDeploy - blue-green plugin extensions
* support blue-green application cleanup with new plugin flag
* enhance error reporting in case no app name is available
* include PR feedback
This step allows to easily create a new release for your GitHub repository
* include PR review feedback - add additional labels
* consider return status of api call
This step allows to restart a set of steps in order to retry in case of e.g. infrastructure failures which first need to be fixed.
* update documentation
This step allows to perform a basic health check on an installed application.
It verifies that your app has a simple health endpoint available and that there is no error when calling it.
since now handlePipelineStepError does not return anything anymore we need to put the
corresponding return statement inside createTransportRequest outside the handlinePipelineStepError
closure.
* simplify parameter handover
* extract default contaner name and map
* condense pod execution methods
* simplify closure handling
* fix map issue
* simplify
* stash only if needed
* fix test case
It comes with an extension to executeDocker and executeDockerOnKubernetes to run sidecar containers.
This helps to execute Selenium tests using two Docker images:
1. Execution runtime for tests (e.g. node image)
2. Selenium instance which holds Selenium server + browser
* add documentation & some name cleanup
* include PR feedback
* add step documentation to structure
Up to now we checked for git commands, but the order was not taken into account.
Test would pass even if the commit happens before git add.
Now the order of the git commits is asserted.
it is the duty of the configuration helper to build a map
providing the configuration. Having facilites to use the
ConfigurationHelper as some kind of configuration registry
makes life more complicated.
there is only one test class making use of it left. This test class is the
GitUtilsTest itself.
Hence moving this member downwards in the test class hierarchy into GitUtilsTest.
I doubt it makes sense to make use of a generic git utils mock somewhere else since this basically
means to test the GitUtils class in the conxtext of other examinees. For that there is no need.
The GitUtils class should be tested by the corresponding test class, but not in a transive manner
by other tests. For all other tests a specific git utils mock should be provided mocking the corresponding
method class. This is already the case today, otherwise we would have more test classes making use
of the generic git utils mock.
- In ArtifactSetVersionTest the method was declared,
but not used at all.
- In MtaUtilsTest there was a particular Object created
for the sole purpose of serving as script.
For that we have the nullScript.
- In DockerArtifactVersioningTest 'this' was configured to
serve as script. There is basically no reason why the
instance of the JUnitTest should serve as script.
Instead we have the nullScript for that purpose.
GStrings might be handed over e.g. via signature to steps.
GStrings in configuration makes it harder to deal with configurations.
E.g.
```if(param == 'a' || param == 'b')``` returns true if a is a GString representing 'a'
but
```if(param in ['a', 'b'])``` returns false.
It would be possible not to use the ```in``` notation in our code. But this
increases readability.
GString are not significant and can be replaced by the corresponding java.lang.String
representation without loss of information. Hence it is justified IMO to ensure
there are no GStrings contained in the configuration map.
if we don't mock the GitUtils here changes inside GitUtils affecting the git commands
issued at the command line requires changes here. In fact we have to react on
implementation details of the GitUtils here. It is better to be independent from that
implementation details here since this leads to more focused and smaller commits.
Up to now we had two constructors, one with a Script and the other one with a map holding some defaults.
In case the constructor with the map was called the step name was uninitialized
- there is no need to do the git commit inside the body of sshAgent
- there is no need to do the git tag inside the body of sshAgent
- side catch: availablility of git user name and git user email is
checked at its own. If one is missing the other may be present
~somehow~ in the configuration.
When we register a closure as file, the closure will be exectutd.
Otherwise we return what is registered.
This gives us a maximum level of flexibility. We can throw exceptions (e.g. FileNotFound) as
as test setup requires this, in simple cases we provide the yaml as a string.
