bg_image
header

Partial Mock

A Partial Mock is a testing technique where only certain methods of an object are mocked, while the rest of the object retains its real implementation. This is useful when you want to stub or mock specific methods but keep others functioning normally.

When to Use a Partial Mock?

  • When you want to test a class but isolate certain methods.

  • When some methods are difficult to test (e.g., they have external dependencies), but others should retain their real logic.

  • When you only need to stub specific methods to control test behavior.

Example in PHP with PHPUnit

Suppose you have a Calculator class but want to mock only the multiply() method while keeping add() as is.

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }

    public function multiply($a, $b) {
        return $a * $b;
    }
}

// PHPUnit Test with Partial Mock
class CalculatorTest extends \PHPUnit\Framework\TestCase {
    public function testPartialMock() {
        // Create a Partial Mock for Calculator
        $calculator = $this->getMockBuilder(Calculator::class)
                           ->onlyMethods(['multiply']) // Only mock this method
                           ->getMock();

        // Define behavior for multiply()
        $calculator->method('multiply')->willReturn(10);

        // Test real add() method
        $this->assertEquals(5, $calculator->add(2, 3));

        // Test mocked multiply() method
        $this->assertEquals(10, $calculator->multiply(2, 3));
    }
}

Here, add() remains unchanged and executes the real implementation, while multiply() always returns 10.

Conclusion

Partial Mocks are useful when you need to isolate specific parts of a class without fully replacing it. They help make tests more stable and efficient by mocking only selected methods.


Fetch API

The Fetch API is a modern JavaScript interface for retrieving resources over the network, such as making HTTP requests to an API or loading data from a server. It largely replaces the older XMLHttpRequest method and provides a simpler, more flexible, and more powerful way to handle network requests.

Basic Functionality

  • The Fetch API is based on Promises, making asynchronous operations easier.
  • It allows fetching data in various formats like JSON, text, or Blob.
  • By default, Fetch uses the GET method but also supports POST, PUT, DELETE, and other HTTP methods.

Simple Example

fetch('https://jsonplaceholder.typicode.com/posts/1')
  .then(response => response.json()) // Convert response to JSON
  .then(data => console.log(data)) // Log the data
  .catch(error => console.error('Error:', error)); // Handle errors

Making a POST Request

fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ title: 'New Post', body: 'Post content', userId: 1 })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

Advantages of the Fetch API

✅ Simpler syntax compared to XMLHttpRequest
✅ Supports async/await for better readability
✅ Flexible request and response handling
✅ Better error management using Promises

The Fetch API is now supported in all modern browsers and is an essential technique for web development.

 

 


Object Query Language - OQL

Object Query Language (OQL) is a query language similar to SQL (Structured Query Language) but specifically designed for object-oriented databases. It is used to query data from object-oriented database systems (OODBs), which store data as objects. OQL was defined as part of the Object Data Management Group (ODMG) standard.

Key Features of OQL:

  1. Object-Oriented Focus:

    • Unlike SQL, which focuses on relational data models, OQL works with objects and their relationships.
    • It can directly access object properties and invoke methods.
  2. SQL-Like Syntax:

    • Many OQL syntax elements are based on SQL, making it easier for developers familiar with SQL to adopt.
    • However, it includes additional features to support object-oriented concepts like inheritance, polymorphism, and method calls.
  3. Querying Complex Objects:

    • OQL can handle complex data structures such as nested objects, collections (e.g., lists, sets), and associations.
  4. Support for Methods:

    • OQL allows calling methods on objects, which SQL does not support.
  5. Integration with Object-Oriented Languages:

Example OQL Query:

Suppose there is a database with a class Person that has the attributes Name and Age. An OQL query might look like this:

SELECT p.Name
FROM Person p
WHERE p.Age > 30

This query retrieves the names of all people whose age is greater than 30.

Applications of OQL:

  • OQL is often used in applications dealing with object-oriented databases, such as CAD systems, scientific databases, or complex business applications.
  • It is particularly suitable for systems with many relationships and hierarchies between objects.

