Tagged articles
Mocking
94 articles · Page 1 of 1
This article explains unit testing fundamentals, compares unit and integration tests, introduces Mockito's core annotations and APIs, walks through a full order‑resend example with detailed test cases, and covers best‑practice methodologies, advanced techniques, common pitfalls, naming conventions, and how to run the tests.
Given-When-ThenJUnit5Java
0 likes · 21 min read

The article shows how replacing module‑level spyOn with a tiny QueryDeps type and a productionDeps factory eliminates implicit coupling, reduces boilerplate, and enables isolated, type‑safe testing of the core query loop in a large Agent project.
AgentFactory PatternMocking
0 likes · 12 min read

This guide explains why isolation is crucial for Python unit tests, clarifies the difference between mocks and stubs, introduces core unittest.mock objects, provides five practical scenarios with full code, shares advanced tips, warns about common pitfalls, and offers actionable steps to write robust, dependency‑free tests.
MockMockingPython
0 likes · 8 min read

This article presents seven validated strategies—layered architecture, contract‑driven assertions, configuration‑driven data, smart mocking, impact‑based test selection, OpenAPI‑generated test skeletons, and health‑dashboard monitoring—to dramatically reduce maintenance effort and increase the robustness of automated API tests in fast‑changing projects.
API TestingCI/CDMocking
0 likes · 9 min read

Learn how to use a lightweight Python @smart_mock decorator to automatically toggle between real API calls and mock responses based on an environment variable, speeding up local development, ensuring reliable CI tests, and keeping your code clean and secure.
DecoratorMockingautomation
0 likes · 8 min read

This guide explains how GoMonkey lets Go developers replace built‑in functions, external library calls, and struct methods at runtime, enabling stable, isolated unit tests without modifying production code.
Backend DevelopmentMockinggomonkey
0 likes · 7 min read

This article explains how Go interfaces enable decoupling, polymorphism, easier testing with mocks, extensibility, and contract‑driven design, using a concrete ClientDetailsService example with in‑memory and Postgres implementations.
Mockingdependency-injectioninterface
0 likes · 7 min read

This article explains why unit testing is essential for code quality, API design, and documentation, then walks through Go's built‑in testing conventions, common *testing.T methods, table‑driven test patterns, mocking with gomonkey, and best practices for writing maintainable tests.
GoMockingTable-Driven Tests
0 likes · 27 min read

This article explains why mocking is essential for reliable unit testing, outlines its core benefits such as environment isolation, speed, and coverage, and provides practical Go examples—including dynamic behavior control, state verification, and using gomock—to help engineers implement robust mock strategies.
GoMock FrameworksMocking
0 likes · 10 min read

This article explains how to use Go's httptest package and the gock library to mock HTTP servers and external API calls, providing step‑by‑step code examples, test case design, and practical tips for reliable backend unit testing.
Backend DevelopmentGoMocking
0 likes · 13 min read

Designing an excellent test framework demands solid programming expertise, architectural thinking, and meticulous attention to detail, covering core capabilities such as coding standards, design patterns, extensibility, automation, CI/CD integration, reporting, performance, and continuous feedback to ensure usability, maintainability, and scalability.
CI/CDMockingautomation
0 likes · 13 min read

This guide explains how to install pytest, create a module with a function that calls an external API, and use unittest.mock fixtures and helper functions to mock requests.get for both successful and failing responses, then run the tests with pytest.
BackendMockingpytest
0 likes · 9 min read

This tutorial demonstrates how to use pytest together with Python's unittest.mock module to mock external HTTP requests, covering fixture creation, mock response setup, and writing test cases for both successful and failed API calls.
API mockingFixtureMocking
0 likes · 9 min read

The article demonstrates how PowerMock can be used to unit‑test a Java FileParser class—showing basic mocks for files and streams, advanced techniques for final and static classes, and achieving full coverage—while warning that its heavy class‑loader overhead can dramatically slow large test suites and increase memory consumption.
JUnitJavaMocking
0 likes · 10 min read

