genesis_ruby 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12cd3e939b78536020d57469e7220098680c647f13ab38c88413b2e63d01fea0
-  data.tar.gz: 1073ba6ff04f83a1832c49960d3e448418bc04697921d4843cd8c05ec6201e42
+  metadata.gz: 25761ad9b4ff17bdcd71f0b5e084c4fce9cbfc5754ade3addf54debd8fcac1df
+  data.tar.gz: 181e7917e70576f2cca9d38e7b59eef4799030ba21fcd52231e78206913827cc
 SHA512:
-  metadata.gz: d003f0096e584454c1bae7e50d5414a0c1361e17619acd15f83e62782fa74988c3c0739cac2fec826ad9c28736bc5705293dcbfa5c861aead55e5556db9fe6ae
-  data.tar.gz: d47c721dc4883cbb8d447dc0373b354a4663bef49f9ea512b836e679a7646b9c5da7ed4ab10cbad4b1b234f33fe6003cf3c56b385f33c62f08c6d3b0cae2b5bc
+  metadata.gz: 556163d312e4e1e5abd5a70174f15fb6c179425499fd49cbf80c02c88d311479391a8afade1428983bbda34f1451b58a76b98ee7fac470dbeb10903b3ff798d8
+  data.tar.gz: 201a4291c694d167212aecb08ab00f449961c0ad66ae6d6040205f583dc34162caba6931916114586cfdacc033df1985977c94b075bedd0eb96a6ca30f5ba627

data/.kiro/specs/f2025112509-add_managed_recurring_api/.config.kiro

@@ -0,0 +1 @@
+{"specId": "24c1b655-56dc-44db-9abb-29e73ec1507e", "workflowType": "requirements-first", "specType": "feature"}

data/.kiro/specs/f2025112509-add_managed_recurring_api/design.md