Advantages of OQL:

  • Direct support for object structures and methods.
  • Efficient querying of complex data.
  • Smooth integration with object-oriented programming languages.

Challenges:

  • Less widely used than SQL due to the dominance of relational databases.
  • More complex to use and implement compared to SQL.

In practice, OQL is less popular than SQL since relational databases are still dominant. However, OQL is very powerful in specialized applications that utilize object-oriented data models.

 

 

 


Remote Function Call - RFC

A Remote Function Call (RFC) is a method that allows a computer program to execute a function on a remote system as if it were called locally. RFC is commonly used in distributed systems to facilitate communication and data exchange between different systems.

Key Principles:

  1. Transparency: Calling a remote function is done in the same way as calling a local function, abstracting the complexities of network communication.
  2. Client-Server Model: The calling system (client) sends a request to the remote system (server), which executes the function and returns the result.
  3. Protocols: RFC relies on standardized protocols to ensure data is transmitted accurately and securely.

Examples:

  • SAP RFC: In SAP systems, RFC is used to exchange data between different modules or external systems. Types include synchronous RFC (sRFC), asynchronous RFC (aRFC), transactional RFC (tRFC), and queued RFC (qRFC).
  • RPC (Remote Procedure Call): RFC is a specific implementation of the broader RPC concept, used in technologies like Java RMI or XML-RPC.

Applications:

  • Integrating software modules across networks.
  • Real-time communication between distributed systems.
  • Automation and process control in complex system landscapes.

Benefits:

  • Efficiency: No direct access to the remote system is required.
  • Flexibility: Systems can be developed independently.
  • Transparency: Developers don’t need to understand underlying network technology.

Challenges:

  • Network Dependency: Requires a stable connection to function.
  • Error Management: Issues like network failures or latency can occur.
  • Security Risks: Data transmitted over the network must be protected.

 


Duplicate Code

Duplicate Code refers to instances where identical or very similar code appears multiple times in a program. It is considered a bad practice because it can lead to issues with maintainability, readability, and error-proneness.

Types of Duplicate Code

1. Exact Duplicates: Code that is completely identical. This often happens when developers copy and paste the same code in different locations.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_sphere(radius):
    return 3.14 * radius * radius  # Identical code

2. Structural Duplicates: Code that is not exactly the same but has similar structure and functionality, with minor differences such as variable names.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_square(side):
    return side * side  # Similar structure

3. Logical Duplicates: Code that performs the same task but is written differently.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius ** 2

def calculate_area_circle_alt(radius):
    return 3.14 * radius * radius  # Same logic, different style

Disadvantages of Duplicate Code

  1. Maintenance Issues: Changes in one location require updating all duplicates, increasing the risk of errors.
  2. Increased Code Size: More code leads to higher complexity and longer development time.
  3. Inconsistency Risks: If duplicates are not updated consistently, it can lead to unexpected bugs.

How to Avoid Duplicate Code

1. Refactoring: Extract similar or identical code into a shared function or method.

Example:

def calculate_area(shape, dimension):
    if shape == 'circle':
        return 3.14 * dimension * dimension
    elif shape == 'square':
        return dimension * dimension

2. Modularization: Use functions and classes to reduce repetition.

3. Apply the DRY Principle: "Don't Repeat Yourself" – avoid duplicating information or logic in your code.

4. Use Tools: Tools like SonarQube or CodeClimate can automatically detect duplicate code.

Reducing duplicate code improves code quality, simplifies maintenance, and minimizes the risk of bugs in the software.


A B Testing

A/B testing is a method used in marketing, web design, and software development to compare two or more versions of an element to determine which one performs better.

How does A/B testing work?

  1. Splitting the audience: The audience is divided into two (or more) groups. One group (Group A) sees the original version (control), while the other group (Group B) sees an alternative version (variation).

  2. Testing changes: Only one specific variable is changed, such as a button color, headline, price, or layout.

  3. Measuring results: User behavior is analyzed, such as click rates, conversion rates, or time spent. The goal is to identify which version yields better results.

  4. Data analysis: Results are statistically evaluated to ensure that the differences are significant and not due to chance.

