src/users-new/UserRepository.spec.ts

import {WapiClient} from '@quobis/wapi-client';
import {expect} from 'chai';
import nanoid from 'nanoid';
import {TestScheduler} from 'rxjs/testing';
import sinon, {StubbedInstance, stubConstructor} from 'ts-sinon';

import {WacRequest} from '../wac-proxy/wac-stack/WacRequest';
import {PresenceService} from '../wac-proxy/wac-stack/presence/PresenceService';
import {PresenceDtoBuilder} from '../wac-proxy/wac-stack/presence/builders';
import {PresenceDto} from '../wac-proxy/wac-stack/presence/types';
import {UserService} from '../wac-proxy/wac-stack/user/UserService';

import {User} from './User';
import {UserRepository} from './UserRepository';
import {UserRole} from './UserRole';

const createUserModel = (presence: PresenceDto): User => ({
	id: presence.address.replace('wac-user:', ''),
	domain: presence.domain,
	username: presence.username,
	phone: '',
	email: '',
	alias: '',
	role: UserRole.USER,
	online: presence.online,
	activity: presence.activity,
	mood: presence.mood,
	note: presence.note,
	avatar: presence.avatar,
	displayName: presence.displayName,
});

describe('users-new/UsersRepository', () => {
	let testScheduler: TestScheduler;
	let presenceService: StubbedInstance<PresenceService>;
	let usersService: StubbedInstance<UserService>;

	beforeEach(() => {
		testScheduler = new TestScheduler((actual, expected) => {
			expect(actual).to.deep.equal(expected);
		});
		const wacRequest = stubConstructor(WacRequest, stubConstructor(WapiClient));
		presenceService = stubConstructor(PresenceService, wacRequest);
		usersService = stubConstructor(UserService, wacRequest);
	});

	afterEach(() => {
		sinon.restore();
	});

	it('should be lazily created', () => {
		new UserRepository(presenceService, usersService);
		sinon.assert.notCalled(presenceService.subscribeToPresences$);
	});

	it('should resolve a user using getUser$ method', () => {
		testScheduler.run(({expectObservable, cold, hot}) => {
			const id = nanoid();
			const presenceDto = PresenceDtoBuilder.of(id).build();
			usersService.getUser$.returns(cold('|'));
			presenceService.subscribeToPresences$.withArgs([`wac-user:${id}`]).returns(cold('a|', {a: [presenceDto]}));
			sinon.stub(presenceService, 'event$').value(hot('^ 499ms a 99ms b', {
				a: {body: {...presenceDto, online: false}},
				b: {body: {...presenceDto, activity: 'away'}},
			}));

			const userRepository = new UserRepository(presenceService, usersService);

			expectObservable(userRepository.getUser$(id)).toBe('100ms a 399ms b 99ms d', {
				a: createUserModel(presenceDto),
				b: createUserModel({...presenceDto, online: false}),
				d: createUserModel({...presenceDto, activity: 'away'}),
			});
		});
	});
});