@@ -0,0 +1,332 @@
+# Design Document: Managed Recurring API
+
+## Overview
+
+This feature adds three new request classes to the genesis_ruby SDK for the Managed Recurring JSON API. These classes allow merchants to programmatically list, retrieve, and cancel managed recurring payment items. The implementation follows the established `Base::Versioned` pattern for versioned JSON API requests and introduces HTTP DELETE method support as a new capability in the SDK's network layer.
+
+**Key design decisions:**
+- Inherit from `Base::Versioned` to leverage versioned JSON endpoint configuration
+- Use the same `:placeholder` path interpolation pattern as `Installments::Show` and `Payee::Retrieve`
+- Add `METHOD_DELETE` and `load_delete_config` following the existing `METHOD_PATCH`/`load_patch_config` precedent
+- Define endpoint path constant in the existing `ManagedRecurring` constants module
+
+## Architecture
+
+```mermaid
+classDiagram
+    class Request {
+        +METHOD_DELETE : String
+        +init_delete_configuration()
+    }
+    class Versioned {
+        +version : String
+        +request_path : String
+        #init_configuration()
+        #process_request_parameters()
+    }
+    class FetchAll {
+        #init_configuration()
+        #request_structure() Hash
+    }
+    class Fetch {
+        +unique_id : String
+        #init_configuration()
+        #init_field_validations()
+        #request_structure() Hash
+        #process_request_parameters()
+    }
+    class Cancel {
+        +unique_id : String
+        #init_configuration()
+        #init_field_validations()
+        #request_structure() Hash
+        #process_request_parameters()
+    }
+    class ApiConfig {
+        +load_delete_config()
+    }
+    class NetHttpAdapter {
+        +execute()
+    }
+
+    Request <|-- Versioned
+    Versioned <|-- FetchAll
+    Versioned <|-- Fetch
+    Versioned <|-- Cancel
+    Request --> ApiConfig
+    Request ..> NetHttpAdapter
+```
+
+**Request flow:**
+1. Merchant instantiates a request class (e.g., `Fetch.new(config)`)
+2. Sets attributes (e.g., `request.unique_id = '...'`)
+3. Calls `build_document` which triggers `process_request_parameters`
+4. For Fetch/Cancel: path placeholder `:unique_id` is replaced with the actual value
+5. Gateway URL is reconfigured with the resolved path
+6. The SDK network layer dispatches the request using the configured HTTP method (GET or DELETE)
+
+## Components and Interfaces
+
+### 1. Service Endpoint Constant
+
+**Module:** `GenesisRuby::Api::Constants::Transactions::Parameters::ManagedRecurring`
+
+A new constant `ITEM_PATH` is added to the existing `ManagedRecurring` module (which already contains `Intervals`, `Frequencies`, etc.).
+
+```ruby
+# In a new file: managed_recurring/service_endpoints.rb
+# or directly in the existing module structure
+ITEM_PATH = 'managed_recurring/items'
+```
+
+**Rationale:** The path omits the `/v1/` prefix because `Base::Versioned` automatically prepends the version. The constant value `managed_recurring/items` is what goes into `request_path`.
+
+### 2. FetchAll Request Class
+
+**Path:** `lib/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_all.rb`
+
+```ruby
+module GenesisRuby::Api::Requests::NonFinancial::ManagedRecurring
+  class FetchAll < Base::Versioned
+    def initialize(configuration, _builder_interface = nil)
+      super configuration
+      self.request_path = ITEM_PATH
+    end
+
+    protected
+
+    def init_configuration
+      super
+      init_get_configuration
+    end
+
+    def request_structure
+      {}
+    end
+  end
+end
+```
+
+**Behavior:** Sends an HTTP GET to `/v1/managed_recurring/items` with no body. Returns a JSON array of managed recurring items.
+
+### 3. Fetch Request Class
+
+**Path:** `lib/genesis_ruby/api/requests/non_financial/managed_recurring/fetch.rb`
+
+```ruby
+module GenesisRuby::Api::Requests::NonFinancial::ManagedRecurring
+  class Fetch < Base::Versioned
+    attr_writer :unique_id
+
+    def initialize(configuration, _builder_interface = nil)
+      super configuration
+      self.request_path = "#{ITEM_PATH}/:unique_id"
+    end
+
+    def unique_id
+      @unique_id.to_s
+    end
+
+    protected
+
+    def init_configuration
+      super
+      init_get_configuration
+    end
+
+    def init_field_validations
+      super
+      required_fields.push *%i[unique_id]
+    end
+
+    def request_structure
+      {}
+    end
+
+    def process_request_parameters
+      super
+      processed_path = request_path.gsub(':unique_id', unique_id)
+      init_api_gateway_configuration(request_path: "#{version}/#{processed_path}", include_token: false)
+    end
+  end
+end
+```
+
+**Behavior:** Sends an HTTP GET to `/v1/managed_recurring/items/{unique_id}`. Requires `unique_id` to be set before building.
+
+### 4. Cancel Request Class
+
+**Path:** `lib/genesis_ruby/api/requests/non_financial/managed_recurring/cancel.rb`
+
+```ruby
+module GenesisRuby::Api::Requests::NonFinancial::ManagedRecurring
+  class Cancel < Base::Versioned
+    attr_writer :unique_id
+
+    def initialize(configuration, _builder_interface = nil)
+      super configuration
+      self.request_path = "#{ITEM_PATH}/:unique_id"
+    end
+
+    def unique_id
+      @unique_id.to_s
+    end
+
+    protected
+
+    def init_configuration
+      super
+      init_delete_configuration
+    end
+
+    def init_field_validations
+      super
+      required_fields.push *%i[unique_id]
+    end
+
+    def request_structure
+      {}
+    end
+
+    def process_request_parameters
+      super
+      processed_path = request_path.gsub(':unique_id', unique_id)
+      init_api_gateway_configuration(request_path: "#{version}/#{processed_path}", include_token: false)
+    end
+  end
+end
+```
+
+**Behavior:** Sends an HTTP DELETE to `/v1/managed_recurring/items/{unique_id}`. Requires `unique_id`. Gateway returns 204 No Content on success.
+
+### 5. HTTP DELETE Support
+
+**Changes to existing files:**
+
+- **`Api::Request`** — Add `METHOD_DELETE = 'DELETE'` constant and `init_delete_configuration` helper method
+- **`Utils::Options::ApiConfig`** — Add `load_delete_config` method following the `load_patch_config` pattern
+- **`Network::Adapter::NetHttpAdapter`** — Add `METHOD_DELETE` case to the `execute` method's case statement
+
+```ruby
+# In ApiConfig
+def load_delete_config
+  self.protocol              = GenesisRuby::Api::Request::PROTOCOL_HTTPS
+  self.port                  = GenesisRuby::Api::Request::PORT_HTTPS
+  self.type                  = GenesisRuby::Api::Request::METHOD_DELETE
+  self.format                = Builder::JSON
+  self.parser_skip_root_node = false
+  self.authorization         = GenesisRuby::Api::Request::AUTH_TYPE_BASIC
+  self.bearer_token          = nil
+end
+```
+
+```ruby
+# In NetHttpAdapter#execute case statement
+when Api::Request::METHOD_DELETE then @response = @request.delete path, headers
+```
+
+```ruby
+# In Api::Request
+def init_delete_configuration
+  @api_config.load_delete_config
+end
+```
+
+## Data Models
+
+### Managed Recurring Item (response payload — read-only)
+
+The SDK receives but does not construct these objects. They are parsed from JSON responses:
+
+| Field          | Type    | Description                              |
+|----------------|---------|------------------------------------------|
+| unique_id      | String  | Unique identifier for the recurring item |
+| interval       | Integer | Number of periods between recurrences    |
+| period         | String  | Period unit (days, months, etc.)          |
+| amount         | Integer | Amount in minor currency units           |
+| max_count      | Integer | Maximum number of recurring charges      |
+| current_count  | Integer | Current number of executed charges       |
+| first_date     | String  | Date of the first recurring charge       |
+| next_date      | String  | Date of the next scheduled charge        |
+| time_of_day    | Integer | Time of day for execution (minutes)      |
+
+### Request Parameters
+
+| Request  | Parameters | Notes                          |
+|----------|-----------|--------------------------------|
+| FetchAll | (none)    | No request body or path params |
+| Fetch    | unique_id | Path parameter, required       |
+| Cancel   | unique_id | Path parameter, required       |
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system — essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
+
+### Property 1: Unique ID path interpolation
+
+*For any* non-empty string `unique_id`, when set on a Fetch or Cancel request and the request is built, the resulting endpoint URL SHALL end with `/managed_recurring/items/{unique_id}` where `{unique_id}` is the exact string that was set.
+
+**Validates: Requirements 3.3, 3.8, 4.3, 4.7**
+
+### Property 2: Empty unique_id rejection
+
+*For any* nil or empty-string value assigned as `unique_id`, building the Fetch or Cancel request SHALL raise a validation error, and the request SHALL NOT be dispatched.
+
+**Validates: Requirements 3.7, 4.6**
+
+## Error Handling
+
+| Scenario                          | Error Type       | Behavior                                              |
+|-----------------------------------|------------------|-------------------------------------------------------|
+| `unique_id` not set on Fetch      | ParameterError   | Raised during `check_requirements` in `build_document`|
+| `unique_id` not set on Cancel     | ParameterError   | Raised during `check_requirements` in `build_document`|
+| Invalid HTTP method in adapter    | RuntimeError     | Raised by NetHttpAdapter `else` branch                |
+| Network failure during request    | NetworkError     | Raised by NetHttpAdapter `safe_execute`               |
+| Gateway returns non-2xx           | Handled by Response | `error?` method returns true                       |
+| Gateway returns 204 (Cancel)      | No error         | Empty response body, `error?` returns false           |
+
+**Design note:** The `Net::HTTPSuccess` class in Ruby covers 2xx status codes (200-299), so a 204 response will correctly be treated as success by `error?`.
+
+## Testing Strategy
+
+### Unit Tests (RSpec)
+
+Each request class gets a dedicated spec file following the existing pattern:
+
+- `spec/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_all_spec.rb`
+- `spec/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_spec.rb`
+- `spec/genesis_ruby/api/requests/non_financial/managed_recurring/cancel_spec.rb`
+
+Each spec verifies:
+- Endpoint URL structure
+- HTTP method (GET or DELETE)
+- JSON format configuration
+- Empty request body (`'{}'`)
+- Required field validation (for Fetch and Cancel)
+- Includes shared examples: `'base request examples'`, `'versioned request examples'`
+
+Additional specs:
+- `METHOD_DELETE` constant in `Api::Request` spec
+- `load_delete_config` in `Utils::Options::ApiConfig` spec
+- DELETE dispatch in `Network::Adapter::NetHttpAdapter` spec
+
+### Property-Based Tests
+
+**Library:** A property-based testing library for Ruby (e.g., `rantly` or custom generators with RSpec)
+
+**Configuration:** Minimum 100 iterations per property test.
+
+| Property | Test Description | Tag |
+|----------|-----------------|-----|
+| 1 | Generate random non-empty strings as unique_id, verify URL interpolation | Feature: f2025112509-add_managed_recurring_api, Property 1: Unique ID path interpolation |
+| 2 | Generate nil/empty/whitespace-only strings, verify validation error raised | Feature: f2025112509-add_managed_recurring_api, Property 2: Empty unique_id rejection |
+
+### Test Execution
+
+```bash
+# Run all managed recurring tests
+bundle exec rspec spec/genesis_ruby/api/requests/non_financial/managed_recurring/
+
+# Run full suite
+bundle exec rspec
+```

