import {KeyValueStorage} from './KeyValueStorage'

describe("tests for key-value storage", ()=>{
    describe('try get data from empty store', ()=>{
        it('get data from empty store',()=>{
            let testStorage = new KeyValueStorage<any>();
            let testKey = 'test';

            expect(()=>{
                testStorage.get(testKey)
            }).toThrowError(`data with key: ${testKey} is missing!`)
        })
    });

    describe("test for put and get data",()=>{

        it('put number by key and get number by key',()=>{
            let numberStorage = new KeyValueStorage<number>();
            let testNumber:number = 123;
            let testKey:string = 'string ';

            numberStorage.add({key: testKey, value: testNumber});
            expect(numberStorage.get(testKey)).toBe(testNumber);
        });

        it('put string by key and get string by key', ()=>{
            let stringStorage = new KeyValueStorage<string>();
            let testString:string = 'testString';
            let testKey:string = 'test';

            stringStorage.add({key: testKey, value: testString});
            expect(stringStorage.get(testKey)).toBe(testString);
        });

        it('put object link and get object link', ()=>{
            let objectLinksStorage = new KeyValueStorage<Object>();
            let testObject = {test:'lol'};
            let testKey:string = 'test';

            objectLinksStorage.add({key: testKey, value: testObject});
            expect(objectLinksStorage.get(testKey)).toBe(testObject);
        })
    });

    describe('exception when try override data without override property flag', ()=>{
        it('put data with non origin keys', ()=>{
            let testStore = new KeyValueStorage<any>();
            let testKey:string = 'test';
            let testValue1:string = 'testValue1';
            let testValue2:string = 'testValue2';

            testStore.add({key: testKey, value: testValue1});
            expect(()=>{
                testStore.add({key: testKey, value: testValue2})
            }).toThrowError(`data with key ${testKey} already exist use force=true flag for override`)
        })
    });

    describe('override data in store', ()=>{
        it('put data to store and override it', ()=>{
            let testStore = new KeyValueStorage<any>();
            let testKey:string = 'test';
            let testVal1:string = 'testVal1';
            let testVal2:string = 'testVal2';

            testStore.add({key: testKey, value: testVal1});
            testStore.add({key: testKey, value: testVal2, force: true});

            expect(testStore.get(testKey)).not.toEqual(testVal1);
            expect(testStore.get(testKey)).toEqual(testVal2);
        })
    });

    describe('test put data with invalid key', ()=>{
        let testStore:KeyValueStorage<any>;
        let testKey:string;
        let testVal:string;

        beforeEach(()=>{
            testStore = new KeyValueStorage<any>();
            testVal = 'testVal';
        });

        it('put data with null key', ()=>{
            testKey = null;

            expect(()=>{
                testStore.add({key: testKey, value: testVal})
            }).toThrowError(`can not put data with null key`)
        });

        it('put data with undefined key', ()=>{
            testKey = undefined;

            expect(()=>{
                testStore.add({key: testKey, value: testVal})
            }).toThrowError(`can not put data with undefined key`)
        })
    });

    describe('check method', ()=>{
        let testStore:KeyValueStorage<any>;
        let testKey:string;
        let testVal:string;

        beforeEach(()=>{
            testStore = new KeyValueStorage<any>();
            testVal = 'testVal';
            testKey = 'validTestKey';
            testStore.add({key: testKey, value: testVal});
        });

        it('returns true if has key', ()=>{
            let result = testStore.check(testKey);
            expect(result).toBe(true);
        });

        it('returns false if has not key', ()=>{
            let result = testStore.check('invalidKey');
            expect(result).toBe(false);
        });
    })
});