How it works

ASUP Updater

ASUP Updater: how?

ASUP Updater automatically checks for security and functionality updates for your applications as often as you want it to. It integrates seamlessly with your GIT repository, meaning your standard development flow is fully respected at all times.

When the Updater is triggered, it connects to your repository and checks the codebase. If there are any new security or functionality updates, ASUP applies them via Composer. When it’s done, it opens a merge/pull request – just like a developer would.

At the same time ASUP Tester can be additionally triggered to generate scenarios based on your input for scenario testing.

From there, you follow your standard development flow. For example, triggering the pipeline to begin deployment to a TEST environment where you can manually review the updates and deploy to production if everything is fine.

After every run, ASUP can let you know which module, plugin or third-party library was updated by sending a report via your preferred reporting channel. It can even send a summary of the actions taken to your team chat.

ASUP is highly customisable, so you can adapt it to suit your own workflow. For example, some of the available parameters include:

  • Auto-merging: yes/no (defaults to ‘no’)
    • Example: You might set this to ‘yes ‘for a TEST deploy, but not allow auto-merging for production.
  • Respect constraints: yes/no (defaults to ‘yes’ for safety reasons)
    • Example: You might set this to ‘no’ if you have everything covered by automated scenario tests and therefore don’t mind seeing what happens if you jump to a new major version.
  • Dry run: yes/no (defaults to ‘no’)
    • Example: You might set this to ‘yes’ if you want to get a report of what would happen if you implemented the updates.

Implementing automated scenario testing

While ASUP Updater takes complete care of the updates, we recommend having automated scenario tests to further reduce the testing time needed. This is where ASUP Tester comes in handy.

Depending on the project, retesting time after updates can take 1–4 hours. Introducing automated scenario tests can eliminate manual testing completely, further streamlining your updates.

ASUP Updater: Supported Technologies

ASUP Updater can be used on all PHP Composer based platforms.

Installation and setup

ASUP is simple to install and set up – just follow the steps below. However, if you need support with installation and configuration, we’ll be happy to help.

  1. Install the Aperta CLI. This is a binary file that you can either add to your project’s directory structure or install globally on your system.
  2. Run the CLI with at least the minimum required parameters. You can enter these parameters directly in the CLI, via a YAML configuration file, or they can be automatically picked up from your environment variables. Example: aperta-cli asup –platform_version 8.1 –vcs_provider gitlab –git_auto_merge 0 –git_branch_target develop –git_clone_url https://my-url.com/project.git
  3. The result is a merge/pull request.

Good to know:

  1. You can request a list of parameters by running: aperta-cli asup – -help
  2. You can create a config.yaml file: the default file that will be used is $HOME/.aperta-cli.yaml or you can specify it with the – -config flag)
What about the alternatives?

We created our Updater to address the main issue we faced when keeping our own PHP projects up to date. Other approaches typically involve making changes directly in the application environment, which brings several problems:

  • Your development flow is not respected. If the update is not done in your GIT repository, deploying it will re-introduce older, non-secure versions.
  • Badly configured updates can result in the application being backed up in production, causing a higher load during the day.
  • If the update fails, a rollback is needed, causing even more downtime and potential hiccups.
  • Manual testing is often required as it’s usually not possible to have completely automated scenario testing.
What about custom code, modules and extensions?

ASUP Updater seamlessly supports custom code, modules, and extensions, ensuring they remain up-to-date and secure as long as they are Composer-based. If your custom code has its own GIT repository, ASUP can connect to it and handle all updates automatically.

ASUP Tester goes beyond one technology. Read more on the Tester page.

ASUP Tester

ASUP Tester: how?
  • Scenario definition: any non-technical user can define test scenarios in text format (.txt files, PDF or Word) and place them in a subfolder of the GIT root of the project. These scenarios should describe specific actions and expected outcomes in a clear, concise manner. We have also recently created a WebUI version so that non-technical people can also generate scenarios.
  • Scenario processing: ASUP’s AI analyzes these scenarios to generate automated test cases. This includes creating both positive (expected behavior) and negative (error handling, edge cases) tests, ensuring comprehensive coverage.
  • ASUP Tester execution environment: the testing is performed in a contained instance, separate from the live environment. This safeguards against any disruptions or risks to the actual data and operations.
  • Integration with development workflow: ASUP Tester process is designed to respect and integrate seamlessly with existing development workflows, particularly those involving GIT repositories.

You can provide input via a features folder in the GIT root of project and put as many .txt files as you want describing scenario’s like example:

Scenario: I’m not logged in and I go to /contact
I’m not logged in
I am on “/contact”
I should see the text “Contact”

Using this information ASUP will create scenarios in both positive and negative ways using Artificial Intelligence and optionally run them in a contained instance, without the need for your data. This is a very important functionality of ASUP and is a differentiator opposed to existing alternatives. If you prefer or have an environment to run the scenario tests on, you can do that also.

Additionally ASUP can do basic checks like bootstrapping the application, checking the database connection etc. This feature is to be released soon.

Supported Technologies and Tools