data/.kiro/specs/f2025112509-add_managed_recurring_api/requirements.md

@@ -0,0 +1,91 @@
+# Requirements Document
+
+## Introduction
+
+Add Managed Recurring API request classes to the genesis_ruby SDK. The Managed Recurring JSON API enables merchants to programmatically manage recurring payment items through three operations: listing all active items, retrieving a single item by unique ID, and cancelling an item. The implementation follows existing SDK patterns for versioned JSON API requests and includes full RSpec test coverage.
+
+## Glossary
+
+- **SDK**: The genesis_ruby RubyGem client library for the Genesis Payment Gateway
+- **Managed_Recurring_Item**: An active recurring payment schedule configured for a merchant, identified by a unique_id
+- **Gateway**: The Genesis Payment Processing Gateway API by emerchantpay
+- **Versioned_Request**: A request class inheriting from `Base::Versioned` that uses versioned JSON API endpoints
+- **Item_Path**: The API endpoint constant `/v1/managed_recurring/items` used for all managed recurring requests
+- **Unique_ID**: A string identifier that uniquely identifies a managed recurring item
+
+## Requirements
+
+### Requirement 1: Service Endpoint Constant
+
+**User Story:** As a developer, I want a constant defining the managed recurring items endpoint path, so that request classes reference a single authoritative path value.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL define the constant `ITEM_PATH` with value `managed_recurring/items` under the `Api::Constants::Transactions::Parameters::ManagedRecurring` module (the `/v1/` prefix is omitted because `Base::Versioned` automatically prepends the version)
+2. THE SDK SHALL make the ITEM_PATH constant accessible to all managed recurring request classes
+
+### Requirement 2: Fetch All Managed Recurring Items
+
+**User Story:** As a merchant integrator, I want to retrieve all active managed recurring items, so that I can display and manage recurring payment schedules.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL provide a request class `NonFinancial::ManagedRecurring::FetchAll` that inherits from `Base::Versioned`
+2. WHEN the FetchAll request is built, THE SDK SHALL configure an HTTP GET request to the managed recurring items endpoint
+3. THE SDK SHALL use the JSON builder interface for the FetchAll request
+4. WHEN the FetchAll request is executed, THE Gateway SHALL return a JSON response containing a list of managed recurring items
+5. THE SDK SHALL send the FetchAll request without a request body
+6. THE SDK SHALL configure the FetchAll request endpoint as `https://{environment}.gate.{endpoint}:443/v1/managed_recurring/items`
+
+### Requirement 3: Fetch Single Managed Recurring Item
+
+**User Story:** As a merchant integrator, I want to retrieve a single managed recurring item by unique ID, so that I can inspect its details.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL provide a request class `NonFinancial::ManagedRecurring::Fetch` that inherits from `Base::Versioned`
+2. THE SDK SHALL expose a `unique_id` attribute on the Fetch request class
+3. WHEN the unique_id attribute is set, THE Fetch request SHALL include the unique_id value in the endpoint URL path
+4. WHEN the Fetch request is built, THE SDK SHALL configure an HTTP GET request to the managed recurring items endpoint with the unique_id appended
+5. THE SDK SHALL use the JSON builder interface for the Fetch request
+6. THE SDK SHALL send the Fetch request without a request body
+7. THE SDK SHALL require the unique_id field before executing the Fetch request
+8. THE SDK SHALL configure the Fetch request endpoint as `https://{environment}.gate.{endpoint}:443/v1/managed_recurring/items/{unique_id}`
+
+### Requirement 4: Cancel Managed Recurring Item
+
+**User Story:** As a merchant integrator, I want to cancel a managed recurring item by unique ID, so that future recurring payments are stopped.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL provide a request class `NonFinancial::ManagedRecurring::Cancel` that inherits from `Base::Versioned`
+2. THE SDK SHALL expose a `unique_id` attribute on the Cancel request class
+3. WHEN the Cancel request is built, THE SDK SHALL configure an HTTP DELETE request to the managed recurring items endpoint with the unique_id appended
+4. THE SDK SHALL use the JSON builder interface for the Cancel request
+5. THE SDK SHALL send the Cancel request without a request body
+6. THE SDK SHALL require the unique_id field before executing the Cancel request
+7. THE SDK SHALL configure the Cancel request endpoint as `https://{environment}.gate.{endpoint}:443/v1/managed_recurring/items/{unique_id}`
+8. WHEN the Gateway processes a successful cancellation, THE Gateway SHALL return HTTP status 204 with no response body
+
+### Requirement 5: HTTP DELETE Method Support
+
+**User Story:** As a developer, I want the SDK to support HTTP DELETE requests, so that the Cancel managed recurring request can use the correct HTTP method.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL define a `METHOD_DELETE` constant with value `DELETE` in the `Api::Request` class
+2. THE SDK SHALL provide a `load_delete_config` method in the `Utils::Options::ApiConfig` class that configures HTTPS protocol, port 443, DELETE method type, JSON format, no root node skipping, and basic authorization
+3. THE SDK SHALL provide an `init_delete_configuration` helper method in the `Api::Request` base class
+4. THE Network_Adapter SHALL handle DELETE method requests by invoking the HTTP delete method on the connection
+
+### Requirement 6: RSpec Test Coverage
+
+**User Story:** As a developer, I want comprehensive RSpec tests for all managed recurring request classes, so that correctness is verified and regressions are prevented.
+
+#### Acceptance Criteria
+
+1. THE SDK SHALL include an RSpec test file for the FetchAll request class that verifies the endpoint URL, HTTP GET method, JSON format, and empty request body
+2. THE SDK SHALL include an RSpec test file for the Fetch request class that verifies the endpoint URL with unique_id, HTTP GET method, JSON format, empty request body, and required field validation
+3. THE SDK SHALL include an RSpec test file for the Cancel request class that verifies the endpoint URL with unique_id, HTTP DELETE method, JSON format, empty request body, and required field validation
+4. THE SDK SHALL include an RSpec test for the METHOD_DELETE constant and the delete configuration in the network adapter
+5. WHEN all managed recurring RSpec tests are executed, THE test suite SHALL pass without failures