This article explains why upgrading JDK 11 prompts the removal of the unmaintained PowerMock framework, outlines the steps to replace it with Mockito‑Only—including JUnit runner configuration, handling static, private, and final methods, multithreaded mock limitations, and performance gains—while providing code examples and migration tips.
JDK11 migrationJava TestingMocking
0 likes · 15 min read

This article shares practical insights on traffic recording and replay for backend testing, covering background, recording rules, scenario coverage, handling read/write interfaces, mock versus real replay, coverage metrics, and diff result comparison to improve system stability and test completeness.
Backend testingMockingR2
0 likes · 11 min read

This article explains how to use Go's httptest package and the gock library to mock HTTP servers and external API calls, providing step‑by‑step code examples, test case structures, and installation instructions for effective backend unit testing.
API TestingBackendGo
0 likes · 12 min read

Discover how Kahlan, a full‑featured BDD testing framework for PHP, enhances unit and integration testing with RSpec‑style syntax, built‑in code coverage, powerful stubbing, monkey‑patching, and flexible reporting, all without requiring PECL extensions.
BDDMockingcode coverage
0 likes · 5 min read

This article introduces the xgo tool for Go, explains its cross‑platform monkey‑patching capabilities, demonstrates how to write unit tests with mock.Patch, shows installation, usage of Trap, Trace, and incremental coverage features, and evaluates its advantages and drawbacks for backend development.
CoverageGoMocking
0 likes · 15 min read

This article presents a concise, beginner-friendly approach to building a Spring Boot unit testing environment using only essential Maven dependencies and test classes, covering both integration-style and pure unit test techniques, complete with annotated examples and practical testing tips.
Integration TestJUnitJava
0 likes · 9 min read

This article presents a zero‑install, web‑integrated proxy that developers can launch via a browser link or QR code, injects an SDK to intercept network calls, offers remote debugging and UI‑driven mock rule configuration, and stores data in IndexedDB, while noting operational overhead and limited applicability.
HTTP interceptionMockingRemote Debugging
0 likes · 11 min read

freezegun is a Python library that lets developers mock and freeze the current time, enabling precise control over time‑dependent code during unit testing, with examples covering basic usage, timezone handling, complex datetime objects, and dynamic time manipulation.
DATETIMEMockingUnit Tests
0 likes · 3 min read


DevOpsMar 7, 2024 · Backend Development
This article explains why unit testing is often seen as burdensome, then provides practical Go techniques—using pure functions, extracting dependencies, object‑oriented design, function variableization, and avoiding init—to write business code that is easy to test and maintain.
GoMockingPure Functions
0 likes · 17 min read

This article explains the core concepts of the Mockito framework, compares it with other Java unit‑testing tools, demonstrates practical code examples, and breaks down the internal workings of annotations like @InjectMocks, @Mock, @RunWith, as well as the Mockito.when() and Mockito.verify() mechanisms.
AnnotationsJUnitMocking
0 likes · 22 min read

The guide shows that by consciously designing Go data structures and function interfaces—using pure functions, parameter injection, interface abstractions, struct‑based objects, or function‑variable patterns—and avoiding init(), developers can expose and control all dependencies, making business code inherently testable and achieving high unit‑test coverage.
Backend DevelopmentBest PracticesGo
0 likes · 17 min read

This guide introduces front‑end unit testing with Jest, explaining TDD and BDD concepts, installation, writing simple and ES6/TypeScript tests, configuring coverage, using common matchers, and employing mock functions, timers, and module mocking to ensure reliable, maintainable code.
JestMockingTDD
0 likes · 14 min read

The article details how the Mooncake platform tackled outdated, manually‑maintained API docs by introducing naming conventions, a one‑click IntelliJ plugin, GitLab MR auto‑parsing, and a metadata center that supports debugging, mocking, and downstream consumption, saving developers hundreds of hours per release.
API DocumentationGitLab CIIntelliJ Plugin
0 likes · 18 min read

The article explains what integration testing is, why it matters in micro‑service e‑commerce systems, demonstrates a Flask order‑creation example, and offers concrete planning, data, case, security, and CI/CD recommendations to ensure contracts between services work as expected.
CI/CDFlaskMicroservices
0 likes · 8 min read

