diff --git a/jest.config.js b/jest.config.js
index 6a119eb3c..fe3f13fc9 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -59,14 +59,6 @@ module.exports = {
     '<rootDir>/src/environments/',
     '<rootDir>/src/@types/',
   ],
-  watchPathIgnorePatterns: [
-    '<rootDir>/node_modules/',
-    '<rootDir>/dist/',
-    '<rootDir>/coverage/',
-    '<rootDir>/src/assets/',
-    '<rootDir>/src/environments/',
-    '<rootDir>/src/@types/',
-  ],
   testPathIgnorePatterns: [
     '<rootDir>/src/app/app.config.ts',
     '<rootDir>/src/app/app.routes.ts',
@@ -86,11 +78,8 @@ module.exports = {
     '<rootDir>/src/app/features/project/project.component.ts',
     '<rootDir>/src/app/features/registries/',
     '<rootDir>/src/app/features/settings/addons/',
-    '<rootDir>/src/app/features/settings/settings-container.component.ts',
-    '<rootDir>/src/app/features/settings/tokens/components/',
     '<rootDir>/src/app/features/settings/tokens/mappers/',
     '<rootDir>/src/app/features/settings/tokens/store/',
-    '<rootDir>/src/app/features/settings/tokens/pages/tokens-list/',
     '<rootDir>/src/app/shared/components/file-menu/',
     '<rootDir>/src/app/shared/components/files-tree/',
     '<rootDir>/src/app/shared/components/line-chart/',
diff --git a/src/app/features/settings/tokens/components/token-add-edit-form/token-add-edit-form.component.spec.ts b/src/app/features/settings/tokens/components/token-add-edit-form/token-add-edit-form.component.spec.ts
index c31f6fe11..cca9abd13 100644
--- a/src/app/features/settings/tokens/components/token-add-edit-form/token-add-edit-form.component.spec.ts
+++ b/src/app/features/settings/tokens/components/token-add-edit-form/token-add-edit-form.component.spec.ts
@@ -1,47 +1,57 @@
 import { Store } from '@ngxs/store';
 
-import { TranslatePipe } from '@ngx-translate/core';
-import { MockPipe, MockProvider } from 'ng-mocks';
+import { TranslateService } from '@ngx-translate/core';
+import { MockProvider } from 'ng-mocks';
 
 import { DialogService, DynamicDialogRef } from 'primeng/dynamicdialog';
 
 import { of } from 'rxjs';
 
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { ActivatedRoute } from '@angular/router';
+import { ReactiveFormsModule } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
 
-import { TranslateServiceMock } from '@shared/mocks';
+import { TokenCreatedDialogComponent } from '@osf/features/settings/tokens/components';
+import { InputLimits } from '@osf/shared/constants';
+import { MOCK_SCOPES, MOCK_STORE, MOCK_TOKEN, TranslateServiceMock } from '@shared/mocks';
 import { ToastService } from '@shared/services';
 
+import { TokenFormControls, TokenModel } from '../../models';
+import { CreateToken, TokensSelectors } from '../../store';
+
 import { TokenAddEditFormComponent } from './token-add-edit-form.component';
 
+import { OSFTestingStoreModule } from '@testing/osf.testing.module';
+
 describe('TokenAddEditFormComponent', () => {
   let component: TokenAddEditFormComponent;
   let fixture: ComponentFixture<TokenAddEditFormComponent>;
-  let store: Partial<Store>;
   let dialogService: Partial<DialogService>;
   let dialogRef: Partial<DynamicDialogRef>;
   let activatedRoute: Partial<ActivatedRoute>;
+  let router: Partial<Router>;
+  let toastService: jest.Mocked<ToastService>;
+  let translateService: jest.Mocked<TranslateService>;
 
-  const mockToken = {
-    id: '1',
-    name: 'Test Token',
-    tokenId: 'token1',
-    scopes: ['read', 'write'],
-    ownerId: 'user1',
-  };
+  const mockTokens: TokenModel[] = [MOCK_TOKEN];
 
-  const mockScopes = [
-    { id: 'read', attributes: { description: 'Read access' } },
-    { id: 'write', attributes: { description: 'Write access' } },
-  ];
+  const fillForm = (tokenName: string = MOCK_TOKEN.name, scopes: string[] = MOCK_TOKEN.scopes): void => {
+    component.tokenForm.patchValue({
+      [TokenFormControls.TokenName]: tokenName,
+      [TokenFormControls.Scopes]: scopes,
+    });
+  };
 
   beforeEach(async () => {
-    store = {
-      dispatch: jest.fn().mockReturnValue(of(undefined)),
-      selectSignal: jest.fn().mockReturnValue(() => mockScopes),
-      selectSnapshot: jest.fn().mockReturnValue([mockToken]),
-    };
+    (MOCK_STORE.selectSignal as jest.Mock).mockImplementation((selector) => {
+      if (selector === TokensSelectors.getScopes) return () => MOCK_SCOPES;
+      if (selector === TokensSelectors.isTokensLoading) return () => false;
+      if (selector === TokensSelectors.getTokens) return () => mockTokens;
+      if (selector === TokensSelectors.getTokenById) {
+        return () => (id: string) => mockTokens.find((token) => token.id === id);
+      }
+      return () => null;
+    });
 
     dialogService = {
       open: jest.fn(),
@@ -52,27 +62,217 @@ describe('TokenAddEditFormComponent', () => {
     };
 
     activatedRoute = {
-      params: of({ id: mockToken.id }),
+      params: of({ id: MOCK_TOKEN.id }),
+    };
+
+    router = {
+      navigate: jest.fn(),
     };
 
     await TestBed.configureTestingModule({
-      imports: [TokenAddEditFormComponent, MockPipe(TranslatePipe)],
+      imports: [TokenAddEditFormComponent, ReactiveFormsModule, OSFTestingStoreModule],
       providers: [
         TranslateServiceMock,
-        MockProvider(Store, store),
+        MockProvider(Store, MOCK_STORE),
         MockProvider(DialogService, dialogService),
         MockProvider(DynamicDialogRef, dialogRef),
         MockProvider(ActivatedRoute, activatedRoute),
-        MockProvider(ToastService),
+        MockProvider(Router, router),
+        MockProvider(ToastService, {
+          showSuccess: jest.fn(),
+          showWarn: jest.fn(),
+          showError: jest.fn(),
+        }),
       ],
     }).compileComponents();
 
     fixture = TestBed.createComponent(TokenAddEditFormComponent);
     component = fixture.componentInstance;
+
+    toastService = TestBed.inject(ToastService) as jest.Mocked<ToastService>;
+    translateService = TestBed.inject(TranslateService) as jest.Mocked<TranslateService>;
+
     fixture.detectChanges();
   });
 
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  it('should patch form with initial values on init', () => {
+    fixture.componentRef.setInput('initialValues', MOCK_TOKEN);
+    const patchSpy = jest.spyOn(component.tokenForm, 'patchValue');
+
+    component.ngOnInit();
+
+    expect(patchSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        [TokenFormControls.TokenName]: MOCK_TOKEN.name,
+        [TokenFormControls.Scopes]: MOCK_TOKEN.scopes,
+      })
+    );
+    expect(component.tokenForm.get(TokenFormControls.TokenName)?.value).toBe(MOCK_TOKEN.name);
+    expect(component.tokenForm.get(TokenFormControls.Scopes)?.value).toEqual(MOCK_TOKEN.scopes);
+  });
+
+  it('should not patch form when initialValues are not provided', () => {
+    fixture.componentRef.setInput('initialValues', null);
+
+    fillForm('Existing Name', ['read']);
+
+    component.ngOnInit();
+
+    expect(component.tokenForm.get(TokenFormControls.TokenName)?.value).toBe('Existing Name');
+    expect(component.tokenForm.get(TokenFormControls.Scopes)?.value).toEqual(['read']);
+  });
+
+  it('should not submit when form is invalid', () => {
+    fillForm('', []);
+
+    const markAllAsTouchedSpy = jest.spyOn(component.tokenForm, 'markAllAsTouched');
+    const markAsDirtySpy = jest.spyOn(component.tokenForm.get(TokenFormControls.TokenName)!, 'markAsDirty');
+    const markScopesAsDirtySpy = jest.spyOn(component.tokenForm.get(TokenFormControls.Scopes)!, 'markAsDirty');
+
+    component.handleSubmitForm();
+
+    expect(markAllAsTouchedSpy).toHaveBeenCalled();
+    expect(markAsDirtySpy).toHaveBeenCalled();
+    expect(markScopesAsDirtySpy).toHaveBeenCalled();
+    expect(MOCK_STORE.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should return early when tokenName is missing', () => {
+    fillForm('', ['read']);
+
+    component.handleSubmitForm();
+
+    expect(MOCK_STORE.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should return early when scopes is missing', () => {
+    fillForm('Test Token', []);
+
+    component.handleSubmitForm();
+
+    expect(MOCK_STORE.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should create token when not in edit mode', () => {
+    fixture.componentRef.setInput('isEditMode', false);
+    fillForm('Test Token', ['read', 'write']);
+
+    MOCK_STORE.dispatch.mockReturnValue(of(undefined));
+
+    component.handleSubmitForm();
+
+    expect(MOCK_STORE.dispatch).toHaveBeenCalledWith(new CreateToken('Test Token', ['read', 'write']));
+  });
+
+  it('should show success toast and close dialog after creating token', () => {
+    fixture.componentRef.setInput('isEditMode', false);
+    fillForm('Test Token', ['read', 'write']);
+
+    MOCK_STORE.dispatch.mockReturnValue(of(undefined));
+
+    component.handleSubmitForm();
+
+    expect(toastService.showSuccess).toHaveBeenCalledWith('settings.tokens.toastMessage.successCreate');
+    expect(dialogRef.close).toHaveBeenCalled();
+  });
+
+  it('should open created dialog with new token name and value after create', () => {
+    fixture.componentRef.setInput('isEditMode', false);
+    fillForm('Test Token', ['read', 'write']);
+
+    const showDialogSpy = jest.spyOn(component, 'showTokenCreatedDialog');
+
+    MOCK_STORE.dispatch.mockReturnValue(of(undefined));
+
+    component.handleSubmitForm();
+
+    expect(showDialogSpy).toHaveBeenCalledWith(MOCK_TOKEN.name, MOCK_TOKEN.id);
+  });
+
+  it('should show success toast and navigate after updating token', () => {
+    fixture.componentRef.setInput('isEditMode', true);
+    fillForm('Updated Token', ['read', 'write']);
+
+    MOCK_STORE.dispatch.mockReturnValue(of(undefined));
+
+    component.handleSubmitForm();
+
+    expect(toastService.showSuccess).toHaveBeenCalledWith('settings.tokens.toastMessage.successEdit');
+    expect(router.navigate).toHaveBeenCalledWith(['settings/tokens']);
+  });
+
+  it('should open dialog with correct configuration', () => {
+    const tokenName = 'Test Token';
+    const tokenValue = 'test-token-value';
+
+    component.showTokenCreatedDialog(tokenName, tokenValue);
+
+    expect(dialogService.open).toHaveBeenCalledWith(
+      TokenCreatedDialogComponent,
+      expect.objectContaining({
+        width: '500px',
+        header: 'settings.tokens.createdDialog.title',
+        closeOnEscape: true,
+        modal: true,
+        closable: true,
+        data: {
+          tokenName,
+          tokenValue,
+        },
+      })
+    );
+  });
+
+  it('should use TranslateService.instant for dialog header', () => {
+    component.showTokenCreatedDialog('Name', 'Value');
+    expect(translateService.instant).toHaveBeenCalledWith('settings.tokens.createdDialog.title');
+  });
+
+  it('should read tokens via selectSignal after create', () => {
+    fixture.componentRef.setInput('isEditMode', false);
+    fillForm('Test Token', ['read']);
+
+    const selectSpy = jest.spyOn(MOCK_STORE, 'selectSignal');
+    MOCK_STORE.dispatch.mockReturnValue(of(undefined));
+
+    component.handleSubmitForm();
+
+    expect(selectSpy).toHaveBeenCalledWith(TokensSelectors.getTokens);
+  });
+
+  it('should expose the same inputLimits as InputLimits.fullName', () => {
+    expect(component.inputLimits).toBe(InputLimits.fullName);
+  });
+
+  it('should require token name', () => {
+    const tokenNameControl = component.tokenForm.get(TokenFormControls.TokenName);
+    expect(tokenNameControl?.hasError('required')).toBe(true);
+  });
+
+  it('should require scopes', () => {
+    const scopesControl = component.tokenForm.get(TokenFormControls.Scopes);
+    expect(scopesControl?.hasError('required')).toBe(true);
+  });
+
+  it('should be valid when both fields are filled', () => {
+    fillForm('Test Token', ['read']);
+
+    expect(component.tokenForm.valid).toBe(true);
+  });
+
+  it('should have correct input limits for token name', () => {
+    expect(component.inputLimits).toBeDefined();
+  });
+
+  it('should expose tokenId from route params', () => {
+    expect(component.tokenId()).toBe(MOCK_TOKEN.id);
+  });
+
+  it('should expose scopes from store via tokenScopes signal', () => {
+    expect(component.tokenScopes()).toEqual(MOCK_SCOPES);
+  });
 });
diff --git a/src/app/features/settings/tokens/components/token-created-dialog/token-created-dialog.component.spec.ts b/src/app/features/settings/tokens/components/token-created-dialog/token-created-dialog.component.spec.ts
index 515a47cdc..66ed909cd 100644
--- a/src/app/features/settings/tokens/components/token-created-dialog/token-created-dialog.component.spec.ts
+++ b/src/app/features/settings/tokens/components/token-created-dialog/token-created-dialog.component.spec.ts
@@ -1,34 +1,30 @@
-import { TranslatePipe } from '@ngx-translate/core';
-import { MockPipe, MockProvider } from 'ng-mocks';
+import { MockComponent, MockProvider } from 'ng-mocks';
 
 import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
+import { NgZone } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { By } from '@angular/platform-browser';
 
-import { TranslateServiceMock } from '@shared/mocks';
-import { ToastService } from '@shared/services';
+import { CopyButtonComponent } from '@shared/components';
+import { MOCK_TOKEN } from '@shared/mocks';
 
 import { TokenCreatedDialogComponent } from './token-created-dialog.component';
 
+import { OSFTestingModule } from '@testing/osf.testing.module';
+
 describe('TokenCreatedDialogComponent', () => {
   let component: TokenCreatedDialogComponent;
   let fixture: ComponentFixture<TokenCreatedDialogComponent>;
 
-  const mockTokenName = 'Test Token';
-  const mockTokenValue = 'test-token-value';
-
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      imports: [TokenCreatedDialogComponent, MockPipe(TranslatePipe)],
+      imports: [TokenCreatedDialogComponent, OSFTestingModule, MockComponent(CopyButtonComponent)],
       providers: [
-        TranslateServiceMock,
-        MockProvider(ToastService),
         MockProvider(DynamicDialogRef, { close: jest.fn() }),
         MockProvider(DynamicDialogConfig, {
           data: {
-            tokenName: mockTokenName,
-            tokenValue: mockTokenValue,
+            tokenName: MOCK_TOKEN.name,
+            tokenValue: MOCK_TOKEN.scopes[0],
           },
         }),
       ],
@@ -43,19 +39,21 @@ describe('TokenCreatedDialogComponent', () => {
     expect(component).toBeTruthy();
   });
 
-  it('should initialize with token data from config', () => {
-    expect(component.tokenName()).toBe(mockTokenName);
-    expect(component.tokenId()).toBe(mockTokenValue);
+  it('should initialize inputs from dialog config', () => {
+    expect(component.tokenName()).toBe(MOCK_TOKEN.name);
+    expect(component.tokenId()).toBe(MOCK_TOKEN.scopes[0]);
   });
 
-  it('should display token name and value in the template', () => {
-    const tokenInput = fixture.debugElement.query(By.css('input')).nativeElement;
-    expect(tokenInput.value).toBe(mockTokenValue);
-  });
+  it('should set selection range after render', () => {
+    const fixture = TestBed.createComponent(TokenCreatedDialogComponent);
+    const zone = TestBed.inject(NgZone);
+    const spy = jest.spyOn(HTMLInputElement.prototype, 'setSelectionRange');
+
+    zone.run(() => {
+      fixture.autoDetectChanges(true);
+      fixture.detectChanges();
+    });
 
-  it('should set input selection range to 0 after render', () => {
-    const input = fixture.debugElement.query(By.css('input')).nativeElement;
-    expect(input.selectionStart).toBe(0);
-    expect(input.selectionEnd).toBe(0);
+    expect(spy).toHaveBeenCalledWith(0, 0);
   });
 });
diff --git a/src/app/features/settings/tokens/pages/token-details/token-details.component.spec.ts b/src/app/features/settings/tokens/pages/token-details/token-details.component.spec.ts
index 4b95a898c..27b2fed98 100644
--- a/src/app/features/settings/tokens/pages/token-details/token-details.component.spec.ts
+++ b/src/app/features/settings/tokens/pages/token-details/token-details.component.spec.ts
@@ -1,75 +1,98 @@
 import { Store } from '@ngxs/store';
 
-import { TranslateModule } from '@ngx-translate/core';
 import { MockProvider } from 'ng-mocks';
 
-import { ConfirmationService, MessageService } from 'primeng/api';
-
 import { of } from 'rxjs';
 
-import { signal } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { ActivatedRoute, provideRouter, RouterModule } from '@angular/router';
+import { ActivatedRoute } from '@angular/router';
 
-import { ToastService } from '@shared/services';
+import { CustomConfirmationService } from '@shared/services';
 
 import { TokenModel } from '../../models';
+import { TokensSelectors } from '../../store';
 
 import { TokenDetailsComponent } from './token-details.component';
 
-describe.only('TokenDetailsComponent', () => {
+import { OSFTestingStoreModule } from '@testing/osf.testing.module';
+
+describe('TokenDetailsComponent', () => {
   let component: TokenDetailsComponent;
   let fixture: ComponentFixture<TokenDetailsComponent>;
-  let store: Partial<Store>;
-  let confirmationService: Partial<ConfirmationService>;
+  let confirmationService: Partial<CustomConfirmationService>;
 
   const mockToken: TokenModel = {
     id: '1',
     name: 'Test Token',
-    tokenId: 'token1',
     scopes: ['read', 'write'],
-    ownerId: 'user1',
   };
 
-  beforeEach(async () => {
-    const tokenSelector = (id: string) => (id === mockToken.id ? mockToken : null);
+  const storeMock = {
+    dispatch: jest.fn().mockReturnValue(of({})),
+    selectSnapshot: jest.fn().mockImplementation((selector: unknown) => {
+      if (selector === TokensSelectors.getTokenById) {
+        return (id: string) => (id === mockToken.id ? mockToken : null);
+      }
+      return null;
+    }),
+    selectSignal: jest.fn().mockImplementation((selector: unknown) => {
+      if (selector === TokensSelectors.isTokensLoading) return () => false;
+      if (selector === TokensSelectors.getTokenById)
+        return () => (id: string) => (id === mockToken.id ? mockToken : null);
+      return () => null;
+    }),
+  } as unknown as jest.Mocked<Store>;
 
-    store = {
-      dispatch: jest.fn().mockReturnValue(of(undefined)),
-      selectSignal: jest.fn().mockReturnValue(signal(tokenSelector)),
-      selectSnapshot: jest.fn().mockReturnValue(tokenSelector),
-    };
+  beforeEach(async () => {
     confirmationService = {
-      confirm: jest.fn(),
+      confirmDelete: jest.fn(),
     };
 
     await TestBed.configureTestingModule({
-      imports: [TokenDetailsComponent, TranslateModule.forRoot(), RouterModule.forRoot([])],
+      imports: [TokenDetailsComponent, OSFTestingStoreModule],
       providers: [
-        MockProvider(ToastService),
-        { provide: Store, useValue: store },
-        { provide: ConfirmationService, useValue: confirmationService },
-        { provide: MessageService, useValue: {} }, // ✅ ADD THIS LINE
+        MockProvider(Store, storeMock),
+        MockProvider(CustomConfirmationService, confirmationService),
         {
           provide: ActivatedRoute,
           useValue: {
             params: of({ id: mockToken.id }),
             snapshot: {
+              paramMap: new Map(Object.entries({ id: mockToken.id })),
               params: { id: mockToken.id },
               queryParams: {},
             },
           },
         },
-        provideRouter([]),
       ],
     }).compileComponents();
 
     fixture = TestBed.createComponent(TokenDetailsComponent);
     component = fixture.componentInstance;
+
     fixture.detectChanges();
   });
 
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  it('should dispatch GetTokenById on init when tokenId exists', () => {
+    component.ngOnInit();
+    expect(storeMock.dispatch).toHaveBeenCalled();
+  });
+
+  it('should confirm and delete token on deleteToken()', () => {
+    (confirmationService.confirmDelete as jest.Mock).mockImplementation(({ onConfirm }: any) => onConfirm());
+
+    component.deleteToken();
+
+    expect(confirmationService.confirmDelete).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headerKey: 'settings.tokens.confirmation.delete.title',
+        messageKey: 'settings.tokens.confirmation.delete.message',
+      })
+    );
+    expect(storeMock.dispatch).toHaveBeenCalled();
+  });
 });
diff --git a/src/app/features/settings/tokens/pages/tokens-list/tokens-list.component.spec.ts b/src/app/features/settings/tokens/pages/tokens-list/tokens-list.component.spec.ts
index a7060bd02..df9ff59a2 100644
--- a/src/app/features/settings/tokens/pages/tokens-list/tokens-list.component.spec.ts
+++ b/src/app/features/settings/tokens/pages/tokens-list/tokens-list.component.spec.ts
@@ -1,4 +1,5 @@
 import { TranslatePipe } from '@ngx-translate/core';
+import { MockPipe } from 'ng-mocks';
 
 import { Button } from 'primeng/button';
 import { Card } from 'primeng/card';
@@ -18,7 +19,12 @@ import { TokensListComponent } from './tokens-list.component';
 jest.mock('@core/store/user', () => ({}));
 jest.mock('@osf/shared/stores/collections', () => ({}));
 jest.mock('@osf/shared/stores/addons', () => ({}));
-jest.mock('@osf/features/settings/tokens/store', () => ({}));
+jest.mock('../../store', () => ({
+  TokensSelectors: {
+    isTokensLoading: function isTokensLoading() {},
+    getTokens: function getTokens() {},
+  },
+}));
 
 const mockGetTokens = jest.fn();
 const mockDeleteToken = jest.fn(() => of(void 0));
@@ -31,9 +37,9 @@ jest.mock('@ngxs/store', () => {
     })),
     select: (selectorFn: any) => {
       const name = selectorFn?.name;
-      if (name === 'isTokensLoading') return of(false);
-      if (name === 'getTokens') return of([]);
-      return of(undefined);
+      if (name === 'isTokensLoading') return () => false;
+      if (name === 'getTokens') return () => [];
+      return () => undefined;
     },
   };
 });
@@ -52,7 +58,7 @@ describe('TokensListComponent', () => {
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      imports: [TokensListComponent, TranslatePipe, Button, Card, Skeleton, RouterLink],
+      imports: [TokensListComponent, MockPipe(TranslatePipe), Button, Card, Skeleton, RouterLink],
       providers: [
         { provide: CustomConfirmationService, useValue: mockConfirmationService },
         { provide: ToastService, useValue: mockToastService },
diff --git a/src/app/features/settings/tokens/tokens.component.spec.ts b/src/app/features/settings/tokens/tokens.component.spec.ts
index de8bf16cc..b39c81f8b 100644
--- a/src/app/features/settings/tokens/tokens.component.spec.ts
+++ b/src/app/features/settings/tokens/tokens.component.spec.ts
@@ -1,24 +1,81 @@
+import { Store } from '@ngxs/store';
+
+import { MockProvider } from 'ng-mocks';
+
+import { DialogService, DynamicDialogRef } from 'primeng/dynamicdialog';
+
+import { BehaviorSubject } from 'rxjs';
+
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 
+import { IS_SMALL } from '@osf/shared/helpers';
+import { MOCK_STORE } from '@shared/mocks';
+
+import { GetScopes } from './store';
 import { TokensComponent } from './tokens.component';
 
 import { OSFTestingModule } from '@testing/osf.testing.module';
 
-describe.skip('TokensComponent', () => {
+describe('TokensComponent', () => {
   let component: TokensComponent;
   let fixture: ComponentFixture<TokensComponent>;
+  let dialogService: DialogService;
+  let isSmallSubject: BehaviorSubject<boolean>;
 
   beforeEach(async () => {
+    isSmallSubject = new BehaviorSubject<boolean>(false);
+
     await TestBed.configureTestingModule({
       imports: [TokensComponent, OSFTestingModule],
+      providers: [
+        MockProvider(Store, MOCK_STORE),
+        MockProvider(DynamicDialogRef, {}),
+        MockProvider(IS_SMALL, isSmallSubject),
+      ],
     }).compileComponents();
 
     fixture = TestBed.createComponent(TokensComponent);
     component = fixture.componentInstance;
+    dialogService = fixture.debugElement.injector.get(DialogService);
+    (MOCK_STORE.dispatch as jest.Mock).mockClear();
     fixture.detectChanges();
   });
 
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  it('should dispatch getScopes on init', () => {
+    expect(MOCK_STORE.dispatch).toHaveBeenCalledWith(new GetScopes());
+  });
+
+  it('should open create token dialog with correct config', () => {
+    const openSpy = jest.spyOn(dialogService, 'open');
+    component.createToken();
+    expect(openSpy).toHaveBeenCalledWith(
+      expect.any(Function),
+      expect.objectContaining({
+        header: 'settings.tokens.form.createTitle',
+        modal: true,
+        closeOnEscape: true,
+        closable: true,
+      })
+    );
+  });
+
+  it('should use width 95vw when IS_SMALL is false', () => {
+    const openSpy = jest.spyOn(dialogService, 'open');
+    isSmallSubject.next(false);
+    fixture.detectChanges();
+    component.createToken();
+    expect(openSpy).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({ width: '95vw' }));
+  });
+
+  it('should use width 800px when IS_SMALL is true', () => {
+    const openSpy = jest.spyOn(dialogService, 'open');
+    isSmallSubject.next(true);
+    fixture.detectChanges();
+    component.createToken();
+    expect(openSpy).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({ width: '800px ' }));
+  });
 });
diff --git a/src/app/shared/mocks/index.ts b/src/app/shared/mocks/index.ts
index 927218bdd..6658112d7 100644
--- a/src/app/shared/mocks/index.ts
+++ b/src/app/shared/mocks/index.ts
@@ -19,4 +19,6 @@ export { MOCK_PROVIDER } from './provider.mock';
 export { MOCK_REGISTRATION } from './registration.mock';
 export * from './resource.mock';
 export { MOCK_REVIEW } from './review.mock';
+export { MOCK_SCOPES } from './scope.mock';
+export { MOCK_TOKEN } from './token.mock';
 export { TranslateServiceMock } from './translate.service.mock';
diff --git a/src/app/shared/mocks/scope.mock.ts b/src/app/shared/mocks/scope.mock.ts
new file mode 100644
index 000000000..a789e2be8
--- /dev/null
+++ b/src/app/shared/mocks/scope.mock.ts
@@ -0,0 +1,7 @@
+import { ScopeModel } from '@osf/features/settings/tokens/models';
+
+export const MOCK_SCOPES: ScopeModel[] = [
+  { id: 'read', description: 'Read access' },
+  { id: 'write', description: 'Write access' },
+  { id: 'delete', description: 'Delete access' },
+];
diff --git a/src/app/shared/mocks/token.mock.ts b/src/app/shared/mocks/token.mock.ts
new file mode 100644
index 000000000..14beb5903
--- /dev/null
+++ b/src/app/shared/mocks/token.mock.ts
@@ -0,0 +1,7 @@
+import { TokenModel } from '@osf/features/settings/tokens/models';
+
+export const MOCK_TOKEN: TokenModel = {
+  id: '1',
+  name: 'Test Token',
+  scopes: ['read', 'write'],
+};
diff --git a/src/testing/mocks/toast.service.mock.ts b/src/testing/mocks/toast.service.mock.ts
index 5c219a9ec..f08fc1f4c 100644
--- a/src/testing/mocks/toast.service.mock.ts
+++ b/src/testing/mocks/toast.service.mock.ts
@@ -3,9 +3,8 @@ import { ToastService } from '@osf/shared/services';
 export const ToastServiceMock = {
   provide: ToastService,
   useValue: {
-    success: jest.fn(),
-    error: jest.fn(),
-    info: jest.fn(),
-    warning: jest.fn(),
+    showSuccess: jest.fn(),
+    showError: jest.fn(),
+    showWarn: jest.fn(),
   },
 };