const ApiKeyModel = require('dashboard/data/api-key-model');

const modelApiURL = 'wadus.com/api/v3/api_keys';
const apiData = {
  name: 'Awesome map key',
  type: 'regular',
  token: 'NmYvZM80laiQQMv5rUGbJA',
  grants: [
    { type: 'apis', apis: [ 'maps', 'sql' ] },
    { type: 'database',
      tables: [{ 'schema': 'public', 'name': 'untitled_table_14', 'permissions': ['insert', 'update', 'read'] }],
      schemas: [] }
  ]
};

const parsedData = {
  name: 'Awesome map key',
  type: 'regular',
  token: 'NmYvZM80laiQQMv5rUGbJA',
  id: 'Awesome map key',
  apis: { maps: true, sql: true },
  tables: {
    untitled_table_14: {
      schema: 'public',
      name: 'untitled_table_14',
      permissions: {
        insert: true,
        update: true,
        read: true
      }
    }
  },
  datasets: {
    create: false,
    listing: false
  }
};

describe('dashboard/data/api-key-model', function () {
  var model;

  beforeEach(function () {
    model = new ApiKeyModel({}, {
      userModel: {
        getSchema: () => 'public'
      }
    });

    spyOn(model, 'url').and.returnValue(modelApiURL);
  });

  it('should have these attributes by default', function () {
    expect(model.attributes).toEqual({
      name: '',
      token: '',
      apis: {
        maps: false,
        sql: false
      },
      datasets: {
        create: false,
        listing: false
      },
      tables: []
    });
  });

  it('throws an error when userModel is missing', function () {
    model = function () {
      return new ApiKeyModel(null, {});
    };

    expect(model).toThrowError('userModel is required');
  });

  describe('.regenerate', function () {
    it('should sync collection', function () {
      spyOn(model, 'sync');

      model.regenerate();

      var spyCallArguments = model.sync.calls.mostRecent().args;
      expect(model.sync).toHaveBeenCalled();
      expect(spyCallArguments[0]).toBeNull();
      expect(spyCallArguments[1]).toBe(model);
      expect(spyCallArguments[2].url).toBe('wadus.com/api/v3/api_keys/token/regenerate');
      expect(spyCallArguments[2].type).toBe('POST');
    });

    it('should set data on sync success', function () {
      spyOn(model, 'sync').and.callFake(function (method, model, options) {
        options.success && options.success({ name: 'wadus' });
      });

      model.regenerate();

      expect(model.get('name')).toBe('wadus');
    });
  });

  describe('.parse', function () {
    it('should parse data properly', function () {
      const options = {
        userModel: {
          getSchema: () => 'public'
        }
      };
      const parsed = model.parse(apiData, options);
      expect(parsed).toEqual(parsedData);
    });
  });

  describe('.toJSON', function () {
    it('should return data properly', function () {
      model.set(parsedData);
      const data = model.toJSON();

      const expectedJSONData = Object.assign({}, apiData, { id: parsedData.id });
      expect(data).toEqual(expectedJSONData);
    });

    it('should return data properly with create and listing set to true', function () {
      const parsedDataCreateListing = Object.assign(parsedData, { datasets: { create: true, listing: true } });
      model.set(parsedDataCreateListing);
      const data = model.toJSON();
      const apiDataCreateListing = Object.assign({},
        apiData, {
          grants: [
            { type: 'apis', apis: [ 'maps', 'sql' ] },
            { type: 'database',
              tables: [{ 'schema': 'public', 'name': 'untitled_table_14', 'permissions': ['insert', 'update', 'read'] }],
              schemas: [{ name: 'public', permissions: ['create'] }],
              table_metadata: [] }
          ]
        });
      const expectedJSONData = Object.assign({}, apiDataCreateListing, { id: parsedData.id });
      expect(data).toEqual(expectedJSONData);
    });
  });

  describe('.isPublic', function () {
    it('should return true if type is default', function () {
      model.set('type', 'regular');
      expect(model.isPublic()).toBe(false);

      model.set('type', 'default');
      expect(model.isPublic()).toBe(true);
    });
  });

  describe('.getApiGrants', function () {
    it('should return granted API permissions', function () {
      model.set('apis', { maps: true, sql: false });
      expect(model.getApiGrants()).toEqual(['maps']);
    });
  });

  describe('.getTablesGrants', function () {
    it('should return tables with granted permissions', function () {
      const tables = {
        untitled_table_14: {
          schema: 'public',
          name: 'untitled_table_14',
          permissions: {
            insert: true,
            update: true,
            read: false
          }
        }
      };

      model.set('tables', tables);
      expect(model.getTablesGrants()).toEqual([{
        name: 'untitled_table_14',
        schema: 'public',
        permissions: ['insert', 'update']
      }]);
    });
  });

  describe('._parseApiGrants', function () {
    it('should return parsed API grants properly', function () {
      const apiGrants = model._parseApiGrants([{ type: 'apis', apis: [ 'maps' ] }]);
      expect(apiGrants).toEqual({ maps: true, sql: false });
    });
  });

  describe('._parseTableGrants', function () {
    it('should return parsed table grants properly', function () {
      const tableGrants = [{
        type: 'database',
        tables: [{ 'schema': 'public', 'name': 'untitled_table_14', 'permissions': ['insert', 'read'] }]
      }];

      const parsedTableGrants = model._parseTableGrants(tableGrants);

      expect(parsedTableGrants).toEqual({
        untitled_table_14: {
          schema: 'public',
          name: 'untitled_table_14',
          permissions: {
            insert: true,
            read: true
          }
        }
      });
    });
  });

  describe('._parseDatabaseGrants', function () {
    it('should be true after parsing database grants', function () {
      const tableGrants = [{
        type: 'database',
        schema: 'public',
        name: 'untitled_table_14',
        permissions: {
          insert: true,
          read: true
        },
        table_metadata: []
      }];

      const parsedDatabaseGrants = model._parseDatabaseGrants(tableGrants);

      expect(parsedDatabaseGrants).toBe(true);
    });

    it('should be false after parsing database grants', function () {
      const tableGrants = [{
        type: 'database',
        schema: 'public',
        name: 'untitled_table_14',
        permissions: {
          insert: true,
          read: true
        }
      }];

      const parsedDatabaseGrants = model._parseDatabaseGrants(tableGrants);

      expect(parsedDatabaseGrants).toBe(false);
    });
  });

  describe('._parseDatabaseSchemas', function () {
    it('should be true after parsing database schemas', function () {
      const tableGrants = [{
        type: 'database',
        schemas: [{ name: 'public', permissions: ['create'] }]
      }];
      const schemaName = 'public';

      const parsedDatabaseSchemas = model._parseDatabaseSchemas(tableGrants, schemaName);

      expect(parsedDatabaseSchemas).toBe(true);
    });

    it('should be false after parsing database schemas', function () {
      const tableGrants = [{
        type: 'database',
        schemas: []
      }];

      const parsedDatabaseSchemas = model._parseDatabaseSchemas(tableGrants);

      expect(parsedDatabaseSchemas).toBe(false);
    });
  });

  describe('._arrayToObj', function () {
    it('should transform an array to an object', function () {
      expect(model._arrayToObj(['sql', 'maps'])).toEqual({sql: true, maps: true});
    });
  });

  describe('._hasPermissionsSelected', function () {
    it('should return true if any table has permissions', function () {
      spyOn(model, 'getTablesGrants').and.returnValues(
        [{ schema: 'public', name: 'table_with_permissions', permissions: ['insert', 'update', 'read'] }],
        [{ schema: 'public', name: 'table_without_permissions', permissions: [] }]
      );

      expect(model.hasPermissionsSelected()).toBe(true);
      expect(model.hasPermissionsSelected()).toBe(false);
    });
  });
});