This article explains why and how to use mock data in frontend development, compares six mainstream mock solutions, and provides a step‑by‑step guide to implementing MSW with Faker in a Vite‑based Vue 3 TypeScript project, including code examples and best‑practice recommendations.
FakerMockingTypeScript
0 likes · 15 min read

This article explores how to effectively use unit testing in daily development, defining its purpose, debunking common misconceptions, presenting the AIR principles, offering coverage level guidelines, and sharing practical tips, code examples, and solutions for handling mocks, static classes, and integration challenges.
Mockingcode coverageunit testing
0 likes · 16 min read


政采云技术May 17, 2023 · Frontend Development
This article explains automated testing concepts, compares unit, integration, TDD and BDD approaches, shows how to write Jest test cases without a framework, configure Jest, use matchers, handle async code, hooks, mocks, timers, snapshots, DOM testing, and provides practical code examples and repository links.
Frontend TestingJestMocking
0 likes · 28 min read


DevOpsMar 21, 2023 · Backend Development
The article shares practical techniques for improving unit test coverage in massive, low‑quality legacy codebases, including creating isolated new modules, applying test‑driven development, decoupling through design patterns, extracting interfaces, using seams, and employing mocking to overcome static dependencies.
Mockingdependency-injectionlegacy code
0 likes · 9 min read


JD TechFeb 14, 2023 · Backend Development
This article introduces the EasyMock platform, outlines its key capabilities for service mocking, explains the technical challenges it solves, and provides a detailed step‑by‑step walkthrough of the JSF Mock implementation—including jar acquisition, JVM class loading, dynamic proxy creation, interface registration, client invocation, and parameter matching/return logic—accompanied by code examples.
ClassLoaderJSFMocking
0 likes · 12 min read

Bilibili’s unified API management platform automates documentation generation for Go and Java services, ties each API version to specific code commits, supports version snapshots, integrates with gateways for debugging and OpenAPI export, and provides service‑level mocking, thereby standardizing microservice development and reducing cross‑team overhead.
API ManagementMicroservicesMocking
0 likes · 20 min read

This article introduces the EasyMock platform, explains its role in providing JSF and HTTP mock services for development and testing, outlines its architecture and capabilities, and details the step‑by‑step technical implementation of JSF Mock including jar downloading, JVM class loading, dynamic proxy creation, registration, client invocation, parameter matching, and response deserialization.
BackendClassLoaderJSF
0 likes · 11 min read

The team combats outdated documentation and costly front‑end maintenance by treating unit tests for the use‑case layer as living documentation, using BDD‑style Given‑When‑Then tests that assert only observable behavior, which improves code readability, eases onboarding, and provides a reliable safety net for future changes.
BDDJavaScriptMocking
0 likes · 13 min read

This open‑source C++ mock framework leverages Frida‑gum to replace any function—including static, member, virtual, and library calls—at runtime without source changes, offering simple MOCK and MOCK_RETURN macros, call‑count expectations, automatic scope‑based rollback, and cross‑platform support for reliable, non‑intrusive unit testing.
C++FridaMocking
0 likes · 11 min read

The article outlines how to design robust SpringBoot unit tests by first mastering business flows and external dependencies, preparing isolated test data, using Mockito’s @Mock/@MockBean and @Spy/@SpyBean correctly—including proper stubbing techniques—and applying best‑practice rules and the ACTS 2.0 framework for data‑driven, coverage‑verified testing.
MockingMockitoSpringBoot
0 likes · 8 min read

This article reviews popular Node.js testing tools—including runners, coverage reporters, assertion libraries, mocking frameworks, HTTP and CLI testing utilities, and CI services—while discussing the practical necessity and ROI considerations of unit testing in modern development.
CICoverageMocking
0 likes · 9 min read

Unstable test cases, caused by shared resources and unchecked assumptions, can mislead developers, hide real bugs, and lead to unfair blame, so this article explains why preconditions must be verified, demonstrates flaky test examples, and offers practical strategies such as resource cleanup, unique test resources, and mock file systems to achieve reliable testing.
Mockingflaky testssoftware testing
0 likes · 4 min read

