This is an automated email from the ASF dual-hosted git repository. kpvdr pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/qpid-interop-test.git
commit a27b3e4171845d4260cf0911c0983fab4f00fd31 Author: QIT Development Team <[email protected]> AuthorDate: Fri Aug 7 16:37:50 2026 -0400 Reorganize repo: add QIT 2.0 summary, move docs and scripts - Add docs/QIT2_SUMMARY.md with full project summary and comparison to original QIT - Move 11 status/architecture md files from root to docs/ - Move 3 debug/manual test scripts from root to scripts/ - Update README.md with current test counts (2076) and fixed doc links Co-Authored-By: Claude Opus 4.6 <[email protected]> --- README.md | 126 ++++--------- ARCHITECTURE.md => docs/ARCHITECTURE.md | 0 .../ARCHITECTURE_PROPOSAL_CONCURRENT_EXECUTION.md | 0 BROKER_SETUP.md => docs/BROKER_SETUP.md | 0 CPP_SHIM_STATUS.md => docs/CPP_SHIM_STATUS.md | 0 .../DOCKER_BROKER_TODO.md | 0 .../DOTNET_SHIM_STATUS.md | 0 FINAL_STATUS.md => docs/FINAL_STATUS.md | 0 .../FINAL_STATUS_WITH_DOTNET.md | 0 PHASE1_COMPLETE.md => docs/PHASE1_COMPLETE.md | 0 PHASE1_STATUS.md => docs/PHASE1_STATUS.md | 0 docs/PHASE2C_REQUIREMENTS.md | 210 +++++++++++++++++++++ docs/QIT2_SUMMARY.md | 141 ++++++++++++++ .../debug_message_encoding.py | 0 test_manual.py => scripts/test_manual.py | 0 .../test_python_jms_mode.py | 0 16 files changed, 389 insertions(+), 88 deletions(-) diff --git a/README.md b/README.md index f21172b..51c8409 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,26 @@ -# QIT - AMQP Interoperability Test Suite +# QIT 2.0 - AMQP Interoperability Test Suite -Modern rewrite of the Qpid Interoperability Test suite for Red Hat AMQ products. +Modern rewrite of the [Apache Qpid Interoperability Test](https://qpid.apache.org/components/interop-test/index.html) suite for verifying AMQP 1.0 client interoperability across multiple language implementations. ## Overview -QIT tests AMQP 1.0 interoperability across multiple client implementations by sending messages between different clients and verifying they can correctly exchange all AMQP types. +QIT 2.0 tests that AMQP 1.0 messages sent by one client can be correctly received by another, through an Apache Artemis broker. It covers data type fidelity, JMS interoperability, message metadata, and large content transfer. -**Tested Clients:** -- Python (Proton) -- C++ (Proton) -- JavaScript (Rhea) -- .NET (AMQP.Net Lite) -- Java (Qpid JMS) -- Java (Proton J2) +**Tested Clients (6):** +- Python (Apache Qpid Proton) +- C++ (Apache Qpid Proton) +- JavaScript (AMQP Rhea) +- .NET (Apache Qpid Proton .NET) +- Java (Apache Qpid JMS) - JMS interop tests +- Java (Apache Qpid ProtonJ2) - native AMQP tests -**Test Coverage:** -- All AMQP 1.0 primitive types -- All AMQP 1.0 complex types (arrays, lists, maps, described types) -- JMS message types and headers -- Large message content -- Direct peer-to-peer (no broker) -- Transaction support (planned) +**Test Coverage (2076 tests default / ~2470 extended):** +- 18 AMQP 1.0 primitive types + 4 complex types (550 tests) +- JMS message types, headers, and application properties (363 tests) +- AMQP Header section fields: durable, priority, ttl, first-acquirer, delivery-count (275 tests) +- Large content: 1MB/10MB binary/string, collections, multi-frame-size (888 tests) + +See [docs/QIT2_SUMMARY.md](docs/QIT2_SUMMARY.md) for the full summary including improvements over the original QIT. ## Quick Start @@ -28,100 +28,50 @@ QIT tests AMQP 1.0 interoperability across multiple client implementations by se - Python 3.11+ - uv (recommended) or pip -- Apache ActiveMQ Artemis (for broker) - See [BROKER_SETUP.md](BROKER_SETUP.md) +- Apache ActiveMQ Artemis - See [docs/BROKER_SETUP.md](docs/BROKER_SETUP.md) ### Installation ```bash -# Install uv (if not already installed) -# On Fedora/RHEL: sudo dnf install uv -# Or: curl -LsSf https://astral.sh/uv/install.sh | sh - # Setup Python environment uv venv source .venv/bin/activate uv sync -# Setup and start broker (see BROKER_SETUP.md for details) +# Setup and start broker (see docs/BROKER_SETUP.md for details) ./scripts/setup-local-broker.sh ./artemis-local/bin/artemis run & -# Run tests +# Run AMQP type tests qit test amqp-types -``` - -**Note**: Both local and Docker broker setups are tested and working. See [BROKER_SETUP.md](BROKER_SETUP.md) for details. - -### Development - -```bash -# Install dev dependencies -uv sync --dev -# Run tests with coverage -pytest --cov=qit - -# Format and lint -ruff format . -ruff check . - -# Type check -mypy src/qit -``` - -## Usage - -```bash -# Run all AMQP type tests -qit test amqp-types - -# Test specific shim pairing -qit test amqp-types --sender python-proton --receiver cpp-proton - -# Run with fuzzing -qit test amqp-types --fuzz - -# Direct mode (no broker) -qit test amqp-types --mode direct - -# Run all tests -qit test all +# Run JMS, AMQP header, and large content tests +pytest tests/test_jms_unified.py -v +pytest tests/test_amqp_headers.py -v +pytest tests/test_large_content.py -v ``` ## Architecture -See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed design documentation. - -**Key Components:** -- **Orchestrator**: Manages test execution, shim coordination, result comparison -- **Shims**: Native client implementations exposing CLI interface -- **Broker Manager**: Docker Compose lifecycle for Artemis -- **Type System**: Comprehensive AMQP 1.0 type definitions with corner cases +See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for detailed design documentation. -## CI/CD Integration - -QIT 2.0 includes a complete Jenkins pipeline for automated testing: - -```bash -# Test locally (simulates CI pipeline) -./scripts/run-ci-locally.sh - -# Generate JUnit XML for CI -qit test amqp-types --junit-xml test-results/results.xml +``` +qit/ + src/qit/ # Python package (orchestrator, type system, xfail) + shims/ # 6 client implementations with uniform CLI + JSON interface + tests/ # pytest test suites + scripts/ # Broker setup, CI helpers, debug tools + docs/ # Architecture, status, setup documentation ``` -See [CI_CD_SETUP.md](CI_CD_SETUP.md) for complete Jenkins setup instructions. - -## Current Status +## CI/CD -**QIT 2.0 - Production Ready** +Jenkins pipeline runs weekly, with extended tier (10MB content) enabled during the first week of each month. Four JUnit XML result files per run: -✅ 5 working shims (Python, JavaScript, C++, .NET, Java) -✅ 450 comprehensive tests (18 types × 5×5 shim combinations) -✅ 80.2% pass rate (all failures are known library limitations) -✅ Complete CI/CD pipeline with JUnit XML reporting -✅ Docker-based broker management -✅ Modern tooling and build system +- `qit-results.xml` - AMQP types (550 tests) +- `qit-jms-results.xml` - JMS interop (363 tests) +- `qit-amqp-header-results.xml` - AMQP headers (275 tests) +- `qit-large-content-results.xml` - Large content (494-888 tests) ## License diff --git a/ARCHITECTURE.md b/docs/ARCHITECTURE.md similarity index 100% rename from ARCHITECTURE.md rename to docs/ARCHITECTURE.md diff --git a/ARCHITECTURE_PROPOSAL_CONCURRENT_EXECUTION.md b/docs/ARCHITECTURE_PROPOSAL_CONCURRENT_EXECUTION.md similarity index 100% rename from ARCHITECTURE_PROPOSAL_CONCURRENT_EXECUTION.md rename to docs/ARCHITECTURE_PROPOSAL_CONCURRENT_EXECUTION.md diff --git a/BROKER_SETUP.md b/docs/BROKER_SETUP.md similarity index 100% rename from BROKER_SETUP.md rename to docs/BROKER_SETUP.md diff --git a/CPP_SHIM_STATUS.md b/docs/CPP_SHIM_STATUS.md similarity index 100% rename from CPP_SHIM_STATUS.md rename to docs/CPP_SHIM_STATUS.md diff --git a/DOCKER_BROKER_TODO.md b/docs/DOCKER_BROKER_TODO.md similarity index 100% rename from DOCKER_BROKER_TODO.md rename to docs/DOCKER_BROKER_TODO.md diff --git a/DOTNET_SHIM_STATUS.md b/docs/DOTNET_SHIM_STATUS.md similarity index 100% rename from DOTNET_SHIM_STATUS.md rename to docs/DOTNET_SHIM_STATUS.md diff --git a/FINAL_STATUS.md b/docs/FINAL_STATUS.md similarity index 100% rename from FINAL_STATUS.md rename to docs/FINAL_STATUS.md diff --git a/FINAL_STATUS_WITH_DOTNET.md b/docs/FINAL_STATUS_WITH_DOTNET.md similarity index 100% rename from FINAL_STATUS_WITH_DOTNET.md rename to docs/FINAL_STATUS_WITH_DOTNET.md diff --git a/PHASE1_COMPLETE.md b/docs/PHASE1_COMPLETE.md similarity index 100% rename from PHASE1_COMPLETE.md rename to docs/PHASE1_COMPLETE.md diff --git a/PHASE1_STATUS.md b/docs/PHASE1_STATUS.md similarity index 100% rename from PHASE1_STATUS.md rename to docs/PHASE1_STATUS.md diff --git a/docs/PHASE2C_REQUIREMENTS.md b/docs/PHASE2C_REQUIREMENTS.md new file mode 100644 index 0000000..3eb815b --- /dev/null +++ b/docs/PHASE2C_REQUIREMENTS.md @@ -0,0 +1,210 @@ +# Phase 2c: Additional JMS Message Types - Implementation Requirements + +## Status: Planned (Not Started) + +Phase 2b completed successfully with TextMessage interoperability across all 6 clients (180 tests passing). + +Phase 2c will add support for 4 additional JMS message types, expanding test coverage from 180 to **900 tests** (5 message types × 6×6 matrix × 5 test values per type). + +## Message Types to Implement + +### 1. BytesMessage (`x-opt-jms-msg-type: 3`) +- **AMQP mapping**: `binary` type in Data section +- **Test values**: Binary data (empty, simple bytes, hex patterns) +- **Expected tests**: 180 (6×6 matrix × 5 values) + +### 2. MapMessage (`x-opt-jms-msg-type: 2`) +- **AMQP mapping**: `map` type in AmqpValue section +- **Test values**: Key-value pairs (empty map, simple pairs, mixed types, nested) +- **Expected tests**: 180 (6×6 matrix × 5 values) + +### 3. StreamMessage (`x-opt-jms-msg-type: 4`) +- **AMQP mapping**: `list` type in AmqpSequence section +- **Test values**: Sequential values (empty list, integers, strings, mixed types, nested) +- **Expected tests**: 180 (6×6 matrix × 5 values) + +### 4. Message (`x-opt-jms-msg-type: 0`) +- **AMQP mapping**: `null` type (empty body) +- **Test values**: Single null value (headers/properties only) +- **Expected tests**: 36 (6×6 matrix × 1 value) + +**Total Phase 2c tests**: 576 additional tests (900 total with Phase 2b) + +## Implementation Work Required + +Each of the 6 client shims needs updates: + +### Per-Shim Changes + +#### 1. Sender Updates +- Add type mapping for new message types in `get_jms_message_type()`: + - `binary` → JMS_BYTES_MESSAGE (3) + - `map` → JMS_MAP_MESSAGE (2) + - `list` → JMS_STREAM_MESSAGE (4) + - Already have: `null` → JMS_MESSAGE (0) + +#### 2. Receiver Updates +- Add decode logic for each JMS message type in `decode_jms_message()`: + - BytesMessage: Extract binary data from Data section, convert to hex string + - MapMessage: Extract map from AmqpValue section + - StreamMessage: Extract list from AmqpSequence section + - Message: Return null/empty + +### Shim-Specific Implementation Details + +#### Python Proton (`shims/python-proton/shim.py`) +- ✅ Sender: Type mapping already exists (lines 76-93) +- ✅ Receiver: Skeleton decode logic exists (lines 262-276) +- ⚠️ Need to verify: Binary/map/list encoding/decoding actually works +- **Status**: Mostly complete, needs testing + +#### JavaScript Rhea (`shims/javascript-rhea/shim.js`) +- ✅ Sender: Type mapping exists in `getJmsMessageType()` +- ⚠️ Receiver: Has skeleton `decodeJmsMessage()` but incomplete +- **Missing**: Full decode implementation for bytes/map/list +- **Status**: Partial + +#### C++ Proton (`shims/cpp-proton/src/sender.cpp`, `receiver.cpp`) +- ✅ Sender: Type mapping exists in `get_jms_message_type()` +- ⚠️ Receiver: Has skeleton `decode_jms_message()` (lines 108-109) +- **Missing**: MapMessage and StreamMessage decode (only constants defined) +- **Status**: Partial + +#### .NET Proton (`shims/dotnet-proton/src/Sender.cs`, `Receiver.cs`) +- ✅ Sender: Type mapping exists in `GetJmsMessageType()` +- ⚠️ Receiver: Has skeleton `DecodeJmsMessage()` (lines 108-109) +- **Missing**: MapMessage and StreamMessage decode (only constants defined) +- **Status**: Partial + +#### Java ProtonJ2 (`shims/java-protonj2/src/.../Sender.java`, `Receiver.java`) +- ✅ Sender: Type mapping exists in `getJmsMessageType()` +- ⚠️ Receiver: Has skeleton `decodeJmsMessage()` (lines 108-109) +- **Missing**: Full decode for bytes/map/list +- **Status**: Partial + +#### JMS Client (`shims/java-qpid-jms/src/.../JmsSender.java`, `JmsReceiver.java`) +- ❌ Sender: Only supports TextMessage type checking +- ❌ Receiver: Only supports TextMessage decoding +- **Missing**: Full BytesMessage, MapMessage, StreamMessage, Message support +- **Critical**: Need to add type cases in message creation switch statement +- **Status**: Requires significant work + +### Test File Updates + +File: `tests/test_jms_unified.py` + +**Already Added (in current working tree, uncommitted):** +- Test data for BytesMessage, MapMessage, StreamMessage, Message +- `test_jms_bytesmessage_interop()` function +- Updated `normalize_message_type()` helper + +**Still Needed:** +- `test_jms_mapmessage_interop()` function +- `test_jms_streammessage_interop()` function +- `test_jms_message_interop()` function (empty message) + +## Current State + +**Code Changes Made (Uncommitted):** +- `tests/test_jms_unified.py`: Added test data and BytesMessage test function + +**Discovery from Testing:** +- BytesMessage test reveals JMS sender doesn't support types beyond TextMessage +- Python→Python BytesMessage receives `None` value (decode issue) + +**Working Tree Status:** +- Modified: `tests/test_jms_unified.py` +- Test count increased from 180 to 360 (TextMessage + BytesMessage) + +## Implementation Plan + +### Approach 1: Incremental by Message Type +1. Complete BytesMessage across all 6 shims (180 tests) +2. Complete MapMessage across all 6 shims (180 tests) +3. Complete StreamMessage across all 6 shims (180 tests) +4. Complete Message across all 6 shims (36 tests) + +**Pros**: Validate each type fully before moving to next +**Cons**: Repetitive - touch each shim 4 times + +### Approach 2: Incremental by Client +1. Complete all 4 types in Python shim +2. Complete all 4 types in JavaScript shim +3. Complete all 4 types in C++ shim +4. Complete all 4 types in .NET shim +5. Complete all 4 types in Java ProtonJ2 shim +6. Complete all 4 types in JMS client shim + +**Pros**: Each shim completed once, easier to focus +**Cons**: Can't validate cross-client interop until multiple shims done + +### Approach 3: Focus on JMS Client First +1. Implement all 4 types in JMS client (sender + receiver) +2. Implement all 4 types in one AMQP client (e.g., Python) +3. Validate JMS ↔ Python for all types (baseline) +4. Expand to remaining AMQP clients + +**Pros**: Establish baseline interop quickly +**Cons**: JMS client requires most work upfront + +**Recommendation**: Approach 3 - JMS client is the "source of truth" for JMS message types, so implementing it first provides clear reference behavior. + +## Estimated Effort + +Based on Phase 2b experience: + +- **JMS Client updates**: 4-6 hours (sender + receiver for 4 types) +- **Python shim updates**: 2-3 hours (mostly testing existing code) +- **JavaScript shim updates**: 2-3 hours (complete decode logic) +- **C++ shim updates**: 3-4 hours (type handling, map/list decode) +- **. NET shim updates**: 3-4 hours (similar to C++) +- **Java ProtonJ2 updates**: 2-3 hours (similar to JavaScript) +- **Test debugging**: 2-4 hours (cross-client edge cases) + +**Total**: 18-27 hours of focused development + +## Success Criteria + +- ✅ All 576 new tests passing (900 total) +- ✅ All 6 clients can send/receive each message type +- ✅ Full N×N interoperability for all 5 message types +- ✅ Jenkins Build passes with ~19-22 minutes execution time +- ✅ Documentation updated + +## Dependencies + +None - all infrastructure from Phase 2b is in place. + +## Next Steps + +When resuming Phase 2c: + +1. **Revert uncommitted test changes** to avoid premature test failures + ```bash + git restore tests/test_jms_unified.py + ``` + +2. **Start with JMS client implementation**: + - Update `JmsSender.java` to support all 5 message types + - Update `JmsReceiver.java` to decode all 5 message types + - Add test case type constants (JMS_BYTESMESSAGE_TYPE, etc.) + +3. **Validate JMS baseline**: + - Test JMS→JMS for each message type + - Ensure all types work before expanding to AMQP clients + +4. **Expand to Python shim** (easiest AMQP client) + +5. **Add one message type at a time** with full test validation + +## Related Documentation + +- Phase 2b completion: Build 71 (180 tests, 100% pass) +- JMS annotation format: `x-opt-jms-msg-type` (Symbol key, signed byte value) +- AMQP type mappings: See shim implementations + +## Notes + +- Phase 2b skeleton code for additional types was added during initial implementation but never tested +- Most shims have the structure in place but incomplete logic +- JMS client is the only shim that needs significant new code diff --git a/docs/QIT2_SUMMARY.md b/docs/QIT2_SUMMARY.md new file mode 100644 index 0000000..f4d0104 --- /dev/null +++ b/docs/QIT2_SUMMARY.md @@ -0,0 +1,141 @@ +# QIT 2.0 Summary + +A complete rewrite of the [Apache Qpid Interoperability Test](https://qpid.apache.org/components/interop-test/index.html) suite for AMQP 1.0 client interoperability testing. + +## What QIT 2.0 Tests + +QIT 2.0 verifies that AMQP 1.0 messages sent by one client implementation can be correctly received by another, through an Apache Artemis broker. It covers data type fidelity, JMS interoperability, message metadata, and large content transfer. + +**Client Implementations (6):** + +| Client | Language | Library | +|--------|----------|---------| +| python-proton | Python | Apache Qpid Proton | +| javascript-rhea | JavaScript | AMQP Rhea | +| cpp-proton | C++ | Apache Qpid Proton | +| dotnet-proton | C# | Apache Qpid Proton .NET | +| java-protonj2 | Java | Apache Qpid ProtonJ2 | +| java-qpid-jms | Java | Apache Qpid JMS | + +## Test Coverage + +**Total: 2076 tests** (default tier) / ~2470 tests (extended tier) + +### AMQP Type Tests (550 tests) + +Full N×N matrix across 5 AMQP clients (25 sender/receiver pairs), testing 22 AMQP 1.0 types: + +- **Primitive types (18):** null, boolean, ubyte, ushort, uint, ulong, byte, short, int, long, float, double, char, timestamp, uuid, binary, string, symbol +- **Complex types (4):** array, list, map, described + +Each type is tested with multiple values including boundary conditions, zero values, max values, and special cases. 71 tests have documented xfails for known client library limitations (JavaScript number precision, .NET/Java char truncation, etc.). + +### JMS Interoperability Tests (363 tests) + +Star configuration: JMS client (java-qpid-jms) always on at least one side, paired with all 5 AMQP clients plus itself (11 sender/receiver pairs). + +- **Message types (5):** TextMessage, BytesMessage, empty Message, MapMessage, StreamMessage +- **JMS headers (5 tests):** JMSCorrelationID (string + binary), JMSReplyTo (queue + topic), JMSType +- **JMS properties (8 types):** boolean, byte, short, int, long, float, double, string + +12 tests have documented xfails (Rhea type loss for typed integers, binary correlation ID limitations in .NET/Java). + +### AMQP Message Header Tests (275 tests) + +Full N×N matrix across 5 AMQP clients (25 pairs), testing all 5 AMQP 1.0 Header section fields: + +- **durable:** true/false (50 tests) +- **priority:** 0, 4, 7, 9 (100 tests) +- **ttl:** 60s, 300s with fuzzy comparison (50 tests) +- **first-acquirer:** true/false (50 tests) +- **delivery-count:** verified as 0 on first delivery (25 tests) + +### Large Content Tests (888 tests) + +Tests message transfer with payloads from 1MB to 10MB across multiple frame sizes. + +**Default tier (494 tests):** +- Binary and string: 1MB across full 6×6 matrix (72 tests) +- Collections: list, array sub-frame and super-frame elements (122 tests) +- Multi-frame-size: 4KB and 1MB Artemis acceptor frame sizes (300 tests) + +**Extended tier (+394 tests, enabled first week of each month or manually):** +- Binary and string: 10MB across full matrix (72 tests) +- Map and described type collections: sub-frame and super-frame (122 tests) +- Extended frame-size variants for map and described types (200 tests) + +## Improvements Over Original QIT + +### Architecture + +| Aspect | Original QIT (0.3.0) | QIT 2.0 | +|--------|---------------------|---------| +| Language | Python 2/3, CMake build system | Python 3.11+, uv packaging | +| Installation | System-wide CMake install to /usr/local | `uv sync` in a virtualenv | +| Shim protocol | Mixed CMake/script invocation | Uniform CLI with JSON I/O | +| Test framework | Custom test runner | pytest with parametrize, markers, xfail | +| CI output | Custom reporting | JUnit XML, integrates with Jenkins natively | +| Parallel execution | Sequential | pytest-xdist (`-j 4`) for AMQP type tests | + +### Client Coverage + +| Client | Original QIT | QIT 2.0 | +|--------|-------------|---------| +| Python Proton | Yes | Yes | +| C++ Proton | Yes (via CMake shim) | Yes (standalone CMake) | +| JavaScript Rhea | Optional, limited | Full support with type detection fix | +| .NET (AMQP.Net Lite) | Optional, limited | Full support (Apache Qpid Proton .NET) | +| Java Qpid JMS | Yes | Yes (JMS interop tests) | +| Java ProtonJ2 | No | Yes (native AMQP tests) | + +### Test Coverage + +| Category | Original QIT | QIT 2.0 | +|----------|-------------|---------| +| AMQP primitive types | ~10 types | 18 types with boundary values | +| AMQP complex types | Not tested | array, list, map, described | +| JMS message types | TextMessage, BytesMessage | + MapMessage, StreamMessage, empty Message | +| JMS headers | JMSCorrelationID, JMSReplyTo, JMSType | Same, with binary correlation ID testing | +| JMS properties | Basic types | All 8 JMS property types with hex encoding | +| AMQP Header section | Not tested | durable, priority, ttl, first-acquirer, delivery-count | +| Large content | Up to 10MB (amqp-large-content-test) | 1MB/10MB binary/string + collection types + multi-frame-size | +| Known failure tracking | Failures fail the test | xfail framework with per-pair skip reasons | +| Total tests | ~200-300 | 2076 (default) / ~2470 (extended) | + +### Key Technical Achievements + +- **Rhea type detection:** Solved Rhea's type information loss via `types.unwrap()` interception, enabling JavaScript to correctly identify all AMQP types on receive. +- **Python Proton TTL unit handling:** Discovered and handled the seconds-vs-milliseconds mismatch in Python Proton's TTL API (getter divides wire ms by 1000, setter multiplies by 1000). +- **xfail framework:** 82 documented known failures across client libraries, each with a specific reason. Tests that fail for known reasons don't mask new regressions. `--strict` mode treats xfails as failures for auditing. +- **Multi-frame-size testing:** Artemis configured with 4KB, default, and 1MB frame sizes on separate acceptor ports, verifying AMQP frame fragmentation works correctly across all clients. +- **JMS annotation compatibility:** All AMQP shims correctly set `x-opt-jms-msg-type` and `x-opt-jms-reply-to` annotations, enabling transparent JMS interop without JMS client libraries. + +## Project Structure + +``` +qit/ + src/qit/ # Python package (orchestrator, type system, xfail) + shims/ + python-proton/ # Python shim (shim.py) + javascript-rhea/ # JavaScript shim (shim.js) + cpp-proton/ # C++ shim (CMake project) + dotnet-proton/ # .NET shim (dotnet project) + java-protonj2/ # Java ProtonJ2 shim (Maven project) + java-qpid-jms/ # Java Qpid JMS shim (Maven project) + tests/ + test_jms_unified.py # JMS interop (363 tests) + test_amqp_headers.py # AMQP Header section (275 tests) + test_large_content.py # Large content (888 tests) + scripts/ # Broker setup, CI helpers + docs/ # Architecture, status, setup docs +``` + +## CI/CD + +Jenkins pipeline runs weekly (Monday 2-5 AM), with extended tier automatically enabled during the first week of each month. The `EXTENDED_MODE` checkbox can be toggled manually in either direction. + +Four JUnit XML result files are produced per run: +- `qit-results.xml` — AMQP type tests (550) +- `qit-jms-results.xml` — JMS interop tests (363) +- `qit-amqp-header-results.xml` — AMQP header tests (275) +- `qit-large-content-results.xml` — Large content tests (494-888) diff --git a/debug_message_encoding.py b/scripts/debug_message_encoding.py similarity index 100% rename from debug_message_encoding.py rename to scripts/debug_message_encoding.py diff --git a/test_manual.py b/scripts/test_manual.py similarity index 100% rename from test_manual.py rename to scripts/test_manual.py diff --git a/test_python_jms_mode.py b/scripts/test_python_jms_mode.py similarity index 100% rename from test_python_jms_mode.py rename to scripts/test_python_jms_mode.py --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
