@salesforce/afv-skills 1.46.0 → 1.48.0

package/skills/service-omni-queue-routing-config-deploy/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: service-omni-queue-routing-config-deploy
+description: "Use to create or update a QueueRoutingConfig record on a Salesforce org via the Data API (idempotent SOQL detect + REST upsert). Naming is target-derived: Case→Case_Routing_Config, VoiceCall→Voice_Routing_Config, Incident→Incident_Routing_Config, MessagingSession→Messaging_Routing_Config (via QRC_ROUTING_TARGET), or pass an explicit developer-name/label/capacity/priority. RoutingModel MostAvailable (default) or LeastActive. Triggers: create a Case or Voice routing config, deploy a QueueRoutingConfig, set up queue routing for Omni Cases/Voice, configure CapacityWeight per queue. Do not use for attribute-based routing (IsAttributeBased=true is out of scope) or routing models other than MostAvailable/LeastActive."
+allowed-tools: Bash Read Write Edit Glob Grep
+metadata:
+  version: "1.0"
+  domains: ["Service"]
+  minApiVersion: "66.0"
+  relatedSkills:
+    - "service-omni-base-settings-configure"
+    - "service-omni-channel-setup-coordinate"
+    - "service-omni-queue-deploy"
+    - "service-omni-service-channel-configure"
+  accessCheck:
+    - type: license
+      value: ServiceCloud
+  cliTools:
+    - tool: ["jq"]
+      semver: ">=1.6"
+    - tool: ["python3"]
+      semver: ">=3.9"
+    - tool: ["sf"]
+      semver: ">=2.139.6"
+---
+
+# service-omni-queue-routing-config-deploy
+
+Create or update a `QueueRoutingConfig` via the Data API. This record tells Omni-Channel how to distribute work to agents on a queue: the routing model (`MostAvailable` for round-robin-style, `LeastActive` for load-balancing), how much capacity each work item consumes (`CapacityWeight` or `CapacityPercentage`), the push timeout, and the routing priority. It is a prerequisite for an Omni-routed `Queue` — `service-omni-queue-deploy` binds the queue to the config Id this skill returns. Detection is by `DeveloperName`, so the skill POSTs a new record or PATCHes an existing one to align, and is safe to re-run.
+
+## Inputs
+
+```bash
+bash scripts/upsert-and-report.sh <org-alias> [routing-model] [developer-name] [master-label] [capacity-weight] [routing-priority] [overflow-assignee] [push-timeout]
+# Case_Routing_Config, preserve model / create MostAvailable:
+bash scripts/upsert-and-report.sh myorg
+# align the Case QRC to LeastActive:
+bash scripts/upsert-and-report.sh myorg LeastActive
+# Voice_Routing_Config (coordinator path):
+QRC_ROUTING_TARGET=VoiceCall bash scripts/upsert-and-report.sh myorg
+# set a fallback/overflow assignee (route overflow work to a supervisor):
+QRC_OVERFLOW_ASSIGNEE=supervisor@example.com bash scripts/upsert-and-report.sh myorg
+# Voice uses 100% capacity and a 30-second push timeout:
+QRC_ROUTING_TARGET=VoiceCall QRC_CAPACITY_PERCENTAGE=100 QRC_PUSH_TIMEOUT=30 bash scripts/upsert-and-report.sh myorg MostAvailable
+```
+
+- `org-alias` (required).
+- `routing-model` (optional, or `ROUTING_MODEL_INPUT`) — `MostAvailable` | `LeastActive`. Omitted: an existing record's model is preserved; a new record is created `MostAvailable`. Provided: written on create, aligned on an existing record.
+- `developer-name` / `master-label` / `capacity-weight` (1..100) / `routing-priority` (≥1) — positional after routing-model, or via `QRC_DEVELOPER_NAME` / `QRC_MASTER_LABEL` / `QRC_CAPACITY_WEIGHT` / `QRC_ROUTING_PRIORITY`. Label, weight `5`, and priority `1` are defaults only when creating a new record; omitted values preserve an existing record.
+- `QRC_CAPACITY_PERCENTAGE` (optional, 0..100) — use percentage capacity instead of weight. It is mutually exclusive with an explicitly supplied capacity weight; switching modes clears the old sibling field.
+- `overflow-assignee` (optional 7th positional, or `QRC_OVERFLOW_ASSIGNEE`) — the fallback User (Username or `005` Id) that receives work when every queue member is unavailable (`OverflowAssigneeId`). Resolved to an **active** User Id before the write; omitted leaves an existing record's overflow untouched and a new record with none.
+- `push-timeout` (optional 8th positional, or `QRC_PUSH_TIMEOUT`, 0..3600 seconds) — how long Omni waits for an agent to accept pushed work. Omitted preserves an existing value.
+- `QRC_ROUTING_TARGET` (env) — `Case | VoiceCall | Incident | MessagingSession`; selects the canonical naming defaults. `service-omni-channel-setup-coordinate` sets this per target.
+
+## Preconditions and safety
+
+- Target org authenticated via `sf` CLI (My Domain URL), Service Cloud license, `sf` CLI ≥ 2.139.6.
+- Omni-Channel base settings enabled (`service-omni-base-settings-configure`) — otherwise `QueueRoutingConfig` is not writable (`INVALID_TYPE`).
+- The three-way `safe_to_write` production guard applies.
+
+## Run
+
+`upsert-and-report.sh` performs detect → upsert → verify:
+
+1. Query `QueueRoutingConfig WHERE DeveloperName = '<target-derived-or-explicit>'`, capturing the existing Id and field values.
+2. Compare against the requested/canonical values.
+3. POST a new record when none exists; no-op (`reused`) when all fields already match; PATCH when a field differs.
+4. Re-query to confirm the final state; block if the re-query shows a mismatch.
+
+## Behavior
+
+**Target-derived naming.** With no explicit name, the DeveloperName follows the routing target (`Case_Routing_Config`, `Voice_Routing_Config`, etc.), so re-runs and the coordinator converge on the same record rather than creating parallel duplicates.
+
+**Preserve over churn.** On an existing record, omitted routing model, label, routing priority, capacity mode/value, overflow assignee, push timeout, and attribute-based flag are preserved. Defaults (`MostAvailable`, target-derived label, weight `5`, priority `1`, non-attribute-based) apply only to a brand-new record. Capacity uses exactly one mode; explicitly changing from weight to percentage, or back, clears the old sibling field so the record cannot contain conflicting capacity settings.
+
+**Fallback / overflow routing.** In the `QueueBased` model, "fallback" is the queue's overflow assignee — the User who receives work when no queue member is available (rather than the item sitting queued indefinitely). Agent availability is an async Omni decision, not observable in a routing flow, so this belongs on the `QueueRoutingConfig`, not the flow. When `overflow-assignee` is provided the skill resolves it to an active User (blocking on an unknown or inactive user, since overflow to an inactive user would silently strand work), writes `OverflowAssigneeId`, and verifies it round-trips.
+
+**Read-back reporting.** All reported field values are re-queried from the org after the write (`values_source: "requeried"`), not echoed from inputs — a 201/204 only means the write was accepted. The skill never deletes a `QueueRoutingConfig` (queues, agents, and work skills may reference the Id) — it always PATCHes to align.
+
+## Output contract
+
+A single JSON object with `status` ∈ `created` | `reused` | `updated` | `blocked`, plus `routing_target`, `developer_name`, `id`, `master_label`, `routing_model`, `routing_priority`, `capacity_mode`, `capacity_weight`, `capacity_percentage`, `is_attribute_based`, `push_timeout`, `overflow_assignee_id`, `overflow_assignee_requested`, `values_source`, a `before` snapshot, `manual_actions`, and `blocking_issue`.
+
+- `created` — no record existed; POST succeeded.
+- `reused` — a record existed with all fields matching; no-op.
+- `updated` — a record existed but a field differed; PATCH succeeded.
+- `blocked` — precondition failed (Omni not enabled, production org, a post-write mismatch, or an `overflow-assignee` that did not resolve to exactly one active User).
+
+`before.existed` records whether a matching record was present at start (with its prior `capacity_weight`/`routing_model` when so); `id` is populated for every non-blocked status; `blocking_issue` is non-null only for `blocked`.
+
+## Limitations
+
+- Attribute-based routing (`IsAttributeBased=true`) is out of scope — it requires an additional attribute schema.
+- Only `MostAvailable` and `LeastActive` are supported on v66.
+- Per-channel capacity weighting is deprecated on v66 (see `service-omni-service-channel-configure`); per-agent capacity totals are configured elsewhere.
+
+## References
+
+| File | When to read |
+|---|---|
+| `references/api-notes.md` | On unexpected errors or when customizing fields — QueueRoutingConfig schema, RoutingModel semantics, and how CapacityWeight interacts with agent capacity |
+| `scripts/tests/test_queue_routing_config_contracts.py` | When validating changes — run `python3 scripts/tests/test_queue_routing_config_contracts.py` from this skill directory |

