üK295 definitions

definitions from all the inputs for üK295

Static Testing

A type of testing that concerns the source code only; the code is not executed.

Dynamic Testing

Testing that executes the program and observes its effects to check functionality and non-functional aspects like performance.

Black-Box Testing

A testing method where the internal structure of the system is not known; focuses on verifying input methods and outputs.

White-Box Testing

A testing method where the internal structure of the system is known; focuses on verifying internal structure and components.

Linting

The process of running a linter tool to flag programming errors, bugs, and stylistic issues in code.

Linter

A static code analysis tool used to flag programming errors, bugs, stylistic errors, and suspicious constructs.

Code Smells

Indicators in code that suggest potential problems; includes issues like duplicates, redundancy, and dead code.

Testing Levels

Different stages of testing including unit testing, integration testing, component testing, and end-to-end testing.

Testing Pyramid

A conceptual framework that illustrates the different levels of testing in software development, emphasizing more low-level tests.

SonarLint

A free IDE extension that helps find and fix bugs, vulnerabilities, and code smells as the developer writes code.

Pros of Static Testing

Relatively early error detection and capability to detect errors in code that is not executed.

Cons of Static Testing

Difficulty in testing complex interactions or problems that occur during runtime.

Exploratory Testing

An approach to testing where testers explore the application without a fixed set of tests.

Unit Testing

Testing individual components or units of a system in isolation.

Integration Testing

Testing the interface between integrated components to ensure they work together.

Component Testing

Testing individual components of a system or application.

End-to-End Testing

A testing method that validates the flow of an application from start to finish.

Test Cases

Specific conditions under which a tester will determine whether a system is working correctly.

Semantic Errors

Programming errors that cause unexpected behavior without syntactically breaking the code.

Executable Test Cases

Test cases that can be executed on the actual code to validate functionality.

Performance Testing

Testing to determine the responsiveness, speed, or stability of a system under a particular workload.

Continuous Analysis Solution

A combined approach like SonarLint paired with SonarQube or SonarCloud to maintain code quality and security continuously.

Runtime Errors

Errors that occur while the program is running, as opposed to compile-time errors.

Testing Documentation

Written records and materials that describe how testing is to be conducted.

Quality Code Practices

Best practices in coding that promote writing clean, efficient, and maintainable code.

Exception Handling

A mechanism to respond to exceptions that occur within a program.

HttpRequestMethodNotSupportedException

An exception thrown when an HTTP method is not supported.

MethodArgumentNotValidException

An exception thrown when method arguments are not valid.

NoResourceFoundException

An exception thrown indicating that a resource was not found.

@ControllerAdvice

A specialization of the @Component annotation that allows you to handle exceptions globally.

@ExceptionHandler

An annotation that defines methods for handling exceptions thrown by request handling methods.

Global Exception Handler

A single class responsible for handling exceptions across all controllers.

Input Validation

The process of ensuring that inputs to a program meet specified requirements.

Annotations

Special markers in code that provide metadata about the class/method/variable.

@NotNull

An annotation indicating that a variable must not be null.

@Min

An annotation that specifies the minimum value for a numeric field.

Log4J2

A logging framework used for creating and managing log files.

Log Levels

Categories that describe the severity or nature of log messages.

INFO

A log level used to indicate regular operational messages.

ERROR

A log level indicating that an error has occurred.

FATAL

A log level indicating a very severe error that will lead to application termination.

DEBUG

A log level useful for debugging; more detailed than INFO.

TRACE

A log level that provides the most detailed logging, often indicating entry/exit points.

Logging Framework

A library that provides tools for logging messages in an application.

@Valid

An annotation indicating that a method parameter should be validated.

MethodArgumentNotValidException

Thrown when a method argument fails validation.

User-Defined Exceptions

Custom exceptions defined by the user to handle specific error scenarios.

Constraint Violations

Occurrences when input does not meet the defined constraints.

@Positive

An annotation that specifies a numeric field must be positive.

@Size

An annotation that specifies the size constraints on a collection or string.

@Pattern

An annotation that validates a string against a specific regular expression pattern.

OCSP

[Test Term] A reference term related to the administrative body responsible for logged content.

Spring Data JPA

A Spring module for managing database access in Java applications.

ORM

Object-Relational Mapping; a technique for mapping object-oriented code onto relational databases.

JPA

Jakarta Persistence API; a specification for database access and object-relational mapping.

Hibernate

An implementation of the JPA that facilitates database interactions.

Model Class

A class that represents a table in a database, marked with @Entity.

Entity Relationship

The association between different entities, such as one-to-many, many-to-one, and many-to-many.

@Entity

An annotation that defines a class as a database entity.

@Id

An annotation that specifies the primary key of an entity.

@GeneratedValue

An annotation used to automatically generate values for primary key fields.

@Table

An annotation that specifies the database table name for an entity.

@Column

An annotation that specifies the database column name for a field.

Foreign Key

A field in one table that uniquely identifies a row of another table.

Primary Key

A unique identifier for a record in a database table.

One-To-Many Relationship

An association where one entity is related to multiple entities.

Many-To-One Relationship

An association where multiple entities relate to one entity.

Many-To-Many Relationship

An association where multiple entities relate to multiple entities.

@OneToMany

An annotation for defining a one-to-many relationship between entities.

@ManyToOne

An annotation for defining a many-to-one relationship.

@JoinColumn

An annotation that specifies the column used for joining tables.

@JoinTable

An annotation that specifies a join table for many-to-many relationships.

business logic

The rules and operations that dictate how data is processed in applications.

Data Access Layer

A layer in an application architecture responsible for interacting with the data source.

DDL

Data Definition Language; commands that define the structure of database schemas.

DML

Data Manipulation Language; commands that manipulate data in a database.

SQL

Structured Query Language; a standard language for managing relational databases.

Load Test Data

To insert initial data into a database upon application startup.

Checkpoint

A review point in a learning session to assess understanding of the material.

Application.properties

A configuration file in Spring applications where properties and settings are defined.

src/main/resources

A directory in a Spring project where resource files are located.

Hypertext

Text with a non-linear structure, connected through hyperlinks to other texts or media.

HTTP

Hypertext Transfer Protocol, a request-response protocol for data transfer over the internet established in 1989.

HTTPS

A secure variant of HTTP that uses encryption to protect data during transfer.

Request-Response Protocol

A communication protocol where a client makes requests to a server and receives responses.

URL

Uniform Resource Locator, the address of a resource on the internet.

HTTP Methods

Actions performed on resources, including POST, GET, PUT, and DELETE.

POST Method

Used to create a new resource by processing data in the request body.

GET Method

Used to retrieve a representation of a resource's state.

PUT Method

Replaces a resource’s state with the state defined in the request body.

DELETE Method

Removes a resource from the server.

Response Code

A 3-digit code indicating the state of a request, like success or error.

Client-Server Architecture

A model where a central server provides services to multiple clients.

Statelessness

A principle where no session information is retained by the server between requests.

REST

Representational State Transfer, an architectural style for creating stateless web APIs.

API

Application Programming Interface, allowing different software to communicate.

Representation

Data format (like XML or JSON) that represents a resource in REST.

CRUD

Create, Read, Update, Delete; basic operations for managing resources.

Layered System

A structure that abstracts deeper application layers for security and scalability.

Uniform Interface

Clear resource identification, self-descriptive messages, and manipulation through representations.