it('each PanelListItem should contain a link to its details', () => {
    const panels: PanelListItem[] = [
      {
        id: faker.random.uuid(),
        title: faker.random.words(),
        startDate: faker.date.recent(),
        endDate: faker.date.future()
      }
    ];

    const action = new PanelActions.LoadPanelsSuccess(panels);

    store.dispatch(action);

    component.panels$.subscribe(data => {
      expect(data.length).toBe(panels.length);
    });

    fixture.whenStable().then(() => {
      let href = fixture.debugElement
        .query(By.css('.panel-details'))
        .nativeElement.getAttribute('href');
      expect(href).toEqual('/create-panel');
    });
  });

	it('#finder-fn',async () => {

		const repo = coordinator.getRepo(Fixtures.IDBRepo1)
		const models = []
		const name = 'hello',
			name2 = `${name} ${name}`

		for (let x = 0; x < 10;x++) {

			const model = new Fixtures.IDBModel1()

			Object.assign(model,{
				id: uuid.v4(),
				name,
				createdAt: Faker.date.past(),
				randomText: Faker.lorem.words(10)
			})

			models.push(model)
		}

		await repo.bulkSave(...models)

		let results = await repo.findByName(name)
		expect(results.length).toBe(models.length)

		// Testing second batch to make sure not all
		const models2 = []
		for (let x = 0; x < 20;x++) {

			const model = new Fixtures.IDBModel1()

			Object.assign(model,{
				id: uuid.v4(),
			    name: name2,
				createdAt: Faker.date.past(),
				randomText: Faker.lorem.words(10)
			})

			models2.push(model)
		}

		await repo.bulkSave(...models2)

		const results2 = await repo.findByName(name2)
		expect(results2.length).toBe(models2.length)

		// Test name 1 again to confirm
		results = await repo.findByName(name)
		expect(results.length).toBe(models.length)

		const keys = models.concat(models2).map(result => repo.key(result.id))
		await repo.bulkRemove(...keys)
		expect(await repo.count()).toBe(0)

	})

				doTest = async (modelClazz,repoClazz) => {
					try {
						let
							model = new modelClazz(),
							repo = coordinator.getRepo(repoClazz)
						
						Object.assign(model, {
							id: uuid.v4(),
							createdAt: Faker.date.past(),
							randomText: Faker.lorem.words(10)
						})
						
						model = await repo.save(model)
						
						const
							model2 = Object.assign(new modelClazz(),model, {
								randomText: Faker.lorem.words(10),
								$$doc: Object.assign({},(model as any).$$doc,{
									_rev: '1-aa86c0e405a07fb76ef3e523dd1c2ae1'
								}),
							})
						
						await repo.save(model2)
						
						return null
					} catch (anErr) {
						return anErr
						
					}
				}

			it('#puts', async() => {
				const
					model = new Fixtures.PDBModel1(),
					repo = coordinator.getRepo(Fixtures.PDBRepo1)
				
				Object.assign(model, {
					id: uuid.v4(),
					createdAt: Faker.date.past(),
					randomText: Faker.lorem.words(10)
				})
				
				const
					savedModel = await repo.save(model),
					key = repo.key(model.id)
				
				// Check we got a doc value
				expect((savedModel as any).$$doc).not.toBe(null)
				
				let
					modelGet = await repo.get(key)
				
				expect(modelGet.id).toBe(model.id)
				expect(modelGet.randomText).toBe(model.randomText)
				
				let currentCount = await repo.count()
				expect(currentCount).toBe(1)
				
				await repo.remove(key)
				expect(await repo.count()).toBe(0)
				
			})

export function getRandomPerson(options: GetRandomPersonOptions) {
  const opts: GetRandomPersonOptions = options || {};

  opts.maxDateOfBirth = opts.maxDateOfBirth || new Date(Date.now() - MS_IN_YEAR);
  opts.minAge = opts.minAge || 18;
  opts.maxAge = opts.maxAge || 105;
  opts.depth = opts.depth || 0;

  // Generates a family tree...of sorts
  const result: Person = {
    name: faker.name.lastName() + faker.name.firstName(),
    employment: {
      companyName: faker.company.companyName()
    },
    regex: /a/g,
    age: faker.random.number(),
    dateOfBirth: faker.date.past(),
    enrolledToVote: faker.random.boolean(),
  };

  if (opts.depth > 0) {
    result.parents = [
      getRandomPerson({ depth: opts.depth - 1 }),
      getRandomPerson({ depth: opts.depth - 1 })
    ];
  }

  return result;
}

 const products = createArray(numberOfProducts, i => {
     return [
         i,
         faker.lorem.words()[0],
         faker.finance.amount(),
         faker.date.past(),
     ]
 })

export const makeBook = (authorId: number): BookModel => {
    return (new BookModel())
        .setTitle(lorem.word())
        .setDescription(lorem.sentences(2))
        .setPrice(random.number(120) + (random.number(99) / 100))
        .setPublishedAt(date.past())
        .setAuthorId(authorId);
};