/// <reference path="../../typings/main.d.ts" />
/// <reference path="../../es-proto.d.ts" />

import * as Chai from "chai"
import * as ES from "elasticsearch";
import * as Domain from '../../src/Domain'
import * as moment from 'moment'
import esHelper from './_ElasticSearch-helper'

const Config = require("../../config.json").test;
const INDEX = "test_index";
const should = Chai.should();
const _ES = new esHelper();

describe("simple product", function() {

  before(function(done) {
    _ES.init(done);
  })


  it("should insert a product with itemNumber & country", function(done) {
    var product = new Domain.Product();
    product.itemNumber = "123";
    product.header = "header123";

    _ES.save(1, product, function(res) {
      res.should.be.a.json;
      res.created.should.be.true;
      done();
    });

            SchemaStore.validate(test,(err,newTest) => {

                should().exist(newTest);
                should().not.exist(err)

            });

before(() => {
  chai.should();
  chai.use(chaiAsPromised);
});

 it("should register a schema in the schemaStore", () => {
     should().exist(SchemaStore.getSchema(Test));
 });

// tslint:disable:no-console
// tslint:disable:no-unused-expression
// tslint:disable:variable-name

import { assert, expect, should, use } from "chai";
import * as chaiAsPromised from "chai-as-promised";
import { SinonFakeTimers, spy, stub, useFakeTimers } from "sinon";
import * as sinonChai from "sinon-chai";

// enable the should interface with sinon
should();
// improve stubs for testing
use(sinonChai);
use(chaiAsPromised);

import { assertNever } from ".";
declare let never: never;

describe("helpers => ", () => {
	describe("assertNever() => ", () => {
		it("throws when called", () => {
			expect(assertNever).to.throw("Unexpected");
		});

		it("contains the unexpected value in its error message", () => {
			expect(() => assertNever("foobar" as never)).to.throw("foobar");
		});

		it("has the correct types", () => {
			function testNever(foo: 1|2) {
				if (foo === 1 || foo === 2) {

'use strict';
import chai from 'chai';
import EntitiesByPriority from './EntitiesByPriority.js';

chai.should();

describe('EntitiesByPriority', () => {

  describe('add', ()=> {
    it('should add the entity', ()=> {
      const entities = new EntitiesByPriority();
      const entity = {};

      entities.add(entity, 0);
    });
  });

  describe('emit', ()=> {

    it(`should emit the event to all entities in priority order`, ()=> {
      const entities = new EntitiesByPriority();
      let calledFirst = [];
      const entity1 = {};
      entity1.emit = () => calledFirst.push(entity1);
      const entity2 = {emit: () => calledFirst.push(entity2)};
      const entity3 = {emit: () => calledFirst.push(entity3)};

      entities.add(entity2, 10);
      entities.add(entity1, 0);
      entities.add(entity3, 20);

            SchemaStore.validate(test,(err,item) => {

                should().not.exist(item);
                should().equal(err.errorCode,"notString")

            });

								convertToTsv(sourcefile, options, (err, tsv) => {
									should().not.exist(err);
									should().exist(tsv);
									assert.equal(tsv, defToTSV(specSheet, options), 'Invalid tsv');
									done();
								});