Examples of A/B testing:

  • Websites: Testing two different landing pages to see which one generates more leads.
  • Emails: Comparing subject lines to determine which leads to higher open rates.
  • Apps: Testing changes in the user interface (UI) to improve usability.

Benefits:

  • Provides data-driven decision-making.
  • Reduces risks when making design or functionality changes.
  • Improves conversion rates and efficiency.

Drawbacks:

  • Can be time-consuming if data collection is slow.
  • Results may not always be clear, especially with small sample sizes.
  • External factors can impact the test.

 


PSR-12

PSR-12 is a coding style guideline defined by the PHP-FIG (PHP Framework Interoperability Group). It builds on PSR-1 (Basic Coding Standard) and PSR-2 (Coding Style Guide), extending them to include modern practices and requirements.


Purpose of PSR-12

PSR-12 aims to establish a consistent and readable code style for PHP projects, facilitating collaboration between developers and maintaining a uniform codebase.


Key Guidelines of PSR-12

1. Indentation

  • Use 4 spaces for indentation (no tabs).

2. Line Length

  • Maximum line length should not exceed 120 characters.
  • Code may be broken into multiple lines for better readability.

3. Namespace and Use Statements

  • Add one blank line after the namespace declaration.
  • use statements should follow the namespace declaration.
  • Imported classes, functions, and constants should be alphabetically sorted without blank lines between them.
namespace App\Controller;

use App\Service\MyService;
use Psr\Log\LoggerInterface;
use Psr\Log\LoggerInterface;

