diff --git a/docs/testing.md b/docs/testing.md
index 3de20e198..e05d231a4 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -1,359 +1,908 @@
-# OSF Angular Testing Strategy
-
-## Index
-
-- [Overview](#overview)
-  - [Pro-tips](#pro-tips)
-- [Best Practices](#best-practices)
-- [Summary Table](#summary-table)
-- [Test Coverage Enforcement (100%)](#test-coverage-enforcement-100)
-- [Key Structure](#key-structure)
-- [Testing Angular Services (with HTTP)](#testing-angular-services-with-http)
-- [Testing Angular Components](#testing-angular-components)
-- [Testing Angular Pipes](#testing-angular-pipes)
-- [Testing Angular Directives](#testing-angular-directives)
-- [Testing Angular NGXS](#testing-ngxs)
+# OSF Angular Unit Testing Guide
+
+## Table of Contents
+
+1. [Test Stack](#1-test-stack)
+2. [Project Testing Infrastructure](#2-project-testing-infrastructure)
+3. [Test File Structure](#3-test-file-structure)
+4. [TestBed Configuration](#4-testbed-configuration)
+5. [Mocking Strategies](#5-mocking-strategies)
+6. [Store Mocking](#6-store-mocking)
+7. [Router & Route Mocking](#7-router--route-mocking)
+8. [Service Mocking](#8-service-mocking)
+9. [Signal-Based Testing](#9-signal-based-testing)
+10. [Async Operations](#10-async-operations)
+11. [Form Testing](#11-form-testing)
+12. [Dialog Testing](#12-dialog-testing)
+13. [Edge Cases](#13-edge-cases)
+14. [Testing Angular Services (HTTP)](#14-testing-angular-services-http)
+15. [Testing NGXS State](#15-testing-ngxs-state)
+16. [Test Data](#16-test-data)
+17. [Coverage Enforcement](#17-coverage-enforcement)
+18. [Best Practices](#18-best-practices)
+19. [Appendix: Assertion Patterns](#appendix-assertion-patterns)
 
 ---
 
-## Overview
+## 1. Test Stack
 
-The OSF Angular project uses a modular and mock-driven testing strategy. A shared `testing/` folder provides reusable mocks, mock data, and testing module configuration to support consistent and maintainable unit tests across the codebase.
+| Tool                      | Purpose                                                                                       |
+| ------------------------- | --------------------------------------------------------------------------------------------- |
+| **Jest**                  | Test runner & assertion library                                                               |
+| **Angular TestBed**       | Component / service compilation                                                               |
+| **ng-mocks**              | `MockComponents`, `MockModule`, `MockProvider`                                                |
+| **NGXS**                  | State management — mocked via `provideMockStore()` for components, real store for state tests |
+| **RxJS**                  | Observable / Subject-based async testing                                                      |
+| **HttpTestingController** | HTTP interception for service and state integration tests                                     |
+| **Custom utilities**      | `src/testing/` — builders, factories, mock data                                               |
 
 ---
 
-### Pro-tips
+## 2. Project Testing Infrastructure
 
-**What to test**
+### Directory: `src/testing/`
 
-The OSF Angular testing strategy enforces 100% coverage while also serving as a guardrail for future engineers. Each test should highlight the most critical aspect of your code — what you’d want the next developer to understand before making changes. If a test fails during a refactor, it should clearly signal that a core feature was impacted, prompting them to investigate why and preserve the intended behavior.
+```
+src/testing/
+├── osf.testing.provider.ts       ← provideOSFCore(), provideOSFHttp()
+├── osf.testing.module.ts         ← OSFTestingModule (legacy — prefer providers)
+├── providers/                    ← Builder-pattern mocks for services
+│   ├── store-provider.mock.ts
+│   ├── route-provider.mock.ts
+│   ├── router-provider.mock.ts
+│   ├── toast-provider.mock.ts
+│   ├── custom-confirmation-provider.mock.ts
+│   ├── custom-dialog-provider.mock.ts
+│   ├── component-provider.mock.ts
+│   ├── loader-service.mock.ts
+│   └── dialog-provider.mock.ts
+├── mocks/                        ← Mock domain models (89+ files)
+│   ├── registries.mock.ts
+│   ├── draft-registration.mock.ts
+│   └── ...
+└── data/                         ← JSON API response fixtures
+    ├── dashboard/
+    ├── addons/
+    └── files/
+```
+
+### `provideOSFCore()` — mandatory base provider
+
+Every component test must include `provideOSFCore()`. It configures animations, translations, and environment tokens.
+
+```typescript
+export function provideOSFCore() {
+  return [
+    provideNoopAnimations(),
+    importProvidersFrom(TranslateModule.forRoot()),
+    TranslationServiceMock,
+    EnvironmentTokenMock,
+  ];
+}
+```
+
+> **Never** import `OSFTestingModule` directly in new tests. It is retained for legacy compatibility only. Use `provideOSFCore()` instead.
 
 ---
 
-**Test Data**
+## 3. Test File Structure
+
+### Core rules
+
+- Prefer a single flat `describe` block per file to keep tests searchable and prevent state leakage. Use nested `describe` blocks when it significantly simplifies setup or groups logically distinct behaviors.
+- For specs where all tests share a single configuration, use `beforeEach` with `TestBed.configureTestingModule` directly. Use a `setup()` helper when tests need different selector values, route configs, or other overrides.
+- No `TestBed.resetTestingModule()` in `afterEach` — Angular auto-resets.
+- Use actual interfaces/types for mock data instead of `any`.
+- Co-locate unit tests with components using `*.spec.ts`.
+
+### Standard structure
+
+```typescript
+describe('MyComponent', () => {
+  let component: MyComponent;
+  let fixture: ComponentFixture<MyComponent>;
+  let store: Store;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({ ... });
+    store = TestBed.inject(Store);
+    fixture = TestBed.createComponent(MyComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});
+```
+
+### `setup()` helper — parameterised tests
+
+Use when tests need different selector values or route configs. Avoids duplicating `TestBed` configuration across tests.
 
-The OSF Angular Test Data module provides a centralized and consistent source of data across all unit tests. It is intended solely for use within unit tests. By standardizing test data, any changes to underlying data models will produce cascading failures, which help expose the full scope of a refactor. This is preferable to isolated or hardcoded test values, which can lead to false positives and missed regressions.
+Extend `BaseSetupOverrides` from `@testing/providers/store-provider.mock` when the spec only needs standard route/selector overrides. Add component-specific fields as needed.
 
-The strategy for structuring test data follows two principles:
+Use `mergeSignalOverrides` from `@testing/providers/store-provider.mock` to apply selector overrides on top of default signal values.
 
-1. Include enough data to cover all relevant permutations required by the test suite.
-2. Ensure the data reflects all possible states (stati) of the model.
+Use `withNoParent()` on `ActivatedRouteMockBuilder` when testing components that guard against a missing parent route.
 
-**Test Scope**
+```typescript
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
 
-The OSF Angular project defines a `@testing` scope that can be used for importing all testing-related modules.
+interface SetupOverrides extends BaseSetupOverrides {
+  routerUrl?: string;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const routeBuilder = ActivatedRouteMockBuilder.create().withParams(overrides.routeParams ?? { id: 'draft-1' });
+  if (overrides.hasParent === false) routeBuilder.withNoParent();
+  const mockRoute = routeBuilder.build();
+
+  const mockRouter = RouterMockBuilder.create()
+    .withUrl(overrides.routerUrl ?? '/registries/drafts/reg-1/1')
+    .build();
+
+  const defaultSignals = [{ selector: MySelectors.getData, value: mockData }];
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [MyComponent],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, mockRoute),
+      MockProvider(Router, mockRouter),
+      provideMockStore({ signals }),
+    ],
+  });
+
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(MyComponent);
+  return { fixture, component: fixture.componentInstance, store };
+}
+
+// Usage
+it('should handle missing data', () => {
+  const { component } = setup({
+    selectorOverrides: [{ selector: MySelectors.getData, value: null }],
+  });
+  expect(component.hasData()).toBe(false);
+});
+
+it('should not dispatch when parent route is absent', () => {
+  const { store } = setup({ hasParent: false });
+  expect(store.dispatch).not.toHaveBeenCalled();
+});
+```
 
 ---
 
-## Best Practices
+## 4. TestBed Configuration
+
+### Standalone components (standard)
+
+```typescript
+TestBed.configureTestingModule({
+  imports: [
+    ComponentUnderTest,
+    ...MockComponents(ChildA, ChildB),
+    MockModule(PrimeNGModule),
+  ],
+  providers: [
+    provideOSFCore(),
+    MockProvider(ActivatedRoute, mockRoute),
+    MockProvider(Router, mockRouter),
+    MockProvider(ToastService, ToastServiceMock.simple()),
+    provideMockStore({ signals: [...] }),
+  ],
+});
+```
 
-- Always import `OsfTestingModule` or `OsfTestingStoreModule` to minimize boilerplate and get consistent mock behavior.
-- Use mocks and mock-data from `testing/` to avoid repeating test setup.
-- Avoid real HTTP, translation, or store dependencies in unit tests by default.
-- Co-locate unit tests with components using `*.spec.ts`.
+### Components with signal-input children
+
+Use `overrideComponent` when a child uses Angular signal viewChild and `MockComponents` cannot stub it correctly.
+
+```typescript
+TestBed.configureTestingModule({ ... })
+  .overrideComponent(FilesControlComponent, {
+      remove: { imports: [FilesTreeComponent] },
+      add: {
+        imports: [
+          MockComponentWithSignal('osf-files-tree', [
+            'files',
+            'selectionMode',
+            'totalCount',
+            'storage',
+            'currentFolder',
+            'isLoading',
+            'scrollHeight',
+            'viewOnly',
+            'resourceId',
+            'provider',
+            'selectedFiles',
+          ]),
+        ],
+      },
+    });
+```
 
 ---
 
-## Summary Table
+## 5. Mocking Strategies
+
+### Priority order
 
-| Location                | Purpose                                |
-| ----------------------- | -------------------------------------- |
-| `osf.testing.module.ts` | Unified test module for shared imports |
-| `src/mocks/*.mock.ts`   | Mock services and tokens               |
-| `src/data/*.data.ts`    | Static mock data for test cases        |
+Always check `@testing/` before writing inline mocks. Builders and factories almost certainly exist.
+
+1. Use existing builders/factories from `@testing/providers/`
+2. Use `MockProvider` with an explicit mock object
+3. Use `MockComponents` / `MockModule` from ng-mocks
+4. Use `MockComponentWithSignal` for signal-input children
+5. Inline `jest.fn()` mocks as a last resort
+
+### Quick reference
+
+| Need                       | Use                                                     |
+| -------------------------- | ------------------------------------------------------- |
+| Store selectors / dispatch | `provideMockStore()`                                    |
+| Router                     | `RouterMockBuilder`                                     |
+| ActivatedRoute             | `ActivatedRouteMockBuilder`                             |
+| ToastService               | `ToastServiceMock.simple()`                             |
+| CustomConfirmationService  | `CustomConfirmationServiceMock.simple()`                |
+| CustomDialogService        | `CustomDialogServiceMockBuilder`                        |
+| LoaderService              | `new LoaderServiceMock()`                               |
+| Child components           | `MockComponents(...)` or `MockComponentWithSignal(...)` |
+| PrimeNG modules            | `MockModule(...)`                                       |
+
+> **Rule:** Bare `MockProvider(Service)` creates ng-mocks stubs, not `jest.fn()`. When you need `.mockImplementation`, `.mockClear`, or assertion checking, always pass an explicit mock as the second argument.
 
 ---
 
-## Test Coverage Enforcement (100%)
+## 6. Store Mocking
+
+### `provideMockStore` configuration options
+
+| Config key  | Maps to                               | Use case                             |
+| ----------- | ------------------------------------- | ------------------------------------ |
+| `signals`   | `store.selectSignal()`                | Signal-based selectors (most common) |
+| `selectors` | `store.select()` / `selectSnapshot()` | Observable-based selectors           |
+| `actions`   | `store.dispatch()` return value       | When component reads dispatch result |
+
+```typescript
+provideMockStore({
+  signals: [
+    { selector: RegistriesSelectors.getDraftRegistration, value: mockDraft },
+    { selector: RegistriesSelectors.getStepsState, value: stepsStateSignal },
+  ],
+  actions: [
+    { action: new CreateDraft({ ... }), value: { id: 'new-draft' } },
+  ],
+})
+```
+
+### `mergeSignalOverrides` — applying selector overrides in `setup()`
 
-This project **strictly enforces 100% test coverage** through the following mechanisms:
+Use `mergeSignalOverrides(defaults, overrides)` from `@testing/providers/store-provider.mock` instead of inlining the merge logic. It replaces matching selectors and preserves the rest.
 
-### Husky Pre-Push Hook
+```typescript
+import { mergeSignalOverrides } from '@testing/providers/store-provider.mock';
 
-Before pushing any code, Husky runs a **pre-push hook** that executes:
+const defaultSignals = [
+  { selector: MySelectors.getData, value: [] },
+  { selector: MySelectors.isLoading, value: false },
+];
+const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+```
+
+### Dispatch assertions
+
+```typescript
+expect(store.dispatch).toHaveBeenCalledWith(new MyAction('id'));
+expect(store.dispatch).not.toHaveBeenCalledWith(expect.any(MyAction));
 
-```bash
-npm run test:coverage
+// Filter by action type across multiple dispatches
+const calls = (store.dispatch as jest.Mock).mock.calls.filter(([a]: [any]) => a instanceof GetProjects);
+expect(calls.length).toBe(1);
 ```
 
-This command:
+### Clearing init dispatches
 
-- Runs the full test suite with `--coverage`.
-- Fails the push if **coverage drops below 100%**.
-- Ensures developers never bypass test coverage enforcement locally.
+When `ngOnInit` dispatches and you need isolated per-test assertions:
 
-> Pro Tip: Use `npm run test:watch` during development to maintain coverage incrementally.
+```typescript
+(store.dispatch as jest.Mock).mockClear();
+component.doSomething();
+expect(store.dispatch).toHaveBeenCalledWith(new SpecificAction());
+```
 
 ---
 
-### GitHub Actions CI
+## 7. Router & Route Mocking
 
-Every pull request and push runs GitHub Actions that:
+### ActivatedRoute
 
-- Run `npm run test:coverage`.
-- Verify test suite passes with **100% code coverage**.
-- Fail the build if even **1 uncovered branch/line/function** exists.
+```typescript
+const mockRoute = ActivatedRouteMockBuilder.create()
+  .withParams({ id: 'draft-1' })
+  .withQueryParams({ projectId: 'proj-1' })
+  .withData({ feature: 'registries' })
+  .build();
 
-This guarantees **test integrity in CI** and **prevents regressions**.
+// Nested child routes
+const mockRoute = ActivatedRouteMockBuilder.create()
+  .withParams({ id: 'reg-1' })
+  .withFirstChild((child) => child.withParams({ step: '2' }))
+  .build();
 
----
+// No parent route (for testing components that guard against missing parent)
+const mockRoute = ActivatedRouteMockBuilder.create().withParams({ id: 'reg-1' }).withNoParent().build();
+```
 
-### Coverage Expectations
+### Router
 
-| File Type   | Coverage Requirement                       |
-| ----------- | ------------------------------------------ |
-| `*.ts`      | 100% line & branch                         |
-| `*.spec.ts` | Required per file                          |
-| Services    | Must mock HTTP via `HttpTestingController` |
-| Components  | DOM + Input + Output event coverage        |
-| Pipes/Utils | All edge cases tested                      |
+```typescript
+const mockRouter = RouterMockBuilder.create().withUrl('/registries/drafts/reg-1/metadata').build();
+
+expect(mockRouter.navigate).toHaveBeenCalledWith(['../1'], expect.objectContaining({ relativeTo: expect.anything() }));
+expect(mockRouter.navigateByUrl).toHaveBeenCalledWith('/registries/prov-1/new');
+```
 
 ---
 
-### Summary
+## 8. Service Mocking
 
-- **Zero exceptions** for test coverage.
-- **Push blocked** without passing 100% tests.
-- GitHub CI double-checks every PR.
+### Simple factories
+
+```typescript
+const toastService = ToastServiceMock.simple();
+const confirmationService = CustomConfirmationServiceMock.simple();
+// Returns plain objects with jest.fn() methods — safe to assert on directly
+```
+
+### Builder pattern
+
+```typescript
+const mockDialog = CustomDialogServiceMockBuilder.create()
+  .withOpen(
+    jest.fn().mockReturnValue({
+      onClose: dialogClose$.pipe(),
+      close: jest.fn(),
+    })
+  )
+  .build();
+```
+
+### Inline mock (no builder exists)
+
+```typescript
+const mockFilesService = {
+  uploadFile: jest.fn(),
+  getFileGuid: jest.fn(),
+};
+MockProvider(FilesService, mockFilesService);
+```
 
 ---
 
-## Key Structure
+## 9. Signal-Based Testing
 
-### `src/testing/osf.testing.module.ts`
+### `WritableSignal` for dynamic state
 
-This module centralizes commonly used providers, declarations, and test utilities. It's intended to be imported into any `*.spec.ts` test file to avoid repetitive boilerplate.
+Pass a `WritableSignal` as the selector value to change state mid-test. The mock store detects `isSignal(value)` and returns it as-is, so updates propagate automatically.
 
-Example usage:
+```typescript
+let stepsStateSignal: WritableSignal<{ invalid: boolean }[]>;
 
-```ts
-import { TestBed } from '@angular/core/testing';
-import { OsfTestingModule } from '@testing/osf.testing.module';
+beforeEach(() => {
+  stepsStateSignal = signal([{ invalid: true }]);
+  provideMockStore({
+    signals: [{ selector: RegistriesSelectors.getStepsState, value: stepsStateSignal }],
+  });
+});
 
-beforeEach(async () => {
-  await TestBed.configureTestingModule({
-    imports: [OsfTestingModule],
-  }).compileComponents();
+it('should react to signal changes', () => {
+  expect(component.isDraftInvalid()).toBe(true);
+  stepsStateSignal.set([{ invalid: false }]);
+  expect(component.isDraftInvalid()).toBe(false);
 });
 ```
 
-### OSFTestingModule
+### Setting signal inputs
+
+```typescript
+fixture.componentRef.setInput('attachedFiles', []);
+fixture.componentRef.setInput('projectId', 'project-1');
+fixture.detectChanges();
 
-**Imports:**
+// Never use direct property assignment for signal inputs
+```
 
-- `NoopAnimationsModule` – disables Angular animations for clean, predictable unit tests.
-- `BrowserModule` – required for bootstrapping Angular features.
-- `CommonModule` – provides core Angular directives (e.g., `ngIf`, `ngFor`).
-- `TranslateModule.forRoot()` – sets up the translation layer for template-based testing with `@ngx-translate`.
+---
 
-**Providers:**
+## 10. Async Operations
 
-- `provideNoopAnimations()` – disables animation via the new standalone provider API.
-- `provideRouter([])` – injects an empty router config for component-level testing.
-- `provideHttpClient(withInterceptorsFromDi())` – ensures DI-compatible HTTP interceptors are respected in tests.
-- `provideHttpClientTesting()` – injects `HttpTestingController` for mocking HTTP requests in unit tests.
-- `TranslationServiceMock` – mocks i18n service methods.
-- `EnvironmentTokenMock` – mocks environment config values.
+### `fakeAsync` + `tick` for debounced operations
 
----
+```typescript
+it('should dispatch after debounce', fakeAsync(() => {
+  (store.dispatch as jest.Mock).mockClear();
+  component.onProjectFilter('abc');
+  tick(300);
+  expect(store.dispatch).toHaveBeenCalledWith(new GetProjects('user-1', 'abc'));
+}));
 
-### OSFTestingStoreModule
+// Deduplication — only the last value dispatches
+it('should debounce rapid calls', fakeAsync(() => {
+  (store.dispatch as jest.Mock).mockClear();
+  component.onProjectFilter('a');
+  component.onProjectFilter('ab');
+  component.onProjectFilter('abc');
+  tick(300);
+  const calls = (store.dispatch as jest.Mock).mock.calls.filter(([a]: [any]) => a instanceof GetProjects);
+  expect(calls.length).toBe(1);
+}));
+```
+
+### `done` callback for output emissions
+
+```typescript
+it('should emit attachFile', (done) => {
+  component.attachFile.subscribe((f) => {
+    expect(f).toEqual({ id: 'file-1' });
+    done();
+  });
+  component.selectFile({ id: 'file-1' } as FileModel);
+});
+```
 
-**Imports:**
+---
 
-- `OSFTestingModule` – reuses core mocks and modules.
+## 11. Form Testing
 
-**Providers:**
+### Validation and submit
 
-- `StoreMock` – mocks NgRx Store for selector and dispatch testing.
-- `ToastServiceMock` – injects a mock version of the UI toast service.
+```typescript
+it('should be invalid when title is empty', () => {
+  component.metadataForm.patchValue({ title: '' });
+  expect(component.metadataForm.get('title')?.valid).toBe(false);
+});
 
-### Testing Mocks
+it('should trim values on submit', () => {
+  component.metadataForm.patchValue({
+    title: '  Padded Title  ',
+    description: '  Padded Desc  ',
+  });
+  (store.dispatch as jest.Mock).mockClear();
+  component.submitMetadata();
+  expect(store.dispatch).toHaveBeenCalledWith(
+    new UpdateDraft('draft-1', expect.objectContaining({ title: 'Padded Title' }))
+  );
+});
+```
 
-The `src/testing/mocks/` directory provides common service and token mocks to isolate unit tests from real implementations.
+### Validator toggling & touched state
 
-**examples**
+```typescript
+it('should toggle validator', () => {
+  component.toggleFromProject();
+  expect(component.draftForm.get('project')?.validator).toBeTruthy();
+  component.toggleFromProject();
+  expect(component.draftForm.get('project')?.validator).toBeNull();
+});
 
-- `environment.token.mock.ts` – Mocks environment tokens like base API URLs.
-- `store.mock.ts` – NGXS or other store-related mocks.
-- `translation.service.mock.ts` – Prevents needing actual i18n setup during testing.
-- `toast.service.mock.ts` – Mocks user feedback services to track invocations without UI.
+it('should mark form touched on init when invalid', () => {
+  expect(component.metadataForm.touched).toBe(true);
+});
+```
 
 ---
 
-### Test Data
+## 12. Dialog Testing
 
-The `src/testing/data/` directory includes fake/mock data used by tests to simulate external API responses or internal state.
+### Subject-based `onClose`
 
-The OSF Angular Test Data module provides a centralized and consistent source of data across all unit tests. It is intended solely for use within unit tests. By standardizing test data, any changes to underlying data models will produce cascading failures, which help expose the full scope of a refactor. This is preferable to isolated or hardcoded test values, which can lead to false positives and missed regressions.
+Always use a real `Subject` for `onClose` — `MockProvider` cannot auto-generate reactive streams. Use `provideDynamicDialogRefMock()` where applicable.
 
-The strategy for structuring test data follows two principles:
+```typescript
+const dialogClose$ = new Subject<any>();
+const mockDialog = CustomDialogServiceMockBuilder.create()
+  .withOpen(
+    jest.fn().mockReturnValue({
+      onClose: dialogClose$.pipe(),
+      close: jest.fn(),
+    })
+  )
+  .build();
 
-1. Include enough data to cover all relevant permutations required by the test suite.
-2. Ensure the data reflects all possible states (stati) of the model.
+it('should navigate on confirm', () => {
+  component.openConfirmDialog();
+  dialogClose$.next(true);
+  expect(mockRouter.navigate).toHaveBeenCalledWith(['/new-reg-1/overview']);
+});
 
-**examples**
+it('should not navigate on cancel', () => {
+  component.openConfirmDialog();
+  dialogClose$.next(false);
+  expect(mockRouter.navigate).not.toHaveBeenCalled();
+});
+```
+
+### Chained dialogs
+
+```typescript
+it('should pass data between dialogs', () => {
+  const selectClose$ = new Subject<any>();
+  const confirmClose$ = new Subject<any>();
+  let callCount = 0;
+
+  (dialog.open as jest.Mock).mockImplementation(() => {
+    callCount++;
+    const subj = callCount === 1 ? selectClose$ : confirmClose$;
+    return { onClose: subj.pipe(), close: jest.fn() };
+  });
+
+  component.openSelectComponentsDialog();
+  selectClose$.next(['comp-1']);
 
-- `addons.authorized-storage.data.ts`
-- `addons.external-storage.data.ts`
-- `addons.configured.data.ts`
-- `addons.operation-invocation.data.ts`
+  expect(dialog.open).toHaveBeenCalledTimes(2);
+  const secondArgs = (dialog.open as jest.Mock).mock.calls[1];
+  expect(secondArgs[1].data.components).toEqual(['comp-1']);
+});
+```
+
+### Confirmation service (auto-confirm pattern)
+
+```typescript
+it('should dispatch on confirm', () => {
+  mockConfirmation.confirmDelete.mockImplementation(({ onConfirm }: any) => onConfirm());
+  (store.dispatch as jest.Mock).mockClear();
+  component.deleteDraft();
+  expect(store.dispatch).toHaveBeenCalledWith(new DeleteDraft('draft-1'));
+});
+```
 
 ---
 
-## Testing Angular Services (with HTTP)
+## 13. Edge Cases
 
-All OSF Angular services that make HTTP requests must be tested using `HttpClientTestingModule` and `HttpTestingController`. This testing style verifies both the API call itself and the logic that maps the response into application data.
+### `ngOnDestroy` — conditional cleanup
 
-When using HttpTestingController to flush HTTP requests in tests, only use data from the @testing/data mocks to ensure consistency and full test coverage.
+Components that auto-save on destroy must skip saves when the resource was already deleted. Test both paths.
 
-Any error handling will also need to be tested.
+```typescript
+it('should skip updates on destroy when draft was deleted', () => {
+  (store.dispatch as jest.Mock).mockClear();
+  component.isDraftDeleted = true;
+  component.ngOnDestroy();
+  expect(store.dispatch).not.toHaveBeenCalled();
+});
 
-### Setup
+it('should dispatch update on destroy when fields changed', () => {
+  component.metadataForm.patchValue({ title: 'Changed Title' });
+  (store.dispatch as jest.Mock).mockClear();
+  component.ngOnDestroy();
+  expect(store.dispatch).toHaveBeenCalledWith(
+    new UpdateDraft('draft-1', expect.objectContaining({ title: 'Changed Title' }))
+  );
+});
 
-```ts
-import { HttpTestingController } from '@angular/common/http/testing';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+it('should not dispatch update on destroy when fields are unchanged', () => {
+  (store.dispatch as jest.Mock).mockClear();
+  component.ngOnDestroy();
+  expect(store.dispatch).not.toHaveBeenCalledWith(expect.any(UpdateDraft));
+});
+```
 
-let service: YourService;
+### Null / undefined selector values
 
-beforeEach(() => {
-  TestBed.configureTestingModule({
-    imports: [OSFTestingModule],
-    providers: [YourService],
+```typescript
+it('should handle null draft', () => {
+  const { component } = setup({
+    selectorOverrides: [{ selector: Selectors.getDraft, value: null }],
   });
+  expect(component).toBeTruthy();
+});
+```
 
-  service = TestBed.inject(YourService);
+### Empty arrays vs populated arrays
+
+```typescript
+it('should mark invalid when required field has empty array', () => {
+  const { component } = setup({
+    selectorOverrides: [{ selector: Selectors.getStepsData, value: { field1: [] } }],
+  });
+  expect(component.steps()[1].invalid).toBe(true);
+});
+
+it('should not mark invalid with non-empty array', () => {
+  const { component } = setup({
+    selectorOverrides: [{ selector: Selectors.getStepsData, value: { field1: ['item'] } }],
+  });
+  expect(component.steps()[1].invalid).toBe(false);
 });
 ```
 
-### Example Test
+### Missing links / properties
 
-```ts
-it('should call correct endpoint and return expected data', inject(
-  [HttpTestingController],
-  (httpMock: HttpTestingController) => {
-    service.getSomething().subscribe((data) => {
-      expect(data).toEqual(mockData);
-    });
+```typescript
+it('should not upload when no upload link', () => {
+  currentFolderSignal.set({ links: {} } as FileFolderModel);
+  component.uploadFiles(file);
+  expect(mockFilesService.uploadFile).not.toHaveBeenCalled();
+});
+```
 
-    const req = httpMock.expectOne('/api/endpoint');
-    expect(req.request.method).toBe('GET');
-    req.flush(getMockDataFromTestingData());
+### File size limits
 
-    httpMock.verify(); // Verify no outstanding HTTP calls
-  }
-));
+```typescript
+it('should warn on oversized file', () => {
+  const oversizedFile = new File([''], 'big.bin');
+  Object.defineProperty(oversizedFile, 'size', { value: FILE_SIZE_LIMIT });
+  component.onFileSelected({ target: { files: [oversizedFile] } } as unknown as Event);
+  expect(toastService.showWarn).toHaveBeenCalledWith('shared.files.limitText');
+});
 ```
 
-### Key Rules
+### Deduplication
 
-- Use `OSFTestingModule` to isolate the service
-- Inject and use `HttpTestingController`
-- Always call `httpMock.expectOne()` to verify the URL and method
-- Always call `req.flush()` to simulate the backend response
-- Add `httpMock.verify()` in each `it` to catch unflushed requests
+```typescript
+it('should deduplicate file selection', () => {
+  const file = { id: 'file-1' } as FileModel;
+  component.onFileTreeSelected(file);
+  component.onFileTreeSelected(file);
+  expect(component.filesSelection).toEqual([file]);
+});
+```
+
+### Conditional dispatch based on state
+
+```typescript
+it('should not dispatch when submitting', () => {
+  const { store } = setup({
+    selectorOverrides: [
+      { selector: Selectors.isDraftSubmitting, value: true },
+      { selector: Selectors.getDraft, value: { ...DEFAULT_DRAFT, hasProject: true } },
+    ],
+  });
+  expect(store.dispatch).not.toHaveBeenCalledWith(expect.any(FetchProjectChildren));
+});
+```
 
 ---
 
-## Testing Angular Components
+## 14. Testing Angular Services (HTTP)
 
-- coming soon
+All services that make HTTP requests must be tested using `HttpClientTestingModule` and `HttpTestingController`. Only use data from `@testing/data` mocks when flushing requests — never hardcode response values inline.
 
----
+### Setup
 
-## Testing Angular Pipes
+```typescript
+import { HttpTestingController } from '@angular/common/http/testing';
+import { provideOSFCore, provideOSFHttp } from '@testing/osf.testing.provider';
 
-- coming soon
+let service: YourService;
 
----
+beforeEach(() => {
+  TestBed.configureTestingModule({
+    imports: [],
+    providers: [provideOSFCore(), provideOSFHttp(), YourService],
+  });
+  service = TestBed.inject(YourService);
+});
+```
 
-## Testing Angular Directives
+### Example test
 
-- coming soon
+```typescript
+it('should call correct endpoint and return expected data', () => {
+  const httpMock = TestBed.inject(HttpTestingController);
 
----
+  service.getSomething().subscribe((data) => {
+    expect(data).toEqual(mockData);
+  });
+
+  const req = httpMock.expectOne('/api/endpoint');
+  expect(req.request.method).toBe('GET');
+  req.flush(getMockDataFromTestingData());
 
-## NGXS State Testing Strategy
+  httpMock.verify();
+});
+```
 
-The OSF Angular strategy for NGXS state testing is to create **small integration test scenarios**. This is a deliberate departure from traditional **black box isolated** testing. The rationale is:
+### Key rules
 
-1. **NGXS actions** tested in isolation are difficult to mock and result in garbage-in/garbage-out tests.
-2. **NGXS selectors** tested in isolation are easy to mock but also lead to garbage-in/garbage-out outcomes.
-3. **NGXS states** tested in isolation are easy to invoke but provide no meaningful validation.
-4. **Mocking service calls** during state testing introduces false positives, since the mocked service responses may not reflect actual backend behavior.
+- Use `provideOSFCore() + provideOSFHttp()` to isolate the service
+- Always call `httpMock.expectOne()` to verify the URL and method
+- Always call `req.flush()` with data from `@testing/data` — never hardcode responses inline
+- Add `httpMock.verify()` at the end of each test to catch unflushed requests
+- Error handling paths must also be tested
 
-This approach favors realism and accuracy over artificial test isolation.
+---
 
-### Test Outline Strategy
+## 15. Testing NGXS State
 
-1. **Dispatch the primary action** – Kick off the state logic under test.
-2. **Dispatch any dependent actions** – Include any secondary actions that rely on the primary action's outcome.
-3. **Verify the loading selector is `true`** – Ensure the loading state is activated during the async flow.
-4. **Verify the service call using `HttpTestingController` and `@testing/data` mocks** – Confirm that the correct HTTP request is made and flushed with known mock data.
-5. **Verify the loading selector is `false`** – Ensure the loading state deactivates after the response is handled.
-6. **Verify the primary data selector** – Check that the core selector related to the dispatched action returns the expected state.
-7. **Verify any additional selectors** – Assert the output of other derived selectors relevant to the action.
-8. **Validate the test with `httpMock.verify()`** – Confirm that all HTTP requests were flushed and none remain unhandled:
+The OSF Angular strategy for NGXS state testing is to create **small integration test scenarios** rather than isolated unit tests. This is a deliberate design decision.
 
-```ts
-expect(httpMock.verify).toBeTruthy();
-```
+### Why integration testing for NGXS?
 
-### Example
+- Actions tested in isolation are hard to mock and produce garbage-in/garbage-out tests
+- Selectors tested in isolation are easy to mock but equally produce false positives
+- States tested in isolation are easy to invoke but provide no meaningful validation
+- Mocking service calls during state tests introduces false positives — mocked responses may not reflect actual backend behaviour
 
-This is an example of an NGXS action test that involves both a **primary action** and a **dependent action**. The dependency must be dispatched first to ensure the test environment mimics the actual runtime behavior. This pattern helps validate not only the action effects but also the full selector state after updates. All HTTP requests are flushed using the centralized `@testing/data` mocks.
+### Test outline — required steps
 
-```ts
-it('should test action, state and selectors', inject([HttpTestingController], (httpMock: HttpTestingController) => {
+1. **Dispatch the primary action** — kick off the state logic under test
+2. **Dispatch any dependent actions** — include secondary actions that rely on the primary action's outcome
+3. **Verify the loading selector is `true`** — ensure loading state activates during the async flow
+4. **Flush HTTP requests with `@testing/data` mocks** — confirm correct requests are made and flushed with known data
+5. **Verify the loading selector is `false`** — ensure loading deactivates after the response is handled
+6. **Verify the primary data selector** — check the core selector returns expected state
+7. **Verify additional selectors** — assert derived selectors relevant to the action
+8. **Call `httpMock.verify()`** — confirm no HTTP requests remain unhandled
+
+### Example
+
+```typescript
+it('should test action, state and selectors', () => {
+  const httpMock = TestBed.inject(HttpTestingController);
   let result: any[] = [];
-  // Dependency Action
+
+  // 1. Dispatch dependent action first
   store.dispatch(new GetAuthorizedStorageAddons('reference-id')).subscribe();
 
-  // Primary Action
+  // 2. Dispatch primary action
   store.dispatch(new GetAuthorizedStorageOauthToken('account-id')).subscribe(() => {
     result = store.selectSnapshot(AddonsSelectors.getAuthorizedStorageAddons);
   });
 
-  // Loading selector is true
+  // 3. Loading selector is true
   const loading = store.selectSignal(AddonsSelectors.getAuthorizedStorageAddonsLoading);
   expect(loading()).toBeTruthy();
 
-  // Http request for service for dependency action
-  let request = httpMock.expectOne('api/path/dependency/action');
-  expect(request.request.method).toBe('GET');
-  // @testing/data response mock
-  request.flush(getAddonsAuthorizedStorageData());
+  // 4a. Flush dependent action HTTP request
+  let req = httpMock.expectOne('api/path/dependency/action');
+  expect(req.request.method).toBe('GET');
+  req.flush(getAddonsAuthorizedStorageData());
 
-  // Http request for service for primary action
-  let request = httpMock.expectOne('api/path/primary/action');
-  expect(request.request.method).toBe('PATCH');
-  // @testing/data response mock with updates
+  // 4b. Flush primary action HTTP request
+  req = httpMock.expectOne('api/path/primary/action');
+  expect(req.request.method).toBe('PATCH');
   const addonWithToken = getAddonsAuthorizedStorageData(1);
   addonWithToken.data.attributes.oauth_token = 'ya2.34234324534';
-  request.flush(addonWithToken);
+  req.flush(addonWithToken);
 
-  // Full testing of the dependency selector
-  expect(result[1]).toEqual(
-    Object({
-      accountOwnerId: '0b441148-83e5-4f7f-b302-b07b528b160b',
-    })
-  );
+  // 5. Loading selector is false
+  expect(loading()).toBeFalsy();
 
-  // Full testing of the primary selector
-  let oauthToken = store.selectSnapshot(AddonsSelectors.getAuthorizedStorageAddonOauthToken(result[0].id));
+  // 6. Primary selector — verify only the targeted record was updated
+  const oauthToken = store.selectSnapshot(AddonsSelectors.getAuthorizedStorageAddonOauthToken(result[0].id));
   expect(oauthToken).toBe('ya29.A0AS3H6NzDCKgrUx');
 
-  // Verify only the requested `account-id` was updated
-  oauthToken = store.selectSnapshot(AddonsSelectors.getAuthorizedStorageAddonOauthToken(result[1].id));
-  expect(oauthToken).toBe(result[1].oauthToken);
+  // 7. Other selector — verify untargeted record is unchanged
+  const otherToken = store.selectSnapshot(AddonsSelectors.getAuthorizedStorageAddonOauthToken(result[1].id));
+  expect(otherToken).toBe(result[1].oauthToken);
 
-  // Loading selector is false
-  expect(loading()).toBeFalsy();
-
-  // httpMock.verify to ensure no other api calls are called.
-  expect(httpMock.verify).toBeTruthy();
-}));
+  // 8. No outstanding requests
+  httpMock.verify();
+});
 ```
 
 ---
+
+## 16. Test Data
+
+Test data lives in two directories under `src/testing/`. Always use these — never hardcode response values inline in tests.
+
+### `testing/mocks/` — domain model mocks (89+ files)
+
+Pre-built mock objects for domain models used directly in component tests. Imported via `@testing/mocks/*`.
+
+| File                         | Purpose                                        |
+| ---------------------------- | ---------------------------------------------- |
+| `registries.mock.ts`         | `MOCK_DRAFT_REGISTRATION`, `MOCK_PAGES_SCHEMA` |
+| `draft-registration.mock.ts` | `MOCK_DRAFT_REGISTRATION` with full shape      |
+| `schema-response.mock.ts`    | Schema response fixtures                       |
+| `contributors.mock.ts`       | Contributor model mocks                        |
+| `project.mock.ts`            | Project model mocks                            |
+
+### `testing/data/` — JSON API response fixtures
+
+Centralised raw JSON API responses used for HTTP flush in service and state integration tests. Imported via `@testing/data/*`.
+
+| File                                  | Purpose                           |
+| ------------------------------------- | --------------------------------- |
+| `addons.authorized-storage.data.ts`   | Authorised storage addon fixtures |
+| `addons.external-storage.data.ts`     | External storage addon fixtures   |
+| `addons.configured.data.ts`           | Configured addon state fixtures   |
+| `addons.operation-invocation.data.ts` | Operation invocation fixtures     |
+
+### Why centralised test data matters
+
+- Any change to an underlying data model produces cascading test failures, exposing the full scope of a refactor
+- Hardcoded inline values lead to false positives and missed regressions
+- Consistent data across tests makes selector and state assertions directly comparable
+
+### Data structure principles
+
+1. Include enough data to cover all relevant permutations required by the test suite
+2. Ensure data reflects all possible states of the model
+
+---
+
+## 17. Coverage Enforcement
+
+This project strictly enforces 90%+ test coverage through GitHub Actions CI.
+
+### Coverage requirements
+
+| File type     | Requirement        | Notes                                      |
+| ------------- | ------------------ | ------------------------------------------ |
+| `*.ts`        | 90%+ line & branch | Zero exceptions                            |
+| Services      | 90%+               | Must mock HTTP via `HttpTestingController` |
+| Components    | 90%+               | DOM + Input + Output event coverage        |
+| Pipes / utils | 90%+               | All edge cases tested                      |
+| NGXS state    | 90%+               | Integration test approach required         |
+
+### Enforcement pipeline
+
+- **GitHub Actions CI:** runs on every PR and push — build fails if a single uncovered branch, line, or function exists
+
+> **Tip:** Use `npm run test:watch` during development to maintain coverage incrementally rather than discovering gaps at push time.
+
+---
+
+## 18. Best Practices
+
+1. **Always use `provideOSFCore()`** — never import `OSFTestingModule` directly in new tests.
+2. **Always use `provideMockStore()`** — never mock `component.actions` via `Object.defineProperty`.
+3. **Always pass explicit mocks to `MockProvider`** when you need `jest.fn()` assertions. Bare `MockProvider(Service)` creates ng-mocks stubs.
+4. **Check `@testing/` before creating inline mocks** — builders and factories almost certainly exist.
+5. **Prefer a single flat `describe` block** per file to keep tests searchable and prevent state leakage. Use nested `describe` blocks when it significantly simplifies setup or groups logically distinct behaviors. No `afterEach`.
+6. **No redundant tests** — merge tests that cover the same code path.
+7. **Use `(store.dispatch as jest.Mock).mockClear()`** when `ngOnInit` dispatches and you need isolated per-test assertions.
+8. **Use `WritableSignal` for dynamic state** — pass `signal()` values to `provideMockStore` when tests need to mutate state mid-test.
+9. **Use `Subject` for dialog `onClose`** — gives explicit control over dialog result timing. Use `provideDynamicDialogRefMock()` where applicable.
+10. **Use `fakeAsync` + `tick`** for debounced operations — specify the exact debounce duration.
+11. **Use `fixture.componentRef.setInput()`** for signal inputs — never direct property assignment.
+12. **Use `ngMocks.faster()`** when all tests in a file share identical `TestBed` config — reuses the compiled module for speed. Do not use if any test requires a different config: shared state will cause subtle test pollution.
+13. **Use typed mock interfaces** (`ToastServiceMockType`, `RouterMockType`, etc.) — avoid `any`.
+14. **Test both positive and negative paths** — confirm an action fires AND confirm it does not fire when conditions are not met.
+15. **Only use `@testing/data` fixtures in HTTP flushes** — never hardcode response values inline in service or state tests.
+16. **Each test should highlight the most critical aspect of the code** — if a test fails during a refactor, it should clearly signal that a core feature was impacted.
+
+---
+
+## Appendix: Assertion Patterns
+
+### Action dispatch
+
+```typescript
+expect(store.dispatch).toHaveBeenCalledWith(new MyAction('id'));
+expect(store.dispatch).not.toHaveBeenCalledWith(expect.any(MyAction));
+expect(store.dispatch).toHaveBeenCalledWith(new UpdateDraft('draft-1', expect.objectContaining({ title: 'Changed' })));
+```
+
+### Router navigation
+
+```typescript
+expect(mockRouter.navigate).toHaveBeenCalledWith(['../1'], expect.objectContaining({ relativeTo: expect.anything() }));
+expect(mockRouter.navigateByUrl).toHaveBeenCalledWith('/target');
+```
+
+### Dialog open calls
+
+```typescript
+expect(mockDialog.open).toHaveBeenCalled();
+const callArgs = (mockDialog.open as jest.Mock).mock.calls[0];
+expect(callArgs[1].header).toBe('expected.title');
+expect(callArgs[1].data.draftId).toBe('draft-1');
+```
+
+### Filtering dispatch calls by action type
+
+```typescript
+const calls = (store.dispatch as jest.Mock).mock.calls.filter(([a]: [any]) => a instanceof GetProjects);
+expect(calls.length).toBe(1);
+expect(calls[0][0]).toEqual(new GetProjects('user-1', 'abc'));
+```
diff --git a/jest.config.js b/jest.config.js
index a59db139c..ff42f9ea5 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -54,10 +54,10 @@ module.exports = {
   extensionsToTreatAsEsm: ['.ts'],
   coverageThreshold: {
     global: {
-      branches: 34.8,
-      functions: 38.0,
-      lines: 65.5,
-      statements: 66.0,
+      branches: 39.5,
+      functions: 41.1,
+      lines: 68.0,
+      statements: 68.4,
     },
   },
   watchPathIgnorePatterns: [
diff --git a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.html b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.html
index 9f8a88dc4..5ca0e95f2 100644
--- a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.html
+++ b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.html
@@ -7,13 +7,12 @@
     @let resourceType = currentResource()?.type;
     @let iconName = resourceType === 'analytic_code' ? 'code' : resourceType;
     @let icon = `custom-icon-${iconName} icon-resource-size`;
-    @let resourceName = resourceType === RegistryResourceType.Code ? 'Analytic Code' : resourceType;
 
     <div class="flex align-content-end gap-3 content">
       <osf-icon class="align-self-start" [iconClass]="icon"></osf-icon>
       <div class="flex flex-column gap-3 mt-1">
         <div class="flex flex-column gap-2">
-          <h2>{{ resourceName }}</h2>
+          <h2>{{ resourceTypeTranslationKey() | translate }}</h2>
           <a class="font-bold" [href]="doiLink()" target="_blank" rel="noopener noreferrer">
             {{ doiLink() }}
           </a>
diff --git a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.spec.ts b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.spec.ts
index b934deae5..8ad13dace 100644
--- a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.spec.ts
+++ b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.spec.ts
@@ -1,89 +1,92 @@
 import { Store } from '@ngxs/store';
 
-import { MockComponent, MockProvider } from 'ng-mocks';
+import { MockComponents, MockProvider } from 'ng-mocks';
 
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { signal } from '@angular/core';
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { IconComponent } from '@osf/shared/components/icon/icon.component';
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
+import { RegistryResourceType } from '@osf/shared/enums/registry-resource.enum';
 
+import { RegistryResource } from '../../models';
 import { RegistryResourcesSelectors } from '../../store/registry-resources';
 import { ResourceFormComponent } from '../resource-form/resource-form.component';
 
 import { AddResourceDialogComponent } from './add-resource-dialog.component';
 
-import { DynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
-import { TranslateServiceMock } from '@testing/mocks/translate.service.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
+import { provideDynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { mergeSignalOverrides, provideMockStore, SignalOverride } from '@testing/providers/store-provider.mock';
+
+const MOCK_RESOURCE: RegistryResource = {
+  id: 'res-1',
+  description: 'Test',
+  finalized: false,
+  type: RegistryResourceType.Data,
+  pid: '10.1234/test',
+};
+
+interface SetupOverrides {
+  registryId?: string;
+  selectorOverrides?: SignalOverride[];
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const mockDialogConfig = { data: { id: overrides.registryId ?? 'registry-123' } };
+
+  const defaultSignals = [
+    { selector: RegistryResourcesSelectors.getCurrentResource, value: null },
+    { selector: RegistryResourcesSelectors.isCurrentResourceLoading, value: false },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [
+      AddResourceDialogComponent,
+      ...MockComponents(LoadingSpinnerComponent, ResourceFormComponent, IconComponent),
+    ],
+    providers: [
+      provideOSFCore(),
+      provideDynamicDialogRefMock(),
+      MockProvider(DynamicDialogConfig, mockDialogConfig),
+      provideMockStore({ signals }),
+    ],
+  });
+
+  const store = TestBed.inject(Store);
+  const dialogRef = TestBed.inject(DynamicDialogRef);
+  const fixture = TestBed.createComponent(AddResourceDialogComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
+
+  return { fixture, component, store, dialogRef };
+}
 
 describe('AddResourceDialogComponent', () => {
-  let component: AddResourceDialogComponent;
-  let fixture: ComponentFixture<AddResourceDialogComponent>;
-  let store: Store;
-  let dialogRef: jest.Mocked<DynamicDialogRef>;
-  let mockDialogConfig: jest.Mocked<DynamicDialogConfig>;
-
-  const mockRegistryId = 'registry-123';
-
-  beforeEach(async () => {
-    mockDialogConfig = {
-      data: {
-        id: mockRegistryId,
-      },
-    } as jest.Mocked<DynamicDialogConfig>;
-
-    await TestBed.configureTestingModule({
-      imports: [
-        AddResourceDialogComponent,
-        OSFTestingModule,
-        MockComponent(LoadingSpinnerComponent),
-        MockComponent(ResourceFormComponent),
-        MockComponent(IconComponent),
-      ],
-      providers: [
-        DynamicDialogRefMock,
-        TranslateServiceMock,
-        MockProvider(DynamicDialogConfig, mockDialogConfig),
-        provideMockStore({
-          signals: [
-            { selector: RegistryResourcesSelectors.getCurrentResource, value: signal(null) },
-            { selector: RegistryResourcesSelectors.isCurrentResourceLoading, value: signal(false) },
-          ],
-        }),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(AddResourceDialogComponent);
-    component = fixture.componentInstance;
-    store = TestBed.inject(Store);
-    dialogRef = TestBed.inject(DynamicDialogRef) as jest.Mocked<DynamicDialogRef>;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
+  it('should create with default values', () => {
+    const { component } = setup();
 
-  it('should initialize with default values', () => {
+    expect(component).toBeTruthy();
     expect(component.doiDomain).toBe('https://doi.org/');
-    expect(component.inputLimits).toBeDefined();
     expect(component.isResourceConfirming()).toBe(false);
     expect(component.isPreviewMode()).toBe(false);
-    expect(component.resourceOptions()).toBeDefined();
   });
 
   it('should initialize form with empty values', () => {
+    const { component } = setup();
+
     expect(component.form.get('pid')?.value).toBe('');
     expect(component.form.get('resourceType')?.value).toBe('');
     expect(component.form.get('description')?.value).toBe('');
   });
 
   it('should validate pid with DOI validator', () => {
+    const { component } = setup();
     const pidControl = component.form.get('pid');
+
     pidControl?.setValue('invalid-doi');
     pidControl?.updateValueAndValidity();
 
@@ -92,53 +95,130 @@ describe('AddResourceDialogComponent', () => {
   });
 
   it('should accept valid DOI format', () => {
+    const { component } = setup();
     const pidControl = component.form.get('pid');
+
     pidControl?.setValue('10.1234/valid.doi');
 
     expect(pidControl?.hasError('doi')).toBe(false);
   });
 
   it('should not preview resource when form is invalid', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch');
-    component.form.get('pid')?.setValue('');
+    const { component, store } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.previewResource();
+
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(component.isPreviewMode()).toBe(false);
+  });
+
+  it('should not preview resource when currentResource is null', () => {
+    const { component, store } = setup();
 
+    component.form.patchValue({ pid: '10.1234/test', resourceType: 'data' });
+    (store.dispatch as jest.Mock).mockClear();
     component.previewResource();
 
-    expect(dispatchSpy).not.toHaveBeenCalled();
+    expect(store.dispatch).not.toHaveBeenCalled();
     expect(component.isPreviewMode()).toBe(false);
   });
 
-  it('should throw error when previewing resource without current resource', () => {
-    component.form.patchValue({
-      pid: '10.1234/test',
-      resourceType: 'dataset',
+  it('should preview resource and set preview mode on success', () => {
+    const { component, store } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: MOCK_RESOURCE }],
     });
 
-    expect(() => component.previewResource()).toThrow();
+    component.form.patchValue({ pid: '10.1234/test', resourceType: 'data', description: 'desc' });
+    (store.dispatch as jest.Mock).mockClear();
+    component.previewResource();
+
+    expect(store.dispatch).toHaveBeenCalled();
+    expect(component.isPreviewMode()).toBe(true);
   });
 
   it('should set isPreviewMode to false when backToEdit is called', () => {
-    component.isPreviewMode.set(true);
+    const { component } = setup();
 
+    component.isPreviewMode.set(true);
     component.backToEdit();
 
     expect(component.isPreviewMode()).toBe(false);
   });
 
-  it('should throw error when adding resource without current resource', () => {
-    expect(() => component.onAddResource()).toThrow();
+  it('should not add resource when currentResource is null', () => {
+    const { component, store, dialogRef } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.onAddResource();
+
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(dialogRef.close).not.toHaveBeenCalled();
   });
 
-  it('should close dialog without deleting when closeDialog is called without current resource', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch');
+  it('should confirm add resource and close dialog on success', () => {
+    const { component, store, dialogRef } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: MOCK_RESOURCE }],
+    });
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.onAddResource();
 
+    expect(component.isResourceConfirming()).toBe(false);
+    expect(store.dispatch).toHaveBeenCalled();
+    expect(dialogRef.close).toHaveBeenCalledWith(true);
+  });
+
+  it('should close dialog without deleting when currentResource is null', () => {
+    const { component, store, dialogRef } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.closeDialog();
+
+    expect(dialogRef.close).toHaveBeenCalled();
+    expect(store.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should delete resource and close dialog when currentResource exists', () => {
+    const { component, store, dialogRef } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: MOCK_RESOURCE }],
+    });
+
+    (store.dispatch as jest.Mock).mockClear();
     component.closeDialog();
 
+    expect(store.dispatch).toHaveBeenCalled();
     expect(dialogRef.close).toHaveBeenCalled();
-    expect(dispatchSpy).not.toHaveBeenCalled();
   });
 
-  it('should compute doiLink as undefined when current resource does not exist', () => {
-    expect(component.doiLink()).toBe('https://doi.org/undefined');
+  it('should compute doiLink from currentResource pid', () => {
+    const { component } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: MOCK_RESOURCE }],
+    });
+
+    expect(component.doiLink()).toBe('https://doi.org/10.1234/test');
+  });
+
+  it('should return empty string for resourceTypeTranslationKey when currentResource is null', () => {
+    const { component } = setup();
+
+    expect(component.resourceTypeTranslationKey()).toBe('');
+  });
+
+  it('should return translation key for resourceTypeTranslationKey when resource type matches', () => {
+    const { component } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: MOCK_RESOURCE }],
+    });
+
+    expect(component.resourceTypeTranslationKey()).toBe('resources.typeOptions.data');
+  });
+
+  it('should return empty string for resourceTypeTranslationKey when type is unknown', () => {
+    const unknownResource = { ...MOCK_RESOURCE, type: 'unknown_type' as RegistryResourceType };
+    const { component } = setup({
+      selectorOverrides: [{ selector: RegistryResourcesSelectors.getCurrentResource, value: unknownResource }],
+    });
+
+    expect(component.resourceTypeTranslationKey()).toBe('');
   });
 });
diff --git a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.ts b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.ts
index 814a8cdf8..7d69a244a 100644
--- a/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.ts
+++ b/src/app/features/registry/components/add-resource-dialog/add-resource-dialog.component.ts
@@ -1,11 +1,11 @@
 import { createDispatchMap, select } from '@ngxs/store';
 
-import { TranslatePipe, TranslateService } from '@ngx-translate/core';
+import { TranslatePipe } from '@ngx-translate/core';
 
 import { Button } from 'primeng/button';
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { finalize, take } from 'rxjs';
+import { finalize } from 'rxjs';
 
 import { ChangeDetectionStrategy, Component, computed, inject, signal } from '@angular/core';
 import { FormControl, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
@@ -38,7 +38,6 @@ export class AddResourceDialogComponent {
   readonly dialogRef = inject(DynamicDialogRef);
   readonly currentResource = select(RegistryResourcesSelectors.getCurrentResource);
   readonly isCurrentResourceLoading = select(RegistryResourcesSelectors.isCurrentResourceLoading);
-  private readonly translateService = inject(TranslateService);
 
   private dialogConfig = inject(DynamicDialogConfig);
   private registryId: string = this.dialogConfig.data.id;
@@ -61,11 +60,20 @@ export class AddResourceDialogComponent {
     deleteResource: SilentDelete,
   });
 
-  public resourceOptions = signal<SelectOption[]>(resourceTypeOptions);
-  public isPreviewMode = signal<boolean>(false);
+  resourceOptions = signal<SelectOption[]>(resourceTypeOptions);
+  isPreviewMode = signal<boolean>(false);
 
   readonly RegistryResourceType = RegistryResourceType;
 
+  readonly resourceTypeTranslationKey = computed(() => {
+    const type = this.currentResource()?.type;
+    const options = this.resourceOptions();
+
+    if (!type || !options.length) return '';
+
+    return options.find((opt) => opt.value === type)?.label ?? '';
+  });
+
   previewResource(): void {
     if (this.form.invalid) {
       return;
@@ -79,7 +87,7 @@ export class AddResourceDialogComponent {
 
     const currentResource = this.currentResource();
     if (!currentResource) {
-      throw new Error(this.translateService.instant('resources.errors.noCurrentResource'));
+      return;
     }
 
     this.actions.previewResource(currentResource.id, addResource).subscribe(() => this.isPreviewMode.set(true));
@@ -94,28 +102,23 @@ export class AddResourceDialogComponent {
     const currentResource = this.currentResource();
 
     if (!currentResource) {
-      throw new Error(this.translateService.instant('resources.errors.noRegistryId'));
+      return;
     }
 
     this.isResourceConfirming.set(true);
     this.actions
       .confirmAddResource(addResource, currentResource.id, this.registryId)
-      .pipe(
-        take(1),
-        finalize(() => {
-          this.dialogRef.close(true);
-          this.isResourceConfirming.set(false);
-        })
-      )
-      .subscribe({});
+      .pipe(finalize(() => this.isResourceConfirming.set(false)))
+      .subscribe(() => this.dialogRef.close(true));
   }
 
   closeDialog(): void {
-    this.dialogRef.close();
     const currentResource = this.currentResource();
 
     if (currentResource) {
       this.actions.deleteResource(currentResource.id);
     }
+
+    this.dialogRef.close();
   }
 }
diff --git a/src/app/features/registry/components/archiving-message/archiving-message.component.spec.ts b/src/app/features/registry/components/archiving-message/archiving-message.component.spec.ts
index 6cf0e635c..5afea533d 100644
--- a/src/app/features/registry/components/archiving-message/archiving-message.component.spec.ts
+++ b/src/app/features/registry/components/archiving-message/archiving-message.component.spec.ts
@@ -1,106 +1,38 @@
 import { MockComponents } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { ENVIRONMENT } from '@core/provider/environment.provider';
-import { IconComponent } from '@osf/shared/components/icon/icon.component';
-import { RegistryStatus } from '@osf/shared/enums/registry-status.enum';
 
-import { RegistrationOverviewModel } from '../../models';
 import { ShortRegistrationInfoComponent } from '../short-registration-info/short-registration-info.component';
 
 import { ArchivingMessageComponent } from './archiving-message.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 
 describe('ArchivingMessageComponent', () => {
-  let component: ArchivingMessageComponent;
-  let fixture: ComponentFixture<ArchivingMessageComponent>;
-  let environment: any;
-
-  const mockRegistration: RegistrationOverviewModel = MOCK_REGISTRATION_OVERVIEW_MODEL;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [
-        ArchivingMessageComponent,
-        OSFTestingModule,
-        ...MockComponents(IconComponent, ShortRegistrationInfoComponent),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(ArchivingMessageComponent);
-    component = fixture.componentInstance;
-    environment = TestBed.inject(ENVIRONMENT);
-
-    fixture.componentRef.setInput('registration', mockRegistration);
-    fixture.detectChanges();
-  });
-
-  it('should have support email from environment', () => {
-    expect(component.supportEmail).toBeDefined();
-    expect(typeof component.supportEmail).toBe('string');
-    expect(component.supportEmail).toBe(environment.supportEmail);
-  });
-
-  it('should receive registration input', () => {
-    expect(component.registration()).toEqual(mockRegistration);
-  });
-
-  it('should have registration as a required input', () => {
-    expect(component.registration()).toBeDefined();
-    expect(component.registration()).toEqual(mockRegistration);
-  });
-
-  it('should handle different registration statuses', () => {
-    const statuses = [
-      RegistryStatus.Accepted,
-      RegistryStatus.Pending,
-      RegistryStatus.Withdrawn,
-      RegistryStatus.Embargo,
-    ];
-
-    statuses.forEach((status) => {
-      const registrationWithStatus = { ...mockRegistration, status };
-      fixture.componentRef.setInput('registration', registrationWithStatus);
-      fixture.detectChanges();
-
-      expect(component.registration().status).toBe(status);
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [ArchivingMessageComponent, ...MockComponents(ShortRegistrationInfoComponent)],
+      providers: [provideOSFCore()],
     });
   });
 
-  it('should be reactive to registration input changes', () => {
-    const updatedRegistration = { ...mockRegistration, title: 'Updated Title' };
-
-    fixture.componentRef.setInput('registration', updatedRegistration);
+  it('should create and receive registration input', () => {
+    const fixture = TestBed.createComponent(ArchivingMessageComponent);
+    fixture.componentRef.setInput('registration', MOCK_REGISTRATION_OVERVIEW_MODEL);
     fixture.detectChanges();
 
-    expect(component.registration().title).toBe('Updated Title');
+    expect(fixture.componentInstance).toBeTruthy();
+    expect(fixture.componentInstance.registration()).toEqual(MOCK_REGISTRATION_OVERVIEW_MODEL);
   });
 
-  it('should update when registration properties change', () => {
-    const updatedRegistration = {
-      ...mockRegistration,
-      title: 'New Title',
-      description: 'New Description',
-    };
-
-    fixture.componentRef.setInput('registration', updatedRegistration);
-    fixture.detectChanges();
-
-    expect(component.registration().title).toBe('New Title');
-    expect(component.registration().description).toBe('New Description');
-  });
-
-  it('should maintain supportEmail reference when registration changes', () => {
-    const initialSupportEmail = component.supportEmail;
-    const updatedRegistration = { ...mockRegistration, title: 'Different Title' };
-
-    fixture.componentRef.setInput('registration', updatedRegistration);
+  it('should have supportEmail from environment', () => {
+    const fixture = TestBed.createComponent(ArchivingMessageComponent);
+    fixture.componentRef.setInput('registration', MOCK_REGISTRATION_OVERVIEW_MODEL);
     fixture.detectChanges();
 
-    expect(component.supportEmail).toBe(initialSupportEmail);
-    expect(component.supportEmail).toBe(environment.supportEmail);
+    expect(fixture.componentInstance.supportEmail).toBe(TestBed.inject(ENVIRONMENT).supportEmail);
   });
 });
diff --git a/src/app/features/registry/components/archiving-message/archiving-message.component.ts b/src/app/features/registry/components/archiving-message/archiving-message.component.ts
index 3525ed5aa..bf66ce905 100644
--- a/src/app/features/registry/components/archiving-message/archiving-message.component.ts
+++ b/src/app/features/registry/components/archiving-message/archiving-message.component.ts
@@ -13,7 +13,7 @@ import { ShortRegistrationInfoComponent } from '../short-registration-info/short
 
 @Component({
   selector: 'osf-archiving-message',
-  imports: [TranslatePipe, Card, IconComponent, Divider, ShortRegistrationInfoComponent],
+  imports: [Card, Divider, IconComponent, ShortRegistrationInfoComponent, TranslatePipe],
   templateUrl: './archiving-message.component.html',
   styleUrl: './archiving-message.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
diff --git a/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.spec.ts b/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.spec.ts
index c4f9447ff..e334b961c 100644
--- a/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.spec.ts
+++ b/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.spec.ts
@@ -2,11 +2,11 @@ import { Store } from '@ngxs/store';
 
 import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { of } from 'rxjs';
+import { of, throwError } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
 import { RegistryResourceType } from '@osf/shared/enums/registry-resource.enum';
@@ -17,168 +17,94 @@ import { ResourceFormComponent } from '../resource-form/resource-form.component'
 
 import { EditResourceDialogComponent } from './edit-resource-dialog.component';
 
-import { DynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideDynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
+const MOCK_RESOURCE: RegistryResource = {
+  id: 'resource-123',
+  pid: '10.1234/test.doi',
+  type: RegistryResourceType.Data,
+  description: 'Test resource description',
+  finalized: false,
+};
+
 describe('EditResourceDialogComponent', () => {
-  let component: EditResourceDialogComponent;
-  let fixture: ComponentFixture<EditResourceDialogComponent>;
-  let store: Store;
-  let mockDialogConfig: jest.Mocked<DynamicDialogConfig>;
-
-  const mockRegistryId = 'registry-123';
-  const mockResource: RegistryResource = {
-    id: 'resource-123',
-    pid: '10.1234/test.doi',
-    type: RegistryResourceType.Data,
-    description: 'Test resource description',
-    finalized: false,
-  };
-
-  beforeEach(async () => {
-    mockDialogConfig = {
-      data: {
-        id: mockRegistryId,
-        resource: mockResource,
-      },
-    } as jest.Mocked<DynamicDialogConfig>;
-
-    await TestBed.configureTestingModule({
-      imports: [
-        EditResourceDialogComponent,
-        OSFTestingModule,
-        ...MockComponents(LoadingSpinnerComponent, ResourceFormComponent),
-      ],
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [EditResourceDialogComponent, ...MockComponents(LoadingSpinnerComponent, ResourceFormComponent)],
       providers: [
-        DynamicDialogRefMock,
-        MockProvider(DynamicDialogConfig, mockDialogConfig),
+        provideOSFCore(),
+        provideDynamicDialogRefMock(),
+        MockProvider(DynamicDialogConfig, { data: { id: 'registry-123', resource: MOCK_RESOURCE } }),
         provideMockStore({
           signals: [{ selector: RegistryResourcesSelectors.isCurrentResourceLoading, value: false }],
         }),
       ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(EditResourceDialogComponent);
-    component = fixture.componentInstance;
-    store = TestBed.inject(Store);
-    fixture.detectChanges();
+    });
   });
 
   it('should initialize form with resource data', () => {
-    expect(component.form.get('pid')?.value).toBe(mockResource.pid);
-    expect(component.form.get('resourceType')?.value).toBe(mockResource.type);
-    expect(component.form.get('description')?.value).toBe(mockResource.description);
-  });
-
-  it('should have required validators on pid and resourceType', () => {
-    const pidControl = component.form.get('pid');
-    const resourceTypeControl = component.form.get('resourceType');
-
-    expect(pidControl?.hasError('required')).toBe(false);
-    expect(resourceTypeControl?.hasError('required')).toBe(false);
-  });
-
-  it('should validate pid with DOI validator when invalid format', () => {
-    const pidControl = component.form.get('pid');
-    pidControl?.setValue('invalid-doi');
-    pidControl?.updateValueAndValidity();
-
-    const hasDoiError = pidControl?.hasError('doi') || pidControl?.hasError('invalidDoi');
-    expect(hasDoiError).toBe(true);
-  });
-
-  it('should accept valid DOI format', () => {
-    const pidControl = component.form.get('pid');
-    pidControl?.setValue('10.1234/valid.doi');
+    const fixture = TestBed.createComponent(EditResourceDialogComponent);
+    fixture.detectChanges();
 
-    expect(pidControl?.hasError('doi')).toBe(false);
+    expect(fixture.componentInstance.form.value).toEqual({
+      pid: MOCK_RESOURCE.pid,
+      resourceType: MOCK_RESOURCE.type,
+      description: MOCK_RESOURCE.description,
+    });
   });
 
-  it('should mark form as invalid when pid is empty', () => {
-    component.form.get('pid')?.setValue('');
-    component.form.get('pid')?.markAsTouched();
-
-    expect(component.form.invalid).toBe(true);
-  });
+  it('should not dispatch when form is invalid', () => {
+    const fixture = TestBed.createComponent(EditResourceDialogComponent);
+    fixture.detectChanges();
+    const store = TestBed.inject(Store);
+    const dispatchSpy = jest.spyOn(store, 'dispatch');
 
-  it('should mark form as invalid when resourceType is empty', () => {
-    component.form.get('resourceType')?.setValue('');
-    component.form.get('resourceType')?.markAsTouched();
+    fixture.componentInstance.form.get('pid')?.setValue('');
+    fixture.componentInstance.save();
 
-    expect(component.form.invalid).toBe(true);
+    expect(dispatchSpy).not.toHaveBeenCalled();
   });
 
-  it('should mark form as valid when all required fields are filled with valid values', () => {
-    component.form.patchValue({
-      pid: '10.1234/test',
-      resourceType: 'dataset',
-      description: 'Test description',
-    });
-
-    expect(component.form.valid).toBe(true);
-  });
+  it('should dispatch UpdateResource and close dialog on success', () => {
+    const fixture = TestBed.createComponent(EditResourceDialogComponent);
+    fixture.detectChanges();
+    const store = TestBed.inject(Store);
+    const dialogRef = TestBed.inject(DynamicDialogRef);
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
-  it('should dispatch UpdateResource action with correct parameters when form is valid', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch').mockReturnValue(of());
-    component.form.patchValue({
+    fixture.componentInstance.form.patchValue({
       pid: '10.1234/updated',
       resourceType: 'paper',
       description: 'Updated description',
     });
+    fixture.componentInstance.save();
 
-    component.save();
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
+    expect(store.dispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        registryId: mockRegistryId,
-        resourceId: mockResource.id,
-        resource: expect.objectContaining({
-          pid: '10.1234/updated',
-          resource_type: 'paper',
-          description: 'Updated description',
-        }),
+        registryId: 'registry-123',
+        resourceId: MOCK_RESOURCE.id,
+        resource: { pid: '10.1234/updated', resource_type: 'paper', description: 'Updated description' },
       })
     );
+    expect(dialogRef.close).toHaveBeenCalledWith(true);
   });
 
-  it('should handle empty description', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch').mockReturnValue(of());
-    component.form.patchValue({
-      pid: '10.1234/test',
-      resourceType: 'dataset',
-      description: '',
-    });
-
-    component.save();
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resource: expect.objectContaining({
-          description: '',
-        }),
-      })
-    );
-  });
+  it('should not close dialog on dispatch error', () => {
+    const fixture = TestBed.createComponent(EditResourceDialogComponent);
+    fixture.detectChanges();
+    const store = TestBed.inject(Store);
+    const dialogRef = TestBed.inject(DynamicDialogRef);
+    jest.spyOn(store, 'dispatch').mockReturnValue(throwError(() => new Error('fail')));
 
-  it('should handle null form values by converting to empty strings', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch').mockReturnValue(of());
-    component.form.patchValue({
-      pid: '10.1234/test',
-      resourceType: 'dataset',
-      description: null,
+    fixture.componentInstance.form.patchValue({
+      pid: '10.1234/updated',
+      resourceType: 'paper',
+      description: '',
     });
+    fixture.componentInstance.save();
 
-    component.save();
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resource: expect.objectContaining({
-          pid: '10.1234/test',
-          resource_type: 'dataset',
-          description: '',
-        }),
-      })
-    );
+    expect(dialogRef.close).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.ts b/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.ts
index a6e84c692..247da58b1 100644
--- a/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.ts
+++ b/src/app/features/registry/components/edit-resource-dialog/edit-resource-dialog.component.ts
@@ -2,8 +2,6 @@ import { createDispatchMap, select } from '@ngxs/store';
 
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { finalize, take } from 'rxjs';
-
 import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
 import { FormControl, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
 
@@ -16,7 +14,7 @@ import { ResourceFormComponent } from '../resource-form/resource-form.component'
 
 @Component({
   selector: 'osf-edit-resource-dialog',
-  imports: [LoadingSpinnerComponent, ReactiveFormsModule, ResourceFormComponent],
+  imports: [ReactiveFormsModule, LoadingSpinnerComponent, ResourceFormComponent],
   templateUrl: './edit-resource-dialog.component.html',
   styleUrl: './edit-resource-dialog.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
@@ -25,7 +23,7 @@ export class EditResourceDialogComponent {
   readonly dialogRef = inject(DynamicDialogRef);
   readonly isCurrentResourceLoading = select(RegistryResourcesSelectors.isCurrentResourceLoading);
 
-  private dialogConfig = inject(DynamicDialogConfig);
+  private readonly dialogConfig = inject(DynamicDialogConfig);
   private registryId: string = this.dialogConfig.data.id;
   private resource: RegistryResource = this.dialogConfig.data.resource as RegistryResource;
 
@@ -58,12 +56,6 @@ export class EditResourceDialogComponent {
 
     this.actions
       .updateResource(this.registryId, this.resource.id, addResource)
-      .pipe(
-        take(1),
-        finalize(() => {
-          this.dialogRef.close(true);
-        })
-      )
-      .subscribe();
+      .subscribe(() => this.dialogRef.close(true));
   }
 }
diff --git a/src/app/features/registry/components/registration-links-card/registration-links-card.component.html b/src/app/features/registry/components/registration-links-card/registration-links-card.component.html
index 612052d22..6e2f582b3 100644
--- a/src/app/features/registry/components/registration-links-card/registration-links-card.component.html
+++ b/src/app/features/registry/components/registration-links-card/registration-links-card.component.html
@@ -9,7 +9,7 @@
           styleClass="text-lg"
           link
           [label]="registrationData().title || 'project.registrations.card.noTitle' | translate"
-          (click)="reviewEmitRegistrationData.emit(registrationData()!.id)"
+          (onClick)="reviewEmitRegistrationData.emit(registrationData()!.id)"
         ></p-button>
       </div>
       <div class="flex flex-wrap flex-column lg:flex-nowrap lg:flex-row justify-content-between gap-5">
@@ -82,17 +82,13 @@
             <p-button
               severity="primary"
               [label]="'common.buttons.view' | translate"
-              (click)="reviewEmitRegistrationData.emit(registrationData()!.id)"
+              (onClick)="reviewEmitRegistrationData.emit(registrationData()!.id)"
             ></p-button>
 
-            @if (
-              registrationDataTyped() &&
-              registrationDataTyped()?.currentUserPermissions &&
-              registrationDataTyped()!.currentUserPermissions.length > 1
-            ) {
+            @if (hasWriteAccess()) {
               <p-button
                 severity="secondary"
-                (click)="updateEmitRegistrationData.emit(registrationData().id)"
+                (onClick)="updateEmitRegistrationData.emit(registrationData().id)"
                 [label]="'common.buttons.update' | translate"
               ></p-button>
             }
diff --git a/src/app/features/registry/components/registration-links-card/registration-links-card.component.spec.ts b/src/app/features/registry/components/registration-links-card/registration-links-card.component.spec.ts
index f10170db1..1155f3d51 100644
--- a/src/app/features/registry/components/registration-links-card/registration-links-card.component.spec.ts
+++ b/src/app/features/registry/components/registration-links-card/registration-links-card.component.spec.ts
@@ -1,6 +1,6 @@
 import { MockComponents } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { ContributorsListComponent } from '@osf/shared/components/contributors-list/contributors-list.component';
 import { DataResourcesComponent } from '@osf/shared/components/data-resources/data-resources.component';
@@ -11,110 +11,77 @@ import { RegistrationLinksCardComponent } from './registration-links-card.compon
 import { createMockLinkedNode } from '@testing/mocks/linked-node.mock';
 import { createMockLinkedRegistration } from '@testing/mocks/linked-registration.mock';
 import { createMockRegistryComponent } from '@testing/mocks/registry-component.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { MockComponentWithSignal } from '@testing/providers/component-provider.mock';
 
 describe('RegistrationLinksCardComponent', () => {
-  let component: RegistrationLinksCardComponent;
-  let fixture: ComponentFixture<RegistrationLinksCardComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
+  beforeEach(() => {
+    TestBed.configureTestingModule({
       imports: [
         RegistrationLinksCardComponent,
-        OSFTestingModule,
         ...MockComponents(DataResourcesComponent, IconComponent, ContributorsListComponent),
+        MockComponentWithSignal('osf-truncated-text'),
       ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistrationLinksCardComponent);
-    component = fixture.componentInstance;
-  });
-
-  it('should create', () => {
-    fixture.componentRef.setInput('registrationData', createMockLinkedRegistration());
-    fixture.detectChanges();
-    expect(component).toBeTruthy();
-  });
-
-  it('should set registrationData input correctly with LinkedRegistration', () => {
-    const mockLinkedRegistration = createMockLinkedRegistration();
-    fixture.componentRef.setInput('registrationData', mockLinkedRegistration);
-    fixture.detectChanges();
-
-    expect(component.registrationData()).toEqual(mockLinkedRegistration);
-  });
-
-  it('should set registrationData input correctly with LinkedNode', () => {
-    const mockLinkedNode = createMockLinkedNode();
-    fixture.componentRef.setInput('registrationData', mockLinkedNode);
-    fixture.detectChanges();
-
-    expect(component.registrationData()).toEqual(mockLinkedNode);
+      providers: [provideOSFCore()],
+    });
   });
 
-  it('should set registrationData input correctly with RegistryComponentModel', () => {
-    const mockRegistryComponent = createMockRegistryComponent();
-    fixture.componentRef.setInput('registrationData', mockRegistryComponent);
-    fixture.detectChanges();
-
-    expect(component.registrationData()).toEqual(mockRegistryComponent);
-  });
-
-  it('should return true when data has reviewsState property', () => {
+  it('should identify LinkedRegistration data', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
     fixture.componentRef.setInput('registrationData', createMockLinkedRegistration());
     fixture.detectChanges();
 
-    expect(component.isRegistrationData()).toBe(true);
+    expect(fixture.componentInstance.isRegistrationData()).toBe(true);
+    expect(fixture.componentInstance.registrationDataTyped()).toEqual(createMockLinkedRegistration());
   });
 
-  it('should return false when data does not have reviewsState property', () => {
+  it('should identify LinkedNode data', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
     fixture.componentRef.setInput('registrationData', createMockLinkedNode());
     fixture.detectChanges();
 
-    expect(component.isRegistrationData()).toBe(false);
+    expect(fixture.componentInstance.isRegistrationData()).toBe(false);
+    expect(fixture.componentInstance.isComponentData()).toBe(false);
+    expect(fixture.componentInstance.registrationDataTyped()).toBeNull();
+    expect(fixture.componentInstance.componentsDataTyped()).toBeNull();
   });
 
-  it('should return true when data has registrationSupplement property', () => {
+  it('should identify RegistryComponentModel data', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
     fixture.componentRef.setInput('registrationData', createMockRegistryComponent());
     fixture.detectChanges();
 
-    expect(component.isComponentData()).toBe(true);
-  });
-
-  it('should return true for LinkedRegistration with registrationSupplement', () => {
-    fixture.componentRef.setInput('registrationData', createMockLinkedRegistration());
-    fixture.detectChanges();
-
-    expect(component.isComponentData()).toBe(true);
+    expect(fixture.componentInstance.isComponentData()).toBe(true);
+    expect(fixture.componentInstance.componentsDataTyped()).toEqual(createMockRegistryComponent());
   });
 
-  it('should return false when data does not have registrationSupplement property', () => {
-    fixture.componentRef.setInput('registrationData', createMockLinkedNode());
+  it('should return true for hasWriteAccess when user has write permission', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
+    fixture.componentRef.setInput(
+      'registrationData',
+      createMockLinkedRegistration({ currentUserPermissions: ['read', 'write'] })
+    );
     fixture.detectChanges();
 
-    expect(component.isComponentData()).toBe(false);
+    expect(fixture.componentInstance.hasWriteAccess()).toBe(true);
   });
 
-  it('should return LinkedRegistration when data has reviewsState', () => {
-    const mockLinkedRegistration = createMockLinkedRegistration();
-    fixture.componentRef.setInput('registrationData', mockLinkedRegistration);
+  it('should return false for hasWriteAccess when user has read-only permission', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
+    fixture.componentRef.setInput(
+      'registrationData',
+      createMockLinkedRegistration({ currentUserPermissions: ['read'] })
+    );
     fixture.detectChanges();
 
-    expect(component.registrationDataTyped()).toEqual(mockLinkedRegistration);
+    expect(fixture.componentInstance.hasWriteAccess()).toBe(false);
   });
 
-  it('should return null when data does not have reviewsState', () => {
+  it('should return false for hasWriteAccess for non-registration data', () => {
+    const fixture = TestBed.createComponent(RegistrationLinksCardComponent);
     fixture.componentRef.setInput('registrationData', createMockLinkedNode());
     fixture.detectChanges();
 
-    expect(component.registrationDataTyped()).toBeNull();
-  });
-
-  it('should return RegistryComponentModel when data has registrationSupplement', () => {
-    const mockRegistryComponent = createMockRegistryComponent();
-    fixture.componentRef.setInput('registrationData', mockRegistryComponent);
-    fixture.detectChanges();
-
-    expect(component.componentsDataTyped()).toEqual(mockRegistryComponent);
+    expect(fixture.componentInstance.hasWriteAccess()).toBe(false);
   });
 });
diff --git a/src/app/features/registry/components/registration-links-card/registration-links-card.component.ts b/src/app/features/registry/components/registration-links-card/registration-links-card.component.ts
index a050662ce..f585d316a 100644
--- a/src/app/features/registry/components/registration-links-card/registration-links-card.component.ts
+++ b/src/app/features/registry/components/registration-links-card/registration-links-card.component.ts
@@ -10,7 +10,7 @@ import { ContributorsListComponent } from '@osf/shared/components/contributors-l
 import { DataResourcesComponent } from '@osf/shared/components/data-resources/data-resources.component';
 import { IconComponent } from '@osf/shared/components/icon/icon.component';
 import { TruncatedTextComponent } from '@osf/shared/components/truncated-text/truncated-text.component';
-import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
+import { UserPermissions } from '@osf/shared/enums/user-permissions.enum';
 
 import { LinkedNode, LinkedRegistration, RegistryComponentModel } from '../../models';
 
@@ -36,8 +36,6 @@ export class RegistrationLinksCardComponent {
   readonly updateEmitRegistrationData = output<string>();
   readonly reviewEmitRegistrationData = output<string>();
 
-  readonly RevisionReviewStates = RevisionReviewStates;
-
   readonly isRegistrationData = computed(() => {
     const data = this.registrationData();
     return 'reviewsState' in data;
@@ -57,4 +55,8 @@ export class RegistrationLinksCardComponent {
     const data = this.registrationData();
     return this.isComponentData() ? (data as RegistryComponentModel) : null;
   });
+
+  readonly hasWriteAccess = computed(
+    () => this.registrationDataTyped()?.currentUserPermissions?.includes(UserPermissions.Write) ?? false
+  );
 }
diff --git a/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.spec.ts b/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.spec.ts
index 56a81a601..765ac611f 100644
--- a/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.spec.ts
+++ b/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.spec.ts
@@ -4,7 +4,7 @@ import { MockComponent, MockProvider } from 'ng-mocks';
 
 import { of } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { UserSelectors } from '@core/store/user';
 import { SocialsShareButtonComponent } from '@osf/shared/components/socials-share-button/socials-share-button.component';
@@ -14,121 +14,123 @@ import { BookmarksSelectors } from '@osf/shared/stores/bookmarks';
 
 import { RegistrationOverviewToolbarComponent } from './registration-overview-toolbar.component';
 
-import { OSFTestingModule } from '@testing/osf.testing.module';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
-import { ToastServiceMockBuilder } from '@testing/providers/toast-provider.mock';
-
-describe('RegistrationOverviewToolbarComponent', () => {
-  let component: RegistrationOverviewToolbarComponent;
-  let fixture: ComponentFixture<RegistrationOverviewToolbarComponent>;
-  let store: jest.Mocked<Store>;
-  let toastService: ReturnType<ToastServiceMockBuilder['build']>;
-
-  const mockResourceId = 'registration-123';
-  const mockResourceTitle = 'Test Registration';
-  const mockBookmarksCollectionId = 'bookmarks-123';
-
-  beforeEach(async () => {
-    toastService = ToastServiceMockBuilder.create().build();
-
-    await TestBed.configureTestingModule({
-      imports: [RegistrationOverviewToolbarComponent, OSFTestingModule, MockComponent(SocialsShareButtonComponent)],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: BookmarksSelectors.getBookmarksCollectionId, value: mockBookmarksCollectionId },
-            { selector: BookmarksSelectors.getBookmarks, value: [] },
-            { selector: BookmarksSelectors.areBookmarksLoading, value: false },
-            { selector: BookmarksSelectors.getBookmarksCollectionIdSubmitting, value: false },
-            { selector: UserSelectors.isAuthenticated, value: true },
-          ],
-        }),
-        MockProvider(ToastService, toastService),
-      ],
-    }).compileComponents();
-
-    store = TestBed.inject(Store) as jest.Mocked<Store>;
-    store.dispatch = jest.fn().mockReturnValue(of(true));
-
-    fixture = TestBed.createComponent(RegistrationOverviewToolbarComponent);
-    component = fixture.componentInstance;
-
-    fixture.componentRef.setInput('resourceId', mockResourceId);
-    fixture.componentRef.setInput('resourceTitle', mockResourceTitle);
-    fixture.componentRef.setInput('isPublic', true);
-  });
-
-  it('should set resourceId input correctly', () => {
-    fixture.detectChanges();
-    expect(component.resourceId()).toBe(mockResourceId);
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { mergeSignalOverrides, provideMockStore, SignalOverride } from '@testing/providers/store-provider.mock';
+import { ToastServiceMock } from '@testing/providers/toast-provider.mock';
+
+const MOCK_RESOURCE_ID = 'registration-123';
+const MOCK_BOOKMARKS_COLLECTION_ID = 'bookmarks-123';
+
+interface SetupOverrides {
+  bookmarks?: { id: string }[];
+  bookmarksCollectionId?: string | null;
+  isAuthenticated?: boolean;
+  selectorOverrides?: SignalOverride[];
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const mockToastService = ToastServiceMock.simple();
+
+  const defaultSignals = [
+    {
+      selector: BookmarksSelectors.getBookmarksCollectionId,
+      value: 'bookmarksCollectionId' in overrides ? overrides.bookmarksCollectionId : MOCK_BOOKMARKS_COLLECTION_ID,
+    },
+    { selector: BookmarksSelectors.getBookmarks, value: overrides.bookmarks ?? [] },
+    { selector: BookmarksSelectors.areBookmarksLoading, value: false },
+    { selector: BookmarksSelectors.getBookmarksCollectionIdSubmitting, value: false },
+    { selector: UserSelectors.isAuthenticated, value: overrides.isAuthenticated ?? true },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [RegistrationOverviewToolbarComponent, MockComponent(SocialsShareButtonComponent)],
+    providers: [provideOSFCore(), MockProvider(ToastService, mockToastService), provideMockStore({ signals })],
   });
 
-  it('should set resourceTitle input correctly', () => {
-    fixture.detectChanges();
-    expect(component.resourceTitle()).toBe(mockResourceTitle);
-  });
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistrationOverviewToolbarComponent);
+  fixture.componentRef.setInput('resourceId', MOCK_RESOURCE_ID);
+  fixture.componentRef.setInput('resourceTitle', 'Test Registration');
+  fixture.componentRef.setInput('isPublic', true);
+  fixture.detectChanges();
 
-  it('should set isPublic input correctly', () => {
-    fixture.detectChanges();
-    expect(component.isPublic()).toBe(true);
-  });
+  return { fixture, component: fixture.componentInstance, store, mockToastService };
+}
 
-  it('should dispatch GetResourceBookmark when bookmarksCollectionId and resourceId exist', () => {
-    fixture.detectChanges();
+describe('RegistrationOverviewToolbarComponent', () => {
+  it('should dispatch GetResourceBookmark on init', () => {
+    const { store } = setup();
 
     expect(store.dispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        bookmarkCollectionId: mockBookmarksCollectionId,
-        resourceId: mockResourceId,
+        bookmarkCollectionId: MOCK_BOOKMARKS_COLLECTION_ID,
+        resourceId: MOCK_RESOURCE_ID,
         resourceType: ResourceType.Registration,
       })
     );
   });
 
-  it('should set isBookmarked to false when bookmarks array is empty', () => {
-    fixture.detectChanges();
-    expect(component.isBookmarked()).toBe(false);
+  it('should not dispatch GetResourceBookmark when bookmarksCollectionId is null', () => {
+    const { store } = setup({ bookmarksCollectionId: null });
+
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
-  it('should not do anything when resourceId is missing', () => {
-    fixture.componentRef.setInput('resourceId', '');
-    fixture.detectChanges();
+  it('should compute isBookmarked from bookmarks', () => {
+    const { component } = setup({ bookmarks: [{ id: MOCK_RESOURCE_ID }] });
 
-    component.toggleBookmark();
+    expect(component.isBookmarked()).toBe(true);
+  });
 
-    expect(store.dispatch).not.toHaveBeenCalled();
-    expect(toastService.showSuccess).not.toHaveBeenCalled();
+  it('should compute isBookmarked as false when not in bookmarks', () => {
+    const { component } = setup({ bookmarks: [{ id: 'other-id' }] });
+
+    expect(component.isBookmarked()).toBe(false);
   });
 
-  it('should add bookmark when isBookmarked is false', () => {
-    fixture.detectChanges();
-    component.isBookmarked.set(false);
-    jest.clearAllMocks();
+  it('should dispatch add bookmark when not bookmarked', () => {
+    const { component, store, mockToastService } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
     component.toggleBookmark();
 
     expect(store.dispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        bookmarkCollectionId: mockBookmarksCollectionId,
-        resourceId: mockResourceId,
+        bookmarkCollectionId: MOCK_BOOKMARKS_COLLECTION_ID,
+        resourceId: MOCK_RESOURCE_ID,
         resourceType: ResourceType.Registration,
       })
     );
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('project.overview.dialog.toast.bookmark.add');
   });
 
-  it('should remove bookmark when isBookmarked is true', () => {
-    fixture.detectChanges();
-    component.isBookmarked.set(true);
-    jest.clearAllMocks();
+  it('should dispatch remove bookmark when already bookmarked', () => {
+    const { component, store, mockToastService } = setup({ bookmarks: [{ id: MOCK_RESOURCE_ID }] });
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
     component.toggleBookmark();
 
     expect(store.dispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        bookmarkCollectionId: mockBookmarksCollectionId,
-        resourceId: mockResourceId,
+        bookmarkCollectionId: MOCK_BOOKMARKS_COLLECTION_ID,
+        resourceId: MOCK_RESOURCE_ID,
         resourceType: ResourceType.Registration,
       })
     );
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('project.overview.dialog.toast.bookmark.remove');
+  });
+
+  it('should not dispatch toggleBookmark when resourceId is empty', () => {
+    const { fixture, store, mockToastService } = setup();
+    fixture.componentRef.setInput('resourceId', '');
+    fixture.detectChanges();
+    jest.spyOn(store, 'dispatch').mockClear().mockReturnValue(of(undefined));
+
+    fixture.componentInstance.toggleBookmark();
+
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(mockToastService.showSuccess).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.ts b/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.ts
index 0038252f3..00640ee98 100644
--- a/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.ts
+++ b/src/app/features/registry/components/registration-overview-toolbar/registration-overview-toolbar.component.ts
@@ -5,7 +5,7 @@ import { TranslatePipe } from '@ngx-translate/core';
 import { Button } from 'primeng/button';
 import { Tooltip } from 'primeng/tooltip';
 
-import { ChangeDetectionStrategy, Component, DestroyRef, effect, inject, input, signal } from '@angular/core';
+import { ChangeDetectionStrategy, Component, computed, DestroyRef, effect, inject, input } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 import { UserSelectors } from '@core/store/user';
@@ -27,23 +27,26 @@ import {
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class RegistrationOverviewToolbarComponent {
-  private toastService = inject(ToastService);
-  private destroyRef = inject(DestroyRef);
+  private readonly toastService = inject(ToastService);
+  private readonly destroyRef = inject(DestroyRef);
 
-  resourceId = input.required<string>();
-  resourceTitle = input.required<string>();
-  isPublic = input<boolean>(false);
+  readonly resourceId = input.required<string>();
+  readonly resourceTitle = input.required<string>();
+  readonly isPublic = input<boolean>(false);
 
-  isBookmarked = signal(false);
-  resourceType = ResourceType.Registration;
+  readonly resourceType = ResourceType.Registration;
 
-  bookmarksCollectionId = select(BookmarksSelectors.getBookmarksCollectionId);
-  bookmarks = select(BookmarksSelectors.getBookmarks);
-  isBookmarksLoading = select(BookmarksSelectors.areBookmarksLoading);
-  isBookmarksSubmitting = select(BookmarksSelectors.getBookmarksCollectionIdSubmitting);
-  isAuthenticated = select(UserSelectors.isAuthenticated);
+  readonly bookmarksCollectionId = select(BookmarksSelectors.getBookmarksCollectionId);
+  readonly bookmarks = select(BookmarksSelectors.getBookmarks);
+  readonly isBookmarksLoading = select(BookmarksSelectors.areBookmarksLoading);
+  readonly isBookmarksSubmitting = select(BookmarksSelectors.getBookmarksCollectionIdSubmitting);
+  readonly isAuthenticated = select(UserSelectors.isAuthenticated);
 
-  actions = createDispatchMap({
+  readonly isBookmarked = computed(
+    () => this.bookmarks()?.some((bookmark) => bookmark.id === this.resourceId()) ?? false
+  );
+
+  private readonly actions = createDispatchMap({
     getResourceBookmark: GetResourceBookmark,
     addResourceToBookmarks: AddResourceToBookmarks,
     removeResourceFromBookmarks: RemoveResourceFromBookmarks,
@@ -57,17 +60,6 @@ export class RegistrationOverviewToolbarComponent {
 
       this.actions.getResourceBookmark(bookmarksCollectionId, this.resourceId(), this.resourceType);
     });
-
-    effect(() => {
-      const bookmarks = this.bookmarks();
-
-      if (!this.resourceId() || !bookmarks?.length) {
-        this.isBookmarked.set(false);
-        return;
-      }
-
-      this.isBookmarked.set(bookmarks.some((bookmark) => bookmark.id === this.resourceId()));
-    });
   }
 
   toggleBookmark(): void {
@@ -75,24 +67,14 @@ export class RegistrationOverviewToolbarComponent {
 
     if (!this.resourceId() || !bookmarksId) return;
 
-    const newBookmarkState = !this.isBookmarked();
-
-    if (newBookmarkState) {
-      this.actions
-        .addResourceToBookmarks(bookmarksId, this.resourceId(), this.resourceType)
-        .pipe(takeUntilDestroyed(this.destroyRef))
-        .subscribe(() => {
-          this.isBookmarked.set(newBookmarkState);
-          this.toastService.showSuccess('project.overview.dialog.toast.bookmark.add');
-        });
-    } else {
-      this.actions
-        .removeResourceFromBookmarks(bookmarksId, this.resourceId(), this.resourceType)
-        .pipe(takeUntilDestroyed(this.destroyRef))
-        .subscribe(() => {
-          this.isBookmarked.set(newBookmarkState);
-          this.toastService.showSuccess('project.overview.dialog.toast.bookmark.remove');
-        });
-    }
+    const action = this.isBookmarked()
+      ? this.actions.removeResourceFromBookmarks(bookmarksId, this.resourceId(), this.resourceType)
+      : this.actions.addResourceToBookmarks(bookmarksId, this.resourceId(), this.resourceType);
+
+    const toastKey = this.isBookmarked()
+      ? 'project.overview.dialog.toast.bookmark.remove'
+      : 'project.overview.dialog.toast.bookmark.add';
+
+    action.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.toastService.showSuccess(toastKey));
   }
 }
diff --git a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.html b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.html
index a615d5e11..508d4540c 100644
--- a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.html
+++ b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.html
@@ -15,7 +15,7 @@
       severity="danger"
       [disabled]="form.invalid"
       (onClick)="withdrawRegistration()"
-      [loading]="submitting"
+      [loading]="submitting()"
     ></p-button>
   </div>
 </div>
diff --git a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.spec.ts b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.spec.ts
index 5e05c64ca..c9f30842c 100644
--- a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.spec.ts
+++ b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.spec.ts
@@ -1,74 +1,83 @@
+import { Store } from '@ngxs/store';
+
 import { MockComponent, MockProvider } from 'ng-mocks';
 
-import { DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+
+import { of, throwError } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { TextInputComponent } from '@osf/shared/components/text-input/text-input.component';
 
 import { RegistrationWithdrawDialogComponent } from './registration-withdraw-dialog.component';
 
-import { DynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideDynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistrationWithdrawDialogComponent', () => {
-  let component: RegistrationWithdrawDialogComponent;
-  let fixture: ComponentFixture<RegistrationWithdrawDialogComponent>;
-  let mockDialogConfig: jest.Mocked<DynamicDialogConfig>;
-
-  beforeEach(async () => {
-    mockDialogConfig = {
-      data: { registryId: 'test-registry-id' },
-    } as jest.Mocked<DynamicDialogConfig>;
-
-    await TestBed.configureTestingModule({
-      imports: [RegistrationWithdrawDialogComponent, OSFTestingModule, MockComponent(TextInputComponent)],
-      providers: [
-        DynamicDialogRefMock,
-        MockProvider(DynamicDialogConfig, mockDialogConfig),
-        provideMockStore({
-          signals: [],
-        }),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistrationWithdrawDialogComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+function setup(registryId = 'reg-123') {
+  TestBed.configureTestingModule({
+    imports: [RegistrationWithdrawDialogComponent, MockComponent(TextInputComponent)],
+    providers: [
+      provideOSFCore(),
+      provideDynamicDialogRefMock(),
+      MockProvider(DynamicDialogConfig, { data: { registryId } }),
+      provideMockStore(),
+    ],
   });
 
-  it('should create', () => {
+  const store = TestBed.inject(Store);
+  const dialogRef = TestBed.inject(DynamicDialogRef);
+  const fixture = TestBed.createComponent(RegistrationWithdrawDialogComponent);
+  fixture.detectChanges();
+
+  return { fixture, component: fixture.componentInstance, store, dialogRef };
+}
+
+describe('RegistrationWithdrawDialogComponent', () => {
+  it('should create with default form state', () => {
+    const { component } = setup();
+
     expect(component).toBeTruthy();
+    expect(component.submitting()).toBe(false);
+    expect(component.form.controls.text.value).toBe('');
   });
 
-  it('should initialize with default values', () => {
-    expect(component.submitting).toBe(false);
-    expect(component.form.get('text')?.value).toBe('');
+  it('should dispatch withdraw and close dialog on success', () => {
+    const { component, store, dialogRef } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
+
+    component.form.controls.text.setValue('Withdrawal reason');
+    component.withdrawRegistration();
+
+    expect(store.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        registryId: 'reg-123',
+        justification: 'Withdrawal reason',
+      })
+    );
+    expect(component.submitting()).toBe(false);
+    expect(dialogRef.close).toHaveBeenCalled();
   });
 
-  it('should have form validators', () => {
-    const textControl = component.form.get('text');
+  it('should not close dialog on dispatch error', () => {
+    const { component, store, dialogRef } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(throwError(() => new Error('fail')));
 
-    expect(textControl?.hasError('required')).toBe(true);
+    component.form.controls.text.setValue('Reason');
+    component.withdrawRegistration();
 
-    textControl?.setValue('Valid withdrawal reason');
-    expect(textControl?.hasError('required')).toBe(false);
+    expect(component.submitting()).toBe(false);
+    expect(dialogRef.close).not.toHaveBeenCalled();
   });
 
-  it('should handle form validation state', () => {
-    expect(component.form.valid).toBe(false);
-
-    component.form.patchValue({
-      text: 'Valid withdrawal reason',
-    });
-
-    expect(component.form.valid).toBe(true);
+  it('should not dispatch when registryId is missing', () => {
+    const { component, store, dialogRef } = setup('');
 
-    component.form.patchValue({
-      text: '',
-    });
+    component.withdrawRegistration();
 
-    expect(component.form.valid).toBe(false);
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(dialogRef.close).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.ts b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.ts
index 8ace79288..b189debd7 100644
--- a/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.ts
+++ b/src/app/features/registry/components/registration-withdraw-dialog/registration-withdraw-dialog.component.ts
@@ -5,9 +5,9 @@ import { TranslatePipe } from '@ngx-translate/core';
 import { Button } from 'primeng/button';
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { finalize, take } from 'rxjs';
+import { finalize } from 'rxjs';
 
-import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
 import { FormControl, FormGroup } from '@angular/forms';
 
 import { WithdrawRegistration } from '@osf/features/registry/store/registry';
@@ -17,7 +17,7 @@ import { CustomValidators } from '@osf/shared/helpers/custom-form-validators.hel
 
 @Component({
   selector: 'osf-registration-withdraw-dialog',
-  imports: [TranslatePipe, TextInputComponent, Button],
+  imports: [Button, TextInputComponent, TranslatePipe],
   templateUrl: './registration-withdraw-dialog.component.html',
   styleUrl: './registration-withdraw-dialog.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
@@ -32,22 +32,16 @@ export class RegistrationWithdrawDialogComponent {
   });
   readonly inputLimits = InputLimits;
 
-  submitting = false;
+  readonly submitting = signal(false);
 
   withdrawRegistration(): void {
     const registryId = this.config.data.registryId;
-    if (registryId) {
-      this.submitting = true;
-      this.actions
-        .withdrawRegistration(registryId, this.form.controls.text.value ?? '')
-        .pipe(
-          take(1),
-          finalize(() => {
-            this.submitting = false;
-            this.dialogRef.close();
-          })
-        )
-        .subscribe();
-    }
+    if (!registryId) return;
+
+    this.submitting.set(true);
+    this.actions
+      .withdrawRegistration(registryId, this.form.controls.text.value ?? '')
+      .pipe(finalize(() => this.submitting.set(false)))
+      .subscribe(() => this.dialogRef.close());
   }
 }
diff --git a/src/app/features/registry/components/registry-blocks-section/registry-blocks-section.component.spec.ts b/src/app/features/registry/components/registry-blocks-section/registry-blocks-section.component.spec.ts
index 595364d11..9e835c38c 100644
--- a/src/app/features/registry/components/registry-blocks-section/registry-blocks-section.component.spec.ts
+++ b/src/app/features/registry/components/registry-blocks-section/registry-blocks-section.component.spec.ts
@@ -1,118 +1,52 @@
 import { MockComponent } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { RegistrationBlocksDataComponent } from '@osf/shared/components/registration-blocks-data/registration-blocks-data.component';
 import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
-import { PageSchema } from '@osf/shared/models/registration/page-schema.model';
 
 import { RegistryBlocksSectionComponent } from './registry-blocks-section.component';
 
 import { createMockPageSchema } from '@testing/mocks/page-schema.mock';
 import { createMockSchemaResponse } from '@testing/mocks/schema-response.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 
 describe('RegistryBlocksSectionComponent', () => {
-  let component: RegistryBlocksSectionComponent;
-  let fixture: ComponentFixture<RegistryBlocksSectionComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [RegistryBlocksSectionComponent, OSFTestingModule, MockComponent(RegistrationBlocksDataComponent)],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistryBlocksSectionComponent);
-    component = fixture.componentInstance;
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [RegistryBlocksSectionComponent, MockComponent(RegistrationBlocksDataComponent)],
+      providers: [provideOSFCore()],
+    });
   });
 
-  it('should create', () => {
-    fixture.componentRef.setInput('schemaBlocks', []);
+  it('should create with required inputs', () => {
+    const fixture = TestBed.createComponent(RegistryBlocksSectionComponent);
+    fixture.componentRef.setInput('schemaBlocks', [createMockPageSchema()]);
     fixture.componentRef.setInput('schemaResponse', null);
     fixture.detectChanges();
 
-    expect(component).toBeTruthy();
+    expect(fixture.componentInstance).toBeTruthy();
+    expect(fixture.componentInstance.isLoading()).toBe(false);
   });
 
-  it('should set schemaBlocks input correctly', () => {
-    const mockBlocks: PageSchema[] = [createMockPageSchema()];
-    fixture.componentRef.setInput('schemaBlocks', mockBlocks);
-    fixture.componentRef.setInput('schemaResponse', null);
-    fixture.detectChanges();
-
-    expect(component.schemaBlocks()).toEqual(mockBlocks);
-  });
-
-  it('should set schemaResponse input correctly', () => {
+  it('should compute updatedFields from schemaResponse', () => {
+    const fixture = TestBed.createComponent(RegistryBlocksSectionComponent);
     const mockResponse = createMockSchemaResponse('response-1', RevisionReviewStates.Approved);
-    fixture.componentRef.setInput('schemaBlocks', []);
-    fixture.componentRef.setInput('schemaResponse', mockResponse);
-    fixture.detectChanges();
+    mockResponse.updatedResponseKeys = ['key1', 'key2'];
 
-    expect(component.schemaResponse()).toEqual(mockResponse);
-  });
-
-  it('should default isLoading to false', () => {
-    fixture.componentRef.setInput('schemaBlocks', []);
-    fixture.componentRef.setInput('schemaResponse', null);
-    fixture.detectChanges();
-
-    expect(component.isLoading()).toBe(false);
-  });
-
-  it('should compute updatedFields from schemaResponse with updatedResponseKeys', () => {
-    const mockResponse = createMockSchemaResponse('response-1', RevisionReviewStates.Approved);
-    mockResponse.updatedResponseKeys = ['key1', 'key2', 'key3'];
     fixture.componentRef.setInput('schemaBlocks', []);
     fixture.componentRef.setInput('schemaResponse', mockResponse);
     fixture.detectChanges();
 
-    expect(component.updatedFields()).toEqual(['key1', 'key2', 'key3']);
+    expect(fixture.componentInstance.updatedFields()).toEqual(['key1', 'key2']);
   });
 
-  it('should return empty array when schemaResponse is null', () => {
+  it('should return empty updatedFields when schemaResponse is null', () => {
+    const fixture = TestBed.createComponent(RegistryBlocksSectionComponent);
     fixture.componentRef.setInput('schemaBlocks', []);
     fixture.componentRef.setInput('schemaResponse', null);
     fixture.detectChanges();
 
-    expect(component.updatedFields()).toEqual([]);
-  });
-
-  it('should handle single updatedResponseKey', () => {
-    const mockResponse = createMockSchemaResponse('response-1', RevisionReviewStates.Approved);
-    mockResponse.updatedResponseKeys = ['single-key'];
-    fixture.componentRef.setInput('schemaBlocks', []);
-    fixture.componentRef.setInput('schemaResponse', mockResponse);
-    fixture.detectChanges();
-
-    expect(component.updatedFields()).toEqual(['single-key']);
-  });
-
-  it('should initialize with all required inputs', () => {
-    const mockBlocks: PageSchema[] = [createMockPageSchema()];
-    const mockResponse = createMockSchemaResponse('response-1', RevisionReviewStates.Approved);
-
-    fixture.componentRef.setInput('schemaBlocks', mockBlocks);
-    fixture.componentRef.setInput('schemaResponse', mockResponse);
-    fixture.detectChanges();
-
-    expect(component.schemaBlocks()).toEqual(mockBlocks);
-    expect(component.schemaResponse()).toEqual(mockResponse);
-    expect(component.isLoading()).toBe(false);
-  });
-
-  it('should handle all inputs being set together', () => {
-    const mockBlocks: PageSchema[] = [createMockPageSchema()];
-    const mockResponse = createMockSchemaResponse('response-1', RevisionReviewStates.Approved);
-    mockResponse.updatedResponseKeys = ['test-key'];
-
-    fixture.componentRef.setInput('schemaBlocks', mockBlocks);
-    fixture.componentRef.setInput('schemaResponse', mockResponse);
-    fixture.componentRef.setInput('isLoading', true);
-    fixture.detectChanges();
-
-    expect(component.schemaBlocks()).toEqual(mockBlocks);
-    expect(component.schemaResponse()).toEqual(mockResponse);
-    expect(component.isLoading()).toBe(true);
-    expect(component.updatedFields()).toEqual(['test-key']);
+    expect(fixture.componentInstance.updatedFields()).toEqual([]);
   });
 });
diff --git a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.html b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.html
index e079f1667..480e1d155 100644
--- a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.html
+++ b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.html
@@ -67,7 +67,7 @@
 
       <div class="flex flex-column gap-1">
         <p class="flex justify-content-end">
-          {{ requestForm.controls[ModerationDecisionFormControls.Comment].value.length }}/{{ decisionCommentLimit }}
+          {{ requestForm.controls[ModerationDecisionFormControls.Comment].value?.length }}/{{ decisionCommentLimit }}
         </p>
 
         <textarea
@@ -96,7 +96,7 @@
 
       <div class="flex flex-column gap-1">
         <p class="flex justify-content-end">
-          {{ requestForm.controls[ModerationDecisionFormControls.Comment].value.length }}/{{ decisionCommentLimit }}
+          {{ requestForm.controls[ModerationDecisionFormControls.Comment].value?.length }}/{{ decisionCommentLimit }}
         </p>
 
         <textarea
@@ -119,13 +119,13 @@
       <p-button
         [label]="'common.buttons.cancel' | translate"
         severity="info"
-        (click)="dialogRef.close(false)"
+        (onClick)="dialogRef.close(false)"
         [disabled]="isSubmitting()"
         class="btn-full-width"
       />
       <p-button
         [label]="'moderation.makeDecision.submitDecision' | translate"
-        (click)="handleSubmission()"
+        (onClick)="handleSubmission()"
         severity="success"
         [disabled]="!requestForm.valid || isSubmitting()"
         [loading]="isSubmitting()"
diff --git a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.spec.ts b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.spec.ts
index 6a637ae08..5a6f91404 100644
--- a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.spec.ts
+++ b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.spec.ts
@@ -1,307 +1,206 @@
+import { Store } from '@ngxs/store';
+
 import { MockPipe, MockProvider } from 'ng-mocks';
 
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
-import { of } from 'rxjs';
+import { of, throwError } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { ModerationDecisionFormControls } from '@osf/shared/enums/moderation-decision-form-controls.enum';
 import { RegistrationReviewStates } from '@osf/shared/enums/registration-review-states.enum';
 import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
 import { ReviewActionTrigger, SchemaResponseActionTrigger } from '@osf/shared/enums/trigger-action.enum';
-import { DateAgoPipe } from '@shared/pipes/date-ago.pipe';
+import { DateAgoPipe } from '@osf/shared/pipes/date-ago.pipe';
 
 import { RegistrySelectors } from '../../store/registry';
 
 import { RegistryMakeDecisionComponent } from './registry-make-decision.component';
 
-import { DynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
+import { provideDynamicDialogRefMock } from '@testing/mocks/dynamic-dialog-ref.mock';
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistryMakeDecisionComponent', () => {
-  let component: RegistryMakeDecisionComponent;
-  let fixture: ComponentFixture<RegistryMakeDecisionComponent>;
-  let mockDialogRef: jest.Mocked<DynamicDialogRef>;
-  let mockDialogConfig: jest.Mocked<DynamicDialogConfig>;
-
-  const mockRegistry = {
-    ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-    reviewsState: RegistrationReviewStates.Accepted,
-    revisionState: RevisionReviewStates.Approved,
-  };
-
-  beforeEach(async () => {
-    mockDialogRef = DynamicDialogRefMock.useValue as unknown as jest.Mocked<DynamicDialogRef>;
-
-    mockDialogConfig = {
-      data: {
-        registry: mockRegistry,
-        revisionId: 'test-revision-id',
-      },
-    } as jest.Mocked<DynamicDialogConfig>;
-
-    await TestBed.configureTestingModule({
-      imports: [RegistryMakeDecisionComponent, OSFTestingModule, MockPipe(DateAgoPipe)],
-      providers: [
-        DynamicDialogRefMock,
-        MockProvider(DynamicDialogConfig, mockDialogConfig),
-        provideMockStore({
-          signals: [
-            { selector: RegistrySelectors.getReviewActions, value: [] },
-            { selector: RegistrySelectors.isReviewActionSubmitting, value: false },
-          ],
-        }),
-      ],
-    }).compileComponents();
+const MOCK_REGISTRY_ACCEPTED = {
+  ...MOCK_REGISTRATION_OVERVIEW_MODEL,
+  reviewsState: RegistrationReviewStates.Accepted,
+  revisionState: RevisionReviewStates.Approved,
+};
+
+interface SetupOverrides {
+  registry?: typeof MOCK_REGISTRY_ACCEPTED;
+  revisionId?: string;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const registry = overrides.registry ?? MOCK_REGISTRY_ACCEPTED;
+  const revisionId = 'revisionId' in overrides ? overrides.revisionId : 'test-revision-id';
+
+  TestBed.configureTestingModule({
+    imports: [RegistryMakeDecisionComponent, MockPipe(DateAgoPipe)],
+    providers: [
+      provideOSFCore(),
+      provideDynamicDialogRefMock(),
+      MockProvider(DynamicDialogConfig, { data: { registry, revisionId } }),
+      provideMockStore({
+        signals: [
+          { selector: RegistrySelectors.getReviewActions, value: [] },
+          { selector: RegistrySelectors.isReviewActionSubmitting, value: false },
+        ],
+      }),
+    ],
+  });
+
+  const store = TestBed.inject(Store);
+  const dialogRef = TestBed.inject(DynamicDialogRef);
+  const fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
+  fixture.detectChanges();
+
+  return { fixture, component: fixture.componentInstance, store, dialogRef };
+}
 
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
+describe('RegistryMakeDecisionComponent', () => {
+  it('should create with default accepted/approved state', () => {
+    const { component } = setup();
 
-  it('should create', () => {
     expect(component).toBeTruthy();
-  });
-
-  it('should initialize form with empty values', () => {
-    expect(component.requestForm.get(ModerationDecisionFormControls.Action)?.value).toBe('');
-    expect(component.requestForm.get(ModerationDecisionFormControls.Comment)?.value).toBe('');
-  });
-
-  it('should compute isPendingReview correctly', () => {
     expect(component.isPendingReview).toBe(false);
-
-    mockDialogConfig.data.registry = { ...mockRegistry, reviewsState: RegistrationReviewStates.Pending };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
-    expect(component.isPendingReview).toBe(true);
-  });
-
-  it('should compute isPendingWithdrawal correctly', () => {
     expect(component.isPendingWithdrawal).toBe(false);
-
-    mockDialogConfig.data.registry = { ...mockRegistry, reviewsState: RegistrationReviewStates.PendingWithdraw };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
-    expect(component.isPendingWithdrawal).toBe(true);
-  });
-
-  it('should compute canWithdraw correctly', () => {
     expect(component.canWithdraw).toBe(true);
-
-    mockDialogConfig.data.registry = {
-      ...mockRegistry,
-      reviewsState: RegistrationReviewStates.Pending,
-      revisionStatus: RevisionReviewStates.RevisionInProgress,
-    };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
-    expect(component.canWithdraw).toBe(false);
   });
 
-  it('should compute acceptValue correctly for pending review', () => {
-    mockDialogConfig.data.registry = { ...mockRegistry, reviewsState: RegistrationReviewStates.Pending };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+  it('should compute pending review properties', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRY_ACCEPTED, reviewsState: RegistrationReviewStates.Pending },
+    });
 
+    expect(component.isPendingReview).toBe(true);
     expect(component.acceptValue).toBe(ReviewActionTrigger.AcceptSubmission);
-  });
-
-  it('should compute rejectValue correctly for pending review', () => {
-    mockDialogConfig.data.registry = { ...mockRegistry, reviewsState: RegistrationReviewStates.Pending };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
     expect(component.rejectValue).toBe(ReviewActionTrigger.RejectSubmission);
   });
 
-  it('should compute rejectValue correctly for pending withdrawal', () => {
-    mockDialogConfig.data.registry = { ...mockRegistry, reviewsState: RegistrationReviewStates.PendingWithdraw };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+  it('should compute pending withdrawal properties', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRY_ACCEPTED, reviewsState: RegistrationReviewStates.PendingWithdraw },
+    });
 
+    expect(component.isPendingWithdrawal).toBe(true);
+    expect(component.acceptValue).toBe(ReviewActionTrigger.AcceptWithdrawal);
     expect(component.rejectValue).toBe(ReviewActionTrigger.RejectWithdrawal);
   });
 
-  it('should handle form submission', () => {
-    const submitDecisionSpy = jest.fn().mockReturnValue(of({}));
-    const closeSpy = jest.spyOn(mockDialogRef, 'close');
-    component.actions = {
-      ...component.actions,
-      submitDecision: submitDecisionSpy,
-    };
-
-    const formValue = {
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
-      [ModerationDecisionFormControls.Comment]: 'Test comment',
-    };
-
-    component.requestForm.patchValue(formValue);
-
-    component.handleSubmission();
-
-    expect(submitDecisionSpy).toHaveBeenCalledWith(
-      {
-        targetId: 'test-revision-id',
-        action: ReviewActionTrigger.AcceptSubmission,
-        comment: 'Test comment',
+  it('should compute revision accept/reject values for non-pending states', () => {
+    const { component } = setup({
+      registry: {
+        ...MOCK_REGISTRY_ACCEPTED,
+        revisionState: RevisionReviewStates.RevisionPendingModeration,
       },
-      true
-    );
-    expect(closeSpy).toHaveBeenCalledWith(formValue);
-  });
+    });
 
-  it('should handle form submission without revision ID', () => {
-    mockDialogConfig.data.revisionId = undefined;
-    const submitDecisionSpy = jest.fn().mockReturnValue(of({}));
-    component.actions = {
-      ...component.actions,
-      submitDecision: submitDecisionSpy,
-    };
+    expect(component.isPendingModeration).toBe(true);
+    expect(component.acceptValue).toBe(SchemaResponseActionTrigger.AcceptRevision);
+    expect(component.rejectValue).toBe(SchemaResponseActionTrigger.RejectRevision);
+  });
 
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
-      [ModerationDecisionFormControls.Comment]: 'Test comment',
+  it('should set embargoEndDate from registry', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRY_ACCEPTED, embargoEndDate: '2024-12-31' },
     });
 
-    component.handleSubmission();
-
-    expect(submitDecisionSpy).toHaveBeenCalledWith(
-      {
-        targetId: 'test-registry-id',
-        action: ReviewActionTrigger.AcceptSubmission,
-        comment: 'Test comment',
-      },
-      false
-    );
+    expect(component.embargoEndDate).toBe('2024-12-31');
   });
 
-  it('should update comment validators when action changes', () => {
+  it('should add required validator when action changes to reject', () => {
+    const { component } = setup();
     const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission,
-    });
-    expect(commentControl?.hasError('required')).toBe(true);
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
-    });
 
-    expect(commentControl?.hasError('required')).toBe(false);
+    component.requestForm.patchValue({ [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission });
+
+    expect(commentControl?.hasError('required')).toBe(true);
   });
 
-  it('should handle form validation state', () => {
-    expect(component.requestForm.valid).toBe(false);
+  it('should clear required validator when action changes to accept', () => {
+    const { component } = setup();
+    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
 
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
-    });
+    component.requestForm.patchValue({ [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission });
+    component.requestForm.patchValue({ [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission });
 
-    expect(component.requestForm.valid).toBe(true);
+    expect(commentControl?.hasError('required')).toBe(false);
   });
 
-  it('should handle different registry states', () => {
-    const states = [
-      { reviewsState: RegistrationReviewStates.Pending, revisionState: RevisionReviewStates.Approved },
-      { reviewsState: RegistrationReviewStates.Accepted, revisionState: RevisionReviewStates.Approved },
-      { reviewsState: RegistrationReviewStates.PendingWithdraw, revisionState: RevisionReviewStates.Approved },
-    ];
-
-    states.forEach((state) => {
-      mockDialogConfig.data.registry = { ...mockRegistry, ...state };
+  it('should compute isCommentInvalid when comment is required, empty and touched', () => {
+    const { component } = setup();
+    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
 
-      fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+    component.requestForm.patchValue({ [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission });
+    commentControl?.markAsTouched();
 
-      expect(component.registry.reviewsState).toBe(state.reviewsState);
-      expect(component.registry.revisionState).toBe(state.revisionState);
-    });
+    expect(component.isCommentInvalid).toBe(true);
   });
 
-  it('should identify comment as required for reject actions', () => {
+  it('should identify comment as required for all reject/force actions', () => {
+    const { component } = setup();
+
     expect(component.isCommentRequired(ReviewActionTrigger.RejectSubmission)).toBe(true);
     expect(component.isCommentRequired(SchemaResponseActionTrigger.RejectRevision)).toBe(true);
     expect(component.isCommentRequired(ReviewActionTrigger.RejectWithdrawal)).toBe(true);
     expect(component.isCommentRequired(ReviewActionTrigger.ForceWithdraw)).toBe(true);
+    expect(component.isCommentRequired(ReviewActionTrigger.AcceptSubmission)).toBe(false);
   });
 
-  it('should compute isCommentInvalid correctly when comment is required and empty', () => {
-    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission,
-      [ModerationDecisionFormControls.Comment]: '',
-    });
-    commentControl?.markAsTouched();
-
-    expect(component.isCommentInvalid).toBe(true);
-  });
+  it('should dispatch and close dialog on successful submission with revisionId', () => {
+    const { component, store, dialogRef } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
-  it('should compute isCommentInvalid as false when control is not touched or dirty', () => {
     component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission,
-      [ModerationDecisionFormControls.Comment]: '',
+      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
+      [ModerationDecisionFormControls.Comment]: 'Test comment',
     });
+    component.handleSubmission();
 
-    expect(component.isCommentInvalid).toBe(false);
+    expect(store.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          targetId: 'test-revision-id',
+          action: ReviewActionTrigger.AcceptSubmission,
+        }),
+        isRevision: true,
+      })
+    );
+    expect(dialogRef.close).toHaveBeenCalled();
   });
 
-  it('should validate comment max length', () => {
-    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
-    const longComment = 'a'.repeat(component.decisionCommentLimit + 1);
-    commentControl?.setValue(longComment);
-    commentControl?.updateValueAndValidity();
-
-    expect(commentControl?.hasError('maxlength')).toBe(true);
-  });
+  it('should use registry id as targetId when revisionId is absent', () => {
+    const { component, store } = setup({ revisionId: undefined });
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
-  it('should update comment validators when action changes to reject', () => {
-    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
     component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission,
+      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
+      [ModerationDecisionFormControls.Comment]: '',
     });
+    component.handleSubmission();
 
-    expect(commentControl?.hasError('required')).toBe(true);
+    expect(store.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({ targetId: 'test-registry-id' }),
+        isRevision: false,
+      })
+    );
   });
 
-  it('should clear comment validators when action changes to accept', () => {
-    const commentControl = component.requestForm.get(ModerationDecisionFormControls.Comment);
-    component.requestForm.patchValue({
-      [ModerationDecisionFormControls.Action]: ReviewActionTrigger.RejectSubmission,
-    });
+  it('should not close dialog on submission error', () => {
+    const { component, store, dialogRef } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(throwError(() => new Error()));
+
     component.requestForm.patchValue({
       [ModerationDecisionFormControls.Action]: ReviewActionTrigger.AcceptSubmission,
+      [ModerationDecisionFormControls.Comment]: '',
     });
+    component.handleSubmission();
 
-    expect(commentControl?.hasError('required')).toBe(false);
-  });
-
-  it('should initialize with correct constants', () => {
-    expect(component.decisionCommentLimit).toBeDefined();
-    expect(component.INPUT_VALIDATION_MESSAGES).toBeDefined();
-    expect(component.ReviewActionTrigger).toBeDefined();
-    expect(component.SchemaResponseActionTrigger).toBeDefined();
-    expect(component.ModerationDecisionFormControls).toBeDefined();
-  });
-
-  it('should set embargoEndDate from registry', () => {
-    const testDate = '2024-12-31';
-    mockDialogConfig.data.registry = { ...mockRegistry, embargoEndDate: testDate };
-    fixture = TestBed.createComponent(RegistryMakeDecisionComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
-    expect(component.embargoEndDate).toBe(testDate);
+    expect(dialogRef.close).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.ts b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.ts
index 2c8c3319f..b823b9a47 100644
--- a/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.ts
+++ b/src/app/features/registry/components/registry-make-decision/registry-make-decision.component.ts
@@ -8,12 +8,10 @@ import { Message } from 'primeng/message';
 import { RadioButton } from 'primeng/radiobutton';
 import { Textarea } from 'primeng/textarea';
 
-import { tap } from 'rxjs';
-
 import { DatePipe } from '@angular/common';
 import { ChangeDetectionStrategy, Component, DestroyRef, inject } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { FormBuilder, FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
+import { FormControl, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
 
 import { SubmissionReviewStatus } from '@osf/features/moderation/enums';
 import { InputLimits } from '@osf/shared/constants/input-limits.const';
@@ -29,95 +27,64 @@ import { RegistrySelectors, SubmitDecision } from '../../store/registry';
 
 @Component({
   selector: 'osf-registry-make-decision',
-  imports: [
-    Button,
-    TranslatePipe,
-    DateAgoPipe,
-    FormsModule,
-    RadioButton,
-    ReactiveFormsModule,
-    Textarea,
-    DatePipe,
-    Message,
-  ],
+  imports: [Button, RadioButton, Textarea, Message, ReactiveFormsModule, TranslatePipe, DateAgoPipe, DatePipe],
   templateUrl: './registry-make-decision.component.html',
   styleUrl: './registry-make-decision.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class RegistryMakeDecisionComponent {
-  private readonly fb = inject(FormBuilder);
   private readonly destroyRef = inject(DestroyRef);
+  private readonly config = inject(DynamicDialogConfig);
 
-  readonly config = inject(DynamicDialogConfig);
   readonly dialogRef = inject(DynamicDialogRef);
 
   readonly ReviewActionTrigger = ReviewActionTrigger;
-  readonly SchemaResponseActionTrigger = SchemaResponseActionTrigger;
   readonly SubmissionReviewStatus = SubmissionReviewStatus;
   readonly ModerationDecisionFormControls = ModerationDecisionFormControls;
-  reviewActions = select(RegistrySelectors.getReviewActions);
+  readonly INPUT_VALIDATION_MESSAGES = INPUT_VALIDATION_MESSAGES;
+  readonly decisionCommentLimit = InputLimits.decisionComment.maxLength;
 
-  isSubmitting = select(RegistrySelectors.isReviewActionSubmitting);
-  requestForm!: FormGroup;
+  readonly reviewActions = select(RegistrySelectors.getReviewActions);
+  readonly isSubmitting = select(RegistrySelectors.isReviewActionSubmitting);
 
-  actions = createDispatchMap({ submitDecision: SubmitDecision });
+  private readonly actions = createDispatchMap({ submitDecision: SubmitDecision });
 
-  registry = this.config.data.registry as RegistrationOverviewModel;
-  embargoEndDate = this.registry.embargoEndDate;
+  readonly registry = this.config.data.registry as RegistrationOverviewModel;
+  readonly embargoEndDate = this.registry.embargoEndDate;
 
-  RevisionReviewStates = RevisionReviewStates;
-  RegistrationReviewStates = RegistrationReviewStates;
+  readonly isPendingModeration = this.registry.revisionState === RevisionReviewStates.RevisionPendingModeration;
 
-  decisionCommentLimit = InputLimits.decisionComment.maxLength;
-  readonly INPUT_VALIDATION_MESSAGES = INPUT_VALIDATION_MESSAGES;
+  readonly isPendingReview = this.registry.reviewsState === RegistrationReviewStates.Pending;
 
-  get isPendingModeration(): boolean {
-    return this.registry.revisionState === RevisionReviewStates.RevisionPendingModeration;
-  }
+  readonly isPendingWithdrawal = this.registry.reviewsState === RegistrationReviewStates.PendingWithdraw;
 
-  get isPendingReview(): boolean {
-    return this.registry.reviewsState === RegistrationReviewStates.Pending;
-  }
+  readonly canWithdraw =
+    this.registry.reviewsState === RegistrationReviewStates.Accepted &&
+    this.registry.revisionState === RevisionReviewStates.Approved;
 
-  get isPendingWithdrawal(): boolean {
-    return this.registry.reviewsState === RegistrationReviewStates.PendingWithdraw;
-  }
+  readonly acceptValue = this.isPendingReview
+    ? ReviewActionTrigger.AcceptSubmission
+    : this.isPendingWithdrawal
+      ? ReviewActionTrigger.AcceptWithdrawal
+      : SchemaResponseActionTrigger.AcceptRevision;
 
-  get canWithdraw(): boolean {
-    return (
-      this.registry.reviewsState === RegistrationReviewStates.Accepted &&
-      this.registry.revisionState === RevisionReviewStates.Approved
-    );
-  }
-  get isCommentInvalid(): boolean {
-    return (
-      this.requestForm.controls[ModerationDecisionFormControls.Comment].errors?.['required'] &&
-      (this.requestForm.controls[ModerationDecisionFormControls.Comment].touched ||
-        this.requestForm.controls[ModerationDecisionFormControls.Comment].dirty)
-    );
-  }
+  readonly rejectValue = this.isPendingReview
+    ? ReviewActionTrigger.RejectSubmission
+    : this.isPendingWithdrawal
+      ? ReviewActionTrigger.RejectWithdrawal
+      : SchemaResponseActionTrigger.RejectRevision;
 
-  get acceptValue(): string {
-    if (this.isPendingReview) {
-      return ReviewActionTrigger.AcceptSubmission;
-    } else if (this.isPendingWithdrawal) {
-      return ReviewActionTrigger.AcceptWithdrawal;
-    }
-    return SchemaResponseActionTrigger.AcceptRevision;
-  }
+  readonly requestForm = new FormGroup({
+    [ModerationDecisionFormControls.Action]: new FormControl('', [Validators.required]),
+    [ModerationDecisionFormControls.Comment]: new FormControl('', [Validators.maxLength(this.decisionCommentLimit)]),
+  });
 
-  get rejectValue(): string {
-    if (this.isPendingReview) {
-      return ReviewActionTrigger.RejectSubmission;
-    } else if (this.isPendingWithdrawal) {
-      return ReviewActionTrigger.RejectWithdrawal;
-    }
-    return SchemaResponseActionTrigger.RejectRevision;
+  get isCommentInvalid(): boolean {
+    const comment = this.requestForm.controls[ModerationDecisionFormControls.Comment];
+    return comment.errors?.['required'] && (comment.touched || comment.dirty);
   }
 
   constructor() {
-    this.initForm();
-
     this.requestForm
       .get(ModerationDecisionFormControls.Action)
       ?.valueChanges.pipe(takeUntilDestroyed(this.destroyRef))
@@ -132,16 +99,16 @@ export class RegistryMakeDecisionComponent {
       .submitDecision(
         {
           targetId: revisionId ? revisionId : this.registry.id,
-          action: this.requestForm.value[ModerationDecisionFormControls.Action],
-          comment: this.requestForm.value[ModerationDecisionFormControls.Comment],
+          action: this.requestForm.value[ModerationDecisionFormControls.Action] ?? '',
+          comment: this.requestForm.value[ModerationDecisionFormControls.Comment] ?? '',
         },
         !!revisionId
       )
-      .pipe(tap(() => this.dialogRef.close(this.requestForm.value)))
-      .subscribe();
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe(() => this.dialogRef.close(this.requestForm.value));
   }
 
-  isCommentRequired(action: string): boolean {
+  isCommentRequired(action: string | null): boolean {
     return (
       action === ReviewActionTrigger.RejectSubmission ||
       action === SchemaResponseActionTrigger.RejectRevision ||
@@ -150,7 +117,7 @@ export class RegistryMakeDecisionComponent {
     );
   }
 
-  private updateCommentValidators(action: string): void {
+  private updateCommentValidators(action: string | null): void {
     const commentControl = this.requestForm.get(ModerationDecisionFormControls.Comment);
     if (commentControl) {
       if (this.isCommentRequired(action)) {
@@ -162,11 +129,4 @@ export class RegistryMakeDecisionComponent {
     }
     this.requestForm.updateValueAndValidity();
   }
-
-  private initForm(): void {
-    this.requestForm = this.fb.group({
-      [ModerationDecisionFormControls.Action]: new FormControl('', [Validators.required]),
-      [ModerationDecisionFormControls.Comment]: new FormControl('', [Validators.maxLength(this.decisionCommentLimit)]),
-    });
-  }
 }
diff --git a/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.spec.ts b/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.spec.ts
index 72dca0a1a..01d1e83b1 100644
--- a/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.spec.ts
+++ b/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.spec.ts
@@ -1,13 +1,12 @@
 import { Store } from '@ngxs/store';
 
-import { MockComponents } from 'ng-mocks';
+import { MockComponents, MockProvider } from 'ng-mocks';
 
 import { of } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { Router } from '@angular/router';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, Router } from '@angular/router';
 
-import { ENVIRONMENT } from '@core/provider/environment.provider';
 import { AffiliatedInstitutionsViewComponent } from '@osf/shared/components/affiliated-institutions-view/affiliated-institutions-view.component';
 import { ContributorsListComponent } from '@osf/shared/components/contributors-list/contributors-list.component';
 import { ResourceCitationsComponent } from '@osf/shared/components/resource-citations/resource-citations.component';
@@ -15,7 +14,7 @@ import { ResourceDoiComponent } from '@osf/shared/components/resource-doi/resour
 import { ResourceLicenseComponent } from '@osf/shared/components/resource-license/resource-license.component';
 import { SubjectsListComponent } from '@osf/shared/components/subjects-list/subjects-list.component';
 import { TagsListComponent } from '@osf/shared/components/tags-list/tags-list.component';
-import { CurrentResourceType, ResourceType } from '@osf/shared/enums/resource-type.enum';
+import { ResourceType } from '@osf/shared/enums/resource-type.enum';
 import { ContributorsSelectors, LoadMoreBibliographicContributors } from '@osf/shared/stores/contributors';
 import { RegistrationProviderSelectors } from '@osf/shared/stores/registration-provider';
 import { FetchSelectedSubjects, SubjectsSelectors } from '@osf/shared/stores/subjects';
@@ -31,160 +30,119 @@ import {
 import { RegistryOverviewMetadataComponent } from './registry-overview-metadata.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistryOverviewMetadataComponent', () => {
-  let component: RegistryOverviewMetadataComponent;
-  let fixture: ComponentFixture<RegistryOverviewMetadataComponent>;
-  let store: jest.Mocked<Store>;
-  let routerMock: ReturnType<RouterMockBuilder['build']>;
-
-  const mockRegistry = {
-    ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-    id: 'registry-123',
-    licenseId: 'license-123',
-  };
-
-  const mockEnvironment = {
-    webUrl: 'https://test.osf.io',
-  };
-
-  beforeEach(async () => {
-    routerMock = RouterMockBuilder.create().build();
-
-    await TestBed.configureTestingModule({
-      imports: [
-        RegistryOverviewMetadataComponent,
-        OSFTestingModule,
-        ...MockComponents(
-          ResourceCitationsComponent,
-          AffiliatedInstitutionsViewComponent,
-          ContributorsListComponent,
-          ResourceDoiComponent,
-          ResourceLicenseComponent,
-          SubjectsListComponent,
-          TagsListComponent
-        ),
-      ],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: RegistrySelectors.getRegistry, value: mockRegistry },
-            { selector: RegistrySelectors.isRegistryAnonymous, value: false },
-            { selector: RegistrySelectors.hasWriteAccess, value: true },
-            { selector: RegistrySelectors.getLicense, value: null },
-            { selector: RegistrySelectors.isLicenseLoading, value: false },
-            { selector: RegistrySelectors.getIdentifiers, value: [] },
-            { selector: RegistrySelectors.isIdentifiersLoading, value: false },
-            { selector: RegistrySelectors.getInstitutions, value: [] },
-            { selector: RegistrySelectors.isInstitutionsLoading, value: false },
-            { selector: RegistrationProviderSelectors.getBrandedProvider, value: null },
-            { selector: SubjectsSelectors.getSubjects, value: [] },
-            { selector: SubjectsSelectors.getSubjectsLoading, value: false },
-            { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
-            { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
-            { selector: ContributorsSelectors.hasMoreBibliographicContributors, value: false },
-          ],
-        }),
-        { provide: Router, useValue: routerMock },
-        { provide: ENVIRONMENT, useValue: mockEnvironment },
-      ],
-    }).compileComponents();
-
-    store = TestBed.inject(Store) as jest.Mocked<Store>;
-    store.dispatch = jest.fn().mockReturnValue(of(true));
-    fixture = TestBed.createComponent(RegistryOverviewMetadataComponent);
-    component = fixture.componentInstance;
+const MOCK_REGISTRY = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, id: 'registry-123', licenseId: 'license-123' };
+
+interface SetupOverrides {
+  registry?: typeof MOCK_REGISTRY | null;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const registryValue = 'registry' in overrides ? overrides.registry! : MOCK_REGISTRY;
+  const mockRouter = RouterMockBuilder.create().build();
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryOverviewMetadataComponent,
+      ...MockComponents(
+        ResourceCitationsComponent,
+        AffiliatedInstitutionsViewComponent,
+        ContributorsListComponent,
+        ResourceDoiComponent,
+        ResourceLicenseComponent,
+        SubjectsListComponent,
+        TagsListComponent
+      ),
+    ],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, ActivatedRouteMockBuilder.create().build()),
+      MockProvider(Router, mockRouter),
+      provideMockStore({
+        signals: [
+          { selector: RegistrySelectors.getRegistry, value: registryValue },
+          { selector: RegistrySelectors.isRegistryAnonymous, value: false },
+          { selector: RegistrySelectors.hasWriteAccess, value: true },
+          { selector: RegistrySelectors.getLicense, value: null },
+          { selector: RegistrySelectors.isLicenseLoading, value: false },
+          { selector: RegistrySelectors.getIdentifiers, value: [] },
+          { selector: RegistrySelectors.isIdentifiersLoading, value: false },
+          { selector: RegistrySelectors.getInstitutions, value: [] },
+          { selector: RegistrySelectors.isInstitutionsLoading, value: false },
+          { selector: RegistrationProviderSelectors.getBrandedProvider, value: null },
+          { selector: SubjectsSelectors.getSelectedSubjects, value: [] },
+          { selector: SubjectsSelectors.areSelectedSubjectsLoading, value: false },
+          { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
+          { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
+          { selector: ContributorsSelectors.hasMoreBibliographicContributors, value: false },
+        ],
+      }),
+    ],
   });
 
-  it('should have currentResourceType set to Registrations', () => {
-    expect(component.currentResourceType).toBe(CurrentResourceType.Registrations);
-  });
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryOverviewMetadataComponent);
+  fixture.detectChanges();
 
-  it('should have correct dateFormat', () => {
-    expect(component.dateFormat).toBe('MMM d, y, h:mm a');
-  });
-
-  it('should have webUrl from environment', () => {
-    expect(component.webUrl).toBe('https://test.osf.io');
-  });
+  return { fixture, component: fixture.componentInstance, store, mockRouter };
+}
 
-  it('should dispatch actions when registry exists', () => {
-    fixture.detectChanges();
+describe('RegistryOverviewMetadataComponent', () => {
+  it('should dispatch all init actions when registry exists', () => {
+    const { store } = setup();
 
+    expect(store.dispatch).toHaveBeenCalledWith(expect.objectContaining({ registryId: 'registry-123' }));
     expect(store.dispatch).toHaveBeenCalledWith(expect.any(GetRegistryInstitutions));
     expect(store.dispatch).toHaveBeenCalledWith(expect.any(FetchSelectedSubjects));
     expect(store.dispatch).toHaveBeenCalledWith(expect.any(GetRegistryLicense));
     expect(store.dispatch).toHaveBeenCalledWith(expect.any(GetRegistryIdentifiers));
   });
 
-  it('should dispatch GetRegistryInstitutions with correct registryId', () => {
-    fixture.detectChanges();
+  it('should not dispatch init actions when registry is null', () => {
+    const { store } = setup({ registry: null });
 
-    const call = (store.dispatch as jest.Mock).mock.calls.find((call) => call[0] instanceof GetRegistryInstitutions);
-    expect(call).toBeDefined();
-    const action = call[0] as GetRegistryInstitutions;
-    expect(action.registryId).toBe('registry-123');
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
-  it('should dispatch FetchSelectedSubjects with correct parameters', () => {
-    fixture.detectChanges();
-
-    const call = (store.dispatch as jest.Mock).mock.calls.find((call) => call[0] instanceof FetchSelectedSubjects);
-    expect(call).toBeDefined();
-    const action = call[0] as FetchSelectedSubjects;
-    expect(action.resourceId).toBe('registry-123');
-    expect(action.resourceType).toBe(ResourceType.Registration);
-  });
+  it('should dispatch SetRegistryCustomCitation on onCustomCitationUpdated', () => {
+    const { component, store } = setup();
 
-  it('should dispatch GetRegistryLicense with licenseId from registry', () => {
-    fixture.detectChanges();
+    component.onCustomCitationUpdated('Custom Citation');
 
-    const call = (store.dispatch as jest.Mock).mock.calls.find((call) => call[0] instanceof GetRegistryLicense);
+    const call = (store.dispatch as jest.Mock).mock.calls.find((c) => c[0] instanceof SetRegistryCustomCitation);
     expect(call).toBeDefined();
-    const action = call[0] as GetRegistryLicense;
-    expect(action.licenseId).toBe('license-123');
+    expect(call[0].citation).toBe('Custom Citation');
   });
 
-  it('should dispatch GetRegistryIdentifiers with correct registryId', () => {
-    fixture.detectChanges();
+  it('should dispatch LoadMoreBibliographicContributors on handleLoadMoreContributors', () => {
+    const { component, store } = setup();
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
-    const call = (store.dispatch as jest.Mock).mock.calls.find((call) => call[0] instanceof GetRegistryIdentifiers);
-    expect(call).toBeDefined();
-    const action = call[0] as GetRegistryIdentifiers;
-    expect(action.registryId).toBe('registry-123');
-  });
-
-  it('should dispatch SetRegistryCustomCitation with citation', () => {
-    const citation = 'Custom Citation Text';
-    component.onCustomCitationUpdated(citation);
+    component.handleLoadMoreContributors();
 
-    expect(store.dispatch).toHaveBeenCalledWith(expect.any(SetRegistryCustomCitation));
-    const call = (store.dispatch as jest.Mock).mock.calls.find((call) => call[0] instanceof SetRegistryCustomCitation);
-    expect(call).toBeDefined();
-    const action = call[0] as SetRegistryCustomCitation;
-    expect(action.citation).toBe(citation);
+    expect(store.dispatch).toHaveBeenCalledWith(
+      new LoadMoreBibliographicContributors('registry-123', ResourceType.Registration)
+    );
   });
 
-  it('should dispatch LoadMoreBibliographicContributors with registry id', () => {
+  it('should not dispatch on handleLoadMoreContributors when registry is null', () => {
+    const { component, store } = setup({ registry: null });
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
+
     component.handleLoadMoreContributors();
 
-    expect(store.dispatch).toHaveBeenCalledWith(expect.any(LoadMoreBibliographicContributors));
-    const call = (store.dispatch as jest.Mock).mock.calls.find(
-      (call) => call[0] instanceof LoadMoreBibliographicContributors
-    );
-    expect(call).toBeDefined();
-    const action = call[0] as LoadMoreBibliographicContributors;
-    expect(action.resourceId).toBe('registry-123');
-    expect(action.resourceType).toBe(ResourceType.Registration);
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
-  it('should navigate to search page with tag as query param', () => {
-    const tag = 'test-tag';
-    component.tagClicked(tag);
+  it('should navigate to search on tagClicked', () => {
+    const { component, mockRouter } = setup();
+
+    component.tagClicked('test-tag');
 
-    expect(routerMock.navigate).toHaveBeenCalledWith(['/search'], { queryParams: { search: tag } });
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['/search'], { queryParams: { search: 'test-tag' } });
   });
 });
diff --git a/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.ts b/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.ts
index 693e8eebd..0fa1ff01a 100644
--- a/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.ts
+++ b/src/app/features/registry/components/registry-overview-metadata/registry-overview-metadata.component.ts
@@ -34,10 +34,10 @@ import {
   selector: 'osf-registry-overview-metadata',
   imports: [
     Button,
-    TranslatePipe,
-    TruncatedTextComponent,
     RouterLink,
     DatePipe,
+    TranslatePipe,
+    TruncatedTextComponent,
     ResourceCitationsComponent,
     ResourceDoiComponent,
     ResourceLicenseComponent,
@@ -87,11 +87,13 @@ export class RegistryOverviewMetadataComponent {
 
   constructor() {
     effect(() => {
-      if (this.registry()?.id) {
-        this.actions.getInstitutions(this.registry()!.id);
-        this.actions.getSubjects(this.registry()!.id, ResourceType.Registration);
-        this.actions.getLicense(this.registry()!.licenseId);
-        this.actions.getIdentifiers(this.registry()!.id);
+      const registry = this.registry();
+
+      if (registry?.id) {
+        this.actions.getInstitutions(registry.id);
+        this.actions.getSubjects(registry.id, ResourceType.Registration);
+        this.actions.getLicense(registry.licenseId);
+        this.actions.getIdentifiers(registry.id);
       }
     });
   }
@@ -101,7 +103,10 @@ export class RegistryOverviewMetadataComponent {
   }
 
   handleLoadMoreContributors(): void {
-    this.actions.loadMoreBibliographicContributors(this.registry()?.id, ResourceType.Registration);
+    const registryId = this.registry()?.id;
+    if (!registryId) return;
+
+    this.actions.loadMoreBibliographicContributors(registryId, ResourceType.Registration);
   }
 
   tagClicked(tag: string) {
diff --git a/src/app/features/registry/components/registry-revisions/registry-revisions.component.html b/src/app/features/registry/components/registry-revisions/registry-revisions.component.html
index bb338aec3..794707631 100644
--- a/src/app/features/registry/components/registry-revisions/registry-revisions.component.html
+++ b/src/app/features/registry/components/registry-revisions/registry-revisions.component.html
@@ -19,15 +19,15 @@
           }
 
           @if (canEdit()) {
-            @if (registryAcceptedUnapproved) {
+            @if (registryAcceptedUnapproved()) {
               <p-button
                 class="w-full"
                 styleClass="w-full"
                 [label]="'registry.overview.reviewUpdate' | translate"
-                [routerLink]="['/registries/revisions/', unApprovedRevisionId, 'review']"
+                [routerLink]="['/registries/revisions/', unApprovedRevisionId(), 'review']"
               />
             }
-            @if (registryApproved) {
+            @if (registryApproved()) {
               <p-button
                 class="w-full"
                 styleClass="w-full"
@@ -36,7 +36,7 @@
                 [loading]="isSubmitting()"
               />
             }
-            @if (registryInProgress) {
+            @if (registryInProgress()) {
               <p-button
                 class="w-full"
                 styleClass="w-full"
diff --git a/src/app/features/registry/components/registry-revisions/registry-revisions.component.spec.ts b/src/app/features/registry/components/registry-revisions/registry-revisions.component.spec.ts
index 40458c7ac..7f235d7f6 100644
--- a/src/app/features/registry/components/registry-revisions/registry-revisions.component.spec.ts
+++ b/src/app/features/registry/components/registry-revisions/registry-revisions.component.spec.ts
@@ -1,353 +1,183 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { MockProvider } from 'ng-mocks';
+
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute } from '@angular/router';
 
 import { RegistrationReviewStates } from '@osf/shared/enums/registration-review-states.enum';
 import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
-import { SchemaResponse } from '@osf/shared/models/registration/schema-response.model';
 
 import { RegistryRevisionsComponent } from './registry-revisions.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
 import { createMockSchemaResponse } from '@testing/mocks/schema-response.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
-
-describe('RegistryRevisionsComponent', () => {
-  let component: RegistryRevisionsComponent;
-  let fixture: ComponentFixture<RegistryRevisionsComponent>;
-
-  const mockRegistry = MOCK_REGISTRATION_OVERVIEW_MODEL;
-
-  const mockSchemaResponses: SchemaResponse[] = [
-    createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-    createMockSchemaResponse('response-2', RevisionReviewStates.Approved, true),
-  ];
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
+
+const MOCK_REGISTRY = MOCK_REGISTRATION_OVERVIEW_MODEL;
+const MOCK_RESPONSES = [
+  createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
+  createMockSchemaResponse('response-2', RevisionReviewStates.Approved, true),
+];
+
+function setup() {
+  TestBed.configureTestingModule({
+    imports: [RegistryRevisionsComponent],
+    providers: [provideOSFCore(), MockProvider(ActivatedRoute, ActivatedRouteMockBuilder.create().build())],
+  });
 
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [RegistryRevisionsComponent, OSFTestingModule],
-    }).compileComponents();
+  const fixture = TestBed.createComponent(RegistryRevisionsComponent);
+  fixture.componentRef.setInput('registry', MOCK_REGISTRY);
+  fixture.componentRef.setInput('schemaResponses', MOCK_RESPONSES);
+  fixture.componentRef.setInput('selectedRevisionIndex', 0);
+  fixture.detectChanges();
 
-    fixture = TestBed.createComponent(RegistryRevisionsComponent);
-    component = fixture.componentInstance;
+  return { fixture, component: fixture.componentInstance };
+}
 
-    fixture.componentRef.setInput('registry', mockRegistry);
-    fixture.componentRef.setInput('schemaResponses', mockSchemaResponses);
-    fixture.componentRef.setInput('selectedRevisionIndex', 0);
-    fixture.detectChanges();
-  });
+describe('RegistryRevisionsComponent', () => {
+  it('should create with default values', () => {
+    const { component } = setup();
 
-  it('should initialize with default input values', () => {
+    expect(component).toBeTruthy();
     expect(component.isSubmitting()).toBe(false);
     expect(component.isModeration()).toBe(false);
     expect(component.canEdit()).toBe(false);
-    expect(component.unApprovedRevisionId).toBe(null);
   });
 
-  it('should expose RevisionReviewStates enum', () => {
-    expect(component.RevisionReviewStates).toBe(RevisionReviewStates);
-  });
+  it('should compute registryInProgress from revisionState', () => {
+    const { fixture, component } = setup();
 
-  it('should receive required inputs', () => {
-    expect(component.registry()).toEqual(mockRegistry);
-    expect(component.schemaResponses()).toEqual(mockSchemaResponses);
-    expect(component.selectedRevisionIndex()).toBe(0);
-  });
+    expect(component.registryInProgress()).toBe(false);
 
-  it('should update when registry input changes', () => {
-    const newRegistry = { ...mockRegistry, id: 'new-registry-id' };
-    fixture.componentRef.setInput('registry', newRegistry);
+    fixture.componentRef.setInput('registry', {
+      ...MOCK_REGISTRY,
+      revisionState: RevisionReviewStates.RevisionInProgress,
+    });
     fixture.detectChanges();
-
-    expect(component.registry()).toEqual(newRegistry);
+    expect(component.registryInProgress()).toBe(true);
   });
 
-  it('should update when schemaResponses input changes', () => {
-    const newResponses = [createMockSchemaResponse('new-response', RevisionReviewStates.Approved)];
-    fixture.componentRef.setInput('schemaResponses', newResponses);
-    fixture.detectChanges();
+  it('should compute registryApproved from revisionState', () => {
+    const { fixture, component } = setup();
 
-    expect(component.schemaResponses()).toEqual(newResponses);
-  });
+    expect(component.registryApproved()).toBe(true);
 
-  it('should update when selectedRevisionIndex input changes', () => {
-    fixture.componentRef.setInput('selectedRevisionIndex', 1);
+    fixture.componentRef.setInput('registry', {
+      ...MOCK_REGISTRY,
+      revisionState: RevisionReviewStates.RevisionInProgress,
+    });
     fixture.detectChanges();
-
-    expect(component.selectedRevisionIndex()).toBe(1);
+    expect(component.registryApproved()).toBe(false);
   });
 
-  it('should update isSubmitting input', () => {
-    fixture.componentRef.setInput('isSubmitting', true);
-    fixture.detectChanges();
+  it('should compute registryAcceptedUnapproved when both conditions met', () => {
+    const { fixture, component } = setup();
 
-    expect(component.isSubmitting()).toBe(true);
-  });
+    expect(component.registryAcceptedUnapproved()).toBe(false);
 
-  it('should update isModeration input', () => {
-    fixture.componentRef.setInput('isModeration', true);
-    fixture.detectChanges();
-
-    expect(component.isModeration()).toBe(true);
-  });
-
-  it('should update canEdit input', () => {
-    fixture.componentRef.setInput('canEdit', true);
+    fixture.componentRef.setInput('registry', {
+      ...MOCK_REGISTRY,
+      revisionState: RevisionReviewStates.Unapproved,
+      reviewsState: RegistrationReviewStates.Accepted,
+    });
     fixture.detectChanges();
-
-    expect(component.canEdit()).toBe(true);
+    expect(component.registryAcceptedUnapproved()).toBe(true);
   });
 
-  describe('registryInProgress', () => {
-    it('should return false when revisionState is not RevisionInProgress', () => {
-      expect(component.registryInProgress).toBe(false);
-    });
+  it('should compute unApprovedRevisionId when registryAcceptedUnapproved', () => {
+    const { fixture, component } = setup();
 
-    it('should return true when revisionState is RevisionInProgress', () => {
-      const inProgressRegistry = { ...mockRegistry, revisionState: RevisionReviewStates.RevisionInProgress };
-      fixture.componentRef.setInput('registry', inProgressRegistry);
-      fixture.detectChanges();
+    expect(component.unApprovedRevisionId()).toBeNull();
 
-      expect(component.registryInProgress).toBe(true);
+    fixture.componentRef.setInput('registry', {
+      ...MOCK_REGISTRY,
+      revisionState: RevisionReviewStates.Unapproved,
+      reviewsState: RegistrationReviewStates.Accepted,
     });
+    fixture.componentRef.setInput('schemaResponses', [
+      createMockSchemaResponse('approved-1', RevisionReviewStates.Approved, false),
+      createMockSchemaResponse('unapproved-1', RevisionReviewStates.Unapproved, false),
+    ]);
+    fixture.detectChanges();
 
-    it('should return false when registry is null', () => {
-      fixture.componentRef.setInput('registry', null);
-      fixture.detectChanges();
-
-      expect(component.registryInProgress).toBe(false);
-    });
+    expect(component.unApprovedRevisionId()).toBe('unapproved-1');
   });
 
-  describe('registryApproved', () => {
-    it('should return true when revisionState is Approved', () => {
-      expect(component.registryApproved).toBe(true);
-    });
-
-    it('should return false when revisionState is not Approved', () => {
-      const notApprovedRegistry = { ...mockRegistry, revisionState: RevisionReviewStates.RevisionInProgress };
-      fixture.componentRef.setInput('registry', notApprovedRegistry);
-      fixture.detectChanges();
-
-      expect(component.registryApproved).toBe(false);
-    });
-
-    it('should return false when registry is null', () => {
-      fixture.componentRef.setInput('registry', null);
-      fixture.detectChanges();
+  it('should label single revision as original', () => {
+    const { fixture, component } = setup();
+    fixture.componentRef.setInput('schemaResponses', [
+      createMockSchemaResponse('single', RevisionReviewStates.Approved, true),
+    ]);
+    fixture.detectChanges();
 
-      expect(component.registryApproved).toBe(false);
-    });
+    expect(component.revisions()).toHaveLength(1);
+    expect(component.revisions()[0].label).toBe('registry.overview.original');
   });
 
-  describe('registryAcceptedUnapproved', () => {
-    it('should return false when conditions are not met', () => {
-      expect(component.registryAcceptedUnapproved).toBe(false);
-    });
-
-    it('should return true when revisionState is Unapproved and reviewsState is Accepted', () => {
-      const unapprovedRegistry = {
-        ...mockRegistry,
-        revisionState: RevisionReviewStates.Unapproved,
-        reviewsState: RegistrationReviewStates.Accepted,
-      };
-      fixture.componentRef.setInput('registry', unapprovedRegistry);
-      fixture.detectChanges();
-
-      expect(component.registryAcceptedUnapproved).toBe(true);
-    });
-
-    it('should return false when revisionState is Unapproved but reviewsState is not Accepted', () => {
-      const unapprovedRegistry = {
-        ...mockRegistry,
-        revisionState: RevisionReviewStates.Unapproved,
-        reviewsState: RegistrationReviewStates.Pending,
-      };
-      fixture.componentRef.setInput('registry', unapprovedRegistry);
-      fixture.detectChanges();
-
-      expect(component.registryAcceptedUnapproved).toBe(false);
-    });
-
-    it('should return false when reviewsState is Accepted but revisionState is not Unapproved', () => {
-      const approvedRegistry = {
-        ...mockRegistry,
-        revisionState: RevisionReviewStates.Approved,
-        reviewsState: RegistrationReviewStates.Accepted,
-      };
-      fixture.componentRef.setInput('registry', approvedRegistry);
-      fixture.detectChanges();
+  it('should label first as latest and last as original for multiple revisions', () => {
+    const { component } = setup();
+    const revisions = component.revisions();
 
-      expect(component.registryAcceptedUnapproved).toBe(false);
-    });
-
-    it('should return false when registry is null', () => {
-      fixture.componentRef.setInput('registry', null);
-      fixture.detectChanges();
-
-      expect(component.registryAcceptedUnapproved).toBe(false);
-    });
+    expect(revisions[0].label).toBe('registry.overview.latest');
+    expect(revisions[revisions.length - 1].label).toBe('registry.overview.original');
   });
 
-  describe('revisions computed signal', () => {
-    it('should return empty array when schemaResponses is empty', () => {
-      fixture.componentRef.setInput('schemaResponses', []);
-      fixture.detectChanges();
-
-      expect(component.revisions()).toHaveLength(0);
-    });
-
-    it('should handle null schemaResponses', () => {
-      fixture.componentRef.setInput('schemaResponses', null as any);
-      fixture.detectChanges();
-
-      expect(component.revisions()).toHaveLength(0);
-    });
-
-    it('should assign "original" label when there is only one revision', () => {
-      const singleResponse = [createMockSchemaResponse('single', RevisionReviewStates.Approved, true)];
-      fixture.componentRef.setInput('schemaResponses', singleResponse);
-      fixture.detectChanges();
-
-      const revisions = component.revisions();
-      expect(revisions).toHaveLength(1);
-      expect(revisions[0].label).toBe('registry.overview.original');
-    });
-
-    it('should assign "latest" label to first revision when multiple revisions exist', () => {
-      const revisions = component.revisions();
-      expect(revisions[0].label).toBe('registry.overview.latest');
-    });
-
-    it('should assign "original" label to last revision when multiple revisions exist', () => {
-      const revisions = component.revisions();
-      const lastIndex = revisions.length - 1;
-      expect(revisions[lastIndex].label).toBe('registry.overview.original');
-    });
+  it('should mark correct revision as selected', () => {
+    const { fixture, component } = setup();
 
-    it('should mark revision as selected when index matches selectedRevisionIndex', () => {
-      fixture.componentRef.setInput('selectedRevisionIndex', 0);
-      fixture.detectChanges();
+    expect(component.revisions()[0].isSelected).toBe(true);
+    expect(component.revisions()[1].isSelected).toBe(false);
 
-      const revisions = component.revisions();
-      expect(revisions[0].isSelected).toBe(true);
-      expect(revisions[1].isSelected).toBe(false);
-    });
-
-    it('should update isSelected when selectedRevisionIndex changes', () => {
-      fixture.componentRef.setInput('selectedRevisionIndex', 1);
-      fixture.detectChanges();
+    fixture.componentRef.setInput('selectedRevisionIndex', 1);
+    fixture.detectChanges();
 
-      const revisions = component.revisions();
-      expect(revisions[0].isSelected).toBe(false);
-      expect(revisions[1].isSelected).toBe(true);
-    });
+    expect(component.revisions()[0].isSelected).toBe(false);
+    expect(component.revisions()[1].isSelected).toBe(true);
+  });
 
-    it('should show all revisions when isModeration is true', () => {
-      const responsesWithUnapproved = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        createMockSchemaResponse('response-2', RevisionReviewStates.Unapproved, false),
-        createMockSchemaResponse('response-3', RevisionReviewStates.Approved, true),
-      ];
-      fixture.componentRef.setInput('schemaResponses', responsesWithUnapproved);
-      fixture.componentRef.setInput('isModeration', true);
-      fixture.detectChanges();
-
-      const revisions = component.revisions();
-      expect(revisions).toHaveLength(3);
-    });
+  it('should show all revisions in moderation mode', () => {
+    const { fixture, component } = setup();
+    fixture.componentRef.setInput('schemaResponses', [
+      createMockSchemaResponse('r-1', RevisionReviewStates.Approved, false),
+      createMockSchemaResponse('r-2', RevisionReviewStates.Unapproved, false),
+      createMockSchemaResponse('r-3', RevisionReviewStates.Approved, true),
+    ]);
+    fixture.componentRef.setInput('isModeration', true);
+    fixture.detectChanges();
 
-    it('should filter to only Approved or isOriginalResponse when isModeration is false', () => {
-      const responsesWithUnapproved = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        createMockSchemaResponse('response-2', RevisionReviewStates.Unapproved, false),
-        createMockSchemaResponse('response-3', RevisionReviewStates.Approved, true),
-      ];
-      fixture.componentRef.setInput('schemaResponses', responsesWithUnapproved);
-      fixture.componentRef.setInput('isModeration', false);
-      fixture.detectChanges();
-
-      const revisions = component.revisions();
-      expect(revisions).toHaveLength(2);
-      expect(revisions.every((r) => r.reviewsState === RevisionReviewStates.Approved || r.isOriginalResponse)).toBe(
-        true
-      );
-    });
+    expect(component.revisions()).toHaveLength(3);
+  });
 
-    it('should include original response even if not approved when isModeration is false', () => {
-      const responsesWithUnapprovedOriginal = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        createMockSchemaResponse('response-2', RevisionReviewStates.Unapproved, true),
-      ];
-      fixture.componentRef.setInput('schemaResponses', responsesWithUnapprovedOriginal);
-      fixture.componentRef.setInput('isModeration', false);
-      fixture.detectChanges();
-
-      const revisions = component.revisions();
-      expect(revisions).toHaveLength(2);
-      expect(revisions.some((r) => r.isOriginalResponse)).toBe(true);
-    });
+  it('should filter to approved or original when not in moderation', () => {
+    const { fixture, component } = setup();
+    fixture.componentRef.setInput('schemaResponses', [
+      createMockSchemaResponse('r-1', RevisionReviewStates.Approved, false),
+      createMockSchemaResponse('r-2', RevisionReviewStates.Unapproved, false),
+      createMockSchemaResponse('r-3', RevisionReviewStates.Approved, true),
+    ]);
+    fixture.componentRef.setInput('isModeration', false);
+    fixture.detectChanges();
 
-    it('should set unApprovedRevisionId when registryAcceptedUnapproved is true', () => {
-      const unapprovedResponse = createMockSchemaResponse('unapproved-id', RevisionReviewStates.Unapproved, false);
-      const responses = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        unapprovedResponse,
-      ];
-      const unapprovedRegistry = {
-        ...mockRegistry,
-        revisionState: RevisionReviewStates.Unapproved,
-        reviewsState: RegistrationReviewStates.Accepted,
-      };
-
-      fixture.componentRef.setInput('registry', unapprovedRegistry);
-      fixture.componentRef.setInput('schemaResponses', responses);
-      fixture.detectChanges();
-
-      expect(component.unApprovedRevisionId).toBe('unapproved-id');
-    });
+    expect(component.revisions()).toHaveLength(2);
+  });
 
-    it('should set unApprovedRevisionId to null when no unapproved revision found', () => {
-      const responses = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        createMockSchemaResponse('response-2', RevisionReviewStates.Approved, true),
-      ];
-      const unapprovedRegistry = {
-        ...mockRegistry,
-        revisionState: RevisionReviewStates.Unapproved,
-        reviewsState: RegistrationReviewStates.Accepted,
-      };
-
-      fixture.componentRef.setInput('registry', unapprovedRegistry);
-      fixture.componentRef.setInput('schemaResponses', responses);
-      fixture.detectChanges();
-
-      expect(component.unApprovedRevisionId).toBe(null);
-    });
+  it('should emit openRevision on emitOpenRevision', () => {
+    const { component } = setup();
+    const spy = jest.fn();
+    component.openRevision.subscribe(spy);
 
-    it('should not set unApprovedRevisionId when registryAcceptedUnapproved is false', () => {
-      const unapprovedResponse = createMockSchemaResponse('unapproved-id', RevisionReviewStates.Unapproved, false);
-      const responses = [
-        createMockSchemaResponse('response-1', RevisionReviewStates.Approved, false),
-        unapprovedResponse,
-      ];
+    component.emitOpenRevision(1);
 
-      fixture.componentRef.setInput('schemaResponses', responses);
-      fixture.detectChanges();
+    expect(spy).toHaveBeenCalledWith(1);
+  });
 
-      expect(component.unApprovedRevisionId).toBe(null);
-    });
+  it('should emit continueUpdate on continueUpdateHandler', () => {
+    const { component } = setup();
+    const spy = jest.fn();
+    component.continueUpdate.subscribe(spy);
 
-    it('should assign correct indices to revisions', () => {
-      const revisions = component.revisions();
-      revisions.forEach((revision, expectedIndex) => {
-        expect(revision.index).toBe(expectedIndex);
-      });
-    });
+    component.continueUpdateHandler();
 
-    it('should preserve all response properties in revisions', () => {
-      const revisions = component.revisions();
-      expect(revisions[0].id).toBe(mockSchemaResponses[0].id);
-      expect(revisions[0].dateCreated).toBe(mockSchemaResponses[0].dateCreated);
-      expect(revisions[0].reviewsState).toBe(mockSchemaResponses[0].reviewsState);
-    });
+    expect(spy).toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/registry-revisions/registry-revisions.component.ts b/src/app/features/registry/components/registry-revisions/registry-revisions.component.ts
index b3ad25218..46560bbcf 100644
--- a/src/app/features/registry/components/registry-revisions/registry-revisions.component.ts
+++ b/src/app/features/registry/components/registry-revisions/registry-revisions.component.ts
@@ -33,16 +33,26 @@ export class RegistryRevisionsComponent {
   readonly continueUpdate = output<void>();
   readonly RevisionReviewStates = RevisionReviewStates;
 
-  unApprovedRevisionId: string | null = null;
+  readonly registryInProgress = computed(
+    () => this.registry()?.revisionState === RevisionReviewStates.RevisionInProgress
+  );
+
+  readonly registryApproved = computed(() => this.registry()?.revisionState === RevisionReviewStates.Approved);
+
+  readonly registryAcceptedUnapproved = computed(
+    () =>
+      this.registry()?.revisionState === RevisionReviewStates.Unapproved &&
+      this.registry()?.reviewsState === RegistrationReviewStates.Accepted
+  );
+
+  readonly unApprovedRevisionId = computed(() => {
+    if (!this.registryAcceptedUnapproved()) return null;
+    return this.schemaResponses()?.find((r) => r.reviewsState === RevisionReviewStates.Unapproved)?.id ?? null;
+  });
 
   revisions = computed(() => {
     let schemaResponses = this.schemaResponses() || [];
 
-    if (this.registryAcceptedUnapproved) {
-      this.unApprovedRevisionId =
-        schemaResponses.find((response) => response.reviewsState === RevisionReviewStates.Unapproved)?.id || null;
-    }
-
     schemaResponses = this.isModeration()
       ? schemaResponses
       : schemaResponses.filter((r) => r.reviewsState === RevisionReviewStates.Approved || r.isOriginalResponse);
@@ -65,21 +75,6 @@ export class RegistryRevisionsComponent {
     });
   });
 
-  get registryInProgress(): boolean {
-    return this.registry()?.revisionState === RevisionReviewStates.RevisionInProgress;
-  }
-
-  get registryApproved(): boolean {
-    return this.registry()?.revisionState === RevisionReviewStates.Approved;
-  }
-
-  get registryAcceptedUnapproved(): boolean {
-    return (
-      this.registry()?.revisionState === RevisionReviewStates.Unapproved &&
-      this.registry()?.reviewsState === RegistrationReviewStates.Accepted
-    );
-  }
-
   emitOpenRevision(index: number) {
     this.openRevision.emit(index);
   }
diff --git a/src/app/features/registry/components/registry-statuses/registry-statuses.component.html b/src/app/features/registry/components/registry-statuses/registry-statuses.component.html
index 04f31e1d1..016932507 100644
--- a/src/app/features/registry/components/registry-statuses/registry-statuses.component.html
+++ b/src/app/features/registry/components/registry-statuses/registry-statuses.component.html
@@ -11,7 +11,7 @@ <h3 class="font-normal">{{ 'registry.overview.statuses.' + registry()?.status +
           <span>
             {{
               'registry.overview.statuses.' + registry()?.status + '.long'
-                | translate: { embargoEndDate: embargoEndDate, email: supportEmail }
+                | translate: { embargoEndDate: embargoEndDate(), email: supportEmail }
             }}
           </span>
 
diff --git a/src/app/features/registry/components/registry-statuses/registry-statuses.component.spec.ts b/src/app/features/registry/components/registry-statuses/registry-statuses.component.spec.ts
index d7ce9a8b5..5b94caebd 100644
--- a/src/app/features/registry/components/registry-statuses/registry-statuses.component.spec.ts
+++ b/src/app/features/registry/components/registry-statuses/registry-statuses.component.spec.ts
@@ -2,12 +2,11 @@ import { Store } from '@ngxs/store';
 
 import { MockProvider } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute } from '@angular/router';
 
-import { ENVIRONMENT } from '@core/provider/environment.provider';
 import { RegistrationReviewStates } from '@osf/shared/enums/registration-review-states.enum';
 import { RegistryStatus } from '@osf/shared/enums/registry-status.enum';
-import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
 import { CustomConfirmationService } from '@osf/shared/services/custom-confirmation.service';
 import { CustomDialogService } from '@osf/shared/services/custom-dialog.service';
 
@@ -16,218 +15,150 @@ import { MakePublic } from '../../store/registry';
 import { RegistryStatusesComponent } from './registry-statuses.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
-import { CustomConfirmationServiceMockBuilder } from '@testing/providers/custom-confirmation-provider.mock';
-import { CustomDialogServiceMockBuilder } from '@testing/providers/custom-dialog-provider.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { CustomConfirmationServiceMock } from '@testing/providers/custom-confirmation-provider.mock';
+import { CustomDialogServiceMock } from '@testing/providers/custom-dialog-provider.mock';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistryStatusesComponent', () => {
-  let component: RegistryStatusesComponent;
-  let fixture: ComponentFixture<RegistryStatusesComponent>;
-  let mockCustomDialogService: ReturnType<CustomDialogServiceMockBuilder['build']>;
-  let mockCustomConfirmationService: ReturnType<CustomConfirmationServiceMockBuilder['build']>;
-  let store: Store;
-
-  const mockRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, embargoEndDate: '2024-01-01T00:00:00Z' };
-  const mockEnvironment = { supportEmail: 'support@osf.io' };
-
-  beforeEach(async () => {
-    mockCustomDialogService = CustomDialogServiceMockBuilder.create().withDefaultOpen().build();
-    mockCustomConfirmationService = CustomConfirmationServiceMockBuilder.create().build();
-
-    await TestBed.configureTestingModule({
-      imports: [RegistryStatusesComponent, OSFTestingModule],
-      providers: [
-        MockProvider(CustomDialogService, mockCustomDialogService),
-        MockProvider(CustomConfirmationService, mockCustomConfirmationService),
-        MockProvider(ENVIRONMENT, mockEnvironment),
-        provideMockStore({
-          signals: [],
-        }),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistryStatusesComponent);
-    component = fixture.componentInstance;
-    store = TestBed.inject(Store);
-
-    fixture.componentRef.setInput('registry', mockRegistry);
-    fixture.detectChanges();
+const MOCK_REGISTRY = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, embargoEndDate: '2024-01-01T00:00:00Z' };
+
+interface SetupOverrides {
+  registry?: typeof MOCK_REGISTRY | null;
+  canEdit?: boolean;
+  isModeration?: boolean;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const mockDialogService = CustomDialogServiceMock.simple();
+  const mockConfirmationService = CustomConfirmationServiceMock.simple();
+
+  TestBed.configureTestingModule({
+    imports: [RegistryStatusesComponent],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, ActivatedRouteMockBuilder.create().build()),
+      MockProvider(CustomDialogService, mockDialogService),
+      MockProvider(CustomConfirmationService, mockConfirmationService),
+      provideMockStore(),
+    ],
   });
 
-  it('should initialize with default input values', () => {
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryStatusesComponent);
+  fixture.componentRef.setInput('registry', overrides.registry ?? MOCK_REGISTRY);
+  fixture.componentRef.setInput('canEdit', overrides.canEdit ?? false);
+  fixture.componentRef.setInput('isModeration', overrides.isModeration ?? false);
+  fixture.detectChanges();
+
+  return { fixture, component: fixture.componentInstance, store, mockDialogService, mockConfirmationService };
+}
+
+describe('RegistryStatusesComponent', () => {
+  it('should create with default values', () => {
+    const { component } = setup();
+
+    expect(component).toBeTruthy();
     expect(component.canEdit()).toBe(false);
     expect(component.isModeration()).toBe(false);
   });
 
-  it('should initialize supportEmail from environment', () => {
-    expect(component.supportEmail).toBe('support@osf.io');
-  });
+  it('should compute canWithdraw as true when accepted and not moderation', () => {
+    const { component } = setup();
 
-  it('should expose RegistryStatus enum', () => {
-    expect(component.RegistryStatus).toBe(RegistryStatus);
+    expect(component.canWithdraw()).toBe(true);
   });
 
-  it('should expose RevisionReviewStates enum', () => {
-    expect(component.RevisionReviewStates).toBe(RevisionReviewStates);
-  });
+  it('should compute canWithdraw as false when not accepted', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRY, reviewsState: RegistrationReviewStates.Pending },
+    });
 
-  it('should receive registry input', () => {
-    expect(component.registry()).toEqual(mockRegistry);
+    expect(component.canWithdraw()).toBe(false);
   });
 
-  it('should update canEdit input', () => {
-    fixture.componentRef.setInput('canEdit', true);
-    fixture.detectChanges();
+  it('should compute canWithdraw as false when moderation', () => {
+    const { component } = setup({ isModeration: true });
 
-    expect(component.canEdit()).toBe(true);
+    expect(component.canWithdraw()).toBe(false);
   });
 
-  it('should update isModeration input', () => {
-    fixture.componentRef.setInput('isModeration', true);
-    fixture.detectChanges();
+  it('should compute isAccepted as true for Accepted status', () => {
+    const { component } = setup();
 
-    expect(component.isModeration()).toBe(true);
+    expect(component.isAccepted()).toBe(true);
+    expect(component.isEmbargo()).toBe(false);
   });
 
-  describe('canWithdraw', () => {
-    it('should return true when reviewsState is Accepted and isModeration is false', () => {
-      expect(component.canWithdraw()).toBe(true);
-    });
-
-    it('should return false when reviewsState is not Accepted', () => {
-      const registryWithPendingReview = { ...mockRegistry, reviewsState: RegistrationReviewStates.Pending };
-      fixture.componentRef.setInput('registry', registryWithPendingReview);
-      fixture.detectChanges();
-
-      expect(component.canWithdraw()).toBe(false);
-    });
-
-    it('should return false when isModeration is true', () => {
-      fixture.componentRef.setInput('isModeration', true);
-      fixture.detectChanges();
-
-      expect(component.canWithdraw()).toBe(false);
-    });
-
-    it('should return false when both conditions are not met', () => {
-      const registryWithPendingReview = { ...mockRegistry, reviewsState: RegistrationReviewStates.Pending };
-      fixture.componentRef.setInput('registry', registryWithPendingReview);
-      fixture.componentRef.setInput('isModeration', true);
-      fixture.detectChanges();
+  it('should compute isEmbargo as true for Embargo status', () => {
+    const { fixture, component } = setup();
+    fixture.componentRef.setInput('registry', { ...MOCK_REGISTRY, status: RegistryStatus.Embargo });
+    fixture.detectChanges();
 
-      expect(component.canWithdraw()).toBe(false);
-    });
+    expect(component.isAccepted()).toBe(false);
+    expect(component.isEmbargo()).toBe(true);
   });
 
-  describe('isAccepted', () => {
-    it('should return true when status is Accepted', () => {
-      expect(component.isAccepted()).toBe(true);
-    });
-
-    it('should return false when status is not Accepted', () => {
-      const registryWithDifferentStatus = { ...mockRegistry, status: RegistryStatus.Pending };
-      fixture.componentRef.setInput('registry', registryWithDifferentStatus);
-      fixture.detectChanges();
-
-      expect(component.isAccepted()).toBe(false);
-    });
-
-    it('should return false when status is Embargo', () => {
-      const embargoRegistry = { ...mockRegistry, status: RegistryStatus.Embargo };
-      fixture.componentRef.setInput('registry', embargoRegistry);
-      fixture.detectChanges();
+  it('should compute embargoEndDate from registry', () => {
+    const { component } = setup();
 
-      expect(component.isAccepted()).toBe(false);
-    });
+    expect(component.embargoEndDate()).toBe(new Date('2024-01-01T00:00:00Z').toDateString());
   });
 
-  describe('isEmbargo', () => {
-    it('should return false when status is not Embargo', () => {
-      expect(component.isEmbargo()).toBe(false);
+  it('should return null embargoEndDate when not set', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRY, embargoEndDate: '' },
     });
 
-    it('should return true when status is Embargo', () => {
-      const embargoRegistry = { ...mockRegistry, status: RegistryStatus.Embargo };
-      fixture.componentRef.setInput('registry', embargoRegistry);
-      fixture.detectChanges();
-
-      expect(component.isEmbargo()).toBe(true);
-    });
+    expect(component.embargoEndDate()).toBeNull();
   });
 
-  describe('embargoEndDate getter', () => {
-    it('should format embargo end date correctly', () => {
-      const date = new Date('2024-01-01T00:00:00Z').toDateString();
-      expect(component.embargoEndDate).toBe(date);
-    });
+  it('should open withdraw dialog with correct parameters', () => {
+    const { component, mockDialogService } = setup();
 
-    it('should return null when registry has no embargo end date', () => {
-      const registryWithoutEmbargo = { ...mockRegistry, embargoEndDate: undefined };
-      fixture.componentRef.setInput('registry', registryWithoutEmbargo);
-      fixture.detectChanges();
+    component.openWithdrawDialog();
 
-      expect(component.embargoEndDate).toBe(null);
+    expect(mockDialogService.open).toHaveBeenCalledWith(expect.any(Function), {
+      header: 'registry.overview.withdrawRegistration',
+      width: '552px',
+      data: { registryId: MOCK_REGISTRY.id },
     });
   });
 
-  describe('openWithdrawDialog', () => {
-    it('should open withdraw dialog with correct parameters', () => {
-      component.openWithdrawDialog();
-
-      expect(mockCustomDialogService.open).toHaveBeenCalledWith(expect.any(Function), {
-        header: 'registry.overview.withdrawRegistration',
-        width: '552px',
-        data: {
-          registryId: mockRegistry.id,
-        },
-      });
-    });
-
-    it('should use correct registryId from registry', () => {
-      const registryWithDifferentId = { ...mockRegistry, id: 'different-registry-id' };
-      fixture.componentRef.setInput('registry', registryWithDifferentId);
-      fixture.detectChanges();
+  it('should not open withdraw dialog when registry is null', () => {
+    const { fixture, component, mockDialogService } = setup();
+    fixture.componentRef.setInput('registry', null);
+    fixture.detectChanges();
+    mockDialogService.open.mockClear();
 
-      component.openWithdrawDialog();
+    component.openWithdrawDialog();
 
-      expect(mockCustomDialogService.open).toHaveBeenCalledWith(expect.any(Function), {
-        header: 'registry.overview.withdrawRegistration',
-        width: '552px',
-        data: {
-          registryId: 'different-registry-id',
-        },
-      });
-    });
+    expect(mockDialogService.open).not.toHaveBeenCalled();
   });
 
-  describe('openEndEmbargoDialog', () => {
-    it('should call confirmDelete with correct parameters', () => {
-      component.openEndEmbargoDialog();
+  it('should call confirmDelete and dispatch MakePublic on confirm', () => {
+    const { component, store, mockConfirmationService } = setup();
+    jest.spyOn(store, 'dispatch');
+
+    (mockConfirmationService.confirmDelete as jest.Mock).mockImplementation((opts) => opts.onConfirm());
+    component.openEndEmbargoDialog();
 
-      expect(mockCustomConfirmationService.confirmDelete).toHaveBeenCalledWith({
+    expect(mockConfirmationService.confirmDelete).toHaveBeenCalledWith(
+      expect.objectContaining({
         headerKey: 'registry.overview.endEmbargo',
         messageKey: 'registry.overview.endEmbargoMessage',
-        acceptLabelKey: 'common.buttons.confirm',
-        onConfirm: expect.any(Function),
-      });
-    });
-
-    it('should dispatch MakePublic with correct registryId', () => {
-      const dispatchSpy = jest.spyOn(store, 'dispatch');
-      const registryWithDifferentId = { ...mockRegistry, id: 'different-registry-id' };
-      fixture.componentRef.setInput('registry', registryWithDifferentId);
-      fixture.detectChanges();
+      })
+    );
+    expect(store.dispatch).toHaveBeenCalledWith(new MakePublic(MOCK_REGISTRY.id));
+  });
 
-      let onConfirmCallback: () => void;
-      (mockCustomConfirmationService.confirmDelete as jest.Mock).mockImplementation((options) => {
-        onConfirmCallback = options.onConfirm;
-      });
+  it('should not call confirmDelete when registry is null', () => {
+    const { fixture, component, mockConfirmationService } = setup();
+    fixture.componentRef.setInput('registry', null);
+    fixture.detectChanges();
 
-      component.openEndEmbargoDialog();
-      onConfirmCallback!();
+    component.openEndEmbargoDialog();
 
-      expect(dispatchSpy).toHaveBeenCalledWith(new MakePublic('different-registry-id'));
-    });
+    expect(mockConfirmationService.confirmDelete).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/registry-statuses/registry-statuses.component.ts b/src/app/features/registry/components/registry-statuses/registry-statuses.component.ts
index 269bca972..abf8b81e9 100644
--- a/src/app/features/registry/components/registry-statuses/registry-statuses.component.ts
+++ b/src/app/features/registry/components/registry-statuses/registry-statuses.component.ts
@@ -21,7 +21,7 @@ import { MakePublic } from '../../store/registry';
 
 @Component({
   selector: 'osf-registry-statuses',
-  imports: [Accordion, AccordionContent, AccordionHeader, AccordionPanel, TranslatePipe, Button, RouterLink],
+  imports: [Accordion, AccordionContent, AccordionHeader, AccordionPanel, Button, RouterLink, TranslatePipe],
   templateUrl: './registry-statuses.component.html',
   styleUrl: './registry-statuses.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
@@ -29,6 +29,7 @@ import { MakePublic } from '../../store/registry';
 export class RegistryStatusesComponent {
   @HostBinding('class') classes = 'flex-1 flex';
   private readonly customDialogService = inject(CustomDialogService);
+  private readonly customConfirmationService = inject(CustomConfirmationService);
   private readonly environment = inject(ENVIRONMENT);
 
   readonly supportEmail = this.environment.supportEmail;
@@ -39,8 +40,8 @@ export class RegistryStatusesComponent {
 
   readonly RegistryStatus = RegistryStatus;
   readonly RevisionReviewStates = RevisionReviewStates;
-  readonly customConfirmationService = inject(CustomConfirmationService);
-  readonly actions = createDispatchMap({ makePublic: MakePublic });
+
+  private readonly actions = createDispatchMap({ makePublic: MakePublic });
 
   canWithdraw = computed(
     () => this.registry()?.reviewsState === RegistrationReviewStates.Accepted && !this.isModeration()
@@ -49,13 +50,10 @@ export class RegistryStatusesComponent {
   isAccepted = computed(() => this.registry()?.status === RegistryStatus.Accepted);
   isEmbargo = computed(() => this.registry()?.status === RegistryStatus.Embargo);
 
-  get embargoEndDate() {
-    const embargoEndDate = this.registry()?.embargoEndDate;
-    if (embargoEndDate) {
-      return new Date(embargoEndDate).toDateString();
-    }
-    return null;
-  }
+  readonly embargoEndDate = computed(() => {
+    const date = this.registry()?.embargoEndDate;
+    return date ? new Date(date).toDateString() : null;
+  });
 
   openWithdrawDialog(): void {
     const registry = this.registry();
@@ -73,6 +71,7 @@ export class RegistryStatusesComponent {
 
   openEndEmbargoDialog(): void {
     const registry = this.registry();
+
     if (registry) {
       this.customConfirmationService.confirmDelete({
         headerKey: 'registry.overview.endEmbargo',
diff --git a/src/app/features/registry/components/resource-form/resource-form.component.html b/src/app/features/registry/components/resource-form/resource-form.component.html
index 0f8b5ff09..1bd7f2189 100644
--- a/src/app/features/registry/components/resource-form/resource-form.component.html
+++ b/src/app/features/registry/components/resource-form/resource-form.component.html
@@ -12,7 +12,7 @@
 
   <osf-form-select
     [fullWidth]="true"
-    [options]="resourceOptions()"
+    [options]="resourceOptions"
     [appendTo]="'body'"
     [control]="getControl('resourceType')"
     [placeholder]="'resources.selectAResourceType'"
@@ -41,8 +41,8 @@
     }
     <p-button
       class="btn-full-width"
+      type="submit"
       [label]="primaryButtonLabel() | translate"
-      (onClick)="handleSubmit()"
       [disabled]="formGroup().invalid"
     />
   </div>
diff --git a/src/app/features/registry/components/resource-form/resource-form.component.spec.ts b/src/app/features/registry/components/resource-form/resource-form.component.spec.ts
index 7bbfcbc13..dfd97a12b 100644
--- a/src/app/features/registry/components/resource-form/resource-form.component.spec.ts
+++ b/src/app/features/registry/components/resource-form/resource-form.component.spec.ts
@@ -2,125 +2,78 @@ import { MockComponents, MockDirective } from 'ng-mocks';
 
 import { Textarea } from 'primeng/textarea';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 import { FormControl, FormGroup } from '@angular/forms';
 
 import { FormSelectComponent } from '@osf/shared/components/form-select/form-select.component';
 import { TextInputComponent } from '@osf/shared/components/text-input/text-input.component';
-import { InputLimits } from '@osf/shared/constants/input-limits.const';
 
 import { resourceTypeOptions } from '../../constants';
 import { RegistryResourceFormModel } from '../../models';
 
 import { ResourceFormComponent } from './resource-form.component';
 
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 
-describe('ResourceFormComponent', () => {
-  let component: ResourceFormComponent;
-  let fixture: ComponentFixture<ResourceFormComponent>;
-
-  const mockFormGroup = new FormGroup<RegistryResourceFormModel>({
-    pid: new FormControl('10.1234/test'),
-    resourceType: new FormControl('dataset'),
-    description: new FormControl('Test description'),
-  });
+const MOCK_FORM_GROUP = new FormGroup<RegistryResourceFormModel>({
+  pid: new FormControl('10.1234/test'),
+  resourceType: new FormControl('dataset'),
+  description: new FormControl('Test description'),
+});
 
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
+describe('ResourceFormComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
       imports: [
         ResourceFormComponent,
-        OSFTestingModule,
-        ...MockComponents(TextInputComponent, FormSelectComponent),
+        ...MockComponents(FormSelectComponent, TextInputComponent),
         MockDirective(Textarea),
       ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(ResourceFormComponent);
-    component = fixture.componentInstance;
-
-    fixture.componentRef.setInput('formGroup', mockFormGroup);
-    fixture.detectChanges();
-  });
-
-  it('should initialize inputLimits with InputLimits constant', () => {
-    expect(component.inputLimits).toBe(InputLimits);
-  });
-
-  it('should initialize resourceOptions signal with resourceTypeOptions', () => {
-    expect(component.resourceOptions()).toEqual(resourceTypeOptions);
-  });
-
-  it('should initialize with default input values', () => {
-    expect(component.showCancelButton()).toBe(true);
-    expect(component.showPreviewButton()).toBe(false);
-    expect(component.cancelButtonLabel()).toBe('common.buttons.cancel');
-    expect(component.primaryButtonLabel()).toBe('common.buttons.save');
-  });
-
-  it('should receive and store formGroup input', () => {
-    expect(component.formGroup()).toBe(mockFormGroup);
-  });
-
-  it('should update when formGroup input changes', () => {
-    const newFormGroup = new FormGroup<RegistryResourceFormModel>({
-      pid: new FormControl('10.1234/new-test'),
-      resourceType: new FormControl('software'),
-      description: new FormControl('New description'),
+      providers: [provideOSFCore()],
     });
-
-    fixture.componentRef.setInput('formGroup', newFormGroup);
-    fixture.detectChanges();
-
-    expect(component.formGroup()).toBe(newFormGroup);
   });
 
-  it('should return correct control for pid', () => {
-    const control = component.getControl('pid');
-    expect(control).toBe(mockFormGroup.get('pid'));
-    expect(control?.value).toBe('10.1234/test');
-  });
-
-  it('should update showCancelButton input', () => {
-    fixture.componentRef.setInput('showCancelButton', false);
+  it('should create with default input values', () => {
+    const fixture = TestBed.createComponent(ResourceFormComponent);
+    fixture.componentRef.setInput('formGroup', MOCK_FORM_GROUP);
     fixture.detectChanges();
 
-    expect(component.showCancelButton()).toBe(false);
+    expect(fixture.componentInstance).toBeTruthy();
+    expect(fixture.componentInstance.showCancelButton()).toBe(true);
+    expect(fixture.componentInstance.showPreviewButton()).toBe(false);
+    expect(fixture.componentInstance.resourceOptions).toEqual(resourceTypeOptions);
   });
 
-  it('should update showPreviewButton input', () => {
-    fixture.componentRef.setInput('showPreviewButton', true);
+  it('should return correct form control via getControl', () => {
+    const fixture = TestBed.createComponent(ResourceFormComponent);
+    fixture.componentRef.setInput('formGroup', MOCK_FORM_GROUP);
     fixture.detectChanges();
 
-    expect(component.showPreviewButton()).toBe(true);
+    expect(fixture.componentInstance.getControl('pid')).toBe(MOCK_FORM_GROUP.get('pid'));
+    expect(fixture.componentInstance.getControl('pid')?.value).toBe('10.1234/test');
   });
 
-  it('should update cancelButtonLabel input', () => {
-    const customLabel = 'Custom Cancel';
-    fixture.componentRef.setInput('cancelButtonLabel', customLabel);
+  it('should emit cancelClicked on handleCancel', () => {
+    const fixture = TestBed.createComponent(ResourceFormComponent);
+    fixture.componentRef.setInput('formGroup', MOCK_FORM_GROUP);
     fixture.detectChanges();
 
-    expect(component.cancelButtonLabel()).toBe(customLabel);
-  });
-
-  it('should update primaryButtonLabel input', () => {
-    const customLabel = 'Custom Save';
-    fixture.componentRef.setInput('primaryButtonLabel', customLabel);
-    fixture.detectChanges();
+    const spy = jest.fn();
+    fixture.componentInstance.cancelClicked.subscribe(spy);
+    fixture.componentInstance.handleCancel();
 
-    expect(component.primaryButtonLabel()).toBe(customLabel);
+    expect(spy).toHaveBeenCalled();
   });
 
-  it('should handle multiple input updates simultaneously', () => {
-    fixture.componentRef.setInput('showCancelButton', false);
-    fixture.componentRef.setInput('showPreviewButton', true);
-    fixture.componentRef.setInput('cancelButtonLabel', 'Custom Cancel');
-    fixture.componentRef.setInput('primaryButtonLabel', 'Custom Save');
+  it('should emit submitClicked on handleSubmit', () => {
+    const fixture = TestBed.createComponent(ResourceFormComponent);
+    fixture.componentRef.setInput('formGroup', MOCK_FORM_GROUP);
     fixture.detectChanges();
 
-    expect(component.showCancelButton()).toBe(false);
-    expect(component.showPreviewButton()).toBe(true);
-    expect(component.cancelButtonLabel()).toBe('Custom Cancel');
-    expect(component.primaryButtonLabel()).toBe('Custom Save');
+    const spy = jest.fn();
+    fixture.componentInstance.submitClicked.subscribe(spy);
+    fixture.componentInstance.handleSubmit();
+
+    expect(spy).toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/components/resource-form/resource-form.component.ts b/src/app/features/registry/components/resource-form/resource-form.component.ts
index 98db1e4fa..f1462e463 100644
--- a/src/app/features/registry/components/resource-form/resource-form.component.ts
+++ b/src/app/features/registry/components/resource-form/resource-form.component.ts
@@ -3,20 +3,19 @@ import { TranslatePipe } from '@ngx-translate/core';
 import { Button } from 'primeng/button';
 import { Textarea } from 'primeng/textarea';
 
-import { ChangeDetectionStrategy, Component, input, output, signal } from '@angular/core';
+import { ChangeDetectionStrategy, Component, input, output } from '@angular/core';
 import { FormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';
 
 import { FormSelectComponent } from '@osf/shared/components/form-select/form-select.component';
 import { TextInputComponent } from '@osf/shared/components/text-input/text-input.component';
 import { InputLimits } from '@osf/shared/constants/input-limits.const';
-import { SelectOption } from '@shared/models/select-option.model';
 
 import { resourceTypeOptions } from '../../constants';
 import { RegistryResourceFormModel } from '../../models';
 
 @Component({
   selector: 'osf-resource-form',
-  imports: [TextInputComponent, TranslatePipe, ReactiveFormsModule, Textarea, FormSelectComponent, Button],
+  imports: [Button, Textarea, ReactiveFormsModule, FormSelectComponent, TextInputComponent, TranslatePipe],
   templateUrl: './resource-form.component.html',
   styleUrl: './resource-form.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
@@ -31,8 +30,8 @@ export class ResourceFormComponent {
   cancelClicked = output<void>();
   submitClicked = output<void>();
 
-  inputLimits = InputLimits;
-  resourceOptions = signal<SelectOption[]>(resourceTypeOptions);
+  readonly inputLimits = InputLimits;
+  readonly resourceOptions = resourceTypeOptions;
 
   getControl(controlName: keyof RegistryResourceFormModel): FormControl<string | null> {
     return this.formGroup().get(controlName) as FormControl<string | null>;
diff --git a/src/app/features/registry/components/short-registration-info/short-registration-info.component.spec.ts b/src/app/features/registry/components/short-registration-info/short-registration-info.component.spec.ts
index cb5c8c3e3..d51619d47 100644
--- a/src/app/features/registry/components/short-registration-info/short-registration-info.component.spec.ts
+++ b/src/app/features/registry/components/short-registration-info/short-registration-info.component.spec.ts
@@ -1,122 +1,66 @@
 import { Store } from '@ngxs/store';
 
-import { MockComponent } from 'ng-mocks';
+import { MockComponent, MockProvider } from 'ng-mocks';
 
 import { of } from 'rxjs';
 
-import { signal } from '@angular/core';
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute } from '@angular/router';
 
 import { ENVIRONMENT } from '@core/provider/environment.provider';
 import { ContributorsListComponent } from '@osf/shared/components/contributors-list/contributors-list.component';
 import { ResourceType } from '@osf/shared/enums/resource-type.enum';
 import { ContributorsSelectors, LoadMoreBibliographicContributors } from '@osf/shared/stores/contributors';
 
-import { RegistrationOverviewModel } from '../../models';
-
 import { ShortRegistrationInfoComponent } from './short-registration-info.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
 describe('ShortRegistrationInfoComponent', () => {
-  let component: ShortRegistrationInfoComponent;
-  let fixture: ComponentFixture<ShortRegistrationInfoComponent>;
-  let store: Store;
-
-  const mockRegistration: RegistrationOverviewModel = MOCK_REGISTRATION_OVERVIEW_MODEL;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [ShortRegistrationInfoComponent, OSFTestingModule, MockComponent(ContributorsListComponent)],
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [ShortRegistrationInfoComponent, MockComponent(ContributorsListComponent)],
       providers: [
+        provideOSFCore(),
+        MockProvider(ActivatedRoute, ActivatedRouteMockBuilder.create().build()),
         provideMockStore({
           signals: [
-            { selector: ContributorsSelectors.getBibliographicContributors, value: signal([]) },
-            { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: signal(false) },
-            { selector: ContributorsSelectors.hasMoreBibliographicContributors, value: signal(false) },
+            { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
+            { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
+            { selector: ContributorsSelectors.hasMoreBibliographicContributors, value: false },
           ],
         }),
       ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(ShortRegistrationInfoComponent);
-    component = fixture.componentInstance;
-    store = TestBed.inject(Store);
-
-    fixture.componentRef.setInput('registration', mockRegistration);
-    fixture.detectChanges();
+    });
   });
 
-  it('should receive registration input', () => {
-    expect(component.registration()).toEqual(mockRegistration);
-  });
+  it('should create and compute associatedProjectUrl', () => {
+    const fixture = TestBed.createComponent(ShortRegistrationInfoComponent);
+    fixture.componentRef.setInput('registration', MOCK_REGISTRATION_OVERVIEW_MODEL);
+    fixture.detectChanges();
 
-  it('should compute associatedProjectUrl from registration and environment', () => {
     const environment = TestBed.inject(ENVIRONMENT);
-    const expectedUrl = `${environment.webUrl}/${mockRegistration.associatedProjectId}`;
+    const expectedUrl = `${environment.webUrl}/${MOCK_REGISTRATION_OVERVIEW_MODEL.associatedProjectId}`;
 
-    expect(component.associatedProjectUrl()).toBe(expectedUrl);
+    expect(fixture.componentInstance).toBeTruthy();
+    expect(fixture.componentInstance.associatedProjectUrl()).toBe(expectedUrl);
   });
 
-  it('should update associatedProjectUrl when registration changes', () => {
-    const environment = TestBed.inject(ENVIRONMENT);
-    const newRegistration: RegistrationOverviewModel = {
-      ...mockRegistration,
-      associatedProjectId: 'new-project-id',
-    };
-
-    fixture.componentRef.setInput('registration', newRegistration);
+  it('should dispatch LoadMoreBibliographicContributors', () => {
+    const fixture = TestBed.createComponent(ShortRegistrationInfoComponent);
+    fixture.componentRef.setInput('registration', MOCK_REGISTRATION_OVERVIEW_MODEL);
     fixture.detectChanges();
 
-    expect(component.associatedProjectUrl()).toBe(`${environment.webUrl}/new-project-id`);
-  });
+    const store = TestBed.inject(Store);
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
 
-  it('should have bibliographicContributors signal', () => {
-    expect(component.bibliographicContributors).toBeDefined();
-    expect(typeof component.bibliographicContributors).toBe('function');
-  });
+    fixture.componentInstance.handleLoadMoreContributors();
 
-  it('should have isBibliographicContributorsLoading signal', () => {
-    expect(component.isBibliographicContributorsLoading).toBeDefined();
-    expect(typeof component.isBibliographicContributorsLoading).toBe('function');
-  });
-
-  it('should have hasMoreBibliographicContributors signal', () => {
-    expect(component.hasMoreBibliographicContributors).toBeDefined();
-    expect(typeof component.hasMoreBibliographicContributors).toBe('function');
-  });
-
-  it('should dispatch LoadMoreBibliographicContributors action with correct parameters', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch').mockReturnValue(of());
-    const registrationId = 'test-registration-id';
-    const registrationWithId: RegistrationOverviewModel = {
-      ...mockRegistration,
-      id: registrationId,
-    };
-
-    fixture.componentRef.setInput('registration', registrationWithId);
-    fixture.detectChanges();
-
-    component.handleLoadMoreContributors();
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
-      new LoadMoreBibliographicContributors(registrationId, ResourceType.Registration)
+    expect(store.dispatch).toHaveBeenCalledWith(
+      new LoadMoreBibliographicContributors(MOCK_REGISTRATION_OVERVIEW_MODEL.id, ResourceType.Registration)
     );
   });
-
-  it('should be reactive to registration input changes', () => {
-    const updatedRegistration: RegistrationOverviewModel = {
-      ...mockRegistration,
-      title: 'Updated Title',
-      associatedProjectId: 'updated-project-id',
-    };
-
-    fixture.componentRef.setInput('registration', updatedRegistration);
-    fixture.detectChanges();
-
-    expect(component.registration().title).toBe('Updated Title');
-    expect(component.registration().associatedProjectId).toBe('updated-project-id');
-  });
 });
diff --git a/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.spec.ts b/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.spec.ts
index 25454c3f5..f3cd8c6cd 100644
--- a/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.spec.ts
+++ b/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.spec.ts
@@ -1,111 +1,35 @@
 import { MockComponents } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 
 import { IconComponent } from '@osf/shared/components/icon/icon.component';
 
-import { RegistrationOverviewModel } from '../../models';
 import { ShortRegistrationInfoComponent } from '../short-registration-info/short-registration-info.component';
 
 import { WithdrawnMessageComponent } from './withdrawn-message.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 
 describe('WithdrawnMessageComponent', () => {
-  let component: WithdrawnMessageComponent;
-  let fixture: ComponentFixture<WithdrawnMessageComponent>;
-
-  const mockRegistration: RegistrationOverviewModel = {
-    ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-    dateWithdrawn: '2023-06-15T10:30:00Z',
-    withdrawalJustification: 'Test withdrawal justification',
-    withdrawn: true,
-  };
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [
-        WithdrawnMessageComponent,
-        OSFTestingModule,
-        ...MockComponents(ShortRegistrationInfoComponent, IconComponent),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(WithdrawnMessageComponent);
-    component = fixture.componentInstance;
-
-    fixture.componentRef.setInput('registration', mockRegistration);
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-
-  it('should receive registration input', () => {
-    expect(component.registration()).toEqual(mockRegistration);
-  });
-
-  it('should be reactive to registration input changes', () => {
-    const updatedRegistration: RegistrationOverviewModel = {
-      ...mockRegistration,
-      dateWithdrawn: '2024-01-20T12:00:00Z',
-      withdrawalJustification: 'Updated justification',
-    };
-
-    fixture.componentRef.setInput('registration', updatedRegistration);
-    fixture.detectChanges();
-
-    expect(component.registration().dateWithdrawn).toBe('2024-01-20T12:00:00Z');
-    expect(component.registration().withdrawalJustification).toBe('Updated justification');
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [WithdrawnMessageComponent, ...MockComponents(ShortRegistrationInfoComponent, IconComponent)],
+      providers: [provideOSFCore()],
+    });
   });
 
-  it('should handle registration with null withdrawal date', () => {
-    const registrationWithNullDate: RegistrationOverviewModel = {
-      ...mockRegistration,
-      dateWithdrawn: null,
+  it('should create and receive registration input', () => {
+    const fixture = TestBed.createComponent(WithdrawnMessageComponent);
+    const mockRegistration = {
+      ...MOCK_REGISTRATION_OVERVIEW_MODEL,
+      withdrawn: true,
+      dateWithdrawn: '2023-06-15T10:30:00Z',
     };
-
-    fixture.componentRef.setInput('registration', registrationWithNullDate);
+    fixture.componentRef.setInput('registration', mockRegistration);
     fixture.detectChanges();
 
-    expect(component.registration().dateWithdrawn).toBeNull();
-  });
-
-  it('should handle different withdrawal dates', () => {
-    const dates = ['2023-01-01T00:00:00Z', '2023-12-31T23:59:59Z', '2024-06-15T10:30:00Z'];
-
-    dates.forEach((date) => {
-      const registrationWithDate: RegistrationOverviewModel = {
-        ...mockRegistration,
-        dateWithdrawn: date,
-      };
-
-      fixture.componentRef.setInput('registration', registrationWithDate);
-      fixture.detectChanges();
-
-      expect(component.registration().dateWithdrawn).toBe(date);
-    });
-  });
-
-  it('should handle different withdrawal justifications', () => {
-    const justifications = [
-      'Short justification',
-      'Very long justification that contains multiple sentences and provides detailed explanation of why the registration was withdrawn.',
-      '',
-    ];
-
-    justifications.forEach((justification) => {
-      const registrationWithJustification: RegistrationOverviewModel = {
-        ...mockRegistration,
-        withdrawalJustification: justification,
-      };
-
-      fixture.componentRef.setInput('registration', registrationWithJustification);
-      fixture.detectChanges();
-
-      expect(component.registration().withdrawalJustification).toBe(justification);
-    });
+    expect(fixture.componentInstance).toBeTruthy();
+    expect(fixture.componentInstance.registration()).toEqual(mockRegistration);
   });
 });
diff --git a/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.ts b/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.ts
index 377307a87..4f371601b 100644
--- a/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.ts
+++ b/src/app/features/registry/components/withdrawn-message/withdrawn-message.component.ts
@@ -13,7 +13,7 @@ import { ShortRegistrationInfoComponent } from '../short-registration-info/short
 
 @Component({
   selector: 'osf-withdrawn-message',
-  imports: [TranslatePipe, Divider, ShortRegistrationInfoComponent, IconComponent, Card, DatePipe],
+  imports: [Card, Divider, ShortRegistrationInfoComponent, IconComponent, DatePipe, TranslatePipe],
   templateUrl: './withdrawn-message.component.html',
   styleUrl: './withdrawn-message.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
diff --git a/src/app/features/registry/pages/registration-recent-activity/registration-recent-activity.component.spec.ts b/src/app/features/registry/pages/registration-recent-activity/registration-recent-activity.component.spec.ts
index 65ba6cf2a..b2923b70c 100644
--- a/src/app/features/registry/pages/registration-recent-activity/registration-recent-activity.component.spec.ts
+++ b/src/app/features/registry/pages/registration-recent-activity/registration-recent-activity.component.spec.ts
@@ -1,56 +1,60 @@
 import { Store } from '@ngxs/store';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { MockComponent, MockProvider } from 'ng-mocks';
+
+import { PaginatorState } from 'primeng/paginator';
+
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute } from '@angular/router';
 
+import { RecentActivityListComponent } from '@osf/shared/components/recent-activity/recent-activity-list.component';
 import { CurrentResourceType } from '@osf/shared/enums/resource-type.enum';
 import { ActivityLogsSelectors, ClearActivityLogs } from '@osf/shared/stores/activity-logs';
 
 import { RegistrationRecentActivityComponent } from './registration-recent-activity.component';
 
 import { MOCK_ACTIVITY_LOGS_WITH_DISPLAY } from '@testing/mocks/activity-log-with-display.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistrationRecentActivityComponent', () => {
-  let component: RegistrationRecentActivityComponent;
-  let fixture: ComponentFixture<RegistrationRecentActivityComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [RegistrationRecentActivityComponent, OSFTestingModule],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: ActivityLogsSelectors.getActivityLogs, value: [] },
-            { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 0 },
-            { selector: ActivityLogsSelectors.getActivityLogsLoading, value: false },
-          ],
-        }),
-        {
-          provide: ActivatedRoute,
-          useValue: ActivatedRouteMockBuilder.create().withParams({ id: 'reg123' }).build(),
-        },
-      ],
-    }).compileComponents();
+function setup(overrides: BaseSetupOverrides = {}) {
+  const routeBuilder = ActivatedRouteMockBuilder.create().withParams(overrides.routeParams ?? { id: 'reg123' });
+  if (overrides.hasParent === false) routeBuilder.withNoParent();
+  const mockRoute = routeBuilder.build();
+
+  const defaultSignals = [
+    { selector: ActivityLogsSelectors.getActivityLogs, value: [] },
+    { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 0 },
+    { selector: ActivityLogsSelectors.getActivityLogsLoading, value: false },
+  ];
 
-    store = TestBed.inject(Store);
-    jest.spyOn(store, 'dispatch');
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
 
-    fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
-    component = fixture.componentInstance;
+  TestBed.configureTestingModule({
+    imports: [RegistrationRecentActivityComponent, MockComponent(RecentActivityListComponent)],
+    providers: [provideOSFCore(), MockProvider(ActivatedRoute, mockRoute), provideMockStore({ signals })],
   });
 
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
+
+  return { fixture, component, store };
+}
+
+describe('RegistrationRecentActivityComponent', () => {
   it('should initialize with default values', () => {
+    const { component } = setup();
+
     expect(component.pageSize).toBe(10);
     expect(component.currentPage()).toBe(1);
     expect(component.firstIndex()).toBe(0);
   });
 
   it('should dispatch GetActivityLogs when registrationId is available', () => {
-    fixture.detectChanges();
+    const { store } = setup();
 
     expect(store.dispatch).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -63,36 +67,13 @@ describe('RegistrationRecentActivityComponent', () => {
   });
 
   it('should not dispatch when registrationId is not available', () => {
-    TestBed.resetTestingModule();
-    TestBed.configureTestingModule({
-      imports: [RegistrationRecentActivityComponent, OSFTestingModule],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: ActivityLogsSelectors.getActivityLogs, value: [] },
-            { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 0 },
-            { selector: ActivityLogsSelectors.getActivityLogsLoading, value: false },
-          ],
-        }),
-        {
-          provide: ActivatedRoute,
-          useValue: { parent: null } as Partial<ActivatedRoute>,
-        },
-      ],
-    }).compileComponents();
-
-    store = TestBed.inject(Store);
-    jest.spyOn(store, 'dispatch');
-
-    fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+    const { store } = setup({ hasParent: false });
 
     expect(store.dispatch).not.toHaveBeenCalled();
   });
 
   it('should dispatch GetActivityLogs when currentPage changes', () => {
-    fixture.detectChanges();
+    const { fixture, component, store } = setup();
 
     (store.dispatch as jest.Mock).mockClear();
 
@@ -110,31 +91,29 @@ describe('RegistrationRecentActivityComponent', () => {
   });
 
   it('should update currentPage and dispatch on page change', () => {
-    fixture.detectChanges();
+    const { fixture, component, store } = setup();
 
     (store.dispatch as jest.Mock).mockClear();
 
-    component.onPageChange({ page: 1 } as any);
+    component.onPageChange({ page: 1 } as PaginatorState);
     fixture.detectChanges();
 
     expect(component.currentPage()).toBe(2);
-    expect(store.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        page: 2,
-      })
-    );
+    expect(store.dispatch).toHaveBeenCalledWith(expect.objectContaining({ page: 2 }));
   });
 
   it('should not update currentPage when page is undefined', () => {
-    fixture.detectChanges();
+    const { component } = setup();
 
     const initialPage = component.currentPage();
-    component.onPageChange({} as any);
+    component.onPageChange({} as PaginatorState);
 
     expect(component.currentPage()).toBe(initialPage);
   });
 
   it('should compute firstIndex correctly', () => {
+    const { component } = setup();
+
     component.currentPage.set(1);
     expect(component.firstIndex()).toBe(0);
 
@@ -146,7 +125,7 @@ describe('RegistrationRecentActivityComponent', () => {
   });
 
   it('should clear store on destroy', () => {
-    fixture.detectChanges();
+    const { fixture, store } = setup();
 
     (store.dispatch as jest.Mock).mockClear();
 
@@ -155,81 +134,17 @@ describe('RegistrationRecentActivityComponent', () => {
     expect(store.dispatch).toHaveBeenCalledWith(expect.any(ClearActivityLogs));
   });
 
-  it('should return activity logs from selector', () => {
-    TestBed.resetTestingModule();
-    TestBed.configureTestingModule({
-      imports: [RegistrationRecentActivityComponent, OSFTestingModule],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: ActivityLogsSelectors.getActivityLogs, value: MOCK_ACTIVITY_LOGS_WITH_DISPLAY },
-            { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 2 },
-            { selector: ActivityLogsSelectors.getActivityLogsLoading, value: false },
-          ],
-        }),
-        {
-          provide: ActivatedRoute,
-          useValue: ActivatedRouteMockBuilder.create().withParams({ id: 'reg123' }).build(),
-        },
+  it('should return selector values', () => {
+    const { component } = setup({
+      selectorOverrides: [
+        { selector: ActivityLogsSelectors.getActivityLogs, value: MOCK_ACTIVITY_LOGS_WITH_DISPLAY },
+        { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 15 },
+        { selector: ActivityLogsSelectors.getActivityLogsLoading, value: true },
       ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+    });
 
     expect(component.activityLogs()).toEqual(MOCK_ACTIVITY_LOGS_WITH_DISPLAY);
-  });
-
-  it('should return totalCount from selector', () => {
-    TestBed.resetTestingModule();
-    TestBed.configureTestingModule({
-      imports: [RegistrationRecentActivityComponent, OSFTestingModule],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: ActivityLogsSelectors.getActivityLogs, value: [] },
-            { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 15 },
-            { selector: ActivityLogsSelectors.getActivityLogsLoading, value: false },
-          ],
-        }),
-        {
-          provide: ActivatedRoute,
-          useValue: ActivatedRouteMockBuilder.create().withParams({ id: 'reg123' }).build(),
-        },
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
     expect(component.totalCount()).toBe(15);
-  });
-
-  it('should return isLoading from selector', () => {
-    TestBed.resetTestingModule();
-    TestBed.configureTestingModule({
-      imports: [RegistrationRecentActivityComponent, OSFTestingModule],
-      providers: [
-        provideMockStore({
-          signals: [
-            { selector: ActivityLogsSelectors.getActivityLogs, value: [] },
-            { selector: ActivityLogsSelectors.getActivityLogsTotalCount, value: 0 },
-            { selector: ActivityLogsSelectors.getActivityLogsLoading, value: true },
-          ],
-        }),
-        {
-          provide: ActivatedRoute,
-          useValue: ActivatedRouteMockBuilder.create().withParams({ id: 'reg123' }).build(),
-        },
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistrationRecentActivityComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-
     expect(component.isLoading()).toBe(true);
   });
 });
diff --git a/src/app/features/registry/pages/registry-components/registry-components.component.spec.ts b/src/app/features/registry/pages/registry-components/registry-components.component.spec.ts
index f4c92add5..fda50eba0 100644
--- a/src/app/features/registry/pages/registry-components/registry-components.component.spec.ts
+++ b/src/app/features/registry/pages/registry-components/registry-components.component.spec.ts
@@ -1,75 +1,116 @@
+import { Store } from '@ngxs/store';
+
 import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
 import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
 import { ViewOnlyLinkMessageComponent } from '@osf/shared/components/view-only-link-message/view-only-link-message.component';
+import { ViewOnlyLinkHelperService } from '@osf/shared/services/view-only-link-helper.service';
 
 import { RegistrationLinksCardComponent } from '../../components/registration-links-card/registration-links-card.component';
 import { RegistryComponentsSelectors } from '../../store/registry-components';
 
 import { RegistryComponentsComponent } from './registry-components.component';
 
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
+import { ViewOnlyLinkHelperMock } from '@testing/providers/view-only-link-helper.mock';
 
-describe('RegistryComponentsComponent', () => {
-  let component: RegistryComponentsComponent;
-  let fixture: ComponentFixture<RegistryComponentsComponent>;
-  let mockActivatedRoute: ReturnType<ActivatedRouteMockBuilder['build']>;
-  let mockRouter: ReturnType<RouterMockBuilder['build']>;
-
-  beforeEach(async () => {
-    mockActivatedRoute = ActivatedRouteMockBuilder.create().build();
-
-    mockRouter = RouterMockBuilder.create().withUrl('/test-url').build();
-
-    await TestBed.configureTestingModule({
-      imports: [
-        RegistryComponentsComponent,
-        OSFTestingModule,
-        ...MockComponents(
-          SubHeaderComponent,
-          LoadingSpinnerComponent,
-          RegistrationLinksCardComponent,
-          ViewOnlyLinkMessageComponent
-        ),
-      ],
-      providers: [
-        MockProvider(ActivatedRoute, mockActivatedRoute),
-        MockProvider(Router, mockRouter),
-        provideMockStore({
-          signals: [
-            { selector: RegistryComponentsSelectors.getRegistryComponents, value: [] },
-            { selector: RegistryComponentsSelectors.getRegistryComponentsLoading, value: false },
-          ],
-        }),
-      ],
-    }).compileComponents();
+interface SetupOverrides extends BaseSetupOverrides {
+  hasViewOnly?: boolean;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const routeBuilder = ActivatedRouteMockBuilder.create().withParams(overrides.routeParams ?? { id: 'reg-1' });
+  if (overrides.hasParent === false) routeBuilder.withNoParent();
+  const mockRoute = routeBuilder.build();
+
+  const mockRouter = RouterMockBuilder.create().withUrl('/test-url').build();
 
-    fixture = TestBed.createComponent(RegistryComponentsComponent);
-    component = fixture.componentInstance;
+  const mockViewOnlyHelper = ViewOnlyLinkHelperMock.simple(overrides.hasViewOnly);
+
+  const defaultSignals = [
+    { selector: RegistryComponentsSelectors.getRegistryComponents, value: [] },
+    { selector: RegistryComponentsSelectors.getRegistryComponentsLoading, value: false },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryComponentsComponent,
+      ...MockComponents(
+        SubHeaderComponent,
+        LoadingSpinnerComponent,
+        RegistrationLinksCardComponent,
+        ViewOnlyLinkMessageComponent
+      ),
+    ],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, mockRoute),
+      MockProvider(Router, mockRouter),
+      MockProvider(ViewOnlyLinkHelperService, mockViewOnlyHelper),
+      provideMockStore({ signals }),
+    ],
   });
 
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryComponentsComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
+
+  return { fixture, component, store, mockRouter };
+}
+
+describe('RegistryComponentsComponent', () => {
   it('should create', () => {
+    const { component } = setup();
+
     expect(component).toBeTruthy();
   });
 
-  it('should initialize actions', () => {
-    expect(component.actions).toBeDefined();
+  it('should dispatch GetRegistryComponents when registryId is available', () => {
+    const { store } = setup();
+
+    expect(store.dispatch).toHaveBeenCalledWith(expect.objectContaining({ registryId: 'reg-1' }));
+  });
+
+  it('should not dispatch when registryId is not available', () => {
+    const { store } = setup({ hasParent: false });
+
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
   it('should navigate to component details', () => {
-    const componentId = 'test-component-id';
-    component.reviewComponentDetails(componentId);
-    expect(mockRouter.navigate).toHaveBeenCalledWith([componentId, 'overview']);
+    const { component, mockRouter } = setup();
+
+    component.reviewComponentDetails('comp-1');
+
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['comp-1', 'overview']);
   });
 
   it('should compute hasViewOnly correctly', () => {
-    expect(component.hasViewOnly()).toBe(false);
+    const { component } = setup({ hasViewOnly: true });
+
+    expect(component.hasViewOnly()).toBe(true);
+  });
+
+  it('should return selector values', () => {
+    const mockComponents = [{ id: 'comp-1', title: 'Component 1' }];
+    const { component } = setup({
+      selectorOverrides: [
+        { selector: RegistryComponentsSelectors.getRegistryComponents, value: mockComponents },
+        { selector: RegistryComponentsSelectors.getRegistryComponentsLoading, value: true },
+      ],
+    });
+
+    expect(component.registryComponents()).toEqual(mockComponents);
+    expect(component.registryComponentsLoading()).toBe(true);
   });
 });
diff --git a/src/app/features/registry/pages/registry-components/registry-components.component.ts b/src/app/features/registry/pages/registry-components/registry-components.component.ts
index b7d346adf..e80c839bb 100644
--- a/src/app/features/registry/pages/registry-components/registry-components.component.ts
+++ b/src/app/features/registry/pages/registry-components/registry-components.component.ts
@@ -2,7 +2,10 @@ import { createDispatchMap, select } from '@ngxs/store';
 
 import { TranslatePipe } from '@ngx-translate/core';
 
-import { ChangeDetectionStrategy, Component, computed, inject, OnInit, signal } from '@angular/core';
+import { map, of } from 'rxjs';
+
+import { ChangeDetectionStrategy, Component, computed, effect, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
@@ -17,21 +20,23 @@ import { GetRegistryComponents, RegistryComponentsSelectors } from '../../store/
   selector: 'osf-registry-components',
   imports: [
     SubHeaderComponent,
-    TranslatePipe,
     LoadingSpinnerComponent,
     RegistrationLinksCardComponent,
     ViewOnlyLinkMessageComponent,
+    TranslatePipe,
   ],
   templateUrl: './registry-components.component.html',
   styleUrl: './registry-components.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class RegistryComponentsComponent implements OnInit {
+export class RegistryComponentsComponent {
   private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
   private readonly viewOnlyService = inject(ViewOnlyLinkHelperService);
 
-  private registryId = signal('');
+  private readonly registryId = toSignal<string | undefined>(
+    this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined)
+  );
 
   actions = createDispatchMap({ getRegistryComponents: GetRegistryComponents });
 
@@ -40,12 +45,14 @@ export class RegistryComponentsComponent implements OnInit {
   registryComponents = select(RegistryComponentsSelectors.getRegistryComponents);
   registryComponentsLoading = select(RegistryComponentsSelectors.getRegistryComponentsLoading);
 
-  ngOnInit(): void {
-    this.registryId.set(this.route.parent?.parent?.snapshot.params['id']);
+  constructor() {
+    effect(() => {
+      const registryId = this.registryId();
 
-    if (this.registryId()) {
-      this.actions.getRegistryComponents(this.registryId());
-    }
+      if (registryId) {
+        this.actions.getRegistryComponents(registryId);
+      }
+    });
   }
 
   reviewComponentDetails(id: string): void {
diff --git a/src/app/features/registry/pages/registry-links/registry-links.component.html b/src/app/features/registry/pages/registry-links/registry-links.component.html
index ce7cc1ac9..037aeea7a 100644
--- a/src/app/features/registry/pages/registry-links/registry-links.component.html
+++ b/src/app/features/registry/pages/registry-links/registry-links.component.html
@@ -19,7 +19,7 @@ <h2>
         <div class="flex flex-column gap-4">
           @for (node of linkedNodes(); track node.id) {
             <osf-registration-links-card
-              (reviewEmitRegistrationData)="navigateToNodes($event)"
+              (reviewEmitRegistrationData)="navigateToOverview($event)"
               [registrationData]="node"
             />
           }
@@ -44,7 +44,7 @@ <h2>
         <div class="flex flex-column gap-4">
           @for (registration of linkedRegistrations(); track registration.id) {
             <osf-registration-links-card
-              (reviewEmitRegistrationData)="navigateToRegistrations($event)"
+              (reviewEmitRegistrationData)="navigateToOverview($event)"
               (updateEmitRegistrationData)="updateRegistration($event)"
               [registrationData]="registration"
             />
diff --git a/src/app/features/registry/pages/registry-links/registry-links.component.spec.ts b/src/app/features/registry/pages/registry-links/registry-links.component.spec.ts
index cbf35df47..15bba5b59 100644
--- a/src/app/features/registry/pages/registry-links/registry-links.component.spec.ts
+++ b/src/app/features/registry/pages/registry-links/registry-links.component.spec.ts
@@ -1,6 +1,9 @@
+import { Store } from '@ngxs/store';
+
 import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { signal, WritableSignal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { RegistriesSelectors } from '@osf/features/registries/store';
@@ -13,77 +16,118 @@ import { RegistryLinksSelectors } from '../../store/registry-links';
 
 import { RegistryLinksComponent } from './registry-links.component';
 
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { LoaderServiceMock } from '@testing/providers/loader-service.mock';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
+
+function setup(overrides: BaseSetupOverrides = {}) {
+  const routeBuilder = ActivatedRouteMockBuilder.create().withParams(overrides.routeParams ?? { id: 'reg-1' });
+  if (overrides.hasParent === false) routeBuilder.withNoParent();
+  const mockRoute = routeBuilder.build();
+
+  const mockRouter = RouterMockBuilder.create().withUrl('/test-url').build();
+  const mockLoaderService = new LoaderServiceMock();
+
+  const defaultSignals = [
+    { selector: RegistryLinksSelectors.getLinkedNodes, value: [] },
+    { selector: RegistryLinksSelectors.getLinkedNodesLoading, value: false },
+    { selector: RegistryLinksSelectors.getLinkedRegistrations, value: [] },
+    { selector: RegistryLinksSelectors.getLinkedRegistrationsLoading, value: false },
+    { selector: RegistriesSelectors.getSchemaResponse, value: null },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryLinksComponent,
+      ...MockComponents(SubHeaderComponent, LoadingSpinnerComponent, RegistrationLinksCardComponent),
+    ],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, mockRoute),
+      MockProvider(Router, mockRouter),
+      MockProvider(LoaderService, mockLoaderService),
+      provideMockStore({ signals }),
+    ],
+  });
 
-describe('RegistryLinksComponent', () => {
-  let component: RegistryLinksComponent;
-  let fixture: ComponentFixture<RegistryLinksComponent>;
-  let mockActivatedRoute: ReturnType<ActivatedRouteMockBuilder['build']>;
-  let mockRouter: ReturnType<RouterMockBuilder['build']>;
-  let mockLoaderService: jest.Mocked<LoaderService>;
-
-  beforeEach(async () => {
-    mockActivatedRoute = ActivatedRouteMockBuilder.create().build();
-    mockRouter = RouterMockBuilder.create().withUrl('/test-url').build();
-    mockLoaderService = {
-      show: jest.fn(),
-      hide: jest.fn(),
-    } as any;
-
-    await TestBed.configureTestingModule({
-      imports: [
-        RegistryLinksComponent,
-        OSFTestingModule,
-        ...MockComponents(SubHeaderComponent, LoadingSpinnerComponent, RegistrationLinksCardComponent),
-      ],
-      providers: [
-        MockProvider(ActivatedRoute, mockActivatedRoute),
-        MockProvider(Router, mockRouter),
-        MockProvider(LoaderService, mockLoaderService),
-        provideMockStore({
-          signals: [
-            { selector: RegistryLinksSelectors.getLinkedNodes, value: [] },
-            { selector: RegistryLinksSelectors.getLinkedNodesLoading, value: false },
-            { selector: RegistryLinksSelectors.getLinkedRegistrations, value: [] },
-            { selector: RegistryLinksSelectors.getLinkedRegistrationsLoading, value: false },
-            { selector: RegistriesSelectors.getSchemaResponse, value: null },
-          ],
-        }),
-      ],
-    }).compileComponents();
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryLinksComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
 
-    fixture = TestBed.createComponent(RegistryLinksComponent);
-    component = fixture.componentInstance;
-  });
+  return { fixture, component, store, mockRouter, mockLoaderService };
+}
 
+describe('RegistryLinksComponent', () => {
   it('should create', () => {
+    const { component } = setup();
+
     expect(component).toBeTruthy();
   });
 
-  it('should initialize actions', () => {
-    expect(component.actions).toBeDefined();
+  it('should dispatch GetLinkedNodes and GetLinkedRegistrations when registryId is available', () => {
+    const { store } = setup();
+
+    expect(store.dispatch).toHaveBeenCalledWith(expect.objectContaining({ registryId: 'reg-1' }));
+    expect(store.dispatch).toHaveBeenCalledTimes(2);
   });
 
-  it('should navigate to registrations', () => {
-    const registrationId = 'test-registration-id';
-    component.navigateToRegistrations(registrationId);
-    expect(mockRouter.navigate).toHaveBeenCalledWith([registrationId, 'overview']);
+  it('should not dispatch when registryId is not available', () => {
+    const { store } = setup({ hasParent: false });
+
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
-  it('should navigate to nodes', () => {
-    const nodeId = 'test-node-id';
-    component.navigateToNodes(nodeId);
-    expect(mockRouter.navigate).toHaveBeenCalledWith([nodeId, 'overview']);
+  it('should navigate to overview', () => {
+    const { component, mockRouter } = setup();
+
+    component.navigateToOverview('node-1');
+
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['node-1', 'overview']);
+  });
+
+  it('should show loader and navigate to justification page on updateRegistration', () => {
+    const schemaResponseSignal: WritableSignal<{ id: string } | null> = signal({ id: 'revision-1' });
+    const { component, mockRouter, mockLoaderService } = setup({
+      selectorOverrides: [{ selector: RegistriesSelectors.getSchemaResponse, value: schemaResponseSignal }],
+    });
+
+    component.updateRegistration('reg-1');
+
+    expect(mockLoaderService.show).toHaveBeenCalled();
+    expect(mockLoaderService.hide).toHaveBeenCalled();
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['/registries/revisions/revision-1/justification']);
   });
 
-  it('should update registration with loader', () => {
-    const registrationId = 'test-registration-id';
+  it('should hide loader but not navigate when schemaResponse is null', () => {
+    const { component, mockRouter, mockLoaderService } = setup();
 
-    expect(() => component.updateRegistration(registrationId)).not.toThrow();
+    component.updateRegistration('reg-1');
 
     expect(mockLoaderService.show).toHaveBeenCalled();
+    expect(mockLoaderService.hide).toHaveBeenCalled();
+    expect(mockRouter.navigate).not.toHaveBeenCalled();
+  });
+
+  it('should return selector values', () => {
+    const mockNodes = [{ id: 'node-1', title: 'Node 1' }];
+    const mockRegistrations = [{ id: 'reg-1', title: 'Registration 1' }];
+    const { component } = setup({
+      selectorOverrides: [
+        { selector: RegistryLinksSelectors.getLinkedNodes, value: mockNodes },
+        { selector: RegistryLinksSelectors.getLinkedNodesLoading, value: true },
+        { selector: RegistryLinksSelectors.getLinkedRegistrations, value: mockRegistrations },
+        { selector: RegistryLinksSelectors.getLinkedRegistrationsLoading, value: true },
+      ],
+    });
+
+    expect(component.linkedNodes()).toEqual(mockNodes);
+    expect(component.linkedNodesLoading()).toBe(true);
+    expect(component.linkedRegistrations()).toEqual(mockRegistrations);
+    expect(component.linkedRegistrationsLoading()).toBe(true);
   });
 });
diff --git a/src/app/features/registry/pages/registry-links/registry-links.component.ts b/src/app/features/registry/pages/registry-links/registry-links.component.ts
index 660acd02b..247287199 100644
--- a/src/app/features/registry/pages/registry-links/registry-links.component.ts
+++ b/src/app/features/registry/pages/registry-links/registry-links.component.ts
@@ -2,9 +2,10 @@ import { createDispatchMap, select } from '@ngxs/store';
 
 import { TranslatePipe } from '@ngx-translate/core';
 
-import { tap } from 'rxjs';
+import { finalize, map, of, tap } from 'rxjs';
 
-import { ChangeDetectionStrategy, Component, inject, OnInit, signal } from '@angular/core';
+import { ChangeDetectionStrategy, Component, DestroyRef, effect, inject } from '@angular/core';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { FetchAllSchemaResponses, RegistriesSelectors } from '@osf/features/registries/store';
@@ -17,17 +18,20 @@ import { GetLinkedNodes, GetLinkedRegistrations, RegistryLinksSelectors } from '
 
 @Component({
   selector: 'osf-registry-links',
-  imports: [SubHeaderComponent, TranslatePipe, LoadingSpinnerComponent, RegistrationLinksCardComponent],
+  imports: [SubHeaderComponent, LoadingSpinnerComponent, RegistrationLinksCardComponent, TranslatePipe],
   templateUrl: './registry-links.component.html',
   styleUrl: './registry-links.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class RegistryLinksComponent implements OnInit {
+export class RegistryLinksComponent {
   private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
   private readonly loaderService = inject(LoaderService);
+  private readonly destroyRef = inject(DestroyRef);
 
-  private registryId = signal('');
+  private readonly registryId = toSignal<string | undefined>(
+    this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined)
+  );
 
   actions = createDispatchMap({
     getLinkedNodes: GetLinkedNodes,
@@ -43,16 +47,18 @@ export class RegistryLinksComponent implements OnInit {
 
   schemaResponse = select(RegistriesSelectors.getSchemaResponse);
 
-  ngOnInit(): void {
-    this.registryId.set(this.route.parent?.parent?.snapshot.params['id']);
+  constructor() {
+    effect(() => {
+      const registryId = this.registryId();
 
-    if (this.registryId()) {
-      this.actions.getLinkedNodes(this.registryId());
-      this.actions.getLinkedRegistrations(this.registryId());
-    }
+      if (registryId) {
+        this.actions.getLinkedNodes(registryId);
+        this.actions.getLinkedRegistrations(registryId);
+      }
+    });
   }
 
-  navigateToRegistrations(id: string): void {
+  navigateToOverview(id: string): void {
     this.router.navigate([id, 'overview']);
   }
 
@@ -61,20 +67,18 @@ export class RegistryLinksComponent implements OnInit {
     this.actions
       .getSchemaResponse(id)
       .pipe(
-        tap(() => {
-          this.loaderService.hide();
-          this.navigateToJustificationPage();
-        })
+        tap(() => this.navigateToJustificationPage()),
+        finalize(() => this.loaderService.hide()),
+        takeUntilDestroyed(this.destroyRef)
       )
       .subscribe();
   }
 
-  navigateToNodes(id: string): void {
-    this.router.navigate([id, 'overview']);
-  }
-
   private navigateToJustificationPage(): void {
     const revisionId = this.schemaResponse()?.id;
-    this.router.navigate([`/registries/revisions/${revisionId}/justification`]);
+
+    if (revisionId) {
+      this.router.navigate([`/registries/revisions/${revisionId}/justification`]);
+    }
   }
 }
diff --git a/src/app/features/registry/pages/registry-overview/registry-overview.component.html b/src/app/features/registry/pages/registry-overview/registry-overview.component.html
index e94064a8a..b7d67b3ca 100644
--- a/src/app/features/registry/pages/registry-overview/registry-overview.component.html
+++ b/src/app/features/registry/pages/registry-overview/registry-overview.component.html
@@ -72,7 +72,7 @@ <h4 class="mb-1">
               <osf-registry-statuses
                 [registry]="registry()"
                 [canEdit]="hasAdminAccess()"
-                [isModeration]="isModeration"
+                [isModeration]="isModeration()"
               ></osf-registry-statuses>
 
               <osf-registry-revisions
@@ -82,7 +82,7 @@ <h4 class="mb-1">
                 (openRevision)="openRevision($event)"
                 (updateRegistration)="onUpdateRegistration($event)"
                 (continueUpdate)="onContinueUpdateRegistration()"
-                [isModeration]="isModeration"
+                [isModeration]="isModeration()"
                 [isSubmitting]="isSchemaResponsesLoading()"
                 [canEdit]="hasAdminAccess()"
               >
diff --git a/src/app/features/registry/pages/registry-overview/registry-overview.component.spec.ts b/src/app/features/registry/pages/registry-overview/registry-overview.component.spec.ts
index ed58b1a97..0b1272d93 100644
--- a/src/app/features/registry/pages/registry-overview/registry-overview.component.spec.ts
+++ b/src/app/features/registry/pages/registry-overview/registry-overview.component.spec.ts
@@ -2,27 +2,22 @@ import { Store } from '@ngxs/store';
 
 import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { of } from 'rxjs';
+import { of, Subject } from 'rxjs';
 
-import { HttpTestingController } from '@angular/common/http/testing';
-import { PLATFORM_ID, signal } from '@angular/core';
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { provideServerRendering } from '@angular/platform-server';
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 
+import { RegistrationOverviewModel } from '@osf/features/registry/models';
 import { DataResourcesComponent } from '@osf/shared/components/data-resources/data-resources.component';
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
 import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
 import { ViewOnlyLinkMessageComponent } from '@osf/shared/components/view-only-link-message/view-only-link-message.component';
 import { RegistrationReviewStates } from '@osf/shared/enums/registration-review-states.enum';
-import { ResourceType } from '@osf/shared/enums/resource-type.enum';
 import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
+import { SchemaResponse } from '@osf/shared/models/registration/schema-response.model';
 import { CustomDialogService } from '@osf/shared/services/custom-dialog.service';
-import { LoaderService } from '@osf/shared/services/loader.service';
 import { ToastService } from '@osf/shared/services/toast.service';
 import { ViewOnlyLinkHelperService } from '@osf/shared/services/view-only-link-helper.service';
-import { GetBookmarksCollectionId } from '@osf/shared/stores/bookmarks';
-import { ContributorsSelectors, GetBibliographicContributors } from '@osf/shared/stores/contributors';
 
 import { ArchivingMessageComponent } from '../../components/archiving-message/archiving-message.component';
 import { RegistrationOverviewToolbarComponent } from '../../components/registration-overview-toolbar/registration-overview-toolbar.component';
@@ -32,624 +27,302 @@ import { RegistryOverviewMetadataComponent } from '../../components/registry-ove
 import { RegistryRevisionsComponent } from '../../components/registry-revisions/registry-revisions.component';
 import { RegistryStatusesComponent } from '../../components/registry-statuses/registry-statuses.component';
 import { WithdrawnMessageComponent } from '../../components/withdrawn-message/withdrawn-message.component';
-import {
-  CreateSchemaResponse,
-  GetRegistryById,
-  GetRegistryReviewActions,
-  GetRegistrySchemaResponses,
-  GetSchemaBlocks,
-  RegistrySelectors,
-} from '../../store/registry';
+import { RegistrySelectors } from '../../store/registry';
 
 import { RegistryOverviewComponent } from './registry-overview.component';
 
 import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
 import { createMockSchemaResponse } from '@testing/mocks/schema-response.mock';
-import { ToastServiceMock } from '@testing/mocks/toast.service.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
-import { CustomDialogServiceMockBuilder } from '@testing/providers/custom-dialog-provider.mock';
-import { LoaderServiceMock } from '@testing/providers/loader-service.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { CustomDialogServiceMock } from '@testing/providers/custom-dialog-provider.mock';
+import { LoaderServiceMock, provideLoaderServiceMock } from '@testing/providers/loader-service.mock';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
-
-describe('RegistryOverviewComponent', () => {
-  let component: RegistryOverviewComponent;
-  let fixture: ComponentFixture<RegistryOverviewComponent>;
-  let store: Store;
-  let httpMock: HttpTestingController;
-
-  const createTestBed = (options?: {
-    isSSR?: boolean;
-    registryId?: string;
-    queryParams?: Record<string, any>;
-    registry?: any;
-    schemaResponses?: any[];
-    hasViewOnly?: boolean;
-  }) => {
-    const registryId = options?.registryId || 'registry-1';
-    const mockRouter = RouterMockBuilder.create().withUrl('/registries/registry-1').build();
-    const parentRoute = {
-      params: of({ id: registryId }),
-      snapshot: { params: { id: registryId }, queryParams: {} },
-    } as any;
-    const mockActivatedRoute = Object.assign(
-      ActivatedRouteMockBuilder.create()
-        .withParams({ id: registryId })
-        .withQueryParams(options?.queryParams || {})
-        .build(),
-      { parent: parentRoute }
-    );
-
-    const mockCustomDialogService = CustomDialogServiceMockBuilder.create().withDefaultOpen().build();
-    const mockLoaderService = new LoaderServiceMock();
-    const mockViewOnlyHelper = {
-      hasViewOnlyParam: jest.fn().mockReturnValue(options?.hasViewOnly || false),
-    };
-
-    const defaultRegistry = options?.registry || null;
-    const defaultSchemaResponses = options?.schemaResponses || [];
-
-    const providers: any[] = [
+import { ToastServiceMock } from '@testing/providers/toast-provider.mock';
+import { ViewOnlyLinkHelperMock } from '@testing/providers/view-only-link-helper.mock';
+
+interface SetupOverrides {
+  registry?: RegistrationOverviewModel | null;
+  schemaResponses?: SchemaResponse[];
+  queryParams?: Record<string, string>;
+  hasViewOnly?: boolean;
+  registryId?: string;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const registryId = overrides.registryId ?? 'registry-1';
+  const registry = overrides.registry ?? null;
+  const schemaResponses = overrides.schemaResponses ?? [];
+
+  const mockRouter = RouterMockBuilder.create().withUrl('/registries/registry-1').build();
+  const mockActivatedRoute = ActivatedRouteMockBuilder.create()
+    .withParams({ id: registryId })
+    .withQueryParams(overrides.queryParams ?? {})
+    .build();
+
+  const mockDialogService = CustomDialogServiceMock.simple();
+  const mockLoaderService = new LoaderServiceMock();
+  const mockToastService = ToastServiceMock.simple();
+  const mockViewOnlyHelper = ViewOnlyLinkHelperMock.simple(overrides.hasViewOnly);
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryOverviewComponent,
+      ...MockComponents(
+        SubHeaderComponent,
+        LoadingSpinnerComponent,
+        RegistryOverviewMetadataComponent,
+        RegistryRevisionsComponent,
+        RegistryStatusesComponent,
+        DataResourcesComponent,
+        ArchivingMessageComponent,
+        WithdrawnMessageComponent,
+        ViewOnlyLinkMessageComponent,
+        RegistrationOverviewToolbarComponent,
+        RegistryBlocksSectionComponent
+      ),
+    ],
+    providers: [
+      provideOSFCore(),
       MockProvider(ActivatedRoute, mockActivatedRoute),
       MockProvider(Router, mockRouter),
-      MockProvider(CustomDialogService, mockCustomDialogService),
-      MockProvider(LoaderService, mockLoaderService),
-      MockProvider(ToastService, ToastServiceMock.useValue),
+      MockProvider(CustomDialogService, mockDialogService),
+      provideLoaderServiceMock(mockLoaderService),
+      MockProvider(ToastService, mockToastService),
       MockProvider(ViewOnlyLinkHelperService, mockViewOnlyHelper),
       provideMockStore({
-        actions: [
-          { action: new GetRegistryById(registryId), value: of(void 0) },
-          { action: new GetBookmarksCollectionId(), value: of(void 0) },
-          { action: new GetBibliographicContributors(registryId, ResourceType.Registration), value: of(void 0) },
-          { action: new GetSchemaBlocks(defaultRegistry?.registrationSchemaLink || ''), value: of(void 0) },
-          { action: new GetRegistrySchemaResponses(registryId), value: of(void 0) },
-          { action: new CreateSchemaResponse(registryId), value: of({ id: 'revision-1' }) },
-          { action: new GetRegistryReviewActions(registryId), value: of(void 0) },
-        ],
         signals: [
-          { selector: RegistrySelectors.getRegistry, value: defaultRegistry },
+          { selector: RegistrySelectors.getRegistry, value: registry },
           { selector: RegistrySelectors.isRegistryLoading, value: false },
           { selector: RegistrySelectors.isRegistryAnonymous, value: false },
-          { selector: RegistrySelectors.getSchemaResponses, value: defaultSchemaResponses },
+          { selector: RegistrySelectors.getSchemaResponses, value: schemaResponses },
           { selector: RegistrySelectors.isSchemaResponsesLoading, value: false },
           { selector: RegistrySelectors.getSchemaBlocks, value: [] },
           { selector: RegistrySelectors.isSchemaBlocksLoading, value: false },
           { selector: RegistrySelectors.areReviewActionsLoading, value: false },
-          { selector: RegistrySelectors.getSchemaResponse, value: defaultSchemaResponses[0] || null },
-          { selector: RegistrySelectors.hasWriteAccess, value: false },
+          { selector: RegistrySelectors.getSchemaResponse, value: schemaResponses[0] ?? null },
           { selector: RegistrySelectors.hasAdminAccess, value: false },
-          { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
-          { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
-          { selector: ContributorsSelectors.hasMoreBibliographicContributors, value: false },
         ],
       }),
-    ];
+    ],
+  });
 
-    if (options?.isSSR) {
-      providers.push(provideServerRendering(), { provide: PLATFORM_ID, useValue: 'server' });
-    }
-
-    return TestBed.configureTestingModule({
-      imports: [
-        RegistryOverviewComponent,
-        OSFTestingModule,
-        ...MockComponents(
-          SubHeaderComponent,
-          RegistrationOverviewToolbarComponent,
-          LoadingSpinnerComponent,
-          RegistryOverviewMetadataComponent,
-          RegistryRevisionsComponent,
-          RegistryStatusesComponent,
-          DataResourcesComponent,
-          ArchivingMessageComponent,
-          WithdrawnMessageComponent,
-          RegistryBlocksSectionComponent,
-          ViewOnlyLinkMessageComponent
-        ),
-      ],
-      providers,
-    });
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryOverviewComponent);
+  fixture.detectChanges();
+
+  return {
+    fixture,
+    component: fixture.componentInstance,
+    store,
+    mockRouter,
+    mockDialogService,
+    mockLoaderService,
+    mockToastService,
   };
+}
 
-  beforeEach(async () => {
-    await createTestBed().compileComponents();
+describe('RegistryOverviewComponent', () => {
+  it('should create with default state', () => {
+    const { component } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
 
-    fixture = TestBed.createComponent(RegistryOverviewComponent);
-    component = fixture.componentInstance;
-    store = TestBed.inject(Store);
-    httpMock = TestBed.inject(HttpTestingController);
+    expect(component).toBeTruthy();
+    expect(component.selectedRevisionIndex()).toBe(0);
+    expect(component.isModeration()).toBe(false);
+    expect(component.revisionId()).toBeNull();
   });
 
-  afterEach(() => {
-    httpMock.verify();
-    jest.clearAllMocks();
+  it('should derive isModeration and revisionId from query params', () => {
+    const { component } = setup({
+      registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
+      queryParams: { revisionId: 'rev-1', mode: 'moderator' },
+    });
+
+    expect(component.revisionId()).toBe('rev-1');
+    expect(component.isModeration()).toBe(true);
   });
 
-  it('should create', () => {
-    expect(component).toBeTruthy();
+  it('should compute showToolbar as false when archiving', () => {
+    const { component } = setup({ registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, archiving: true } });
+
+    expect(component.showToolbar()).toBe(false);
   });
 
-  describe('Initialization', () => {
-    it('should initialize with default values', () => {
-      expect(component.isModeration).toBe(false);
-      expect(component.revisionId).toBeUndefined();
-      expect(component.revisionInProgress).toBeUndefined();
-      expect(component.selectedRevisionIndex()).toBe(0);
-    });
+  it('should compute showToolbar as false when withdrawn', () => {
+    const { component } = setup({ registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, withdrawn: true } });
 
-    it('should handle loading states', () => {
-      expect(component.isRegistryLoading()).toBe(false);
-      expect(component.isSchemaBlocksLoading()).toBe(false);
-      expect(component.areReviewActionsLoading()).toBe(false);
-    });
+    expect(component.showToolbar()).toBe(false);
+  });
 
-    it('should handle registry data', () => {
-      expect(component.registry()).toBeNull();
-      expect(component.isAnonymous()).toBe(false);
-      expect(component.schemaBlocks()).toEqual([]);
-      expect(component.currentRevision()).toBeNull();
-    });
+  it('should compute showToolbar as true for normal registry', () => {
+    const { component } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
 
-    it('should handle permissions', () => {
-      expect(component.hasWriteAccess()).toBe(false);
-      expect(component.hasAdminAccess()).toBe(false);
-    });
+    expect(component.showToolbar()).toBe(true);
   });
 
-  describe('Computed Properties', () => {
-    beforeEach(async () => {
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+  it('should compute canMakeDecision when in moderation mode and not archiving/withdrawn', () => {
+    const { component } = setup({
+      registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
+      queryParams: { mode: 'moderator' },
     });
 
-    it('should compute hasViewOnly based on router query params', async () => {
-      TestBed.resetTestingModule();
-      const mockViewOnlyHelper = {
-        hasViewOnlyParam: jest.fn().mockReturnValue(true),
-      };
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        hasViewOnly: true,
-      }).compileComponents();
-      TestBed.overrideProvider(ViewOnlyLinkHelperService, { useValue: mockViewOnlyHelper });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.hasViewOnly()).toBe(true);
-    });
+    expect(component.canMakeDecision()).toBe(true);
+  });
 
-    it('should compute hasViewOnly as false when view-only param is not present', async () => {
-      TestBed.resetTestingModule();
-      const mockViewOnlyHelper = {
-        hasViewOnlyParam: jest.fn().mockReturnValue(false),
-      };
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        hasViewOnly: false,
-      }).compileComponents();
-      TestBed.overrideProvider(ViewOnlyLinkHelperService, { useValue: mockViewOnlyHelper });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.hasViewOnly()).toBe(false);
+  it('should compute canMakeDecision as false when archiving even in moderator mode', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, archiving: true },
+      queryParams: { mode: 'moderator' },
     });
 
-    it('should compute showToolbar as false when archiving', async () => {
-      const archivingRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, archiving: true };
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: archivingRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.showToolbar()).toBe(false);
-    });
+    expect(component.canMakeDecision()).toBe(false);
+  });
 
-    it('should compute showToolbar as false when withdrawn', async () => {
-      const withdrawnRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, withdrawn: true };
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: withdrawnRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.showToolbar()).toBe(false);
+  it('should compute isInitialState from reviewsState', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, reviewsState: RegistrationReviewStates.Initial },
     });
 
-    it('should compute showToolbar as true when not archiving or withdrawn', () => {
-      expect(component.showToolbar()).toBe(true);
-    });
+    expect(component.isInitialState()).toBe(true);
+  });
 
-    it('should compute isInitialState based on reviewsState', async () => {
-      const initialStateRegistry = {
-        ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-        reviewsState: RegistrationReviewStates.Initial,
-      };
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: initialStateRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.isInitialState()).toBe(true);
+  it('should compute isRootRegistration when rootParentId matches id', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, rootParentId: MOCK_REGISTRATION_OVERVIEW_MODEL.id },
     });
 
-    it('should compute canMakeDecision when in moderation mode', async () => {
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        queryParams: { mode: 'moderator' },
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.canMakeDecision()).toBe(true);
-    });
+    expect(component.isRootRegistration()).toBe(true);
+  });
 
-    it('should compute canMakeDecision as false when archiving', async () => {
-      const archivingRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, archiving: true };
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: archivingRegistry,
-        queryParams: { mode: 'moderator' },
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.canMakeDecision()).toBe(false);
+  it('should compute isRootRegistration when rootParentId is null', () => {
+    const { component } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, rootParentId: undefined },
     });
 
-    it('should compute isRootRegistration when rootParentId matches id', async () => {
-      const rootRegistry = {
-        ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-        rootParentId: MOCK_REGISTRATION_OVERVIEW_MODEL.id,
-      };
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: rootRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.isRootRegistration()).toBe(true);
-    });
+    expect(component.isRootRegistration()).toBe(true);
+  });
 
-    it('should compute isRootRegistration when rootParentId is null', async () => {
-      const noRootRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, rootParentId: null };
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: noRootRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.isRootRegistration()).toBe(true);
-    });
+  it('should compute hasViewOnly from ViewOnlyLinkHelperService', () => {
+    const { component } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL, hasViewOnly: true });
 
-    it('should compute schemaResponse based on selectedRevisionIndex', async () => {
-      const schemaResponses = [
-        createMockSchemaResponse('revision-1', RevisionReviewStates.Approved),
-        createMockSchemaResponse('revision-2', RevisionReviewStates.Approved),
-      ];
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        schemaResponses,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      expect(component.schemaResponse()?.id).toBe('revision-1');
-      component.openRevision(1);
-      expect(component.schemaResponse()?.id).toBe('revision-2');
-    });
+    expect(component.hasViewOnly()).toBe(true);
   });
 
-  describe('Methods', () => {
-    beforeEach(async () => {
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-    });
+  it('should compute revisionInProgress from schemaResponses', () => {
+    const schemaResponses = [
+      createMockSchemaResponse('rev-1', RevisionReviewStates.Approved),
+      createMockSchemaResponse('rev-2', RevisionReviewStates.RevisionInProgress),
+    ];
+    const { component } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL, schemaResponses });
 
-    it('should open revision and update selectedRevisionIndex', () => {
-      const revisionIndex = 2;
-      component.openRevision(revisionIndex);
-      expect(component.selectedRevisionIndex()).toBe(revisionIndex);
-    });
+    expect(component.revisionInProgress()?.id).toBe('rev-2');
+  });
 
-    it('should call onUpdateRegistration and navigate to justification page', async () => {
-      TestBed.resetTestingModule();
-      const mockLoaderService = new LoaderServiceMock();
-      const showSpy = jest.spyOn(mockLoaderService, 'show');
-      const schemaResponse = createMockSchemaResponse('revision-1', RevisionReviewStates.Approved);
-      const navigateSpy = jest.fn();
-      const testRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, id: 'registry-1' };
-      await createTestBed({
-        registry: testRegistry,
-      }).compileComponents();
-      TestBed.overrideProvider(LoaderService, { useValue: mockLoaderService });
-      TestBed.overrideProvider(Router, {
-        useValue: {
-          ...RouterMockBuilder.create().withUrl('/registries/registry-1').build(),
-          navigate: navigateSpy,
-        },
-      });
-      const mockStore = TestBed.inject(Store);
-      jest.spyOn(mockStore, 'selectSignal').mockImplementation((selector: any) => {
-        if (selector === RegistrySelectors.getSchemaResponse) {
-          return signal(schemaResponse);
-        }
-        if (selector === RegistrySelectors.getRegistry) {
-          return signal(testRegistry);
-        }
-        return signal(null);
-      });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-
-      component.onUpdateRegistration('registry-1');
-
-      expect(showSpy).toHaveBeenCalled();
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      expect(navigateSpy).toHaveBeenCalledWith([`/registries/revisions/revision-1/justification`]);
-    });
+  it('should compute schemaResponse based on selectedRevisionIndex', () => {
+    const schemaResponses = [
+      createMockSchemaResponse('rev-1', RevisionReviewStates.Approved),
+      createMockSchemaResponse('rev-2', RevisionReviewStates.Approved),
+    ];
+    const { component } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL, schemaResponses });
 
-    it('should navigate to justification page when continuing update for approved revision', async () => {
-      TestBed.resetTestingModule();
-      const navigateSpy = jest.fn();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      TestBed.overrideProvider(Router, {
-        useValue: {
-          ...RouterMockBuilder.create().withUrl('/registries/registry-1').build(),
-          navigate: navigateSpy,
-        },
-      });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      component.revisionInProgress = createMockSchemaResponse('revision-1', RevisionReviewStates.Approved);
-
-      component.onContinueUpdateRegistration();
-
-      expect(navigateSpy).toHaveBeenCalledWith([`/registries/revisions/revision-1/justification`]);
-    });
+    expect(component.schemaResponse()?.id).toBe('rev-1');
 
-    it('should navigate to review page when continuing update for unapproved revision', async () => {
-      TestBed.resetTestingModule();
-      const navigateSpy = jest.fn();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      TestBed.overrideProvider(Router, {
-        useValue: {
-          ...RouterMockBuilder.create().withUrl('/registries/registry-1').build(),
-          navigate: navigateSpy,
-        },
-      });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-      component.revisionInProgress = createMockSchemaResponse('revision-1', RevisionReviewStates.Unapproved);
-
-      component.onContinueUpdateRegistration();
-
-      expect(navigateSpy).toHaveBeenCalledWith([`/registries/revisions/revision-1/review`]);
-    });
+    component.openRevision(1);
 
-    it('should handle open make decision dialog', async () => {
-      const registryId = 'registry-1';
-      TestBed.resetTestingModule();
-      const mockCustomDialogService = CustomDialogServiceMockBuilder.create().build();
-      const openSpy = jest.spyOn(mockCustomDialogService, 'open');
-      const navigateSpy = jest.fn();
-      const navigateByUrlSpy = jest.fn().mockResolvedValue(true);
-      const showSuccessSpy = jest.fn();
-
-      await createTestBed({
-        registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, id: registryId },
-        queryParams: { revisionId: 'revision-1' },
-      }).compileComponents();
-      TestBed.overrideProvider(CustomDialogService, { useValue: mockCustomDialogService });
-      TestBed.overrideProvider(Router, {
-        useValue: {
-          ...RouterMockBuilder.create().withUrl('/registries/registry-1').build(),
-          navigate: navigateSpy,
-          navigateByUrl: navigateByUrlSpy,
-        },
-      });
-      TestBed.overrideProvider(ToastService, {
-        useValue: {
-          showSuccess: showSuccessSpy,
-        },
-      });
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-
-      const mockDialogRef = {
-        onClose: {
-          pipe: jest.fn(() =>
-            of({
-              action: 'accept',
-            })
-          ),
-        },
-      };
-      openSpy.mockReturnValue(mockDialogRef as any);
-
-      component.handleOpenMakeDecisionDialog();
-
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      expect(openSpy).toHaveBeenCalledWith(RegistryMakeDecisionComponent, expect.any(Object));
-      expect(showSuccessSpy).toHaveBeenCalledWith('moderation.makeDecision.acceptSuccess');
-      expect(navigateByUrlSpy).toHaveBeenCalled();
-    });
+    expect(component.schemaResponse()?.id).toBe('rev-2');
   });
 
-  describe('Effects', () => {
-    it('should dispatch actions when registry ID is available', async () => {
-      const dispatchSpy = jest.spyOn(store, 'dispatch');
+  it('should dispatch init actions when registryId is available', () => {
+    const { store } = setup({ registryId: 'reg-1', registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
 
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registryId: 'registry-1',
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+    expect(store.dispatch).toHaveBeenCalled();
+  });
 
-      await new Promise((resolve) => setTimeout(resolve, 100));
+  it('should dispatch schema actions when registry exists and is not withdrawn', () => {
+    const { store } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
 
-      expect(dispatchSpy).toHaveBeenCalled();
-    });
+    const calls = (store.dispatch as jest.Mock).mock.calls.map((c) => c[0]);
+    const hasSchemaResponses = calls.some((a) => a.constructor?.name === 'GetRegistrySchemaResponses');
 
-    it('should fetch schema blocks and responses when registry is available', async () => {
-      const registry = {
-        ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-        id: 'registry-1',
-        registrationSchemaLink: 'https://example.com/schema',
-      };
-
-      TestBed.resetTestingModule();
-      await createTestBed({ registry }).compileComponents();
-      const mockStore = TestBed.inject(Store);
-      const dispatchSpy = jest.spyOn(mockStore, 'dispatch');
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
-
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      const calls = dispatchSpy.mock.calls.map((call) => call[0]);
-      const hasSchemaBlocks = calls.some(
-        (action) => action instanceof GetSchemaBlocks && (action as any).schemaLink === registry.registrationSchemaLink
-      );
-      const hasSchemaResponses = calls.some(
-        (action) => action instanceof GetRegistrySchemaResponses && (action as any).registryId === registry.id
-      );
-      expect(hasSchemaBlocks || hasSchemaResponses).toBe(true);
-    });
+    expect(hasSchemaResponses).toBe(true);
+  });
 
-    it('should handle query params for revisionId and mode', async () => {
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        queryParams: { revisionId: 'revision-1', mode: 'moderator' },
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+  it('should not dispatch schema actions when registry is withdrawn', () => {
+    const { store } = setup({ registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, withdrawn: true } });
 
-      await new Promise((resolve) => setTimeout(resolve, 100));
+    const calls = (store.dispatch as jest.Mock).mock.calls.map((c) => c[0]);
+    const hasSchemaResponses = calls.some((a) => a.constructor?.name === 'GetRegistrySchemaResponses');
 
-      expect(component.revisionId).toBe('revision-1');
-      expect(component.isModeration).toBe(true);
-    });
+    expect(hasSchemaResponses).toBe(false);
   });
 
-  describe('State-based Behavior', () => {
-    it('should handle archiving registry', async () => {
-      const archivingRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, archiving: true };
+  it('should call loaderService.show and navigate on onUpdateRegistration', () => {
+    const currentRevision = createMockSchemaResponse('new-rev', RevisionReviewStates.RevisionInProgress);
+    const { component, store, mockRouter, mockLoaderService } = setup({
+      registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
+      schemaResponses: [currentRevision],
+    });
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
+
+    component.onUpdateRegistration('registry-1');
 
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: archivingRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+    expect(mockLoaderService.show).toHaveBeenCalled();
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['/registries/revisions/new-rev/justification']);
+  });
 
-      expect(component.showToolbar()).toBe(false);
-      expect(component.canMakeDecision()).toBe(false);
+  it('should navigate to justification on onContinueUpdateRegistration for approved revision', () => {
+    const schemaResponses = [createMockSchemaResponse('rev-1', RevisionReviewStates.RevisionInProgress)];
+    const { component, mockRouter } = setup({
+      registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
+      schemaResponses,
     });
 
-    it('should handle withdrawn registry', async () => {
-      const withdrawnRegistry = { ...MOCK_REGISTRATION_OVERVIEW_MODEL, withdrawn: true };
+    component.onContinueUpdateRegistration();
 
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: withdrawnRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+    expect(mockRouter.navigate).toHaveBeenCalledWith(['/registries/revisions/rev-1/justification']);
+  });
 
-      expect(component.showToolbar()).toBe(false);
-      expect(component.canMakeDecision()).toBe(false);
-    });
+  it('should not navigate on onContinueUpdateRegistration when no revisionInProgress', () => {
+    const { component, mockRouter } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
+    (mockRouter.navigate as jest.Mock).mockClear();
 
-    it('should handle different review states', async () => {
-      const pendingRegistry = {
-        ...MOCK_REGISTRATION_OVERVIEW_MODEL,
-        reviewsState: RegistrationReviewStates.Pending,
-      };
+    component.onContinueUpdateRegistration();
 
-      TestBed.resetTestingModule();
-      await createTestBed({ registry: pendingRegistry }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      fixture.detectChanges();
+    expect(mockRouter.navigate).not.toHaveBeenCalled();
+  });
 
-      expect(component.isInitialState()).toBe(false);
+  it('should not open dialog when registry id is falsy', () => {
+    const { component, store, mockDialogService } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, id: '' },
     });
+    jest.spyOn(store, 'dispatch').mockClear();
 
-    it('should find revision in progress from schema responses', async () => {
-      const schemaResponses = [
-        createMockSchemaResponse('revision-1', RevisionReviewStates.Approved),
-        createMockSchemaResponse('revision-2', RevisionReviewStates.RevisionInProgress),
-        createMockSchemaResponse('revision-3', RevisionReviewStates.Approved),
-      ];
-
-      TestBed.resetTestingModule();
-      await createTestBed({
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-        schemaResponses,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
-      component.openRevision(1);
-      fixture.detectChanges();
-
-      expect(component.revisionInProgress?.id).toBe('revision-2');
-    });
+    component.handleOpenMakeDecisionDialog();
+
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(mockDialogService.open).not.toHaveBeenCalled();
   });
 
-  describe('SSR', () => {
-    beforeEach(async () => {
-      TestBed.resetTestingModule();
-      await createTestBed({
-        isSSR: true,
-        registryId: 'registry-1',
-        registry: MOCK_REGISTRATION_OVERVIEW_MODEL,
-      }).compileComponents();
-      fixture = TestBed.createComponent(RegistryOverviewComponent);
-      component = fixture.componentInstance;
+  it('should open make decision dialog and handle success response', () => {
+    const onCloseSubject = new Subject<any>();
+    const { component, store, mockDialogService, mockToastService, mockRouter } = setup({
+      registry: { ...MOCK_REGISTRATION_OVERVIEW_MODEL, id: 'reg-1' },
+      queryParams: { revisionId: 'rev-1' },
     });
+    jest.spyOn(store, 'dispatch').mockReturnValue(of(undefined));
+    mockDialogService.open.mockReturnValue({ onClose: onCloseSubject.asObservable() } as any);
 
-    it('should render server-side without errors', () => {
-      expect(() => {
-        fixture.detectChanges();
-      }).not.toThrow();
-      expect(component).toBeTruthy();
-    });
+    component.handleOpenMakeDecisionDialog();
 
-    it('should not access browser-only APIs during SSR', () => {
-      const platformId = TestBed.inject(PLATFORM_ID);
-      expect(platformId).toBe('server');
-      fixture.detectChanges();
-      expect(component).toBeTruthy();
-    });
+    expect(mockDialogService.open).toHaveBeenCalledWith(
+      RegistryMakeDecisionComponent,
+      expect.objectContaining({ data: expect.objectContaining({ revisionId: 'rev-1' }) })
+    );
 
-    it('should execute constructor effects without errors in SSR context', () => {
-      const dispatchSpy = jest.spyOn(store, 'dispatch');
-      fixture.detectChanges();
-      expect(dispatchSpy).toHaveBeenCalled();
-      expect(component).toBeTruthy();
-    });
+    onCloseSubject.next({ action: 'accept_submission' });
+
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('moderation.makeDecision.acceptSubmissionSuccess');
+    expect(mockRouter.navigateByUrl).toHaveBeenCalled();
   });
 });
diff --git a/src/app/features/registry/pages/registry-overview/registry-overview.component.ts b/src/app/features/registry/pages/registry-overview/registry-overview.component.ts
index 03978f4f0..e6c579ac8 100644
--- a/src/app/features/registry/pages/registry-overview/registry-overview.component.ts
+++ b/src/app/features/registry/pages/registry-overview/registry-overview.component.ts
@@ -4,7 +4,7 @@ import { TranslatePipe } from '@ngx-translate/core';
 
 import { Message } from 'primeng/message';
 
-import { map, of, switchMap, tap } from 'rxjs';
+import { map, of, switchMap } from 'rxjs';
 
 import { DatePipe } from '@angular/common';
 import {
@@ -28,13 +28,12 @@ import { RegistrationReviewStates } from '@osf/shared/enums/registration-review-
 import { ResourceType } from '@osf/shared/enums/resource-type.enum';
 import { RevisionReviewStates } from '@osf/shared/enums/revision-review-states.enum';
 import { toCamelCase } from '@osf/shared/helpers/camel-case';
-import { SchemaResponse } from '@osf/shared/models/registration/schema-response.model';
 import { CustomDialogService } from '@osf/shared/services/custom-dialog.service';
 import { LoaderService } from '@osf/shared/services/loader.service';
 import { ToastService } from '@osf/shared/services/toast.service';
 import { ViewOnlyLinkHelperService } from '@osf/shared/services/view-only-link-helper.service';
 import { GetBookmarksCollectionId } from '@osf/shared/stores/bookmarks';
-import { ContributorsSelectors, GetBibliographicContributors } from '@osf/shared/stores/contributors';
+import { GetBibliographicContributors } from '@osf/shared/stores/contributors';
 
 import { ArchivingMessageComponent } from '../../components/archiving-message/archiving-message.component';
 import { RegistrationOverviewToolbarComponent } from '../../components/registration-overview-toolbar/registration-overview-toolbar.component';
@@ -56,6 +55,7 @@ import {
 @Component({
   selector: 'osf-registry-overview',
   imports: [
+    Message,
     SubHeaderComponent,
     LoadingSpinnerComponent,
     RegistryOverviewMetadataComponent,
@@ -63,13 +63,12 @@ import {
     RegistryStatusesComponent,
     DataResourcesComponent,
     ArchivingMessageComponent,
-    TranslatePipe,
     WithdrawnMessageComponent,
-    Message,
-    DatePipe,
     ViewOnlyLinkMessageComponent,
     RegistrationOverviewToolbarComponent,
     RegistryBlocksSectionComponent,
+    DatePipe,
+    TranslatePipe,
   ],
   templateUrl: './registry-overview.component.html',
   styleUrl: './registry-overview.component.scss',
@@ -94,40 +93,41 @@ export class RegistryOverviewComponent {
   readonly isSchemaBlocksLoading = select(RegistrySelectors.isSchemaBlocksLoading);
   readonly areReviewActionsLoading = select(RegistrySelectors.areReviewActionsLoading);
   readonly currentRevision = select(RegistrySelectors.getSchemaResponse);
-
-  bibliographicContributors = select(ContributorsSelectors.getBibliographicContributors);
-  isBibliographicContributorsLoading = select(ContributorsSelectors.isBibliographicContributorsLoading);
-  hasMoreBibliographicContributors = select(ContributorsSelectors.hasMoreBibliographicContributors);
-
-  readonly hasWriteAccess = select(RegistrySelectors.hasWriteAccess);
   readonly hasAdminAccess = select(RegistrySelectors.hasAdminAccess);
 
-  isModeration = false;
-  revisionId: string | null = null;
-  revisionInProgress: SchemaResponse | undefined;
-  selectedRevisionIndex = signal(0);
+  readonly selectedRevisionIndex = signal(0);
+
+  private readonly queryParams = toSignal(this.route.queryParams);
+  readonly revisionId = computed(() => (this.queryParams()?.['revisionId'] as string) ?? null);
+  readonly isModeration = computed(() => this.queryParams()?.['mode'] === 'moderator');
 
-  hasViewOnly = computed(() => this.viewOnlyService.hasViewOnlyParam(this.router));
-  showToolbar = computed(() => !this.registry()?.archiving && !this.registry()?.withdrawn);
-  isInitialState = computed(() => this.registry()?.reviewsState === RegistrationReviewStates.Initial);
-  canMakeDecision = computed(() => !this.registry()?.archiving && !this.registry()?.withdrawn && this.isModeration);
+  readonly hasViewOnly = computed(() => this.viewOnlyService.hasViewOnlyParam(this.router));
+  readonly showToolbar = computed(() => !this.registry()?.archiving && !this.registry()?.withdrawn);
+  readonly isInitialState = computed(() => this.registry()?.reviewsState === RegistrationReviewStates.Initial);
+  readonly canMakeDecision = computed(
+    () => !this.registry()?.archiving && !this.registry()?.withdrawn && this.isModeration()
+  );
 
   isRootRegistration = computed(() => {
     const rootId = this.registry()?.rootParentId;
     return !rootId || rootId === this.registry()?.id;
   });
 
-  private registryId = toSignal(this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined));
+  readonly revisionInProgress = computed(() => {
+    const responses = this.schemaResponses() || [];
+    return responses.find((r) => r.reviewsState === RevisionReviewStates.RevisionInProgress);
+  });
 
   readonly schemaResponse = computed(() => {
     const index = this.selectedRevisionIndex();
     const schemaResponses = this.schemaResponses() || [];
-
-    this.revisionInProgress = schemaResponses?.find((r) => r.reviewsState === RevisionReviewStates.RevisionInProgress);
-
     return index !== null ? schemaResponses[index] : null;
   });
 
+  private readonly registryId = toSignal(
+    this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined)
+  );
+
   private readonly actions = createDispatchMap({
     getRegistryById: GetRegistryById,
     getBookmarksId: GetBookmarksCollectionId,
@@ -141,32 +141,21 @@ export class RegistryOverviewComponent {
   constructor() {
     effect(() => {
       const registry = this.registry();
-
-      if (registry?.id && !registry?.withdrawn) {
+      if (registry?.id && !registry.withdrawn) {
         this.actions.getSchemaBlocks(registry.registrationSchemaLink);
-        this.actions.getSchemaResponses(registry?.id);
+        this.actions.getSchemaResponses(registry.id);
       }
     });
 
     effect(() => {
-      if (this.registryId()) {
-        this.actions.getRegistryById(this.registryId());
-        this.actions.getBibliographicContributors(this.registryId(), ResourceType.Registration);
+      const id = this.registryId();
+      if (id) {
+        this.actions.getRegistryById(id);
+        this.actions.getBibliographicContributors(id, ResourceType.Registration);
       }
     });
 
     this.actions.getBookmarksId();
-
-    this.route.queryParams
-      .pipe(
-        takeUntilDestroyed(),
-        map((params) => ({ revisionId: params['revisionId'], mode: params['mode'] })),
-        tap(({ revisionId, mode }) => {
-          this.revisionId = revisionId;
-          this.isModeration = mode === 'moderator';
-        })
-      )
-      .subscribe();
   }
 
   openRevision(revisionIndex: number): void {
@@ -175,41 +164,34 @@ export class RegistryOverviewComponent {
 
   onUpdateRegistration(id: string): void {
     this.loaderService.show();
-
     this.actions
       .createSchemaResponse(id)
-      .pipe(
-        tap(() => {
-          this.revisionInProgress = this.currentRevision()!;
-          this.navigateToJustificationPage();
-        })
-      )
-      .subscribe();
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe({
+        next: () => {
+          const revisionId = this.currentRevision()?.id;
+          if (revisionId) {
+            this.router.navigate([`/registries/revisions/${revisionId}/justification`]);
+          }
+        },
+      });
   }
 
   onContinueUpdateRegistration(): void {
-    const unapproved = this.revisionInProgress?.reviewsState === RevisionReviewStates.Unapproved;
-
+    const unapproved = this.revisionInProgress()?.reviewsState === RevisionReviewStates.Unapproved;
     if (unapproved) {
-      this.navigateToJustificationReview();
+      this.navigateToRevision('review');
     } else {
-      this.navigateToJustificationPage();
+      this.navigateToRevision('justification');
     }
   }
 
-  private navigateToJustificationPage(): void {
-    const revisionId = this.revisionId || this.revisionInProgress?.id;
-    this.router.navigate([`/registries/revisions/${revisionId}/justification`]);
-  }
+  handleOpenMakeDecisionDialog(): void {
+    const registryId = this.registry()?.id;
+    if (!registryId) return;
 
-  private navigateToJustificationReview(): void {
-    const revisionId = this.revisionId || this.revisionInProgress?.id;
-    this.router.navigate([`/registries/revisions/${revisionId}/review`]);
-  }
-
-  handleOpenMakeDecisionDialog() {
     this.actions
-      .getRegistryReviewActions(this.registry()?.id || '')
+      .getRegistryReviewActions(registryId)
       .pipe(
         switchMap(() =>
           this.customDialogService
@@ -218,11 +200,12 @@ export class RegistryOverviewComponent {
               width: '600px',
               data: {
                 registry: this.registry(),
-                revisionId: this.revisionId,
+                revisionId: this.revisionId(),
               },
             })
             .onClose.pipe(takeUntilDestroyed(this.destroyRef))
-        )
+        ),
+        takeUntilDestroyed(this.destroyRef)
       )
       .subscribe((data) => {
         if (data) {
@@ -236,8 +219,14 @@ export class RegistryOverviewComponent {
             this.router.navigateByUrl(currentUrl);
           });
 
-          this.actions.getRegistryById(this.registry()?.id || '');
+          this.actions.getRegistryById(registryId);
         }
       });
   }
+
+  private navigateToRevision(page: 'justification' | 'review'): void {
+    const revisionId = this.revisionId() || this.revisionInProgress()?.id;
+    if (!revisionId) return;
+    this.router.navigate([`/registries/revisions/${revisionId}/${page}`]);
+  }
 }
diff --git a/src/app/features/registry/pages/registry-resources/registry-resources.component.html b/src/app/features/registry/pages/registry-resources/registry-resources.component.html
index 68ffcaef7..cf0747a89 100644
--- a/src/app/features/registry/pages/registry-resources/registry-resources.component.html
+++ b/src/app/features/registry/pages/registry-resources/registry-resources.component.html
@@ -25,13 +25,12 @@
       @for (resource of resources(); track resource.id) {
         <div class="resource-block gap-3 p-3 flex flex-column md:p-4 md:flex-row">
           <div class="flex w-full gap-3 md:w-auto">
-            @let iconName = resource.type === 'analytic_code' ? 'code' : resource.type;
+            @let iconName = resource.type === RegistryResourceType.Code ? 'code' : resource.type;
             @let icon = `custom-icon-${iconName} icon-resource-size`;
-            @let resourceName = resource.type === 'analytic_code' ? 'analytic code' : resource.type;
             <osf-icon class="align-self-start" [iconClass]="icon"></osf-icon>
 
             <div class="flex flex-column gap-2">
-              <h2>{{ resourceName }}</h2>
+              <h2>{{ getResourceTypeTranslationKey(resource.type) | translate }}</h2>
               <a class="font-bold" [href]="doiDomain + resource.pid" target="_blank" rel="noopener noreferrer">
                 {{ doiDomain + resource.pid }}
               </a>
diff --git a/src/app/features/registry/pages/registry-resources/registry-resources.component.spec.ts b/src/app/features/registry/pages/registry-resources/registry-resources.component.spec.ts
index 9c574290a..493da3132 100644
--- a/src/app/features/registry/pages/registry-resources/registry-resources.component.spec.ts
+++ b/src/app/features/registry/pages/registry-resources/registry-resources.component.spec.ts
@@ -1,162 +1,283 @@
+import { Store } from '@ngxs/store';
+
 import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { of } from 'rxjs';
+import { Subject, throwError } from 'rxjs';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute } from '@angular/router';
 
 import { IconComponent } from '@osf/shared/components/icon/icon.component';
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
 import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
-import { UserPermissions } from '@osf/shared/enums/user-permissions.enum';
+import { RegistryResourceType } from '@osf/shared/enums/registry-resource.enum';
 import { CustomConfirmationService } from '@osf/shared/services/custom-confirmation.service';
 import { CustomDialogService } from '@osf/shared/services/custom-dialog.service';
 import { ToastService } from '@osf/shared/services/toast.service';
 
+import { RegistryResource } from '../../models';
 import { RegistrySelectors } from '../../store/registry';
 import { RegistryResourcesSelectors } from '../../store/registry-resources';
 
 import { RegistryResourcesComponent } from './registry-resources.component';
 
 import { MOCK_PROJECT_IDENTIFIERS } from '@testing/mocks/project-overview.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
-import { CustomConfirmationServiceMockBuilder } from '@testing/providers/custom-confirmation-provider.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
+import { CustomConfirmationServiceMock } from '@testing/providers/custom-confirmation-provider.mock';
 import { CustomDialogServiceMockBuilder } from '@testing/providers/custom-dialog-provider.mock';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
-import { ToastServiceMockBuilder } from '@testing/providers/toast-provider.mock';
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
+import { ToastServiceMock } from '@testing/providers/toast-provider.mock';
+
+const MOCK_RESOURCE: RegistryResource = {
+  id: 'res-1',
+  description: 'Test resource',
+  finalized: true,
+  type: RegistryResourceType.Data,
+  pid: '10.123/test',
+};
+
+function setup(overrides: BaseSetupOverrides = {}) {
+  const routeBuilder = ActivatedRouteMockBuilder.create().withParams(overrides.routeParams ?? { id: 'reg-1' });
+  if (overrides.hasParent === false) routeBuilder.withNoParent();
+  const mockRoute = routeBuilder.build();
+
+  const dialogClose$ = new Subject<unknown>();
+  const mockDialogService = CustomDialogServiceMockBuilder.create()
+    .withOpen(
+      jest.fn().mockReturnValue({
+        onClose: dialogClose$.pipe(),
+        close: jest.fn(),
+      })
+    )
+    .build();
+
+  const mockConfirmationService = CustomConfirmationServiceMock.simple();
+  const mockToastService = ToastServiceMock.simple();
+
+  const defaultSignals = [
+    { selector: RegistryResourcesSelectors.getResources, value: [] },
+    { selector: RegistryResourcesSelectors.isResourcesLoading, value: false },
+    { selector: RegistryResourcesSelectors.getCurrentResource, value: null },
+    { selector: RegistrySelectors.getRegistry, value: null },
+    { selector: RegistrySelectors.getIdentifiers, value: [MOCK_PROJECT_IDENTIFIERS] },
+    { selector: RegistrySelectors.hasWriteAccess, value: true },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryResourcesComponent,
+      ...MockComponents(LoadingSpinnerComponent, SubHeaderComponent, IconComponent),
+    ],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, mockRoute),
+      MockProvider(CustomDialogService, mockDialogService),
+      MockProvider(CustomConfirmationService, mockConfirmationService),
+      MockProvider(ToastService, mockToastService),
+      provideMockStore({ signals }),
+    ],
+  });
 
-describe('RegistryResourcesComponent', () => {
-  let component: RegistryResourcesComponent;
-  let fixture: ComponentFixture<RegistryResourcesComponent>;
-  let mockActivatedRoute: ReturnType<ActivatedRouteMockBuilder['build']>;
-  let mockCustomDialogService: ReturnType<CustomDialogServiceMockBuilder['build']>;
-  let mockCustomConfirmationService: ReturnType<CustomConfirmationServiceMockBuilder['build']>;
-  let mockToastService: ReturnType<ToastServiceMockBuilder['build']>;
-
-  const mockRegistryId = 'test-registry-id';
-  const mockRegistry = {
-    currentUserPermissions: [UserPermissions.Write],
-    identifiers: [{ id: 'test-id' }],
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryResourcesComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
+
+  return {
+    fixture,
+    component,
+    store,
+    dialogClose$,
+    mockDialogService,
+    mockConfirmationService,
+    mockToastService,
   };
+}
 
-  beforeEach(async () => {
-    mockActivatedRoute = ActivatedRouteMockBuilder.create().withParams({ id: mockRegistryId }).build();
-    mockCustomDialogService = CustomDialogServiceMockBuilder.create().withDefaultOpen().build();
-    mockCustomConfirmationService = CustomConfirmationServiceMockBuilder.create().build();
-    mockToastService = ToastServiceMockBuilder.create().build();
-
-    await TestBed.configureTestingModule({
-      imports: [
-        RegistryResourcesComponent,
-        OSFTestingModule,
-        ...MockComponents(SubHeaderComponent, LoadingSpinnerComponent, IconComponent),
-      ],
-      providers: [
-        MockProvider(ActivatedRoute, mockActivatedRoute),
-        MockProvider(CustomDialogService, mockCustomDialogService),
-        MockProvider(CustomConfirmationService, mockCustomConfirmationService),
-        MockProvider(ToastService, mockToastService),
-        provideMockStore({
-          signals: [
-            { selector: RegistryResourcesSelectors.getResources, value: [] },
-            { selector: RegistryResourcesSelectors.isResourcesLoading, value: false },
-            { selector: RegistryResourcesSelectors.getCurrentResource, value: null },
-            { selector: RegistrySelectors.getRegistry, value: mockRegistry },
-            { selector: RegistrySelectors.getIdentifiers, value: [MOCK_PROJECT_IDENTIFIERS] },
-            { selector: RegistrySelectors.hasWriteAccess, value: true },
-          ],
-        }),
-      ],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(RegistryResourcesComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
+describe('RegistryResourcesComponent', () => {
+  it('should create with default values', () => {
+    const { component } = setup();
 
-  it('should initialize with default values', () => {
+    expect(component).toBeTruthy();
     expect(component.isAddingResource()).toBe(false);
     expect(component.doiDomain).toBe('https://doi.org/');
   });
 
-  it('should compute canEdit correctly', () => {
-    expect(component.canEdit()).toBe(true);
+  it('should dispatch getResources when registryId is available', () => {
+    const { store } = setup();
+
+    expect(store.dispatch).toHaveBeenCalledWith(expect.objectContaining({ registryId: 'reg-1' }));
+  });
+
+  it('should not dispatch getResources when registryId is not available', () => {
+    const { store } = setup({ hasParent: false });
+
+    expect(store.dispatch).not.toHaveBeenCalled();
   });
 
-  it('should compute addButtonVisible correctly', () => {
+  it('should compute addButtonVisible when identifiers exist and canEdit', () => {
+    const { component } = setup();
+
     expect(component.addButtonVisible()).toBe(true);
   });
 
-  it('should add resource successfully', () => {
-    component.registryId = mockRegistryId;
+  it('should compute addButtonVisible as false when no identifiers', () => {
+    const { component } = setup({
+      selectorOverrides: [{ selector: RegistrySelectors.getIdentifiers, value: [] }],
+    });
 
-    const mockActions = {
-      addResource: jest.fn().mockReturnValue(of({})),
-    };
+    expect(component.addButtonVisible()).toBe(false);
+  });
 
-    Object.defineProperty(component, 'actions', {
-      value: mockActions,
-      writable: true,
+  it('should compute addButtonVisible as false when canEdit is false', () => {
+    const { component } = setup({
+      selectorOverrides: [{ selector: RegistrySelectors.hasWriteAccess, value: false }],
     });
 
+    expect(component.addButtonVisible()).toBe(false);
+  });
+
+  it('should add resource and show success toast on dialog confirm', () => {
+    const { component, dialogClose$, mockDialogService, mockToastService, store } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
     component.addResource();
 
-    expect(mockActions.addResource).toHaveBeenCalledWith(mockRegistryId);
+    expect(component.isAddingResource()).toBe(true);
+    expect(store.dispatch).toHaveBeenCalled();
+    expect(mockDialogService.open).toHaveBeenCalled();
 
-    expect(component).toBeTruthy();
+    dialogClose$.next(true);
+    dialogClose$.complete();
+
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('resources.toastMessages.addResourceSuccess');
+    expect(component.isAddingResource()).toBe(false);
   });
 
-  it('should not add resource if no registry ID', () => {
-    component.registryId = undefined;
-    const initialAddingState = component.isAddingResource();
+  it('should reset isAddingResource when dialog is dismissed', () => {
+    const { component, dialogClose$ } = setup();
 
     component.addResource();
 
-    expect(component.isAddingResource()).toBe(initialAddingState);
+    expect(component.isAddingResource()).toBe(true);
+
+    dialogClose$.next(null);
+    dialogClose$.complete();
+
+    expect(component.isAddingResource()).toBe(false);
   });
 
-  it('should open add resource dialog', () => {
-    component.registryId = mockRegistryId;
-    const dialogRef = { onClose: { pipe: jest.fn() } };
+  it('should show error toast when addResource dispatch errors', () => {
+    const { component, store, mockToastService } = setup();
 
-    const actualService = component['customDialogService'];
-    actualService.open = jest.fn().mockReturnValue(dialogRef);
+    jest.spyOn(store, 'dispatch').mockReturnValue(throwError(() => new Error('fail')));
+    component.addResource();
 
-    const result = component.openAddResourceDialog();
+    expect(mockToastService.showError).toHaveBeenCalledWith('resources.toastMessages.addResourceError');
+  });
 
-    expect(actualService.open).toHaveBeenCalledWith(expect.any(Function), {
-      header: 'resources.add',
-      width: '500px',
-      data: { id: mockRegistryId },
-    });
-    expect(result).toBe(dialogRef.onClose);
+  it('should not add resource when registryId is not available', () => {
+    const { component, store, mockDialogService } = setup({ hasParent: false });
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.addResource();
+
+    expect(component.isAddingResource()).toBe(false);
+    expect(store.dispatch).not.toHaveBeenCalled();
+    expect(mockDialogService.open).not.toHaveBeenCalled();
+  });
+
+  it('should open edit dialog on updateResource', () => {
+    const { component, mockDialogService } = setup();
+
+    component.updateResource(MOCK_RESOURCE);
+
+    expect(mockDialogService.open).toHaveBeenCalledWith(
+      expect.any(Function),
+      expect.objectContaining({
+        header: 'resources.edit',
+        data: { id: 'reg-1', resource: MOCK_RESOURCE },
+      })
+    );
+  });
+
+  it('should show success toast on updateResource dialog confirm', () => {
+    const { component, dialogClose$, mockToastService } = setup();
+
+    component.updateResource(MOCK_RESOURCE);
+    dialogClose$.next(true);
+    dialogClose$.complete();
+
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('resources.toastMessages.updatedResourceSuccess');
+  });
+
+  it('should show error toast when updateResource dialog errors', () => {
+    const errorSubject = new Subject<unknown>();
+    const { component, mockDialogService, mockToastService } = setup();
+
+    mockDialogService.open.mockReturnValue({ onClose: errorSubject.pipe() } as any);
+    component.updateResource(MOCK_RESOURCE);
+    errorSubject.error(new Error('fail'));
+
+    expect(mockToastService.showError).toHaveBeenCalledWith('resources.toastMessages.updateResourceError');
+  });
+
+  it('should not update resource when registryId is not available', () => {
+    const { component, mockDialogService } = setup({ hasParent: false });
+
+    component.updateResource(MOCK_RESOURCE);
+
+    expect(mockDialogService.open).not.toHaveBeenCalled();
   });
 
   it('should delete resource with confirmation', () => {
-    component.registryId = mockRegistryId;
-    const resourceId = 'resource-id';
+    const { component, mockConfirmationService } = setup();
+
+    component.deleteResource('res-1');
+
+    expect(mockConfirmationService.confirmDelete).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headerKey: 'resources.delete',
+        messageKey: 'resources.deleteText',
+        acceptLabelKey: 'common.buttons.remove',
+        onConfirm: expect.any(Function),
+      })
+    );
+  });
 
-    component.deleteResource(resourceId);
+  it('should dispatch delete and show toast on confirm', () => {
+    const { component, mockConfirmationService, mockToastService, store } = setup();
 
-    expect(mockCustomConfirmationService.confirmDelete).toHaveBeenCalledWith({
-      headerKey: 'resources.delete',
-      messageKey: 'resources.deleteText',
-      acceptLabelKey: 'common.buttons.remove',
-      onConfirm: expect.any(Function),
-    });
+    mockConfirmationService.confirmDelete.mockImplementation(({ onConfirm }: { onConfirm: () => void }) => onConfirm());
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.deleteResource('res-1');
+
+    expect(store.dispatch).toHaveBeenCalled();
+    expect(mockToastService.showSuccess).toHaveBeenCalledWith('resources.toastMessages.deletedResourceSuccess');
   });
 
-  it('should not delete resource if no registry ID', () => {
-    component.registryId = undefined;
-    const resourceId = 'resource-id';
+  it('should not delete resource when registryId is not available', () => {
+    const { component, mockConfirmationService } = setup({ hasParent: false });
+
+    component.deleteResource('res-1');
+
+    expect(mockConfirmationService.confirmDelete).not.toHaveBeenCalled();
+  });
+
+  it('should return translation key for known resource type', () => {
+    const { component } = setup();
+
+    expect(component.getResourceTypeTranslationKey(RegistryResourceType.Data)).toBe('resources.typeOptions.data');
+    expect(component.getResourceTypeTranslationKey(RegistryResourceType.Code)).toBe('resources.typeOptions.code');
+  });
 
-    component.deleteResource(resourceId);
+  it('should return empty string for unknown resource type', () => {
+    const { component } = setup();
 
-    expect(mockCustomConfirmationService.confirmDelete).not.toHaveBeenCalled();
+    expect(component.getResourceTypeTranslationKey('unknown')).toBe('');
   });
 });
diff --git a/src/app/features/registry/pages/registry-resources/registry-resources.component.ts b/src/app/features/registry/pages/registry-resources/registry-resources.component.ts
index a433ece15..c8cc676f5 100644
--- a/src/app/features/registry/pages/registry-resources/registry-resources.component.ts
+++ b/src/app/features/registry/pages/registry-resources/registry-resources.component.ts
@@ -4,21 +4,32 @@ import { TranslatePipe } from '@ngx-translate/core';
 
 import { Button } from 'primeng/button';
 
-import { filter, finalize, switchMap, take } from 'rxjs';
+import { filter, finalize, map, of, switchMap } from 'rxjs';
 
-import { ChangeDetectionStrategy, Component, computed, DestroyRef, HostBinding, inject, signal } from '@angular/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  computed,
+  DestroyRef,
+  effect,
+  HostBinding,
+  inject,
+  signal,
+} from '@angular/core';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { ActivatedRoute } from '@angular/router';
 
 import { IconComponent } from '@osf/shared/components/icon/icon.component';
 import { LoadingSpinnerComponent } from '@osf/shared/components/loading-spinner/loading-spinner.component';
 import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
+import { RegistryResourceType } from '@osf/shared/enums/registry-resource.enum';
 import { CustomConfirmationService } from '@osf/shared/services/custom-confirmation.service';
 import { CustomDialogService } from '@osf/shared/services/custom-dialog.service';
 import { ToastService } from '@osf/shared/services/toast.service';
 
 import { AddResourceDialogComponent } from '../../components/add-resource-dialog/add-resource-dialog.component';
 import { EditResourceDialogComponent } from '../../components/edit-resource-dialog/edit-resource-dialog.component';
+import { resourceTypeOptions } from '../../constants';
 import { RegistryResource } from '../../models';
 import { RegistrySelectors } from '../../store/registry';
 import {
@@ -30,7 +41,7 @@ import {
 
 @Component({
   selector: 'osf-registry-resources',
-  imports: [SubHeaderComponent, TranslatePipe, Button, LoadingSpinnerComponent, IconComponent],
+  imports: [Button, SubHeaderComponent, LoadingSpinnerComponent, IconComponent, TranslatePipe],
   templateUrl: './registry-resources.component.html',
   styleUrl: './registry-resources.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
@@ -49,7 +60,10 @@ export class RegistryResourcesComponent {
   readonly registry = select(RegistrySelectors.getRegistry);
   readonly identifiers = select(RegistrySelectors.getIdentifiers);
 
-  registryId = this.route.snapshot.parent?.params['id'];
+  private readonly registryId = toSignal<string | undefined>(
+    this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined)
+  );
+
   isAddingResource = signal(false);
   doiDomain = 'https://doi.org/';
 
@@ -59,24 +73,36 @@ export class RegistryResourcesComponent {
     deleteResource: DeleteResource,
   });
 
+  readonly RegistryResourceType = RegistryResourceType;
+
   canEdit = select(RegistrySelectors.hasWriteAccess);
 
   addButtonVisible = computed(() => !!this.identifiers().length && this.canEdit());
 
+  getResourceTypeTranslationKey(type: string): string {
+    return resourceTypeOptions.find((opt) => opt.value === type)?.label ?? '';
+  }
+
   constructor() {
-    this.actions.getResources(this.registryId);
+    effect(() => {
+      const registryId = this.registryId();
+
+      if (registryId) {
+        this.actions.getResources(registryId);
+      }
+    });
   }
 
   addResource() {
-    if (!this.registryId) return;
+    const registryId = this.registryId();
+    if (!registryId) return;
 
     this.isAddingResource.set(true);
 
     this.actions
-      .addResource(this.registryId)
+      .addResource(registryId)
       .pipe(
-        take(1),
-        switchMap(() => this.openAddResourceDialog()),
+        switchMap(() => this.openAddResourceDialog(registryId)),
         filter((res) => !!res),
         finalize(() => this.isAddingResource.set(false)),
         takeUntilDestroyed(this.destroyRef)
@@ -87,22 +113,15 @@ export class RegistryResourcesComponent {
       });
   }
 
-  openAddResourceDialog() {
-    return this.customDialogService.open(AddResourceDialogComponent, {
-      header: 'resources.add',
-      width: '500px',
-      data: { id: this.registryId },
-    }).onClose;
-  }
-
   updateResource(resource: RegistryResource) {
-    if (!this.registryId) return;
+    const registryId = this.registryId();
+    if (!registryId) return;
 
     this.customDialogService
       .open(EditResourceDialogComponent, {
         header: 'resources.edit',
         width: '500px',
-        data: { id: this.registryId, resource: resource },
+        data: { id: registryId, resource },
       })
       .onClose.pipe(
         takeUntilDestroyed(this.destroyRef),
@@ -115,7 +134,8 @@ export class RegistryResourcesComponent {
   }
 
   deleteResource(id: string) {
-    if (!this.registryId) return;
+    const registryId = this.registryId();
+    if (!registryId) return;
 
     this.customConfirmationService.confirmDelete({
       headerKey: 'resources.delete',
@@ -123,10 +143,18 @@ export class RegistryResourcesComponent {
       acceptLabelKey: 'common.buttons.remove',
       onConfirm: () => {
         this.actions
-          .deleteResource(id, this.registryId)
-          .pipe(take(1))
+          .deleteResource(id, registryId)
+          .pipe(takeUntilDestroyed(this.destroyRef))
           .subscribe(() => this.toastService.showSuccess('resources.toastMessages.deletedResourceSuccess'));
       },
     });
   }
+
+  private openAddResourceDialog(registryId: string) {
+    return this.customDialogService.open(AddResourceDialogComponent, {
+      header: 'resources.add',
+      width: '500px',
+      data: { id: registryId },
+    }).onClose;
+  }
 }
diff --git a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.html b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.html
index 799fd09be..14f46fd74 100644
--- a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.html
+++ b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.html
@@ -22,7 +22,7 @@
 <section class="flex flex-column lg:flex-row lg:flex-wrap bg-white flex-1 p-5 gap-4 w-full wiki-page">
   <osf-wiki-list
     [list]="wikiList()"
-    [resourceId]="resourceId"
+    [resourceId]="resourceId() ?? ''"
     [isLoading]="isWikiListLoading()"
     [componentsList]="componentsWikiList()"
     [currentWikiId]="currentWikiId()"
diff --git a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.spec.ts b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.spec.ts
index 48a66ad6c..edcbcdfd4 100644
--- a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.spec.ts
+++ b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.spec.ts
@@ -1,17 +1,18 @@
-import { MockComponents, MockProvider } from 'ng-mocks';
+import { Store } from '@ngxs/store';
 
-import { Subject } from 'rxjs';
+import { MockComponents, MockProvider } from 'ng-mocks';
 
-import { signal } from '@angular/core';
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { signal, WritableSignal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 
-import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
+import { ViewOnlyLinkMessageComponent } from '@osf/shared/components/view-only-link-message/view-only-link-message.component';
 import { CompareSectionComponent } from '@osf/shared/components/wiki/compare-section/compare-section.component';
 import { ViewSectionComponent } from '@osf/shared/components/wiki/view-section/view-section.component';
 import { WikiListComponent } from '@osf/shared/components/wiki/wiki-list/wiki-list.component';
 import { ResourceType } from '@osf/shared/enums/resource-type.enum';
 import { WikiModes } from '@osf/shared/models/wiki/wiki.model';
+import { ViewOnlyLinkHelperService } from '@osf/shared/services/view-only-link-helper.service';
 import {
   ClearWiki,
   GetCompareVersionContent,
@@ -23,166 +24,218 @@ import {
   ToggleMode,
   WikiSelectors,
 } from '@osf/shared/stores/wiki';
-import { ViewOnlyLinkMessageComponent } from '@shared/components/view-only-link-message/view-only-link-message.component';
 
 import { RegistryWikiComponent } from './registry-wiki.component';
 
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
 import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
-import { provideMockStore } from '@testing/providers/store-provider.mock';
+import { BaseSetupOverrides, mergeSignalOverrides, provideMockStore } from '@testing/providers/store-provider.mock';
+import { ViewOnlyLinkHelperMock } from '@testing/providers/view-only-link-helper.mock';
+
+const MOCK_WIKI_LIST = [{ id: 'wiki-1', name: 'Wiki 1' }];
+
+interface SetupOverrides extends BaseSetupOverrides {
+  queryParams?: Record<string, string>;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const queryParams = overrides.queryParams ?? { wiki: 'wiki-123' };
+
+  const routeBuilder = ActivatedRouteMockBuilder.create()
+    .withParams(overrides.routeParams ?? { id: 'resource-123' })
+    .withQueryParams(queryParams);
+
+  const mockRoute = routeBuilder.build();
+  const mockRouter = RouterMockBuilder.create().build();
+  const mockViewOnlyHelper = ViewOnlyLinkHelperMock.simple();
+
+  const defaultSignals = [
+    { selector: WikiSelectors.getWikiModes, value: { view: true, edit: false, compare: false } },
+    { selector: WikiSelectors.getPreviewContent, value: 'Preview content' },
+    { selector: WikiSelectors.getWikiVersionContent, value: 'Version content' },
+    { selector: WikiSelectors.getCompareVersionContent, value: 'Compare content' },
+    { selector: WikiSelectors.getWikiList, value: MOCK_WIKI_LIST },
+    { selector: WikiSelectors.getComponentsWikiList, value: [] },
+    { selector: WikiSelectors.getCurrentWikiId, value: 'wiki-123' },
+    { selector: WikiSelectors.getWikiVersions, value: [] },
+    { selector: WikiSelectors.getWikiListLoading, value: false },
+    { selector: WikiSelectors.getComponentsWikiListLoading, value: false },
+    { selector: WikiSelectors.getWikiVersionsLoading, value: false },
+  ];
+
+  const signals = mergeSignalOverrides(defaultSignals, overrides.selectorOverrides);
+
+  TestBed.configureTestingModule({
+    imports: [
+      RegistryWikiComponent,
+      ...MockComponents(WikiListComponent, ViewSectionComponent, CompareSectionComponent, ViewOnlyLinkMessageComponent),
+    ],
+    providers: [
+      provideOSFCore(),
+      MockProvider(ActivatedRoute, mockRoute),
+      MockProvider(Router, mockRouter),
+      MockProvider(ViewOnlyLinkHelperService, mockViewOnlyHelper),
+      provideMockStore({ signals }),
+    ],
+  });
+
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryWikiComponent);
+  const component = fixture.componentInstance;
+  fixture.detectChanges();
+
+  return { fixture, component, store, mockRouter, routeBuilder };
+}
 
 describe('RegistryWikiComponent', () => {
-  let component: RegistryWikiComponent;
-  let fixture: ComponentFixture<RegistryWikiComponent>;
-  let routerMock: ReturnType<RouterMockBuilder['build']>;
-  let activatedRouteMock: ReturnType<ActivatedRouteMockBuilder['build']>;
-  let storeDispatchSpy: jest.SpyInstance;
-  let queryParamsSubject: Subject<any>;
-
-  const mockResourceId = 'resource-123';
-  const mockWikiId = 'wiki-123';
-  const mockWikiList = [{ id: 'wiki-1', name: 'Wiki 1' }] as any;
-
-  beforeEach(async () => {
-    queryParamsSubject = new Subject();
-    routerMock = RouterMockBuilder.create().build();
-    activatedRouteMock = ActivatedRouteMockBuilder.create()
-      .withParams({ id: mockResourceId })
-      .withQueryParams({ wiki: mockWikiId })
-      .build();
-
-    Object.defineProperty(activatedRouteMock, 'queryParams', {
-      value: queryParamsSubject.asObservable(),
-      writable: true,
-    });
+  it('should dispatch getWikiList and getComponentsWikiList on construction', () => {
+    const { store } = setup();
 
-    const mockStore = provideMockStore({
-      signals: [
-        { selector: WikiSelectors.getWikiModes, value: signal({ view: true, edit: false, compare: false }) },
-        { selector: WikiSelectors.getPreviewContent, value: signal('Preview content') },
-        { selector: WikiSelectors.getWikiVersionContent, value: signal('Version content') },
-        { selector: WikiSelectors.getCompareVersionContent, value: signal('Compare content') },
-        { selector: WikiSelectors.getWikiList, value: signal(mockWikiList) },
-        { selector: WikiSelectors.getComponentsWikiList, value: signal([]) },
-        { selector: WikiSelectors.getCurrentWikiId, value: signal(mockWikiId) },
-        { selector: WikiSelectors.getWikiVersions, value: signal([]) },
-        { selector: WikiSelectors.getWikiListLoading, value: signal(false) },
-        { selector: WikiSelectors.getComponentsWikiListLoading, value: signal(false) },
-        { selector: WikiSelectors.getWikiVersionsLoading, value: signal(false) },
-      ],
-    });
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    const getWikiListCall = calls.find(([a]: [unknown]) => a instanceof GetWikiList);
+    const getComponentsCall = calls.find(([a]: [unknown]) => a instanceof GetComponentsWikiList);
 
-    storeDispatchSpy = jest.spyOn(mockStore.useValue, 'dispatch');
-
-    await TestBed.configureTestingModule({
-      imports: [
-        RegistryWikiComponent,
-        OSFTestingModule,
-        ...MockComponents(
-          SubHeaderComponent,
-          WikiListComponent,
-          ViewSectionComponent,
-          CompareSectionComponent,
-          ViewOnlyLinkMessageComponent
-        ),
-      ],
-      providers: [MockProvider(Router, routerMock), MockProvider(ActivatedRoute, activatedRouteMock), mockStore],
-    }).compileComponents();
+    expect(getWikiListCall).toBeDefined();
+    expect(getWikiListCall[0].resourceType).toBe(ResourceType.Registration);
+    expect(getWikiListCall[0].resourceId).toBe('resource-123');
 
-    fixture = TestBed.createComponent(RegistryWikiComponent);
-    component = fixture.componentInstance;
+    expect(getComponentsCall).toBeDefined();
+    expect(getComponentsCall[0].resourceType).toBe(ResourceType.Registration);
+    expect(getComponentsCall[0].resourceId).toBe('resource-123');
   });
 
-  it('should dispatch getWikiList and getComponentsWikiList on construction', () => {
-    expect(storeDispatchSpy).toHaveBeenCalledTimes(2);
+  it('should dispatch setCurrentWiki and getWikiVersions from initial query params', () => {
+    const { store } = setup();
 
-    const getWikiListCall = storeDispatchSpy.mock.calls.find((call) => call[0] instanceof GetWikiList);
-    const getComponentsWikiListCall = storeDispatchSpy.mock.calls.find(
-      (call) => call[0] instanceof GetComponentsWikiList
-    );
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    const setCurrentWikiCall = calls.find(([a]: [unknown]) => a instanceof SetCurrentWiki);
+    const getVersionsCall = calls.find(([a]: [unknown]) => a instanceof GetWikiVersions);
 
-    expect(getWikiListCall).toBeDefined();
-    expect(getWikiListCall[0].resourceType).toBe(ResourceType.Registration);
-    expect(getWikiListCall[0].resourceId).toBe(mockResourceId);
+    expect(setCurrentWikiCall).toBeDefined();
+    expect(setCurrentWikiCall[0].wikiId).toBe('wiki-123');
+
+    expect(getVersionsCall).toBeDefined();
+    expect(getVersionsCall[0].wikiId).toBe('wiki-123');
+  });
+
+  it('should navigate to first wiki when no wiki query param', () => {
+    const { mockRouter } = setup({ queryParams: {} });
+
+    expect(mockRouter.navigate).toHaveBeenCalledWith([], expect.objectContaining({ queryParams: { wiki: 'wiki-1' } }));
+  });
+
+  it('should not navigate to first wiki when wiki query param exists', () => {
+    const { mockRouter } = setup();
 
-    expect(getComponentsWikiListCall).toBeDefined();
-    expect(getComponentsWikiListCall[0].resourceType).toBe(ResourceType.Registration);
-    expect(getComponentsWikiListCall[0].resourceId).toBe(mockResourceId);
+    expect(mockRouter.navigate).not.toHaveBeenCalled();
   });
 
-  it('should call toggleMode action when toggleMode is called', () => {
-    storeDispatchSpy.mockClear();
+  it('should handle query params changes and dispatch setCurrentWiki and getWikiVersions', () => {
+    const { store, routeBuilder } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
+
+    routeBuilder.withQueryParams({ wiki: 'new-wiki-456' });
 
-    component.toggleMode(WikiModes.Edit);
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    const setCurrentWikiCall = calls.find(([a]: [unknown]) => a instanceof SetCurrentWiki);
+    const getVersionsCall = calls.find(([a]: [unknown]) => a instanceof GetWikiVersions);
 
-    expect(storeDispatchSpy).toHaveBeenCalledWith(expect.any(ToggleMode));
-    const action = storeDispatchSpy.mock.calls[0][0] as ToggleMode;
-    expect(action.mode).toBe(WikiModes.Edit);
+    expect(setCurrentWikiCall[0].wikiId).toBe('new-wiki-456');
+    expect(getVersionsCall[0].wikiId).toBe('new-wiki-456');
   });
 
-  it('should dispatch getWikiVersionContent when onSelectVersion is called with versionId', () => {
-    storeDispatchSpy.mockClear();
-    const versionId = 'version-123';
+  it('should not process query params when wiki is empty', () => {
+    const { store } = setup({ queryParams: {} });
 
-    component.onSelectVersion(versionId);
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    const setCurrentWikiCall = calls.find(([a]: [unknown]) => a instanceof SetCurrentWiki);
 
-    expect(storeDispatchSpy).toHaveBeenCalledWith(expect.any(GetWikiVersionContent));
-    const action = storeDispatchSpy.mock.calls[0][0] as GetWikiVersionContent;
-    expect(action.wikiId).toBe(mockWikiId);
-    expect(action.versionId).toBe(versionId);
+    expect(setCurrentWikiCall).toBeUndefined();
   });
 
-  it('should not dispatch getWikiVersionContent when onSelectVersion is called with empty versionId', () => {
-    storeDispatchSpy.mockClear();
+  it('should call toggleMode action', () => {
+    const { component, store } = setup();
 
-    component.onSelectVersion('');
+    (store.dispatch as jest.Mock).mockClear();
+    component.toggleMode(WikiModes.Compare);
 
-    const getVersionContentCall = storeDispatchSpy.mock.calls.find((call) => call[0] instanceof GetWikiVersionContent);
-    expect(getVersionContentCall).toBeUndefined();
+    expect(store.dispatch).toHaveBeenCalledWith(expect.any(ToggleMode));
+    expect((store.dispatch as jest.Mock).mock.calls[0][0].mode).toBe(WikiModes.Compare);
   });
 
-  it('should dispatch getCompareVersionContent when onSelectCompareVersion is called', () => {
-    storeDispatchSpy.mockClear();
-    const versionId = 'version-123';
+  it('should dispatch getWikiVersionContent on onSelectVersion', () => {
+    const { component, store } = setup();
 
-    component.onSelectCompareVersion(versionId);
+    (store.dispatch as jest.Mock).mockClear();
+    component.onSelectVersion('version-1');
 
-    expect(storeDispatchSpy).toHaveBeenCalledWith(expect.any(GetCompareVersionContent));
-    const action = storeDispatchSpy.mock.calls[0][0] as GetCompareVersionContent;
-    expect(action.wikiId).toBe(mockWikiId);
-    expect(action.versionId).toBe(versionId);
+    expect(store.dispatch).toHaveBeenCalledWith(expect.any(GetWikiVersionContent));
+    const action = (store.dispatch as jest.Mock).mock.calls[0][0] as GetWikiVersionContent;
+    expect(action.wikiId).toBe('wiki-123');
+    expect(action.versionId).toBe('version-1');
   });
 
-  it('should handle query params changes and dispatch setCurrentWiki and getWikiVersions', () => {
-    storeDispatchSpy.mockClear();
-    const newWikiId = 'new-wiki-123';
+  it('should not dispatch getWikiVersionContent with empty versionId', () => {
+    const { component, store } = setup();
 
-    queryParamsSubject.next({ wiki: newWikiId });
+    (store.dispatch as jest.Mock).mockClear();
+    component.onSelectVersion('');
 
-    const setCurrentWikiCall = storeDispatchSpy.mock.calls.find((call) => call[0] instanceof SetCurrentWiki);
-    expect(setCurrentWikiCall).toBeDefined();
-    expect((setCurrentWikiCall[0] as SetCurrentWiki).wikiId).toBe(newWikiId);
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    expect(calls.find(([a]: [unknown]) => a instanceof GetWikiVersionContent)).toBeUndefined();
+  });
 
-    const getVersionsCall = storeDispatchSpy.mock.calls.find((call) => call[0] instanceof GetWikiVersions);
-    expect(getVersionsCall).toBeDefined();
-    expect((getVersionsCall[0] as GetWikiVersions).wikiId).toBe(newWikiId);
+  it('should dispatch getCompareVersionContent on onSelectCompareVersion', () => {
+    const { component, store } = setup();
+
+    (store.dispatch as jest.Mock).mockClear();
+    component.onSelectCompareVersion('version-2');
+
+    expect(store.dispatch).toHaveBeenCalledWith(expect.any(GetCompareVersionContent));
+    const action = (store.dispatch as jest.Mock).mock.calls[0][0] as GetCompareVersionContent;
+    expect(action.wikiId).toBe('wiki-123');
+    expect(action.versionId).toBe('version-2');
   });
 
-  it('should not process query params when wiki is empty', () => {
-    storeDispatchSpy.mockClear();
+  it('should not dispatch getCompareVersionContent with empty versionId', () => {
+    const { component, store } = setup();
 
-    queryParamsSubject.next({ wiki: '' });
+    (store.dispatch as jest.Mock).mockClear();
+    component.onSelectCompareVersion('');
 
-    const setCurrentWikiCall = storeDispatchSpy.mock.calls.find((call) => call[0] instanceof SetCurrentWiki);
-    expect(setCurrentWikiCall).toBeUndefined();
+    const calls = (store.dispatch as jest.Mock).mock.calls;
+    expect(calls.find(([a]: [unknown]) => a instanceof GetCompareVersionContent)).toBeUndefined();
   });
 
   it('should dispatch clearWiki on destroy', () => {
-    storeDispatchSpy.mockClear();
+    const { fixture, store } = setup();
 
+    (store.dispatch as jest.Mock).mockClear();
     fixture.destroy();
 
-    expect(storeDispatchSpy).toHaveBeenCalledWith(expect.any(ClearWiki));
+    expect(store.dispatch).toHaveBeenCalledWith(expect.any(ClearWiki));
+  });
+
+  it('should compute isWikiListLoading from both loading selectors', () => {
+    const wikiListLoadingSignal: WritableSignal<boolean> = signal(false);
+    const componentsLoadingSignal: WritableSignal<boolean> = signal(false);
+
+    const { component } = setup({
+      selectorOverrides: [
+        { selector: WikiSelectors.getWikiListLoading, value: wikiListLoadingSignal },
+        { selector: WikiSelectors.getComponentsWikiListLoading, value: componentsLoadingSignal },
+      ],
+    });
+
+    expect(component.isWikiListLoading()).toBe(false);
+
+    wikiListLoadingSignal.set(true);
+    expect(component.isWikiListLoading()).toBe(true);
+
+    wikiListLoadingSignal.set(false);
+    componentsLoadingSignal.set(true);
+    expect(component.isWikiListLoading()).toBe(true);
   });
 });
diff --git a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.ts b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.ts
index 1a711879f..732f4f8e5 100644
--- a/src/app/features/registry/pages/registry-wiki/registry-wiki.component.ts
+++ b/src/app/features/registry/pages/registry-wiki/registry-wiki.component.ts
@@ -5,11 +5,11 @@ import { TranslatePipe } from '@ngx-translate/core';
 import { Button } from 'primeng/button';
 import { ButtonGroup } from 'primeng/buttongroup';
 
-import { filter, map, mergeMap, tap } from 'rxjs';
+import { filter, map, of, switchMap, tap } from 'rxjs';
 
 import { isPlatformBrowser } from '@angular/common';
 import { ChangeDetectionStrategy, Component, computed, DestroyRef, inject, PLATFORM_ID } from '@angular/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { SubHeaderComponent } from '@osf/shared/components/sub-header/sub-header.component';
@@ -36,14 +36,14 @@ import {
 @Component({
   selector: 'osf-registry-wiki',
   imports: [
-    SubHeaderComponent,
     Button,
     ButtonGroup,
-    TranslatePipe,
+    SubHeaderComponent,
     WikiListComponent,
     ViewSectionComponent,
     CompareSectionComponent,
     ViewOnlyLinkMessageComponent,
+    TranslatePipe,
   ],
   templateUrl: './registry-wiki.component.html',
   styleUrl: './registry-wiki.component.scss',
@@ -62,7 +62,11 @@ export class RegistryWikiComponent {
   previewContent = select(WikiSelectors.getPreviewContent);
   versionContent = select(WikiSelectors.getWikiVersionContent);
   compareVersionContent = select(WikiSelectors.getCompareVersionContent);
-  isWikiListLoading = select(WikiSelectors.getWikiListLoading || WikiSelectors.getComponentsWikiListLoading);
+
+  private readonly wikiListLoading = select(WikiSelectors.getWikiListLoading);
+  private readonly componentsWikiListLoading = select(WikiSelectors.getComponentsWikiListLoading);
+  isWikiListLoading = computed(() => this.wikiListLoading() || this.componentsWikiListLoading());
+
   wikiList = select(WikiSelectors.getWikiList);
   currentWikiId = select(WikiSelectors.getCurrentWikiId);
   wikiVersions = select(WikiSelectors.getWikiVersions);
@@ -71,7 +75,9 @@ export class RegistryWikiComponent {
 
   hasViewOnly = computed(() => this.viewOnlyService.hasViewOnlyParam(this.router));
 
-  readonly resourceId = this.route.parent?.snapshot.params['id'];
+  readonly resourceId = toSignal<string | undefined>(
+    this.route.parent?.params.pipe(map((params) => params['id'])) ?? of(undefined)
+  );
 
   actions = createDispatchMap({
     toggleMode: ToggleMode,
@@ -85,32 +91,33 @@ export class RegistryWikiComponent {
     clearWiki: ClearWiki,
   });
 
-  wikiIdFromQueryParams = this.route.snapshot.queryParams['wiki'];
-
   constructor() {
-    this.actions
-      .getWikiList(ResourceType.Registration, this.resourceId)
-      .pipe(
-        takeUntilDestroyed(this.destroyRef),
-        tap(() => {
-          if (!this.wikiIdFromQueryParams) {
-            this.navigateToWiki(this.wikiList()?.[0]?.id || '');
-          }
-        })
-      )
-      .subscribe();
-
-    this.actions.getComponentsWikiList(ResourceType.Registration, this.resourceId);
+    const resourceId = this.resourceId();
+    const wikiIdFromQueryParams = this.route.snapshot.queryParams['wiki'];
+
+    if (resourceId) {
+      this.actions
+        .getWikiList(ResourceType.Registration, resourceId)
+        .pipe(
+          takeUntilDestroyed(this.destroyRef),
+          tap(() => {
+            if (!wikiIdFromQueryParams) {
+              this.navigateToWiki(this.wikiList()?.[0]?.id || '');
+            }
+          })
+        )
+        .subscribe();
+
+      this.actions.getComponentsWikiList(ResourceType.Registration, resourceId);
+    }
 
     this.route.queryParams
       .pipe(
         takeUntilDestroyed(this.destroyRef),
         map((params) => params['wiki']),
-        filter((wikiId) => wikiId),
-        tap((wikiId) => {
-          this.actions.setCurrentWiki(wikiId);
-        }),
-        mergeMap((wikiId) => this.actions.getWikiVersions(wikiId))
+        filter((wikiId) => !!wikiId),
+        tap((wikiId) => this.actions.setCurrentWiki(wikiId)),
+        switchMap((wikiId) => this.actions.getWikiVersions(wikiId))
       )
       .subscribe();
 
@@ -132,7 +139,9 @@ export class RegistryWikiComponent {
   }
 
   onSelectCompareVersion(versionId: string) {
-    this.actions.getCompareVersionContent(this.currentWikiId(), versionId);
+    if (versionId) {
+      this.actions.getCompareVersionContent(this.currentWikiId(), versionId);
+    }
   }
 
   private navigateToWiki(wiki: string) {
diff --git a/src/app/features/registry/registry.component.spec.ts b/src/app/features/registry/registry.component.spec.ts
index f485c737f..5c59c5f26 100644
--- a/src/app/features/registry/registry.component.spec.ts
+++ b/src/app/features/registry/registry.component.spec.ts
@@ -1,7 +1,10 @@
 import { Store } from '@ngxs/store';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { ActivatedRoute } from '@angular/router';
+import { MockProvider } from 'ng-mocks';
+
+import { PLATFORM_ID, Provider } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
 
 import { HelpScoutService } from '@core/services/help-scout.service';
 import { PrerenderReadyService } from '@core/services/prerender-ready.service';
@@ -10,84 +13,164 @@ import { AnalyticsService } from '@osf/shared/services/analytics.service';
 import { DataciteService } from '@osf/shared/services/datacite/datacite.service';
 import { MetaTagsService } from '@osf/shared/services/meta-tags.service';
 import { ContributorsSelectors } from '@osf/shared/stores/contributors';
+import { CurrentResourceSelectors } from '@shared/stores/current-resource';
 
 import { RegistrySelectors } from './store/registry';
+import { RegistrationOverviewModel } from './models';
 import { RegistryComponent } from './registry.component';
 
 import { DataciteMockFactory } from '@testing/mocks/datacite.service.mock';
-import { OSFTestingModule } from '@testing/osf.testing.module';
+import { MOCK_REGISTRATION_OVERVIEW_MODEL } from '@testing/mocks/registration-overview-model.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 import { AnalyticsServiceMockFactory } from '@testing/providers/analytics.service.mock';
 import { HelpScoutServiceMockFactory } from '@testing/providers/help-scout.service.mock';
 import { MetaTagsServiceMockFactory } from '@testing/providers/meta-tags.service.mock';
 import { PrerenderReadyServiceMockFactory } from '@testing/providers/prerender-ready.service.mock';
 import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
+import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
 import { provideMockStore } from '@testing/providers/store-provider.mock';
 
-describe('RegistryComponent', () => {
-  let component: RegistryComponent;
-  let fixture: ComponentFixture<RegistryComponent>;
-  let helpScoutService: ReturnType<typeof HelpScoutServiceMockFactory>;
-  let metaTagsService: ReturnType<typeof MetaTagsServiceMockFactory>;
-  let dataciteService: ReturnType<typeof DataciteMockFactory>;
-  let prerenderReadyService: ReturnType<typeof PrerenderReadyServiceMockFactory>;
-  let analyticsService: ReturnType<typeof AnalyticsServiceMockFactory>;
-  let store: Store;
-  let mockActivatedRoute: ReturnType<ActivatedRouteMockBuilder['build']>;
-
-  beforeEach(async () => {
-    mockActivatedRoute = ActivatedRouteMockBuilder.create().withParams({ id: 'registry-1' }).build();
-
-    helpScoutService = HelpScoutServiceMockFactory();
-    metaTagsService = MetaTagsServiceMockFactory();
-    dataciteService = DataciteMockFactory();
-    prerenderReadyService = PrerenderReadyServiceMockFactory();
-    analyticsService = AnalyticsServiceMockFactory();
-
-    await TestBed.configureTestingModule({
-      imports: [RegistryComponent, OSFTestingModule],
-      providers: [
-        { provide: HelpScoutService, useValue: helpScoutService },
-        { provide: MetaTagsService, useValue: metaTagsService },
-        { provide: DataciteService, useValue: dataciteService },
-        { provide: PrerenderReadyService, useValue: prerenderReadyService },
-        { provide: AnalyticsService, useValue: analyticsService },
-        { provide: ActivatedRoute, useValue: mockActivatedRoute },
-        provideMockStore({
-          signals: [
-            { selector: RegistrySelectors.getRegistry, value: null },
-            { selector: RegistrySelectors.isRegistryLoading, value: false },
-            { selector: RegistrySelectors.getIdentifiers, value: [] },
-            { selector: RegistrySelectors.getLicense, value: null },
-            { selector: RegistrySelectors.isLicenseLoading, value: false },
-            { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
-            { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
-          ],
-        }),
+interface SetupOverrides {
+  registryId?: string;
+  registry?: RegistrationOverviewModel | null;
+  platform?: string;
+}
+
+function setup(overrides: SetupOverrides = {}) {
+  const registryId = overrides.registryId ?? 'registry-1';
+  const registry = overrides.registry ?? null;
+
+  const helpScoutService = HelpScoutServiceMockFactory();
+  const metaTagsService = MetaTagsServiceMockFactory();
+  const dataciteService = DataciteMockFactory();
+  const prerenderReadyService = PrerenderReadyServiceMockFactory();
+  const analyticsService = AnalyticsServiceMockFactory();
+  const routerBuilder = RouterMockBuilder.create();
+  const mockRouter = routerBuilder.build();
+
+  const providers: Provider[] = [
+    provideOSFCore(),
+    MockProvider(HelpScoutService, helpScoutService),
+    MockProvider(MetaTagsService, metaTagsService),
+    MockProvider(DataciteService, dataciteService),
+    MockProvider(PrerenderReadyService, prerenderReadyService),
+    MockProvider(AnalyticsService, analyticsService),
+    MockProvider(ActivatedRoute, ActivatedRouteMockBuilder.create().withParams({ id: registryId }).build()),
+    MockProvider(Router, mockRouter),
+    provideMockStore({
+      signals: [
+        { selector: RegistrySelectors.getRegistry, value: registry },
+        { selector: RegistrySelectors.isRegistryLoading, value: false },
+        { selector: RegistrySelectors.getIdentifiers, value: [] },
+        { selector: RegistrySelectors.getLicense, value: { name: 'MIT' } },
+        { selector: RegistrySelectors.isLicenseLoading, value: false },
+        { selector: ContributorsSelectors.getBibliographicContributors, value: [] },
+        { selector: ContributorsSelectors.isBibliographicContributorsLoading, value: false },
+        { selector: CurrentResourceSelectors.getCurrentResource, value: null },
       ],
-    }).compileComponents();
+    }),
+  ];
+
+  if (overrides.platform) {
+    providers.push({ provide: PLATFORM_ID, useValue: overrides.platform });
+  }
 
-    store = TestBed.inject(Store);
-    fixture = TestBed.createComponent(RegistryComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
+  TestBed.configureTestingModule({
+    imports: [RegistryComponent],
+    providers,
   });
 
-  it('should call the helpScoutService', () => {
+  const store = TestBed.inject(Store);
+  const fixture = TestBed.createComponent(RegistryComponent);
+  fixture.detectChanges();
+
+  return {
+    fixture,
+    component: fixture.componentInstance,
+    store,
+    routerBuilder,
+    helpScoutService,
+    metaTagsService,
+    dataciteService,
+    prerenderReadyService,
+    analyticsService,
+  };
+}
+
+describe('RegistryComponent', () => {
+  it('should set helpScout resource type and prerender not ready on creation', () => {
+    const { helpScoutService, prerenderReadyService } = setup();
+
     expect(helpScoutService.setResourceType).toHaveBeenCalledWith('registration');
+    expect(prerenderReadyService.setNotReady).toHaveBeenCalled();
   });
 
-  it('should call unsetResourceType and clearCurrentProvider on destroy', () => {
-    const dispatchSpy = jest.spyOn(store, 'dispatch');
+  it('should call dataciteService.logIdentifiableView', () => {
+    const { dataciteService } = setup();
+
+    expect(dataciteService.logIdentifiableView).toHaveBeenCalled();
+  });
+
+  it('should dispatch init actions when registryId is available', () => {
+    const { store } = setup();
+
+    expect(store.dispatch).toHaveBeenCalled();
+  });
+
+  it('should not dispatch init actions when registryId is empty', () => {
+    const { store } = setup({ registryId: '' });
+
+    expect(store.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should call setMetaTags when all data is loaded', () => {
+    const { metaTagsService } = setup({ registry: MOCK_REGISTRATION_OVERVIEW_MODEL });
+
+    expect(metaTagsService.updateMetaTags).toHaveBeenCalledWith(
+      expect.objectContaining({
+        osfGuid: MOCK_REGISTRATION_OVERVIEW_MODEL.id,
+        title: MOCK_REGISTRATION_OVERVIEW_MODEL.title,
+        description: MOCK_REGISTRATION_OVERVIEW_MODEL.description,
+        siteName: 'OSF',
+      }),
+      expect.anything()
+    );
+  });
+
+  it('should not call setMetaTags when registry is null', () => {
+    const { metaTagsService } = setup({ registry: null });
+
+    expect(metaTagsService.updateMetaTags).not.toHaveBeenCalled();
+  });
+
+  it('should send analytics on NavigationEnd event', () => {
+    const { routerBuilder, analyticsService } = setup();
+
+    routerBuilder.emit(new NavigationEnd(1, '/registries/registry-1', '/registries/registry-1'));
+
+    expect(analyticsService.sendCountedUsageForRegistrationAndProjects).toHaveBeenCalledWith(
+      '/registries/registry-1',
+      null
+    );
+  });
+
+  it('should unset helpScout and clear provider on destroy', () => {
+    const { component, store, helpScoutService } = setup();
+    jest.spyOn(store, 'dispatch');
+
     component.ngOnDestroy();
+
     expect(helpScoutService.unsetResourceType).toHaveBeenCalled();
-    expect(dispatchSpy).toHaveBeenCalledWith(new ClearCurrentProvider());
+    expect(store.dispatch).toHaveBeenCalledWith(new ClearCurrentProvider());
   });
 
-  it('should call prerenderReady.setNotReady in constructor', () => {
-    expect(prerenderReadyService.setNotReady).toHaveBeenCalled();
-  });
+  it('should not dispatch clearCurrentProvider on destroy when not browser', () => {
+    const { component, store, helpScoutService } = setup({ platform: 'server' });
+    jest.spyOn(store, 'dispatch').mockClear();
 
-  it('should call dataciteService.logIdentifiableView', () => {
-    expect(dataciteService.logIdentifiableView).toHaveBeenCalled();
+    component.ngOnDestroy();
+
+    expect(helpScoutService.unsetResourceType).toHaveBeenCalled();
+    expect(store.dispatch).not.toHaveBeenCalledWith(new ClearCurrentProvider());
   });
 });
diff --git a/src/app/features/registry/registry.component.ts b/src/app/features/registry/registry.component.ts
index ddc1d89d9..75e90c022 100644
--- a/src/app/features/registry/registry.component.ts
+++ b/src/app/features/registry/registry.component.ts
@@ -63,17 +63,19 @@ export class RegistryComponent implements OnDestroy {
     getIdentifiers: GetRegistryIdentifiers,
   });
 
-  private registryId = toSignal(this.route.params.pipe(map((params) => params['id'])));
-  readonly currentResource = select(CurrentResourceSelectors.getCurrentResource);
-  readonly registry = select(RegistrySelectors.getRegistry);
-  readonly isRegistryLoading = select(RegistrySelectors.isRegistryLoading);
-  readonly identifiersForDatacite$ = toObservable(select(RegistrySelectors.getIdentifiers)).pipe(
+  private readonly registryId = toSignal(this.route.params.pipe(map((params) => params['id'])));
+  private readonly currentResource = select(CurrentResourceSelectors.getCurrentResource);
+  private readonly registry = select(RegistrySelectors.getRegistry);
+  private readonly isRegistryLoading = select(RegistrySelectors.isRegistryLoading);
+  private readonly identifiersForDatacite$ = toObservable(select(RegistrySelectors.getIdentifiers)).pipe(
     map((identifiers) => (identifiers?.length ? { identifiers } : null))
   );
-  readonly bibliographicContributors = select(ContributorsSelectors.getBibliographicContributors);
-  readonly isBibliographicContributorsLoading = select(ContributorsSelectors.isBibliographicContributorsLoading);
-  readonly license = select(RegistrySelectors.getLicense);
-  readonly isLicenseLoading = select(RegistrySelectors.isLicenseLoading);
+  private readonly bibliographicContributors = select(ContributorsSelectors.getBibliographicContributors);
+  private readonly isBibliographicContributorsLoading = select(
+    ContributorsSelectors.isBibliographicContributorsLoading
+  );
+  private readonly license = select(RegistrySelectors.getLicense);
+  private readonly isLicenseLoading = select(RegistrySelectors.isLicenseLoading);
 
   private readonly lastMetaTagsRegistryId = signal<string | null>(null);
 
@@ -118,10 +120,10 @@ export class RegistryComponent implements OnDestroy {
 
     this.router.events
       .pipe(
-        filter((event) => event instanceof NavigationEnd),
+        filter((event): event is NavigationEnd => event instanceof NavigationEnd),
         takeUntilDestroyed(this.destroyRef)
       )
-      .subscribe((event: NavigationEnd) => {
+      .subscribe((event) => {
         this.analyticsService.sendCountedUsageForRegistrationAndProjects(
           event.urlAfterRedirects,
           this.currentResource()
diff --git a/src/app/shared/components/registration-blocks-data/registration-blocks-data.component.spec.ts b/src/app/shared/components/registration-blocks-data/registration-blocks-data.component.spec.ts
index 798ac1001..32d80b19c 100644
--- a/src/app/shared/components/registration-blocks-data/registration-blocks-data.component.spec.ts
+++ b/src/app/shared/components/registration-blocks-data/registration-blocks-data.component.spec.ts
@@ -1,67 +1,103 @@
-import { TranslatePipe } from '@ngx-translate/core';
-import { MockPipe } from 'ng-mocks';
+import { TestBed } from '@angular/core/testing';
 
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { By } from '@angular/platform-browser';
+import { FieldType } from '@osf/shared/enums/field-type.enum';
+import { Question } from '@osf/shared/models/registration/page-schema.model';
 
 import { RegistrationBlocksDataComponent } from './registration-blocks-data.component';
 
 import { MOCK_REVIEW } from '@testing/mocks/review.mock';
+import { provideOSFCore } from '@testing/osf.testing.provider';
 
-describe('RegistrationBlocksDataComponent', () => {
-  let component: RegistrationBlocksDataComponent;
-  let fixture: ComponentFixture<RegistrationBlocksDataComponent>;
-
-  const mockReviewData = MOCK_REVIEW;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [RegistrationBlocksDataComponent, MockPipe(TranslatePipe)],
-    }).compileComponents();
+const MOCK_QUESTIONS: Question[] = [
+  { id: '1', displayText: 'Q1', required: true, responseKey: 'question1', fieldType: FieldType.Text },
+  { id: '2', displayText: 'Q2', required: false, responseKey: 'question2', fieldType: FieldType.Checkbox },
+];
 
-    fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
-    component = fixture.componentInstance;
+describe('RegistrationBlocksDataComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [RegistrationBlocksDataComponent],
+      providers: [provideOSFCore()],
+    });
   });
 
   it('should create', () => {
-    expect(component).toBeTruthy();
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.detectChanges();
+
+    expect(fixture.componentInstance).toBeTruthy();
   });
 
-  it('should compute updatedKeysMap correctly', () => {
+  it('should compute updatedKeysMap from updatedFields', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
     fixture.componentRef.setInput('updatedFields', ['question1', 'question3']);
     fixture.detectChanges();
 
-    const expectedMap = { question1: true, question3: true };
-    expect(component.updatedKeysMap()).toEqual(expectedMap);
+    expect(fixture.componentInstance.updatedKeysMap()).toEqual({ question1: true, question3: true });
   });
 
-  it('should return empty object when updatedFields is empty', () => {
+  it('should return empty updatedKeysMap when updatedFields is empty', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
     fixture.componentRef.setInput('updatedFields', []);
     fixture.detectChanges();
 
-    expect(component.updatedKeysMap()).toEqual({});
+    expect(fixture.componentInstance.updatedKeysMap()).toEqual({});
   });
 
-  it('should handle single updated field', () => {
-    fixture.componentRef.setInput('updatedFields', ['question1']);
+  it('should render questions with review data', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.componentRef.setInput('questions', MOCK_QUESTIONS);
+    fixture.componentRef.setInput('reviewData', MOCK_REVIEW);
+    fixture.detectChanges();
+
+    const headings = fixture.nativeElement.querySelectorAll('h4');
+    expect(headings.length).toBe(2);
+    expect(headings[0].textContent).toContain('Q1');
+  });
+
+  it('should show required error when question is required and no data on non-overview page', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.componentRef.setInput('questions', MOCK_QUESTIONS);
+    fixture.componentRef.setInput('reviewData', {});
+    fixture.componentRef.setInput('isOverviewPage', false);
     fixture.detectChanges();
 
-    expect(component.updatedKeysMap()).toEqual({ question1: true });
+    const errorMessages = fixture.nativeElement.querySelectorAll('p-message[severity="error"]');
+    expect(errorMessages.length).toBe(1);
   });
 
-  it('should not show required error message on overview page', () => {
+  it('should not show required error on overview page', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.componentRef.setInput('questions', MOCK_QUESTIONS);
+    fixture.componentRef.setInput('reviewData', {});
     fixture.componentRef.setInput('isOverviewPage', true);
     fixture.detectChanges();
 
-    const errorMessages = fixture.debugElement.queryAll(By.css('p-message[severity="error"]'));
+    const errorMessages = fixture.nativeElement.querySelectorAll('p-message[severity="error"]');
     expect(errorMessages.length).toBe(0);
   });
 
-  it('should not show required error message when data is present', () => {
-    fixture.componentRef.setInput('reviewData', mockReviewData);
+  it('should show updated tag when field is updated and not original revision', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.componentRef.setInput('questions', MOCK_QUESTIONS);
+    fixture.componentRef.setInput('reviewData', MOCK_REVIEW);
+    fixture.componentRef.setInput('updatedFields', ['question1']);
+    fixture.componentRef.setInput('isOriginalRevision', false);
     fixture.detectChanges();
 
-    const errorMessages = fixture.debugElement.queryAll(By.css('p-message[severity="error"]'));
-    expect(errorMessages.length).toBe(0);
+    const tags = fixture.nativeElement.querySelectorAll('p-tag');
+    expect(tags.length).toBe(1);
+  });
+
+  it('should not show updated tag on original revision', () => {
+    const fixture = TestBed.createComponent(RegistrationBlocksDataComponent);
+    fixture.componentRef.setInput('questions', MOCK_QUESTIONS);
+    fixture.componentRef.setInput('reviewData', MOCK_REVIEW);
+    fixture.componentRef.setInput('updatedFields', ['question1']);
+    fixture.componentRef.setInput('isOriginalRevision', true);
+    fixture.detectChanges();
+
+    const tags = fixture.nativeElement.querySelectorAll('p-tag');
+    expect(tags.length).toBe(0);
   });
 });
diff --git a/src/testing/providers/analytics.service.mock.ts b/src/testing/providers/analytics.service.mock.ts
index f0c061422..ccbe734ec 100644
--- a/src/testing/providers/analytics.service.mock.ts
+++ b/src/testing/providers/analytics.service.mock.ts
@@ -5,5 +5,6 @@ import { AnalyticsService } from '@osf/shared/services/analytics.service';
 export function AnalyticsServiceMockFactory() {
   return {
     sendCountedUsage: jest.fn().mockReturnValue(of(void 0)),
+    sendCountedUsageForRegistrationAndProjects: jest.fn(),
   } as unknown as jest.Mocked<AnalyticsService>;
 }
diff --git a/src/testing/providers/route-provider.mock.ts b/src/testing/providers/route-provider.mock.ts
index 739aea0b5..477e3200c 100644
--- a/src/testing/providers/route-provider.mock.ts
+++ b/src/testing/providers/route-provider.mock.ts
@@ -7,6 +7,7 @@ export class ActivatedRouteMockBuilder {
   private queryParamsObj: Record<string, any> = {};
   private dataObj: Record<string, any> = {};
   private firstChildBuilder: ActivatedRouteMockBuilder | null = null;
+  private hasParent = true;
 
   private params$ = new BehaviorSubject<Record<string, any>>({});
   private queryParams$ = new BehaviorSubject<Record<string, any>>({});
@@ -40,6 +41,11 @@ export class ActivatedRouteMockBuilder {
     return this;
   }
 
+  withNoParent(): ActivatedRouteMockBuilder {
+    this.hasParent = false;
+    return this;
+  }
+
   withFirstChild(configureFn: (builder: ActivatedRouteMockBuilder) => void): ActivatedRouteMockBuilder {
     this.firstChildBuilder = new ActivatedRouteMockBuilder();
     configureFn(this.firstChildBuilder);
@@ -56,13 +62,17 @@ export class ActivatedRouteMockBuilder {
 
     const firstChild = this.firstChildBuilder ? this.firstChildBuilder.build() : null;
 
+    const parent = this.hasParent
+      ? ({
+          params: this.params$.asObservable(),
+          snapshot: {
+            params: this.paramsObj,
+          },
+        } as any)
+      : null;
+
     const route: Partial<ActivatedRoute> = {
-      parent: {
-        params: this.params$.asObservable(),
-        snapshot: {
-          params: this.paramsObj,
-        },
-      } as any,
+      parent,
       snapshot: {
         params: this.paramsObj,
         queryParams: this.queryParamsObj,
diff --git a/src/testing/providers/store-provider.mock.ts b/src/testing/providers/store-provider.mock.ts
index 7a07c4299..27b1562b1 100644
--- a/src/testing/providers/store-provider.mock.ts
+++ b/src/testing/providers/store-provider.mock.ts
@@ -60,6 +60,25 @@ export interface ProvideMockStoreOptions {
  * });
  * ```
  */
+export interface SignalOverride {
+  selector: unknown;
+  value: unknown;
+}
+
+export interface BaseSetupOverrides {
+  routeParams?: Record<string, string>;
+  hasParent?: boolean;
+  selectorOverrides?: SignalOverride[];
+}
+
+export function mergeSignalOverrides(defaults: SignalOverride[], overrides?: SignalOverride[]): SignalOverride[] {
+  if (!overrides) return defaults;
+  return defaults.map((s) => {
+    const override = overrides.find((o) => o.selector === s.selector);
+    return override ? { ...s, value: override.value } : s;
+  });
+}
+
 export function provideMockStore(options: ProvideMockStoreOptions = {}): { provide: typeof Store; useValue: Store } {
   /**
    * Stores mock selector values used by `select` and `selectSnapshot`.
diff --git a/src/testing/providers/view-only-link-helper.mock.ts b/src/testing/providers/view-only-link-helper.mock.ts
new file mode 100644
index 000000000..3eb31e4ae
--- /dev/null
+++ b/src/testing/providers/view-only-link-helper.mock.ts
@@ -0,0 +1,17 @@
+import { ViewOnlyLinkHelperService } from '@osf/shared/services/view-only-link-helper.service';
+
+export type ViewOnlyLinkHelperMockType = Partial<ViewOnlyLinkHelperService> & {
+  hasViewOnlyParam: jest.Mock;
+  getViewOnlyParam: jest.Mock;
+  getViewOnlyParamFromUrl: jest.Mock;
+};
+
+export const ViewOnlyLinkHelperMock = {
+  simple(hasViewOnly = false): ViewOnlyLinkHelperMockType {
+    return {
+      hasViewOnlyParam: jest.fn().mockReturnValue(hasViewOnly),
+      getViewOnlyParam: jest.fn().mockReturnValue(null),
+      getViewOnlyParamFromUrl: jest.fn().mockReturnValue(null),
+    };
+  },
+};