Spock is an open‑source Java/Groovy testing framework that blends JUnit‑style structure with a concise Groovy DSL, offering data‑driven “given‑expect‑where” tests, straightforward mocking and property injection, Maven‑based setup, and seamless PowerMock integration for static‑method mocking, making it a powerful alternative to traditional unit‑test tools.
GroovyJavaMocking
0 likes · 17 min read


DevOpsMar 10, 2022 · Fundamentals
The article explains why unit tests are essential for software quality, identifies five typical pitfalls—testing per function instead of per feature, chasing code‑coverage metrics, over‑reliance on mocks, writing tests that never fail, and handling nondeterministic behavior—and provides practical recommendations to overcome each issue.
Mockingcode coveragesoftware quality
0 likes · 11 min read

This article walks through the fundamentals of front‑end unit testing, covering why tests matter, popular frameworks like Jest, core APIs, mocking techniques, and how to use React Testing Library to render components, query elements, and simulate user events for reliable, maintainable code.
JestMockingReact Testing Library
0 likes · 17 min read

The article explains Go’s table‑driven testing pattern, showing how separating test data into a slice of structs simplifies test code, improves quality, and enables subtests, parallel execution, assertions, mocking, and custom templates, illustrated with a GetWeekDay example and advanced techniques.
GoMockingParallel Testing
0 likes · 14 min read

The author describes encountering quality‑assurance challenges in Spring Boot, revisiting unit‑testing frameworks like Spock, Mockito, and PowerMock, struggling with static‑method mocking, and ultimately adopting a "reset and rebuild" strategy to resolve dependency conflicts and improve test coverage.
MockingMockitoPowerMock
0 likes · 5 min read

This guide explains how to use Dubbo's cloud‑native features—service listings, dynamic routing (conditional, tag, and mesh), runtime configuration, testing, and mock support—providing step‑by‑step examples, YAML definitions, and Maven snippets for effective service governance.
Cloud NativeMockingdynamic routing
0 likes · 6 min read

This article explains how leveraging JSON serialization can dramatically simplify and accelerate Java unit test development by reducing boilerplate code for data mocking and verification, offering practical examples, naming conventions, resource organization, and integration tips for backend projects.
JSONJavaMocking
0 likes · 37 min read

This article explains five typical pitfalls that make unit tests ineffective—testing per function instead of behavior, chasing code‑coverage, over‑reliance on mocks, writing tests that never fail, and allowing nondeterminism—while offering practical guidance on how to avoid each issue.
Mockingcode coveragesoftware testing
0 likes · 11 min read

This article explains what unit testing is, shows how to write Go unit tests using the testing package, demonstrates more expressive assertions with GoConvey, and introduces mock creation with mockery, providing practical code examples and best‑practice tips for backend developers.
GoGoConveyMocking
0 likes · 7 min read

The article presents a comprehensive guide to using the Spock testing framework for Java and Groovy backend development, illustrating its BDD‑style DSL, data‑driven tables, integrated mocking (including static methods via PowerMock), exception verification, in‑memory DAO testing, and enhanced coverage reporting compared to JUnit.
BDDGroovyJava
0 likes · 35 min read

This article introduces Mockito, a Java mocking framework, explains when to use it for testing code with external dependencies, and provides step‑by‑step guidance—including Maven setup, creating mock objects in Scala, and configuring mock behavior—complete with code snippets and reference links.
JavaMavenMocking
0 likes · 5 min read

This article describes how the PC teacher desktop client adopts a layered MVL architecture, introduces unit testing with GoogleTest and GoogleMock, explains the underlying TEST and RUN_ALL_TESTS macro mechanisms, demonstrates mock view implementation, and shows how code coverage is measured to achieve targeted test coverage levels.
C++Mockingcode coverage
0 likes · 15 min read

This comprehensive guide walks Java developers through the principles and practical steps of writing high‑coverage unit tests using Mockito and PowerMock, covering framework basics, Maven dependencies, typical service code, test case structure, mocking techniques, verification methods, exception handling, and common pitfalls with solutions.
JavaMockingMockito
0 likes · 44 min read


