skip to content

Some case repositories copy a case's steps into a cycle but resolve its title, folder and links live. What surprises does that mixed model produce?

level: middleimportance: nice to knowfreq 38%

answer

  1. part copy, part pointer, one item
  2. steps frozen, metadata follows the master
  3. a name nobody saw during execution
  4. the pointer, not the bytes
  5. test the item view and the export

basics

~20 s

One item can disagree with itself: frozen steps under a title, folder or link that followed the master. Reports group and label by the live half while testers executed the copied half, and a referenced attachment can change even though the steps around it did not.

solid answer

~50 s

A hybrid repository copies the expensive, execution-critical part of a case - usually the ordered steps and their expected results - and leaves cheaper metadata as a pointer. The result is an item whose halves can date from different days. A cycle report can list a case under a name nobody saw, or group it into a folder it was moved to after execution, while the steps beside it are the frozen originals. Attachments are the sharpest edge: if the copy stores a reference rather than the bytes, replacing the file changes what the frozen steps tell a tester to use. None of this is a defect in the product, but it means "this cycle is snapshotted" is never a complete statement. The useful question is always *which fields* are copied, and that has to be established per repository rather than assumed.

go deeper

for a junior

Know that a cycle can copy some parts of a case and point at others, so a frozen set of steps may still sit under a title or folder that changed.

for a middle

Describe the usual split between copied steps and live metadata, and how to establish it empirically by editing one field at a time and reopening the item.

for a senior

Show awareness that reports and exports can resolve fields the item view copied, and attach evidence to the execution rather than trusting a case's file pointer.

for a principal

Set the expectation across teams that a snapshot claim names its fields, so nobody reads a historical report as frozen when only its steps ever were.

## Why products mix the models at all Copying is not free. The steps of a case are the bulk of it, and duplicating them per cycle is a real storage and search cost; metadata is small but is exactly what people want to be current - a renamed case should look renamed, a reorganised folder should group reports the new way, a link to a requirement should follow the requirement. So products split the difference, and most of them do it without announcing it. The result is the **hybrid**: part copy, part pointer, in one item. A typical division looks like this, though every repository draws the line somewhere slightly different: | Part of the case | Commonly copied | Commonly live | |---|---|---| | Ordered steps and expected results | yes | - | | Preconditions and inline test data | usually | sometimes | | Title and description | sometimes | often | | Folder placement, owner, priority, tags | rarely | usually | | Links to requirements and defects | rarely | usually | | Attachments | the pointer, not the bytes | effectively yes | ## The surprises, and where each one shows up - **An item that contradicts itself.** The steps are the originals; the title above them is the rewrite. A tester reading a cycle report sees a name that never appeared during execution, which makes the result look like it belongs to a different case. - **Reports that regroup after the fact.** If folder placement is live, reorganising the tree changes how a months-old cycle is grouped and totalled. The numbers do not change, but which bucket they fall in does, and a comparison against last release's report stops lining up. - **Attachments that change under frozen steps.** A step reading "use the attached data file" is stable text pointing at unstable bytes. Replace the file and the frozen instruction now means something else - the worst version of this failure, because nothing on the item looks edited. - **Links that answer differently than they did.** If the case's links to requirements are resolved live, the coverage the cycle appears to demonstrate can grow or shrink long after the cycle closed, without a single result changing. - **A correction that half-arrives.** Fix a case and rename it in the same edit: open cycles get the new name and keep the old steps. Testers see evidence the fix landed and execute the unfixed instructions. ## Establishing the line in a given repository The division is rarely documented in a form you can rely on, so test it - it takes minutes and the answer holds for every cycle afterwards: 1. Put one case into a cycle and record a result on it. 2. In the master, change **one word of a step**, the **title**, the **folder**, and **replace an attachment** - four edits, one per candidate field. 3. Reopen the cycle item and see which of the four followed. 4. Repeat step 3 on the **cycle's report or export**, not just the item view. Reports frequently resolve fields the item view copied, so the two surfaces can disagree. Step 4 is the one people skip and the one that produces the surprises. An item can render the copied title while the export lists the live one, because the export builds its rows from the case rather than from the cycle's record. ## Living with a hybrid Once you know the line, the practical rules are short: - **Never say "the cycle is snapshotted" without naming the fields.** It is a claim about specific data, and the unqualified version is the one that misleads a reader six months later. - **Treat referenced files as unstable.** If evidence matters, attach the file to the execution rather than relying on the case's pointer, so the bytes live with the result. - **Prefer additive edits during an open cycle.** Renaming and re-foldering are the edits most likely to be live, and they are also the ones with no urgency - they can wait until the cycle closes. - **Read a historical report twice.** Once for its numbers, which are stable, and once for its labels and grouping, which may not be. The underlying point generalises past this leaf: a snapshot is only as frozen as its least frozen field, and the fields most likely to have been left live are precisely the ones a reader uses to identify what they are looking at.

  • How would you make an attachment genuinely part of a cycle's evidence in a hybrid repository?
    Attach it to the execution record rather than relying on the case's pointer. Files hung off a result belong to that result and are not replaced when someone updates the case's copy. Where the file is large or shared, record its identity - a name plus a checksum in the result comment - so a later reader can tell whether the current file is the one that was used.
  • Why can a cycle's item view and its exported report disagree about the same field?
    They are often built from different sources. The item view renders the cycle's own record, while an export or report frequently joins back to the case to fetch names, folders and links. In a hybrid repository that means one surface can show the copied value and the other the live one. It is worth checking both before trusting either as the record of what was executed.

saying these in an interview costs you the question

  • Assuming a snapshot freezes the whole case
  • Trusting a historical report's grouping after a tree reorganisation
  • Treating a referenced attachment as frozen evidence
  • Testing only the item view, never the export
  • Renaming a case while its cycle is still being executed