createTestComponentFactory({
    component: DocumentsCheckComponent,
    declarations: [DocumentIconComponent],
    providers: [CalculatorService],
    mocks: [SessionService]
    imports: [MaterialModule]
});

const spectator = createService({
    service: AuthService,
    providers: [CalculatorService],
    mocks: [DateService]
});

describe("AuthService", () => {

  const spectator = createService({
    service: AuthService,
    mocks: [DateService]
  });

  it("should not be logged in", () => {
    const dateService = spectator.get<DateService>(DateService);
    dateService.isExpired.and.returnValue(true);
    expect(spectator.service.isLoggedIn()).toBeFalsy();
  });
});

describe('HttpClient testing', () => {
  let http = createHTTPFactory<TodosDataService>(TodosDataService);

  it('can test HttpClient.post', () => {
    let { dataService, controller, expectOne } = http();

    dataService.saveToDo({id: 1}).subscribe();

    const req = expectOne('todos', HTTPMethod.POST);
    expect(req.request.body['id']).toEqual(1);
  });
});

describe('HumanizeAccountPipe', () => {
  let pipe: HumanizeAccountPipe;

  beforeEach(() => pipe = new HumanizeAccountPipe());

  it('converts account no to human readable form', () => {
    expect(
      pipe.transform({
        accountNo: '0000000000000123',
        accountBank: '0100'
      })
    ).toBe('123/0100');
  });
});

let spectator: Spectator<ButtonComponent>;
const createComponent = createTestComponentFactory(ButtonComponent);
  
beforeEach(() => spectator = createComponent());

it('should have a success class by default', () => {
    expect(spectator.query('button')).toHaveClass('success');
});

it('should emit the $event on click', () => {
    spectator = createComponent({}, false);
    let output;
    spectator.output<{ type: string }>('click').subscribe(result => output = result);

    spectator.component.onClick({ type: 'click' });
    spectator.detectChanges();
    expect(output).toEqual({ type: 'click' });
});

@Component({ selector: 'custom-host', template: '' })
class CustomHostComponent {
  title = 'Custom HostComponent';
}

describe('With Custom Host Component', function () {
  let host: SpectatorWithHost<ZippyComponent, CustomHostComponent>;

  const createHost = createHostComponentFactory({
    component: ZippyComponent,
    host: CustomHostComponent
  });

  it('should display the host component title', () => {
    host = createHost(`<zippy [title]="title"></zippy>`);

    expect(host.query('.zippy__title')).toHaveText('Custom HostComponent');
  });
});

// whitebox
spectator.detectChanges();

// blackbox
host.detectChanges();

// whitebox
spectator = createComponent({}, false);

// blackbox
host = createHost(
  '<app-applications-header></app-applications-header>',
  false
);

let emittedValue!: CommonCheck;
host
 .output<CommonCheck>('checked')
 .subscribe(value => (emittedValue = value));

host.detectChanges();

expect(emittedValue).toEqual(...);

import { MockComponent } from 'ng-mocks';

describe('DocumentsCheckComponent', () => {
  const createComponent = createTestComponentFactory({
    component: DocumentsCheckComponent,
    declarations: [MockComponent(DocumentIconComponent)],
    imports: [MaterialModule]
  });
)};

const createComponent = createTestComponentFactory({
  component: StepsComponent,
  declarations: [...],
  imports: [...],
  mocks: [...],
  providers: [
    mockFeatureFlagsService({
      'admin-unified-dashboard-blocking-buttons': true,
      'admin-unified-dashboard-phase-3': true
    })
  ]
});

component.loan = {
  id: 5
} as any;