describe('AcLabelDescComponent', () => {
	let component: AcLabelDescComponent;
	let fixture: ComponentFixture<AcLabelDescComponent>;

	const cesiumService = mock(CesiumService);
	const labelCollection = mock(Cesium.LabelCollection);

	when(cesiumService.getScene()).thenReturn({primitives: instance(labelCollection)});

	beforeEach(async(() => {
		TestBed.configureTestingModule({
			declarations: [AcLabelDescComponent],
			providers: [LabelDrawerService,
				providerFromMock(CesiumService, cesiumService),
				mockProvider(LayerService),
				mockProvider(CesiumProperties),
				mockProvider(ComputationCache)]
		})
			.compileComponents();
	}));

	beforeEach(() => {
		fixture = TestBed.createComponent(AcLabelDescComponent);
		component = fixture.componentInstance;
		fixture.detectChanges();
	});

	it('should create', () => {
		expect(component).toBeTruthy();
	});
});

	beforeEach(async(() => {
		const mockCesiumService = mock(CesiumService);
		const mockStaticCircleDrawerService = mock(StaticCircleDrawerService);
		const mockLayerService = mock(LayerService);
		const mockComputationCache = mock(ComputationCache);
		const mockCesiumProperties = mock(CesiumProperties);

		TestBed.configureTestingModule({
			declarations: [AcStaticCircleDescComponent],
			providers: [
				{
					provide: CesiumService,
					useValue: mockCesiumService
				},
				{
					provide: StaticCircleDrawerService,
					useValue: mockStaticCircleDrawerService
				},
				{
					provide: LayerService,
					useValue: mockLayerService
				},
				{
					provide: ComputationCache,
					useValue: mockComputationCache
				},
				{
					provide: CesiumProperties,
					useValue: mockCesiumProperties
				}
			]
		})
			.compileComponents();
	}));

describe('AcAcrComponent', () => {
    let component: AcArcComponent;
    let fixture: ComponentFixture<AcArcComponent>;

    const cesiumService = mock(CesiumService);
    const arcCollection = mock(Cesium.PrimitiveCollection);

    when(cesiumService.getScene()).thenReturn({primitives: instance(arcCollection)});

    beforeEach(async(() => {
        TestBed.configureTestingModule({
            declarations: [AcArcComponent],
            providers: [ArcDrawerService,
                providerFromMock(CesiumService, cesiumService)]
        })
	        .compileComponents();
        fixture = TestBed.createComponent(AcArcComponent);
        component = fixture.componentInstance;

    }));

    it('should create', () => {
        expect(component).toBeTruthy();
    });
});

  beforeEach(() => {
    const mockedAssetService = mock(AssetService);
    when(mockedAssetService.resolveFromRequire(anyNumber())).thenReturn({
      height: 100,
      scale: 1,
      uri: 'lol',
      width: 100
    });
    const assetService = instance(mockedAssetService);

    const mockedColorService = mock(ColorService);
    when(mockedColorService.toNativeColor(anyString())).thenReturn(666);
    const colorService = instance(mockedColorService);

    uut = new OptionsProcessor(store, new UniqueIdProvider(), colorService, assetService);
  });

    it("should call onSuccess after segment loading succeeded", () => {
        const loader = mock<LoaderInterface>(LoaderInterfaceEmptyImpl);

        const onSuccess = sinon.spy();
        let segmentLoadedListener: Function = () => { throw new Error("SegmentLoaded listener not set"); };
        when(loader.on(Events.SegmentLoaded, anyFunction())).thenCall((eventName_unused, listener) => {
            segmentLoadedListener = listener;
        });

        const segment = new Segment(
            "id",
            testPlaylist.baseUrl + "segment-1045.ts",
            testPlaylist.url,
            testPlaylist.url,
            undefined,
            "1045",
            undefined, 0, new ArrayBuffer(0));

        const manager = new SegmentManager(instance(loader));
        manager.processPlaylist(testPlaylist.url, testPlaylist.content, testPlaylist.url);
        manager.loadSegment(segment.url, undefined, onSuccess, () => {});
        segmentLoadedListener(segment);

        onSuccess.calledWith(segment.data);
    });

describe('CesiumService', () => {
	let mapContainer;
	const defaultZooms = 1;
	const viewerFactory = mock(ViewerFactory);
	const element = document.createElement("div");
	const defaultTilt = true;
	const mode3D = Cesium.SceneMode.SCENE3D;
	const mode2D = Cesium.SceneMode.SCENE2D;
	const modeColumbus = Cesium.SceneMode.COLUMBUS_VIEW;

	when(viewerFactory.createViewer(anything(),anything())).thenReturn({
		scene: {
			screenSpaceCameraController: {
				minimumZoomDistance: defaultZooms,
				maximumZoomDistance: defaultZooms,
				enableTilt: defaultTilt
			},
			mode: mode3D,
			morphTo2D: function () {
				this.mode = mode2D;
			},
			morphToColumbusView: function () {
				this.mode = modeColumbus;
			},
			morphTo3D: function () {
				this.mode = mode3D;
			}
		}
	});

	beforeEach(() => {
		mapContainer = document.createElement('mapContainer');
		document.body.appendChild(mapContainer);

		TestBed.configureTestingModule({
			providers: [CesiumService, providerFromMock(ViewerFactory, viewerFactory)]
		});
	});

	beforeEach(inject([CesiumService], (service: CesiumService) => {
		service.init(mapContainer);
	}));

	afterEach(() => {
		mapContainer.remove();
	});

	it('should create', inject([CesiumService], (service: CesiumService) => {
		expect(service).toBeDefined();
	}));

	it('should initialize and return viewer', inject([CesiumService], (service: CesiumService) => {
		expect(service.getViewer()).toBeDefined();
	}));

	it('should return scene', inject([CesiumService], (service: CesiumService) => {
		expect(service.getScene()).toBeDefined();
	}));
});

 test('adding simple test adds it directly', () => {
   const group = new HealthCheckGroup('test1');
   const mockHealthCheck = mock<HealthCheck>(HealthCheck);
   when(mockHealthCheck.getCheckName()).thenReturn('simpleId');
   group.addCheck(instance(mockHealthCheck));
   group.healthChecks.size.must.equal(1);
   Array.from(group.healthChecks.keys()).must.eql(['simpleId']);
 });

 test('Readonly flag is passed (true)', async () => {
   const check = new MySQLHealthCheck('testCheck', true);
   const mockedMysqlClient = mock(MySQLClient);
   when(mockedMysqlClient.ping(anything())).thenReturn(Promise.resolve(undefined));
   check.mysqlClient = instance(mockedMysqlClient);
   await check.doCheck();
   verify(mockedMysqlClient.ping(true)).once();
 });

 @test
 'Callback is called without Error object if config api key is equal to request api key'() {
   const apiKey = 'this-is-a-test-api-key';
   const verification = ApiKeyVerification.verifyApiKey('this-is-a-test-api-key');
   const mockedCb = mock(CbClass);
   const cbInstance = instance(mockedCb);
   verification('', '', 'this-is-a-test-api-key', cbInstance.cb);
   verify(mockedCb.cb()).once();
 }