4. Classes

  • The opening { for a class or method must be placed on the next line.
  • Visibility (public, protected, private) is mandatory for all methods and properties.
class MyClass
{
    private string $property;

    public function myMethod(): void
    {
        // code
    }
}

5. Methods and Functions

  • Each parameter must be placed on a new line if the parameter list is wrapped.
  • Return types should be explicitly declared.
public function myFunction(
    int $param1,
    string $param2
): string {
    return 'example';
}

6. Control Structures (if, while, for, etc.)

  • The opening { must be on the same line as the control structure.
  • A space is required between the control structure and the condition.
if ($condition) {
    // code
} elseif ($otherCondition) {
    // code
} else {
    // code
}

7. Arrays

  • Use the short syntax ([]) for arrays.
  • In multiline arrays, each element should appear on a new line.
$array = [
    'first' => 'value1',
    'second' => 'value2',
];

8. Type Declarations

  • Parameter, return, and property types are mandatory (where possible).
  • Nullable types are prefixed with ?.
public function getValue(?int $id): ?string
{
    return $id !== null ? (string) $id : null;
}

9. Files

  • PHP files must start with the <?php tag and must not include a closing ?> tag.
  • Add blank lines between declarations like classes or functions.

Differences from PSR-2

PSR-12 extends PSR-2 by:

  • Supporting modern PHP features (e.g., nullable types, declare(strict_types=1), traits, type hinting).
  • Clarifying rules for line lengths, wrapped method parameters, and arrays.
  • Requiring explicit type declarations.

Benefits of PSR-12

  • Simplifies code reviews.
  • Improves readability and maintainability.
  • Enhances interoperability between PHP projects.
  • Ensures consistency with modern PHP practices.

Summary

PSR-12 is the standard for modern and consistent PHP code. It improves code quality and simplifies collaboration, especially in team environments. Tools like PHP_CodeSniffer or PHP-CS-Fixer can help ensure adherence to PSR-12 effortlessly.


PSR-3

PSR-3 is a PHP-FIG (PHP Framework Interoperability Group) recommendation that establishes a standardized interface for logging libraries in PHP applications. This interface defines methods and rules that allow developers to work with logs consistently across different frameworks and libraries, making it easier to replace or change logging libraries within a project without changing the codebase that calls the logger.

Key Points of PSR-3:

  1. Standardized Logger Interface: PSR-3 defines a Psr\Log\LoggerInterface with a set of methods corresponding to different log levels, such as emergency(), alert(), critical(), error(), warning(), notice(), info(), and debug().

  2. Log Levels: The standard specifies eight log levels (emergency, alert, critical, error, warning, notice, info, and debug), which follow an escalating level of severity. These are based on the widely used RFC 5424 Syslog protocol, ensuring compatibility with many logging systems.

  3. Message Interpolation: PSR-3 includes a basic formatting mechanism known as message interpolation, where placeholders (like {placeholder}) within log messages are replaced with actual values. For instance:
    $logger->error("User {username} not found", ['username' => 'johndoe']);
    This allows for consistent, readable logs without requiring complex string manipulation.

  4. Flexible Implementation: Any logging library that implements LoggerInterface can be used in PSR-3 compatible code, such as Monolog, which is widely used in the PHP ecosystem.

  5. Error Handling: PSR-3 also allows the log() method to be used to log at any severity level dynamically, by passing the severity level as a parameter.

Example Usage

Here’s a basic example of how a PSR-3 compliant logger might be used:

use Psr\Log\LoggerInterface;

class UserService
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function findUser($username)
    {
        $this->logger->info("Searching for user {username}", ['username' => $username]);
        // ...
    }
}

Benefits of PSR-3:

  • Interoperability: You can switch between different logging libraries without changing your application’s code.
  • Consistency: Using PSR-3, developers follow a unified structure for logging, which simplifies code readability and maintainability.
  • Adaptability: With its flexible design, PSR-3 supports complex applications that may require different logging levels and log storage mechanisms.

For more details, you can check the official PHP-FIG documentation for PSR-3.

 

 


PSR-1

PSR-1 is a PHP Standards Recommendation created by the PHP-FIG (Framework Interop Group) that defines basic coding standards for PHP code style and structure to ensure interoperability between different PHP projects and frameworks. Its main purpose is to establish a consistent baseline for PHP code, making it easier to understand and collaborate on projects across the PHP ecosystem. PSR-1, also known as the Basic Coding Standard, includes several key guidelines:

  1. File Formatting:

    • All PHP files should use only <?php or <?= tags.
    • Files should use UTF-8 encoding without BOM (Byte Order Mark).
  2. Namespace and Class Names:

    • Class names must be declared in StudlyCaps (PascalCase).
    • PHP classes should follow the “one class per file” rule and be defined within namespaces that match the directory structure.
  3. Constants, Properties, and Method Naming:

    • Constants should be written in all uppercase letters with underscores (e.g., CONST_VALUE).
    • Method names should follow camelCase.
  4. Autoloading:

    • PSR-1 encourages using PSR-4 or PSR-0 autoloading standards to make class loading automatic and avoid manual include or require statements.

PSR-1 is considered a foundational standard, and it works in tandem with PSR-2 and PSR-12, which define more detailed code formatting guidelines. Together, these standards help improve code readability and consistency across PHP projects.

 


PHP Mess Detector - PHPMD

PHP Mess Detector (PHPMD) is a static analysis tool for PHP that helps detect potential problems in your code. It identifies a wide range of code issues, including:

  1. Code Complexity: PHPMD checks for overly complex methods or classes, which may indicate areas that are difficult to maintain or extend.
  2. Unused Code: It can detect variables, parameters, and methods that are defined but not used, reducing unnecessary clutter in the codebase.
  3. Code Violations: PHPMD looks for violations related to clean code practices, such as long methods, large classes, or deeply nested conditionals.
  4. Maintainability: It provides insights into areas that may hinder the long-term maintainability of your project.

PHPMD is configurable, allowing you to define custom rules or use predefined rule sets like "unused code" or "naming conventions." It works similarly to PHP_CodeSniffer, but while CodeSniffer focuses more on style and formatting issues, PHPMD is more focused on the logic and structure of the code.

Key Features:

  • Customizable Rule Sets: You can tailor rules to match the specific requirements of your project.
  • Integration with Build Tools: It can be integrated into CI/CD pipelines to automatically check code for potential issues.
  • Extensible: Developers can extend PHPMD by writing custom rules for project-specific concerns.

In summary, PHPMD helps ensure code quality and maintainability by pointing out potential "messes" that might otherwise go unnoticed.