DevOpsMay 13, 2021 · Fundamentals
This article explains why comprehensive interface testing is essential for software quality, outlines testing layers such as unit, module, and entry (interface) testing, details core testing principles and best‑practice guidelines, and provides practical advice on test code structure, efficiency, framework selection, and coverage to ensure reliable, maintainable systems.
Mockinginterface testingsoftware quality
0 likes · 9 min read

This comprehensive guide walks you through writing effective Java unit tests, covering test framework basics, Maven dependencies, typical code examples, step‑by‑step test case creation, mocking techniques with Mockito and PowerMock, verification strategies, handling special cases, and best practices for achieving high coverage.
JUnitJavaMocking
0 likes · 48 min read

This article explains unit testing concepts, introduces TestNG and PowerMock frameworks for Spring Boot, details common annotations, provides Maven dependency snippets and comprehensive Java test examples, and demonstrates advanced mocking techniques, parameterized tests, and assertion strategies to improve code reliability and coverage.
JavaMockingPowerMock
0 likes · 14 min read

The article explains why mocking external components you don’t control can introduce maintenance problems, such as hidden bugs and upgrade difficulties, and suggests using real implementations, library‑provided fakes, or wrapper classes instead, while offering code examples and practical guidance.
JavaMockingTest Doubles
0 likes · 5 min read

Overusing mocks in unit tests can make test code harder to understand, harder to maintain, and give a false sense of correctness, so developers should recognize signs of excessive mocking and consider alternatives such as hermetic servers or fake objects.
Mockingsoftware testingtest design
0 likes · 4 min read

This comprehensive guide walks Java developers through setting up PowerMock and Mockito, demonstrates creating and spying on mocks, stubbing methods, using parameter matchers, verifying interactions—including static and private members—and explains essential annotations and best‑practice principles for robust, maintainable unit tests.
JavaMockingMockito
0 likes · 24 min read

This article presents the background, research, design choices, core features, extensions, challenges, and outcomes of Mars, a proxy‑based lightweight frontend mock platform developed by Ctrip's IBU ticket team to improve development efficiency and testing flexibility across devices and environments.
CtripDevelopment ToolsMocking
0 likes · 10 min read

This article shares practical techniques to enhance software testability, covering strategies for bypassing graphical and SMS captchas, efficient test data creation, automated and brute‑force data injection, mocking services, and deploying test‑specific code without affecting production environments.
Backend testingCAPTCHAData Generation
0 likes · 11 min read

Hulk is a non‑intrusive HTTP mock platform built with Django, mitmproxy, Vue, MongoDB and MySQL that lets teams mock client‑side, gateway-level and inter‑service APIs via configurable responses, without modifying production code, thereby reducing test‑data creation effort, stabilizing automation and improving overall testing efficiency.
DjangoHTTPMocking
0 likes · 14 min read

The article introduces CtripPaymentRepeater, a Java‑based system that captures real traffic from a stable version, manages it as test cases, and replays it against new releases to automatically detect regressions while minimizing manual effort and ensuring data safety.
Backend testingMockingTraffic Replay
0 likes · 13 min read

TestableMock is a Java unit‑testing helper that lets developers access private fields and methods, quickly mock any method call, and effectively test void methods by providing annotations and utility classes, with detailed code examples and usage guidelines for both Java and Kotlin projects.
JavaMockingPrivate Access
0 likes · 12 min read

The article explains the different types of test doubles—Dumb, Fake, Stub, and Mock—provides guidelines on when to prefer real implementations, discusses the drawbacks of overusing Stubs and Mocks, and offers practical advice for writing and maintaining Fakes in software testing.
MockingTest Doublesfakes
0 likes · 10 min read

This article explains how unit testing goes beyond coverage metrics, showing that writing testable code improves design, performance, and robustness, and provides practical guidance on refactoring, mock usage, data‑driven tests, TDD, BDD, and agile development practices.
BDDMockingTDD
0 likes · 17 min read

This article explains how to use Mockito's doNothing, doAnswer, doThrow, and doCallRealMethod to mock void methods in Java, demonstrating parameter verification, argument capture, and real‑method invocation with detailed code examples and reasoning behind each approach.
JUnitJavaMocking
0 likes · 6 min read