package/skills/service-omni-queue-routing-config-deploy/references/api-notes.md

@@ -0,0 +1,127 @@
+# QueueRoutingConfig — API notes
+
+Load this reference **only when the skill hits an unexpected error or when customizing fields**. The happy path is straightforward and doesn't need this doc.
+
+**sObject type:** `QueueRoutingConfig` (first-class, SOQL-queryable via the Data API). **API version:** v66.
+
+---
+
+## Schema (fields we use)
+
+| Field | Type | v1 default | Semantics |
+|---|---|---|---|
+| `Id` | Id | (auto-generated) | Primary key |
+| `DeveloperName` | string(80) | `Case_Routing_Config` | Unique per-org identifier; used for idempotent detection |
+| `MasterLabel` | string(80) | `Case Routing Config` | UI display name |
+| `RoutingModel` | picklist | `MostAvailable` | See RoutingModel Semantics below |
+| `RoutingPriority` | integer | `1` | **REQUIRED, non-nillable** (confirmed via `sf sobject describe`). Omitting it makes every POST fail with `REQUIRED_FIELD_MISSING`. `1` = highest priority |
+| `IsAttributeBased` | boolean | `false` | Whether to use attribute-based routing (v1 does not — requires attribute definitions) |
+| `CapacityWeight` | integer(1..10) | `5` | How much of an agent's capacity ONE work item from this queue consumes. See CapacityWeight interaction below |
+| `PushTimeout` | integer (sec) | `null` | Seconds to wait before pushing work back to queue if agent doesn't accept. `null` = use Omni default of 30 sec |
+| `OverflowAssigneeId` | User Id | `null` | Fallback User that work is assigned to when all queue members are unavailable. `null` = no overflow (work stays queued indefinitely). Settable via the skill's `overflow-assignee` input (`QRC_OVERFLOW_ASSIGNEE`) — a Username or `005` Id resolved to an **active** User before the write; omitting it preserves the existing value rather than clearing it |
+
+## RoutingModel semantics
+
+| Value | Behavior |
+|---|---|
+| `MostAvailable` | Route to the agent with the most remaining capacity (i.e., handling the fewest current work items) |
+| `LeastActive` | Route to the agent whose last work-item interaction was longest ago (load-balancing over time) |
+
+**Not supported on v66:** `Priority` (removed), `SkillsBased` (moved to WorkSkillRouting on v66).
+
+For most Omni Case setups, `MostAvailable` is the right default — it maximizes queue throughput. `LeastActive` is useful when you want to keep all agents equally busy over time (e.g., to prevent burnout of high-performers).
+
+## CapacityWeight interaction with agent capacity
+
+Capacity in Omni-Channel v66 is a three-way math:
+
+- **Agent total capacity:** `PresenceUserConfig.Capacity` (default 10) — how much total work an agent can hold at once
+- **Per-queue weight:** `QueueRoutingConfig.CapacityWeight` (this skill's default 5) — how much a single work item from this queue consumes
+- **Per-channel weight:** removed on v66 — used to be `ServiceChannel.CapacityWeight`; no longer configurable
+
+**Concrete example:**
+- Agent with `PresenceUserConfig.Capacity=10`
+- Case routes through `Case_Routing_Config` with `CapacityWeight=5`
+- Agent can hold `10 / 5 = 2` cases simultaneously
+- If a third case comes in, it stays queued until the agent completes one
+
+**Rules of thumb:**
+- Weight = 1 → agent holds 10 cases at once (high-throughput but hard to focus)
+- Weight = 5 → agent holds 2 cases at once (this skill's default — balanced)
+- Weight = 10 → agent holds 1 case at a time (deep focus, low throughput)
+
+---
+
+## Data API endpoints used
+
+**GET (query):**
+
+```text
+GET /services/data/v66.0/query?q=SELECT+Id,+DeveloperName,+MasterLabel,+RoutingModel,+IsAttributeBased,+CapacityWeight,+PushTimeout,+OverflowAssigneeId+FROM+QueueRoutingConfig+WHERE+DeveloperName='Case_Routing_Config'
+```
+
+Or equivalently via `sf data query --query "SELECT ... FROM QueueRoutingConfig WHERE ..."` (which is what the skill's script uses).
+
+**POST (create):**
+
+```text
+POST /services/data/v66.0/sobjects/QueueRoutingConfig
+Content-Type: application/json
+
+{
+  "DeveloperName": "Case_Routing_Config",
+  "MasterLabel": "Case Routing Config",
+  "RoutingModel": "MostAvailable",
+  "RoutingPriority": 1,
+  "CapacityWeight": 5,
+  "IsAttributeBased": false
+}
+```
+
+Response: `{"id":"0K9RZ...", "success":true, "errors":[]}` (HTTP 201).
+`RoutingPriority` is REQUIRED — a POST without it fails with `REQUIRED_FIELD_MISSING`.
+
+**PATCH (update):**
+
+```text
+PATCH /services/data/v66.0/sobjects/QueueRoutingConfig/<id>
+Content-Type: application/json
+
+{
+  "MasterLabel": "Case Routing Config",
+  "RoutingModel": "MostAvailable",
+  "RoutingPriority": 1,
+  "CapacityWeight": 5,
+  "IsAttributeBased": false
+}
+```
+
+Response: empty body (HTTP 204). Note that PATCH does NOT include `DeveloperName` — Salesforce doesn't allow renaming via PATCH on QueueRoutingConfig.
+
+Both invoked via `sf api request rest --target-org <alias> <path> --method POST|PATCH --body <json>`.
+
+---
+
+## Failure modes
+
+| Symptom | Root cause | Skill behavior |
+|---|---|---|
+| Query returns `INVALID_TYPE` for QueueRoutingConfig | OmniChannelSettings not enabled | Skill translates to: `"OmniChannelSettings is not enabled on this org. Run service-omni-base-settings-configure first."` |
+| POST returns `DUPLICATE_VALUE` on DeveloperName | Race with concurrent skill run | Retry once — the pre-check will now find the record and PATCH instead |
+| POST/PATCH returns `INVALID_FIELD_VALUE` on RoutingModel | Value is not `MostAvailable` or `LeastActive` | Fail with a clear message naming the valid values |
+| POST/PATCH returns `INVALID_FIELD_VALUE` on CapacityWeight | Value < 1 or > 10 | Fail with a clear message naming the valid range |
+| PATCH silently changes nothing | Field values already match | Not a failure — just means Salesforce detected no diff. Skill correctly reports `status: reused` from its own pre-check |
+| POST returns `INSUFFICIENT_ACCESS_OR_READONLY` | Executing user lacks `Manage Public List Views` OR the org has other Omni restrictions | Fail with escalation guidance |
+
+---
+
+## Why Data API instead of Metadata API
+
+QueueRoutingConfig is a first-class sObject on Salesforce (unlike ServiceChannel, whose tuning fields are Metadata-only). The Data API has these advantages here:
+
+- **Speed:** ~1 sec per call vs ~10 sec for Metadata deploy
+- **Idempotency:** SOQL query returns clean field values for pre-check comparison; Metadata retrieve is slower and returns XML that needs parsing
+- **Reversibility:** PATCH just updates fields; Metadata deploy replaces the whole record
+- **No DX project overhead:** no `assets/`, no `sfdx-project.json`, no `package.xml`
+
+Metadata API is still supported (`sf project deploy start --metadata "QueueRoutingConfig:Case_Routing_Config"` works), but adds latency with no functional benefit for this entity.

package/skills/service-omni-queue-routing-config-deploy/scripts/tests/_bootstrap.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+SKILLS_ROOT = Path(__file__).resolve().parents[3]
+SCRIPT = "service-omni-queue-routing-config-deploy/scripts/upsert-and-report.sh"
+
+_FAKE_SF = r'''#!/usr/bin/env bash
+sub="${1:-} ${2:-}"; args="$*"
+SANDBOX="${FAKE_SANDBOX:-true}"; TRIAL="${FAKE_TRIAL:-null}"; ORG_TYPE="${FAKE_ORG_TYPE:-Developer Edition}"
+B_RM="${FAKE_BEFORE_RM:-MostAvailable}"; B_CW="${FAKE_BEFORE_CW:-5}"; B_CP="${FAKE_BEFORE_CP:-null}"
+B_PT="${FAKE_BEFORE_PT:-null}"; B_RP="${FAKE_BEFORE_RP:-1}"; B_ML="${FAKE_BEFORE_ML:-Case Routing Config}"
+F_RM="${FAKE_FINAL_RM:-MostAvailable}"; F_CW="${FAKE_FINAL_CW:-5}"; F_CP="${FAKE_FINAL_CP:-null}"
+F_PT="${FAKE_FINAL_PT:-null}"; F_RP="${FAKE_FINAL_RP:-1}"; F_ML="${FAKE_FINAL_ML:-Case Routing Config}"
+case "$sub" in
+  "org display") echo '{"status":0,"result":{"id":"00Dxx0000000000EAA"}}';;
+  "data query")
+    if printf '%s' "$args" | grep -q "FROM Organization"; then
+      printf '{"status":0,"result":{"records":[{"IsSandbox":%s,"TrialExpirationDate":%s,"OrganizationType":"%s"}]}}' "$SANDBOX" "$TRIAL" "$ORG_TYPE"
+    elif printf '%s' "$args" | grep -q "FROM User"; then
+      echo '{"status":0,"result":{"records":[{"Id":"005000000000001AAA","IsActive":true}],"totalSize":1}}'
+    elif printf '%s' "$args" | grep -q "FROM QueueRoutingConfig"; then
+      if printf '%s' "$args" | grep -q "WHERE Id="; then
+        printf '{"status":0,"result":{"totalSize":1,"records":[{"Id":"0Jrxx0000000001","DeveloperName":"Case_Routing_Config","MasterLabel":"%s","RoutingModel":"%s","RoutingPriority":%s,"IsAttributeBased":false,"CapacityWeight":%s,"CapacityPercentage":%s,"PushTimeout":%s,"OverflowAssigneeId":null}]}}' "$F_ML" "$F_RM" "$F_RP" "$F_CW" "$F_CP" "$F_PT"
+      elif [ "${FAKE_EXISTING:-0}" = "1" ]; then
+        printf '{"status":0,"result":{"totalSize":1,"records":[{"Id":"0Jrxx0000000001","DeveloperName":"Case_Routing_Config","MasterLabel":"%s","RoutingModel":"%s","RoutingPriority":%s,"IsAttributeBased":false,"CapacityWeight":%s,"CapacityPercentage":%s,"PushTimeout":%s,"OverflowAssigneeId":null}]}}' "$B_ML" "$B_RM" "$B_RP" "$B_CW" "$B_CP" "$B_PT"
+      else
+        echo '{"status":0,"result":{"records":[],"totalSize":0}}'
+      fi
+    else echo '{"status":0,"result":{"records":[],"totalSize":0}}'; fi;;
+  "api request")
+    if printf '%s' "$args" | grep -q "method POST"; then
+      echo '{"id":"0Jrxx0000000001","success":true,"errors":[]}'
+    else echo ''; fi;;
+  *) echo '{"status":0,"result":{}}';;
+esac
+'''
+
+
+def run(args, path_prefix=None, scrub_sf=False, extra_env=None):
+    env = dict(os.environ)
+    if scrub_sf:
+        env["PATH"] = os.pathsep.join(d for d in env.get("PATH", "").split(os.pathsep)
+                                      if d and not os.path.exists(os.path.join(d, "sf")))
+    if path_prefix:
+        env["PATH"] = path_prefix + os.pathsep + env.get("PATH", "")
+    if extra_env:
+        env.update({key: str(value) for key, value in extra_env.items()})
+    proc = subprocess.run(["bash", str(SKILLS_ROOT / SCRIPT), *args], capture_output=True,
+                          text=True, env=env, cwd=str(SKILLS_ROOT))
+    return proc.returncode, (proc.stdout or "") + (proc.stderr or "")
+
+
+def last_json(out: str) -> dict:
+    decoder = json.JSONDecoder()
+    result, index = None, 0
+    while index < len(out):
+        if out[index] not in "{[":
+            index += 1
+            continue
+        try:
+            candidate, end = decoder.raw_decode(out, index)
+            if isinstance(candidate, dict):
+                result = candidate
+            index = end
+        except json.JSONDecodeError:
+            index += 1
+    assert result is not None, out
+    return result
+
+
+class FakeSf:
+    def __init__(self, body=_FAKE_SF):
+        self.body = body
+        self.tmp = None
+
+    def __enter__(self):
+        self.tmp = tempfile.mkdtemp(prefix="qrc-fake-sf-")
+        executable = Path(self.tmp) / "sf"
+        executable.write_text(self.body)
+        executable.chmod(0o755)
+        return self.tmp
+
+    def __exit__(self, *_):
+        import shutil
+        shutil.rmtree(self.tmp, ignore_errors=True)

package/skills/service-omni-queue-routing-config-deploy/scripts/tests/test_queue_routing_config_contracts.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _bootstrap import FakeSf, last_json, run  # noqa: E402
+
+
+class InputTests(unittest.TestCase):
+    def test_weight_and_percentage_are_mutually_exclusive(self):
+        with FakeSf() as fake:
+            rc, out = run(["org", "LeastActive", "Case_Routing_Config", "Case Routing Config", "7"],
+                          path_prefix=fake, extra_env={"QRC_CAPACITY_PERCENTAGE": "100"})
+        self.assertEqual(rc, 1, out)
+        self.assertIn("mutually exclusive", out)
+
+    def test_invalid_timeout_is_rejected(self):
+        with FakeSf() as fake:
+            rc, out = run(["org"], path_prefix=fake, extra_env={"QRC_PUSH_TIMEOUT": "99999"})
+        self.assertEqual(rc, 1, out)
+        self.assertIn("Invalid push-timeout", out)
+
+
+class BehaviorTests(unittest.TestCase):
+    def test_create_percentage_capacity_and_timeout(self):
+        with FakeSf() as fake:
+            rc, out = run(["org", "LeastActive"], path_prefix=fake,
+                          extra_env={"QRC_CAPACITY_PERCENTAGE": "100", "QRC_PUSH_TIMEOUT": "30",
+                                     "FAKE_FINAL_RM": "LeastActive", "FAKE_FINAL_CP": "100.0",
+                                     "FAKE_FINAL_PT": "30", "FAKE_FINAL_CW": "null"})
+        self.assertEqual(rc, 0, out)
+        result = last_json(out)
+        self.assertEqual(result["capacity_mode"], "percentage", out)
+        self.assertEqual(result["capacity_percentage"], 100.0, out)
+        self.assertEqual(result["push_timeout"], 30, out)
+
+    def test_matching_existing_record_is_reused(self):
+        with FakeSf() as fake:
+            rc, out = run(["org"], path_prefix=fake, extra_env={"FAKE_EXISTING": "1"})
+        self.assertEqual(rc, 0, out)
+        self.assertEqual(last_json(out)["status"], "reused", out)
+
+    def test_existing_custom_values_are_preserved_when_not_requested(self):
+        custom = {
+            "FAKE_EXISTING": "1",
+            "FAKE_BEFORE_RM": "LeastActive",
+            "FAKE_BEFORE_CW": "17",
+            "FAKE_BEFORE_PT": "45",
+            "FAKE_BEFORE_RP": "7",
+            "FAKE_BEFORE_ML": "Existing Queue Policy",
+            "FAKE_FINAL_RM": "LeastActive",
+            "FAKE_FINAL_CW": "17",
+            "FAKE_FINAL_PT": "45",
+            "FAKE_FINAL_RP": "7",
+            "FAKE_FINAL_ML": "Existing Queue Policy",
+        }
+        with FakeSf() as fake:
+            rc, out = run(["org"], path_prefix=fake, extra_env=custom)
+        self.assertEqual(rc, 0, out)
+        result = last_json(out)
+        self.assertEqual(result["status"], "reused", out)
+        self.assertEqual(result["master_label"], "Existing Queue Policy", out)
+        self.assertEqual(result["capacity_weight"], 17, out)
+        self.assertEqual(result["routing_priority"], 7, out)
+        self.assertEqual(result["push_timeout"], 45, out)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)