data/.kiro/specs/f2025112509-add_managed_recurring_api/tasks.md

@@ -0,0 +1,139 @@
+# Implementation Plan: Managed Recurring API
+
+## Overview
+
+Add three new request classes (FetchAll, Fetch, Cancel) for the Managed Recurring JSON API to the genesis_ruby SDK, along with HTTP DELETE method support in the network layer. Implementation follows existing `Base::Versioned` patterns and includes full RSpec coverage.
+
+## Tasks
+
+- [x] 1. Add HTTP DELETE method support
+  - [x] 1.1 Add `METHOD_DELETE` constant and `init_delete_configuration` helper to `Api::Request`
+    - Add `METHOD_DELETE = 'DELETE'` constant alongside existing METHOD_PATCH in `lib/genesis_ruby/api/request.rb`
+    - Add `init_delete_configuration` protected method that calls `@api_config.load_delete_config`
+    - _Requirements: 5.1, 5.3_
+
+  - [x] 1.2 Add `load_delete_config` method to `Utils::Options::ApiConfig`
+    - Add `load_delete_config` method in `lib/genesis_ruby/utils/options/api_config.rb` following `load_patch_config` pattern
+    - Configure: HTTPS protocol, port 443, METHOD_DELETE type, JSON format, no root node skipping, basic authorization
+    - _Requirements: 5.2_
+
+  - [x] 1.3 Add DELETE case to `NetHttpAdapter#execute`
+    - Add `when Api::Request::METHOD_DELETE then @response = @request.delete path, headers` to the case statement in `lib/genesis_ruby/network/adapter/net_http_adapter.rb`
+    - _Requirements: 5.4_
+
+  - [x]* 1.4 Write RSpec tests for HTTP DELETE support
+    - Add test for `METHOD_DELETE` constant in `spec/genesis_ruby/api/request_spec.rb`
+    - Add test for `load_delete_config` in `spec/genesis_ruby/utils/options/api_config_spec.rb`
+    - Add test for DELETE dispatch in `spec/genesis_ruby/network/adapter/net_http_adapter_spec.rb`
+    - _Requirements: 6.4_
+
+- [x] 2. Add ITEM_PATH constant for managed recurring endpoint
+  - [x] 2.1 Create `service_endpoints.rb` constant file in the ManagedRecurring module
+    - Create `lib/genesis_ruby/api/constants/transactions/parameters/managed_recurring/service_endpoints.rb`
+    - Define `ITEM_PATH = 'managed_recurring/items'` under `GenesisRuby::Api::Constants::Transactions::Parameters::ManagedRecurring` module
+    - Path omits `/v1/` prefix because `Base::Versioned` automatically prepends the version
+    - _Requirements: 1.1, 1.2_
+
+- [x] 3. Implement FetchAll request class
+  - [x] 3.1 Create `NonFinancial::ManagedRecurring::FetchAll` request class
+    - Create `lib/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_all.rb`
+    - Inherit from `Base::Versioned`, set `request_path = ITEM_PATH`
+    - Override `init_configuration` to call `init_get_configuration`
+    - Return empty hash `{}` from `request_structure`
+    - Include the `ITEM_PATH` constant via the ManagedRecurring constants module
+    - _Requirements: 2.1, 2.2, 2.3, 2.5, 2.6_
+
+  - [x]* 3.2 Write RSpec tests for FetchAll request
+    - Create `spec/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_all_spec.rb`
+    - Verify endpoint URL `https://staging.gate.emerchantpay.net:443/v1/managed_recurring/items`
+    - Verify HTTP GET method, JSON format, empty request body (`'{}'`)
+    - Include shared examples: `'base request examples'`, `'versioned request examples'`
+    - _Requirements: 6.1_
+
+- [x] 4. Implement Fetch request class
+  - [x] 4.1 Create `NonFinancial::ManagedRecurring::Fetch` request class
+    - Create `lib/genesis_ruby/api/requests/non_financial/managed_recurring/fetch.rb`
+    - Inherit from `Base::Versioned`, expose `unique_id` attribute (reader returns `.to_s`)
+    - Set `request_path = "#{ITEM_PATH}/:unique_id"`
+    - Override `init_configuration` to call `init_get_configuration`
+    - Override `init_field_validations` to push `unique_id` to `required_fields`
+    - Override `process_request_parameters` to gsub `:unique_id` placeholder and reconfigure gateway URL
+    - Return empty hash `{}` from `request_structure`
+    - Follow `Installments::Show` pattern for path interpolation
+    - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8_
+
+  - [x]* 4.2 Write RSpec tests for Fetch request
+    - Create `spec/genesis_ruby/api/requests/non_financial/managed_recurring/fetch_spec.rb`
+    - Verify endpoint URL with unique_id interpolation: `https://staging.gate.emerchantpay.net:443/v1/managed_recurring/items/{unique_id}`
+    - Verify HTTP GET method, JSON format, empty request body
+    - Verify required field validation raises error when unique_id is not set
+    - Verify unique_id attribute returns string
+    - Include shared examples: `'base request examples'`, `'versioned request examples'`
+    - _Requirements: 6.2_
+
+  - [x]* 4.3 Write property test for unique_id path interpolation (Fetch)
+    - **Property 1: Unique ID path interpolation**
+    - Generate random non-empty strings as unique_id, verify the built URL ends with `/managed_recurring/items/{unique_id}`
+    - **Validates: Requirements 3.3, 3.8**
+
+- [x] 5. Implement Cancel request class
+  - [x] 5.1 Create `NonFinancial::ManagedRecurring::Cancel` request class
+    - Create `lib/genesis_ruby/api/requests/non_financial/managed_recurring/cancel.rb`
+    - Inherit from `Base::Versioned`, expose `unique_id` attribute (reader returns `.to_s`)
+    - Set `request_path = "#{ITEM_PATH}/:unique_id"`
+    - Override `init_configuration` to call `init_delete_configuration`
+    - Override `init_field_validations` to push `unique_id` to `required_fields`
+    - Override `process_request_parameters` to gsub `:unique_id` placeholder and reconfigure gateway URL
+    - Return empty hash `{}` from `request_structure`
+    - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7_
+
+  - [x]* 5.2 Write RSpec tests for Cancel request
+    - Create `spec/genesis_ruby/api/requests/non_financial/managed_recurring/cancel_spec.rb`
+    - Verify endpoint URL with unique_id interpolation: `https://staging.gate.emerchantpay.net:443/v1/managed_recurring/items/{unique_id}`
+    - Verify HTTP DELETE method, JSON format, empty request body
+    - Verify required field validation raises error when unique_id is not set
+    - Verify unique_id attribute returns string
+    - Include shared examples: `'base request examples'`, `'versioned request examples'`
+    - _Requirements: 6.3_
+
+  - [x]* 5.3 Write property test for unique_id path interpolation (Cancel)
+    - **Property 1: Unique ID path interpolation**
+    - Generate random non-empty strings as unique_id, verify the built URL ends with `/managed_recurring/items/{unique_id}`
+    - **Validates: Requirements 4.3, 4.7**
+
+- [x] 6. Checkpoint - Ensure all tests pass
+  - Ensure all tests pass, ask the user if questions arise.
+
+  - [x]* 6.1 Write property test for empty unique_id rejection
+    - **Property 2: Empty unique_id rejection**
+    - Generate nil/empty/whitespace-only strings, verify validation error is raised for both Fetch and Cancel
+    - **Validates: Requirements 3.7, 4.6**
+
+- [x] 7. Final checkpoint - Ensure full test suite passes
+  - Run `bundle exec rspec` and `bundle exec rake styles` to confirm no failures or style violations.
+  - Ensure all tests pass, ask the user if questions arise.
+
+## Notes
+
+- Tasks marked with `*` are optional and can be skipped for faster MVP
+- Each task references specific requirements for traceability
+- Checkpoints ensure incremental validation
+- Property tests validate universal correctness properties from the design document
+- The `ITEM_PATH` constant value is `'managed_recurring/items'` (no `/v1/` prefix — `Base::Versioned` prepends version automatically)
+- Path interpolation follows the same `:placeholder` pattern as `Installments::Show` and `Payee::Retrieve`
+- HTTP DELETE support follows the `METHOD_PATCH`/`load_patch_config` precedent
+- All new files are auto-loaded by `dependencies.rb` glob patterns
+
+## Task Dependency Graph
+
+```json
+{
+  "waves": [
+    { "id": 0, "tasks": ["1.1", "1.2", "2.1"] },
+    { "id": 1, "tasks": ["1.3", "1.4", "3.1"] },
+    { "id": 2, "tasks": ["3.2", "4.1", "5.1"] },
+    { "id": 3, "tasks": ["4.2", "4.3", "5.2", "5.3"] },
+    { "id": 4, "tasks": ["6.1"] }
+  ]
+}
+```

data/.kiro/specs/f2025112603-add_reverify_endpoint_to_payee_account/.config.kiro

@@ -0,0 +1 @@
+{"specId": "55eb2a05-457c-4c7a-b5c5-23e33de035dc", "workflowType": "requirements-first", "specType": "feature"}