Our Scenario Testing tools cover a variety of tech stacks and frameworks, including:

  • PHP:
    • Behat
  • Ruby:
    • Cucumber
    • Spinach
  • Java:
    • Cucumber-JVM
    • JBehave
    • Gauge
  • JavaScript:
    • Cucumber-JS
    • Yadda
    • Gauge (with Taiko)
  • .NET:
    • SpecFlow
    • Cucumber.NET
    • LightBDD
  • Go:
    • Godog
  • Swift:
    • Cucumberish
  • Elixir:
    • WhiteBread
  • Haskell:
    • Hspec-Gherkin
  • Kotlin:
    • Kukumber
  • Rust:
    • Cucumber-rs
  • Perl:
    • Test::BDD::Cucumber
  • Objective-C:
    • OCDSpec2
  • Scala:
    • Cucumber-Scala
  • Groovy:
    • Cucumber-Groovy
  • Dart:
    • Cucumber-Dart
  • PowerShell:
    • Pester
  • Apex/Salesforce:
    • ApexUnit
  • Julia:
    • Cucumber.jl
  • Python:
    • Behave
    • pytest-bdd
    • radish
    • Lettuce
    • Cucumber-Py
Setting Up ASUP Tester
  • With our WebUI you can easily create scenarios by manually inputting human written scenarios or by using our recorder tool which is even more user friendly.
  • Define test scenarios: create text, PDF or Word files with your test scenarios and place them in the GIT root of your project under a scenarios subfolder.
  • Using this information ASUP will create scenarios in both positive and negative ways using AI and run them in a contained instance, without the need for your data. This is a very important functionality of ASUP and is a differentiator opposed to existing alternatives.
  • Additionally ASUP will do basic checks like bootstrapping the application, checking the database connection etc.
  • Run automated testing: trigger the automated testing via the ASUP CLI, specifying any required parameters and configurations.
  • Review results: after testing, review the detailed reports provided by ASUP to understand the impact and effectiveness of the updates.

ASUP’s Automated Testing feature represents a significant advancement in the management of your projects, offering a blend of AI-driven efficiency, security, and integration with existing development workflows.

Key features and benefits

The key features are:

  • AI-Enhanced test generation: utilizes advanced AI algorithms to generate a broad range of test scenarios, optimizing the thoroughness and efficiency of the testing process.
  • Isolated testing environments: executes tests in a secure, contained instance, allowing for risk-free testing without accessing or compromising live data.
  • Compatibility with Composer-based PHP frameworks: Fully supports all Composer-based PHP CMS or frameworks, ensuring wide applicability.
  • GIT repository integration: Seamlessly integrates with existing GIT workflows, maintaining the integrity and continuity of the development process.
  • Customizable test parameters: offers flexibility in defining test parameters, allowing teams to tailor the testing process to their specific project requirements.
  • Comprehensive reporting: after each test run, ASUP provides detailed reports on the outcomes, including specifics of the updates tested and their results. These reports can be sent through preferred communication channels.

    The features bring us major benefits:

  • Enhanced efficiency: reduces the time and effort required for manual testing, speeding up the overall development cycle.
  • Improved security and reliability: ensures that updates are not only timely but also secure and functionally sound, reducing the risk of deploying flawed updates.
  • Cost-effective solution: minimizes the resources needed for manual testing, leading to cost savings and optimized resource utilization.
  • Quality Assurance: with thorough testing, updates maintain high standards of quality, performance, and compatibility.
ASUP architecture

When triggering ASUP, you specify the branch it should start from. If your infrastructure supports merge/pull requests, it will open a request to update back into that branch.

However, to clarify this, you will find some example scenarios below.

I use a DevOps platform with pipelines

The most typical ways to trigger ASUP are:

  • using your existing pipeline;
  • creating a new pipeline;
  • setting up a schedule.

Whichever you choose, you trigger ASUP via the ASUP CLI.

I use a DevOps platform without pipelines

Since ASUP is a stand-alone platform, it doesn’t need pipelines. You can simply run ASUP, or schedule a run, in the ASUP CLI and provide the parameters.

If you don’t have the possibility to schedule tasks at a specific time and date (e.g. via Cron), we can provide this for you.

I only have a basic GIT repository

In these cases, ASUP is still very powerful but will not be able to create a merge/pull request. The end result here will be a separate branch.

Yes, you can still use ASUP if you don’t use pipelines. ASUP is designed in such a way that it doesn’t need pipelines. See I use a DevOps platform without pipelines.

ASUP is highly configurable, with parameters that let you control what it’s allowed to do and what it can’t do. Because we agree that updates should not be deployed to production without prior testing, auto-merging defaults to ‘no’. We originally added this parameter to allow users to specify that their develop branch gets automatically updated.

Staying on top of security and functionality updates is of course best practice, regardless of whether or not you use ASUP. With ASUP, the automation of the updates saves time and effort, but of course testing is advised. As you decide yourself how often to run ASUP, you can find the optimal schedule for your team, taking the need for testing into account. Another option is to automate your testing to limit the amount of manual work.

No, there’s no obligation to have automated scenario testing when using ASUP. However, we are big fans of combining the two because you can save a considerable amount of time when updates are automatically tested.

When triggering ASUP, you specify which branch it should start from. So technically, you could run it twice. However, we only recommend running ASUP on your develop branch to respect the development workflow.

Yes! We’d be delighted to offer a free demo of ASUP. Request your ASUP demo here.

No problem, we’re here to help you get the most out of ASUP. Contact us for assistance.