/*
 * Copyright (C) Sapphirecode - All Rights Reserved
 * This file is part of crypto-helper which is released under MIT.
 * See file 'LICENSE' for full license details.
 * Created by Timo Hocker <timo@scode.ovh>, May 2020
 */

// @ts-nocheck
'use strict';

const crypto = require ('../../index');

// eslint-disable-next-line max-lines-per-function
describe ('crypto helper', () => {
  it ('random_hex', () => {
    const hex = crypto.random_hex (16);
    expect (hex.length)
      .toEqual (16);
    expect (hex)
      .toMatch (/^[0-9a-f]+$/iu);
  });

  it ('random_hex with default length', () => {
    const hex = crypto.random_hex ();
    expect (hex.length)
      .toEqual (8);
    expect (hex)
      .toMatch (/^[0-9a-f]+$/iu);
  });

  it ('random_hex should refuse lenght smaller 1', () => {
    expect (
      () => (crypto.random_hex (0))
    )
      .toThrowError ('invalid length');
  });

  it ('random_hex should always return correct length', () => {
    for (let i = 1; i < 32; i++) {
      const hex = crypto.random_hex (i);
      expect (hex.length)
        .toEqual (i);
    }
  });

  it ('random_string', () => {
    const str = crypto.random_string (16);
    expect (str.length)
      .toEqual (16);
  });

  it ('random_string with default length', () => {
    const str = crypto.random_string ();
    expect (str.length)
      .toEqual (8);
  });

  it ('random_string should refuse lenght smaller 1', () => {
    expect (
      () => (crypto.random_string (0))
    )
      .toThrowError ('invalid length');
  });

  it ('random_string should always return correct length', () => {
    for (let i = 1; i < 32; i++) {
      const str = crypto.random_string (i);
      expect (str.length)
        .toEqual (i);
    }
  });


  it ('hash_sha512', () => {
    const hash = crypto.hash_sha512 ('a', 'b');
    expect (
      hash
    )
      .toEqual (
      // eslint-disable-next-line max-len
        '2d408a0717ec188158278a796c689044361dc6fdde28d6f04973b80896e1823975cdbf12eb63f9e0591328ee235d80e9b5bf1aa6a44f4617ff3caf6400eb172d'
      );
  });

  it ('checksum', () => {
    const hash = crypto.checksum ('foo');
    expect (
      hash
    )
      .toEqual (
      // eslint-disable-next-line max-len
        '2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae'
      );
  });

  it ('create_salt', () => {
    const salt = crypto.create_salt ();
    expect (salt.length)
      .toEqual (64);
    expect (salt)
      .toMatch (/^[0-9a-f]+$/iu);
  });

  it ('sign_object', () => {
    const obj = { foo: 'bar' };
    expect (() => {
      const str = crypto.sign_object (obj, 'baz');
      expect (typeof str)
        .toEqual ('string');
    }).not.toThrow ();
  });

  it ('decode_signed', () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    const dec = crypto.decode_signed (str);
    expect (obj)
      .toEqual (dec);
  });

  it ('verify_signature', () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    const dec = crypto.verify_signature (str, 'baz');
    expect (obj)
      .toEqual (dec);
  });

  it ('should return null on invalid input', () => {
    const ver = crypto.verify_signature (null, 'foo');
    expect (ver)
      .toEqual (null);
    const dec = crypto.decode_signed (null, 'foo');
    expect (dec)
      .toEqual (null);
  });

  it ('should not fail verification if timeout unspecified', async () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    await new Promise ((res) => {
      setTimeout (res, 10);
    });
    const dec = crypto.verify_signature (str, 'baz');
    expect (obj)
      .toEqual (dec);
  });

  it ('should reject tampered signatures', () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    const dec = crypto.verify_signature (str, 'foo');
    expect (dec)
      .toEqual (null);
  });

  it ('should reject old signatures', async () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    await new Promise ((res) => {
      setTimeout (res, 10);
    });
    const dec = crypto.verify_signature (str, 'baz', 1);
    expect (dec)
      .toEqual (null);
  });

  it ('should not reject valid signatures', async () => {
    const obj = { foo: 'bar' };
    const str = crypto.sign_object (obj, 'baz');
    await new Promise ((res) => {
      setTimeout (res, 10);
    });
    const dec = crypto.verify_signature (str, 'baz', 100);
    expect (obj)
      .toEqual (dec);
  });

  it ('should decode problematic token', () => {
  // eslint-disable-next-line max-len
    const str = 'eyJpYXQiOjE1ODE0NDAwMTIyODgsIm9iaiI6eyJpZCI6MX19.24ZOsWrnfkNe%2FbM0r7DaVJMqE2bfn2aAM%2BZSzWeSf31OCTlXXNWD34RBL2X5v3UliYQ4IIsLNBFbaW9texPHug%3D%3D';
    const obj = crypto.decode_signed (str);
    expect (obj)
      .toEqual ({ id: 1 });
  });
});