'use strict';

const parseConnection = require('../../lib/knex-builder/internal/parse-connection');
const test = require('tape');

test('parses standard connections', function (t) {
  t.plan(1);
  t.deepLooseEqual(
    parseConnection('postgres://username:pass@path.to.some-url:6000/testdb'),
    {
      client: 'postgres',
      connection: {
        user: 'username',
        password: 'pass',
        port: '6000',
        host: 'path.to.some-url',
        database: 'testdb',
      },
    }
  );
});

test('parses standard connections without password', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection('mysql://username@path.to.some-url:3306/testdb'),
    {
      client: 'mysql',
      connection: {
        user: 'username',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
      },
    }
  );
});

test('mysql connection protocol with query string params', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection(
      'mysql://user:pass@path.to.some-url:3306/testdb?foo=bar&anotherParam=%2Fa%2Fb%2Fc'
    ),
    {
      client: 'mysql',
      connection: {
        user: 'user',
        password: 'pass',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
        foo: 'bar',
        anotherParam: '/a/b/c',
      },
    }
  );
});

test('mysql connection protocol allows skip username', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection(
      'mysql://:pass@path.to.some-url:3306/testdb?foo=bar&anotherParam=%2Fa%2Fb%2Fc'
    ),
    {
      client: 'mysql',
      connection: {
        user: '',
        password: 'pass',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
        foo: 'bar',
        anotherParam: '/a/b/c',
      },
    }
  );
});

test('mysql connection protocol allows skip password', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection('mysql://username@path.to.some-url:3306/testdb'),
    {
      client: 'mysql',
      connection: {
        user: 'username',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
      },
    }
  );
});

test('mysql connection protocol allows empty password', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection('mysql://username:@path.to.some-url:3306/testdb'),
    {
      client: 'mysql',
      connection: {
        user: 'username',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
      },
    }
  );
});

test('decodes username and password', function (t) {
  t.plan(1);
  t.deepEqual(parseConnection('mysql://user%3A@path.to.some-url:3306/testdb'), {
    client: 'mysql',
    connection: {
      user: 'user:',
      host: 'path.to.some-url',
      port: '3306',
      database: 'testdb',
    },
  });
});

test('do not encode password', function (t) {
  t.plan(1);
  t.deepEqual(
    parseConnection(
      'mysql://user:password-start:rest@path.to.some-url:3306/testdb?'
    ),
    {
      client: 'mysql',
      connection: {
        user: 'user',
        password: 'password-start:rest',
        host: 'path.to.some-url',
        port: '3306',
        database: 'testdb',
      },
    }
  );
});

test('parses mssql connections, aliasing host to server', function (t) {
  t.plan(1);
  const mssql = {
    client: 'mssql',
    connection: {
      user: 'username',
      password: 'pass',
      server: 'path.to.some-url',
      port: '6000',
      database: 'testdb',
    },
  };
  t.deepEqual(
    parseConnection('mssql://username:pass@path.to.some-url:6000/testdb'),
    mssql
  );
});

test('parses mssql connections, aliasing host to server and adding extra params', function (t) {
  t.plan(1);
  const mssql = {
    client: 'mssql',
    connection: {
      user: 'user',
      password: 'pass',
      server: 'path.to.some-url',
      port: '6000',
      database: 'testdb',
      param: 'value',
    },
  };
  t.deepEqual(
    parseConnection(
      'mssql://user:pass@path.to.some-url:6000/testdb?param=value'
    ),
    mssql
  );
});

test('assume a path is sqlite', function (t) {
  t.plan(1);
  t.deepEqual(parseConnection('/path/to/file.db'), {
    client: 'sqlite3',
    connection: {
      filename: '/path/to/file.db',
    },
  });
});

test('assume a relative path is sqlite', function (t) {
  t.plan(1);
  t.deepEqual(parseConnection('./path/to/file.db'), {
    client: 'sqlite3',
    connection: {
      filename: './path/to/file.db',
    },
  });
});

test('parse windows path as sqlite config', function (t) {
  t.plan(1);
  // reset process.platform to windows, reset require cache, require fresh
  // after test restore back
  const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');

  Object.defineProperty(process, 'platform', {
    value: 'win32',
  });

  const modulePath = require.resolve(
    '../../lib/knex-builder/internal/parse-connection'
  );
  const oldCache = require.cache[modulePath];
  delete require.cache[modulePath];

  const parseConnection = require('../../lib/knex-builder/internal/parse-connection');
  try {
    t.deepLooseEqual(
      parseConnection('C:\\Documents\\Newsletters\\Summer2018.pdf'),
      {
        client: 'sqlite3',
        connection: {
          filename: 'C:\\Documents\\Newsletters\\Summer2018.pdf',
        },
      }
    );
  } finally {
    Object.defineProperty(process, 'platform', originalPlatform);
    require.cache[modulePath] = oldCache;
  }
});

test('#852, ssl param with PG query string', function (t) {
  t.plan(1);
  t.deepLooseEqual(
    parseConnection('postgres://user:password@host:0000/database?ssl=true'),
    {
      client: 'postgres',
      connection: {
        host: 'host',
        port: '0000',
        user: 'user',
        password: 'password',
        database: 'database',
        ssl: true,
      },
    }
  );
});

test('support postgresql connection protocol', function (t) {
  t.plan(1);
  t.deepLooseEqual(
    parseConnection('postgresql://user:password@host:0000/database?ssl=true'),
    {
      client: 'postgresql',
      connection: {
        host: 'host',
        port: '0000',
        user: 'user',
        password: 'password',
        database: 'database',
        ssl: true,
      },
    }
  );
});

test('#4628, supports mysql / mariadb client JSON parameters', function (t) {
  t.plan(2);

  t.deepLooseEqual(
    parseConnection(
      'mysql://user:password@host:1234/database?ssl={"ca": "should exist"}'
    ),
    {
      client: 'mysql',
      connection: {
        host: 'host',
        port: '1234',
        user: 'user',
        password: 'password',
        database: 'database',
        ssl: {
          ca: 'should exist',
        },
      },
    }
  );

  t.deepLooseEqual(
    parseConnection(
      'mariadb://user:password@host:1234/database?ssl={"ca": "should exist"}'
    ),
    {
      client: 'mariadb',
      connection: {
        host: 'host',
        port: '1234',
        user: 'user',
        password: 'password',
        database: 'database',
        ssl: {
          ca: 'should exist',
        },
      },
    }
  );
});