The article explains how to set up Jest for front‑end unit testing, demonstrates basic test writing, async handling, hooks, snapshot and React component testing, shows coverage configuration and thresholds, compares Jest’s built‑in features to Mocha’s limitations, and offers tips on concurrency, mocking, and test‑driven development.
JavaScriptJestMocking
0 likes · 21 min read

This guide explains why unit testing matters, compares Java testing tools, introduces PowerMock’s capabilities, details essential annotations, shows how to configure dependencies, and provides step‑by‑step code examples for mocking public, final, static, private, constructor, field and superclass methods.
JUnitJavaMocking
0 likes · 10 min read

This article explains why flaky tests harm development, demonstrates how shared resources cause instability, and provides practical guidelines—such as using exclusive resources, refactoring for dependency injection, writing one‑scenario tests, and avoiding verification of non‑state‑changing calls—to create reliable, focused unit tests.
Mockingflaky testsunit testing
0 likes · 7 min read

JMock is a zero‑configuration, intelligent mocking platform that simplifies service dependency testing for backend applications by providing Maven‑based SDK integration, automatic environment detection, configurable mock switches, diverse data sources, and automatic data generation to accelerate development and reduce testing overhead.
BackendJavaMocking
0 likes · 12 min read

This guide shows how to replace System.in and System.out with in‑memory streams during unit testing, provides reusable helper classes for setting and restoring these streams, and includes a complete example demonstrating input simulation and output capture in Java.
IO StreamsJavaMocking
0 likes · 5 min read

This article explains the fundamentals of unit testing, covering its definition, core concepts, essential principles, practical techniques such as mocking, and its role in test automation and continuous integration within modern agile development.
Continuous IntegrationMockingTest Automation
0 likes · 7 min read

The article introduces the MockRpc platform, which uses Spring‑based extensions and a mock server to fully decouple front‑end services from middle‑end services in a micro‑service architecture, enabling zero‑intrusion testing, configurable mock data, and improved development efficiency for JD Retail.
DevOpsMicroservicesMocking
0 likes · 11 min read


AntTechDec 20, 2019 · Frontend Development
This article outlines the evolution of mini‑program development at Ant Group, describing three engineering stages, essential tooling such as state management, Datahub mocking, monitoring, internationalization, component libraries, and SubApp architecture to bring mini‑programs closer to mainstream front‑end engineering practices.
MockingState Managementi18n
0 likes · 10 min read

This article explains the fundamentals of unit testing in Java, covering what unit tests are, why they matter, when to write them, and detailed step‑by‑step examples using Mockito, PowerMock, JUnit, and Spring Boot to mock dependencies, verify behavior, and assert results across DAO, service, and controller layers.
JUnitMockingMockito
0 likes · 28 min read


转转QANov 22, 2019 · Backend Development
This article presents a comprehensive approach to simulate third‑party payment scenarios by using Java bytecode instrumentation and DNS redirection, enabling reliable testing of payment‑related business logic without modifying production services, while reducing deployment and development costs.
BackendJava InstrumentationMocking
0 likes · 6 min read

The article introduces the concept of full‑link mocking for complex, multi‑dependency applications, explains its technical background, describes the implementation architecture and performance considerations, and discusses practical challenges such as duplicate calls, cache consistency, and HTTP 302 forwarding.
BackendCacheMocking
0 likes · 9 min read

This article explains how to design and implement a mock plugin for Dubbo-based services, enabling stable CI integration, multi‑service mocking, per‑test case responses, custom annotations, and service‑chain routing, with detailed code examples and deployment steps.
CIDubboJava
0 likes · 19 min read

This article demonstrates practical SpringBoot techniques for masking external dependencies by mocking beans directly in the container and securing configuration values with Jasypt encryption, enabling local debugging without full service startup and protecting sensitive credentials.
Bean ReplacementConfiguration EncryptionJava
0 likes · 8 min read

