Testing

[1] Feature Tests


[2] Functional Testing


[3] Performace and Load Testing


[4] Security Testing

[5] Test Driven Development


[6] Unit Testing


[7] User Testing

• We also use the Red Green Refactor cycle
  
  
  • We write a (failing) test where the test cases will pass when we build the right function
    
    
  • We write our code until the test is passing
    
    
  • We refactor our code

• Gherkin is a plain-text language with a simple structure.
  
  
• It is designed to be easy to learn by non-programmers
  
  
• Allows concise description of test scenarios and examples to illustrate business rules in most real-world domains.

Feature: Account Holder withdraws cash

Scenario: Account has sufficient funds
    Given The account balance is $100
      And the card is valid
      And the machine contains enough money
    When the Account Holder requests $20
    Then the ATM should dispense $20
      And the account balance should be $80
      And the card should be returned

• Consider the abs() function in Python and Abs() in C#
  
  
• abs()/Abs() returns the absolute value of a number (the distance of the number from zero)
  
  
• Using Arrange-Action-Assert we can write a test to ensure the behaviour of abs()/Abs() is what we expect

# Test abs
def test_abs()

    # Arrange (Setup the testing scenario, mock any data)
    value = 7.5

    # Action (call the function to be tested)
    result = abs(value)

    # Assert (Provide the expected outcome)
    assert result == 7.5

[TestClass]
public class MathTests
{
    [TestMethod]
    public void TestAbs()
    {
        // Arrange (Setup the testing scenario, mock any data)
        double value = 7.5;

        // Action (call the function to be tested)
        double result = Math.Abs(value);

        // Assert (Provide the expected outcome)
        Assert.AreEqual(7.5, result);
    }
}

• Alpha testing
  • Usually the job of UX Designers
  • Do the users actually want these features?
  • What have you missed?
  • Involve focus groups early on

• Beta testing
  • Far more users
  • Aware that some bugs may persist, but may be edge cases
  • Windows Release candidates, iOS betas etc.

• When features make up a product or usable system, you will of course want to test that system and in turn when this becomes a release

• Think about the end of a sprint when you are ready to release your product to your users you will again want to test that the release functions on all platforms/ hardware etc.

name: Upload Python Package

on:
  release:
    types: [published]

permissions:
  contents: read

jobs:
  release-build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.10"

      - name: Build release distributions
        run:  python -m pip install build && python -m build

      - name: Upload distributions
        uses: actions/upload-artifact@v4
        with:
          name: release-dists
          path: dist/

  pypi-publish:
    runs-on: ubuntu-latest
    needs:
      - release-build
    permissions:
      id-token: write

    environment:
      name: pypi
      url: https://pypi.org/project/pylings/${{ github.event.release.name }}

    steps:
      - name: Retrieve release distributions
        uses: actions/download-artifact@v4
        with:
          name: release-dists
          path: dist/

      - name: Publish release distributions to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          packages-dir: dist/

• Remember when we said last week that we ran our tests before we deployed our software?
  • What we really mean are our functional tests (Unit, Feature, System and Release tests)
    
    
• Things like user testing are undertaken ad-hoc and usually arranged by the Product Manager or Scrum Master
  
  
• In bigger organisations performance and load testing may undertaken by you infrastructure team
  
  
• Security testing should always involve a third party. Either you don’t have the expertise in your organisation or you will be biased and fail to test something important.