This article provides a comprehensive guide to using Jest for front‑end unit testing, covering the lack of tests, benefits, installation, basic assertions, matchers, asynchronous testing, lifecycle hooks, mock functions, module mocking, snapshot testing, and best practices to improve code quality and development efficiency.
JavaScriptJestMocking
0 likes · 15 min read

This article shares practical SpringBoot techniques for locally mocking external service dependencies and encrypting configuration properties, detailing step-by-step bean replacement using PowerMockito, configuration encryption with Jasypt, and accompanying code examples for seamless development without starting full distributed services.
@BeanJavaMocking
0 likes · 8 min read

This article explains how the PouchContainer project automates code‑style enforcement and comprehensive Golang unit testing using tools like golint, gometalinter, shellcheck, markdownlint, table‑driven tests, and mock implementations, integrating them into CI pipelines to ensure reliable releases.
Code styleContinuous IntegrationMocking
0 likes · 16 min read

This article explains how microservice architecture transforms testing by classifying five test types—unit, integration, component, contract, and end‑to‑end—introduces Ctrip's automated comparison tool that replays production logs with mock services, and highlights its design goals, implementation details, and advantages for improving test coverage and reliability.
Contract TestingMockingautomation
0 likes · 8 min read

This article explains why unit testing is essential for PHP projects, introduces SOLID design principles, shows how to choose and install PHPSpec, demonstrates writing specifications, mocking, argument matching, exception testing, and configuring code‑coverage reports, all with concrete code examples.
MockingPHPSpecSOLID
0 likes · 10 min read

Learn how to enhance PHP code quality by implementing unit tests using PHPSpec and PHPUnit, covering SOLID principles, mock objects, test setup, code coverage integration, and best practices for writing maintainable, reliable backend code.
Backend DevelopmentMockingPHP
0 likes · 11 min read

This guide explains how to configure Fiddler for capturing HTTPS traffic from mobile devices, install and trust its certificate on iPhone, and leverage features such as request inspection, saving sessions, replaying, mock responses with AutoResponder, and setting global or per‑request breakpoints.
FiddlerHTTPS captureMocking
0 likes · 7 min read

This guide explains how to configure Fiddler to capture HTTPS traffic from mobile devices, install the required certificates on iPhone and Android, use AutoResponder for mock responses, and apply global or per‑request breakpoints to modify or replay network calls during mobile app testing.
FiddlerHTTPS captureMocking
0 likes · 7 min read

The article introduces JD’s iOS Mocker, a server‑side mock service that decouples client development from backend progress, provides comprehensive mock data for all shopping‑flow interfaces, improves testing efficiency, ensures UI robustness, and outlines its architecture, usage workflow, and future extensions.
APIMockingclient‑server
0 likes · 7 min read

The article introduces ARES, a module-level automated regression testing system that records real online data, replays it offline as a black-box test, and provides low-cost deployment, full automation, high coverage, and detailed reporting to simplify testing of complex backend services.
Mockingautomated testingmodule testing
0 likes · 14 min read

This article explains the importance of unit testing in Android development, outlines why developers should invest time in it, and provides a step‑by‑step guide on writing effective Android unit tests using JUnit, Mockito, Dagger2, and Robolectric, along with practical tips, CI integration, and common pitfalls.
AndroidCIDagger2
0 likes · 23 min read

When writing integration tests that involve database operations, developers must ensure that test execution does not pollute the original data, and the article explores strategies such as using transaction rollbacks, recreating databases, and mocking database interfaces to maintain data integrity.
Backend DevelopmentMockingdatabase
0 likes · 2 min read

The article presents a comprehensive overview of mobile UI automation and performance testing practices, covering WalmartLabs' Appium-based framework, Taobao's SDK timing and frame‑drop analysis, quality assurance systems, crash analysis, static code scanning, AppCrawler, Macaca, MockServer usage, and Docker‑based test environments.
AppiumDockerMobile Automation
0 likes · 8 min read

This article explains the fundamentals of unit testing, compares it with integration testing and test‑driven development, describes what makes a good unit test, shows how to improve code testability, and provides concrete C# examples using XUnit, FluentAssertions, and Moq.
.NETC++Mocking
0 likes · 18 min read
