@tomei/media 0.10.0 → 0.10.1-test.1

package/src/__tests__/common.service.spec.ts

@@ -0,0 +1,203 @@
+jest.mock('@nestjs/config', () => ({
+  ConfigService: jest.fn().mockImplementation(() => ({
+    get: jest.fn().mockReturnValue('http://localhost:3000'),
+  })),
+}));
+
+jest.mock('@nestjs/common', () => ({
+  Injectable: () => (target: any) => target,
+  HttpException: class HttpException extends Error {
+    constructor(
+      public response: any,
+      public status: number,
+    ) {
+      super(typeof response === 'string' ? response : JSON.stringify(response));
+    }
+  },
+  InternalServerErrorException: class InternalServerErrorException extends Error {
+    constructor(message: string) {
+      super(message);
+    }
+  },
+}));
+
+jest.mock('axios');
+jest.mock('lodash', () => ({
+  omit: jest.fn((obj, keys) => {
+    const result = { ...obj };
+    keys.forEach((k: string) => delete result[k]);
+    return result;
+  }),
+  omitBy: jest.fn((obj, fn) => obj),
+  keys: jest.fn((obj) => Object.keys(obj)),
+  pick: jest.fn((obj, keys) => {
+    const result: any = {};
+    keys.forEach((k: string) => {
+      if (k in obj) result[k] = obj[k];
+    });
+    return result;
+  }),
+}));
+
+jest.mock('@paralleldrive/cuid2', () => ({
+  createId: jest.fn().mockReturnValue('new-cuid'),
+}));
+
+import axios from 'axios';
+import { CommonService } from '../common/common.service';
+
+const mockAxios = axios as jest.Mocked<typeof axios>;
+
+const mockConfigService = {
+  get: jest.fn().mockReturnValue('http://localhost:3000'),
+} as any;
+
+describe('CommonService', () => {
+  let service: CommonService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new CommonService(mockConfigService);
+  });
+
+  describe('handleAxiosError', () => {
+    it('throws HttpException when error has a response', () => {
+      const err = { response: { data: 'Bad Request', status: 400 } };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+
+    it('throws HttpException when error has a request but no response', () => {
+      const err = { request: 'timeout' };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+
+    it('throws InternalServerErrorException for generic errors', () => {
+      const err = { message: 'Something went wrong' };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+  });
+
+  describe('addActivityHistory', () => {
+    it('posts activity and returns EntityId', async () => {
+      mockAxios.post = jest
+        .fn()
+        .mockResolvedValue({ data: { EntityId: 'entity-123' } });
+
+      const record = {
+        Action: 'Insert',
+        EntityValueBefore: {},
+        EntityValueAfter: {
+          Title: 'Test',
+          CreatedById: 'u1',
+          CreatedAt: new Date(),
+        },
+        PerformedById: 'user-001',
+        EntityId: 'entity-001',
+      };
+
+      const result = await service.addActivityHistory(
+        record,
+        'Media',
+        'create',
+      );
+      expect(result).toBe('entity-123');
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        'http://localhost:3000/activity-histories',
+        expect.objectContaining({ EntityId: 'entity-001' }),
+      );
+    });
+
+    it('uses update activity label for update method', async () => {
+      mockAxios.post = jest
+        .fn()
+        .mockResolvedValue({ data: { EntityId: 'e2' } });
+
+      const record = {
+        EntityValueBefore: { Title: 'Old' },
+        EntityValueAfter: { Title: 'New' },
+        PerformedById: 'user-001',
+        EntityId: 'entity-002',
+      };
+
+      await service.addActivityHistory(record, 'Media', 'update');
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ Action: 'Update' }),
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      const axiosError = { response: { data: 'Error', status: 500 } };
+      mockAxios.post = jest.fn().mockRejectedValue(axiosError);
+
+      const record = {
+        EntityValueBefore: {},
+        EntityValueAfter: {},
+        PerformedById: 'u1',
+        EntityId: 'e1',
+      };
+
+      await expect(
+        service.addActivityHistory(record, 'Media', 'create'),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('getList', () => {
+    it('returns rows from the response', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockResolvedValue({ data: { rows: ['item1', 'item2'] } });
+
+      const result = await service.getList('MediaTypes');
+      expect(result).toEqual(['item1', 'item2']);
+      expect(mockAxios.get).toHaveBeenCalledWith(
+        'http://localhost:3000/lists/items',
+        expect.objectContaining({ params: { ListName: 'MediaTypes' } }),
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockRejectedValue({ response: { data: 'err', status: 500 } });
+      await expect(service.getList('Any')).rejects.toThrow();
+    });
+  });
+
+  describe('addFieldTranslation', () => {
+    it('posts field translation', async () => {
+      mockAxios.post = jest.fn().mockResolvedValue({});
+      const payload = { field: 'Title', value: 'Tajuk' } as any;
+
+      await service.addFieldTranslation(payload);
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        'http://localhost:3000/field-translations',
+        payload,
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.post = jest.fn().mockRejectedValue({ message: 'fail' });
+      await expect(service.addFieldTranslation({} as any)).rejects.toThrow();
+    });
+  });
+
+  describe('getMedia', () => {
+    it('returns rows from the response', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockResolvedValue({ data: { rows: [{ MediaId: 'm1' }] } });
+      const result = await service.getMedia({
+        ObjectId: 'obj1',
+        ObjectType: 'Rental',
+      } as any);
+      expect(result).toEqual([{ MediaId: 'm1' }]);
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.get = jest.fn().mockRejectedValue({ message: 'fail' });
+      await expect(service.getMedia({} as any)).rejects.toThrow();
+    });
+  });
+});

package/src/__tests__/medias.repository.spec.ts

@@ -0,0 +1,158 @@
+jest.mock('@nestjs/swagger', () => ({
+  ApiProperty: () => () => {},
+  ApiPropertyOptional: () => () => {},
+}));
+
+jest.mock('sequelize-typescript', () => ({
+  Table: () => () => {},
+  Column: () => () => {},
+  Model: class Model {
+    static findByPk = jest.fn();
+    static findOne = jest.fn();
+    static findAll = jest.fn();
+    static findAndCountAll = jest.fn();
+    static create = jest.fn();
+    get = jest.fn();
+    update = jest.fn();
+    destroy = jest.fn();
+  },
+  DataType: {
+    STRING: 'STRING',
+    TEXT: 'TEXT',
+    DATE: 'DATE',
+    BOOLEAN: 'BOOLEAN',
+    ENUM: () => 'ENUM',
+  },
+  PrimaryKey: () => () => {},
+  ForeignKey: () => () => {},
+  BelongsTo: () => () => {},
+  HasMany: () => () => {},
+  CreatedAt: () => () => {},
+  UpdatedAt: () => () => {},
+  Default: () => () => {},
+  AllowNull: () => () => {},
+}));
+
+jest.mock('sequelize', () => ({
+  Op: { substring: Symbol('Op.substring') },
+  DataTypes: {},
+}));
+
+jest.mock('@tomei/general', () => ({
+  RepositoryBase: class RepositoryBase {
+    constructor(_model: any) {}
+  },
+  IRepositoryBase: {},
+}));
+
+import { MediasRepository } from '../medias.repository';
+import { MediasModel } from '../entities/medias.entity';
+
+const mockModel = {
+  MediaId: 'media-001',
+  get: jest.fn().mockReturnValue({}),
+  update: jest.fn(),
+  destroy: jest.fn(),
+};
+
+describe('MediasRepository', () => {
+  let repo: MediasRepository;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    repo = new MediasRepository();
+  });
+
+  describe('findByPk', () => {
+    it('returns a MediasModel when found', async () => {
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(mockModel);
+      const result = await repo.findByPk('media-001', undefined);
+      expect(result).toBe(mockModel);
+      expect(MediasModel.findOne).toHaveBeenCalledWith({
+        where: { MediaId: 'media-001' },
+        transaction: undefined,
+      });
+    });
+
+    it('passes the transaction option', async () => {
+      const tx = { id: 'tx-1' };
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(mockModel);
+      await repo.findByPk('media-001', tx);
+      expect(MediasModel.findOne).toHaveBeenCalledWith({
+        where: { MediaId: 'media-001' },
+        transaction: tx,
+      });
+    });
+
+    it('returns null when record is not found', async () => {
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(null);
+      const result = await repo.findByPk('missing-id', undefined);
+      expect(result).toBeNull();
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel.findOne as jest.Mock).mockRejectedValue(
+        new Error('DB error'),
+      );
+      await expect(repo.findByPk('media-001', undefined)).rejects.toThrow(
+        'DB error',
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('destroys the record by MediaId', async () => {
+      (MediasModel as any).destroy = jest.fn().mockResolvedValue(1);
+      await repo.delete('media-001');
+      expect((MediasModel as any).destroy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({ MediaId: 'media-001' }),
+        }),
+      );
+    });
+
+    it('passes the transaction option', async () => {
+      const tx = { id: 'tx-2' };
+      (MediasModel as any).destroy = jest.fn().mockResolvedValue(1);
+      await repo.delete('media-001', tx);
+      expect((MediasModel as any).destroy).toHaveBeenCalledWith(
+        expect.objectContaining({ transaction: tx }),
+      );
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel as any).destroy = jest
+        .fn()
+        .mockRejectedValue(new Error('Delete failed'));
+      await expect(repo.delete('media-001')).rejects.toThrow('Delete failed');
+    });
+  });
+
+  describe('findAndCountAll', () => {
+    it('returns count and rows with options', async () => {
+      const mockResult = { count: 2, rows: [mockModel, mockModel] };
+      (MediasModel.findAndCountAll as jest.Mock).mockResolvedValue(mockResult);
+      const result = await repo.findAndCountAll({ limit: 10, offset: 0 });
+      expect(result).toEqual(mockResult);
+      expect(MediasModel.findAndCountAll).toHaveBeenCalledWith({
+        limit: 10,
+        offset: 0,
+      });
+    });
+
+    it('returns all records when no options are given', async () => {
+      const mockResult = { count: 1, rows: [mockModel] };
+      (MediasModel.findAndCountAll as jest.Mock).mockResolvedValue(mockResult);
+      const result = await repo.findAndCountAll(undefined);
+      expect(result).toEqual(mockResult);
+      expect(MediasModel.findAndCountAll).toHaveBeenCalledWith();
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel.findAndCountAll as jest.Mock).mockRejectedValue(
+        new Error('Query failed'),
+      );
+      await expect(repo.findAndCountAll({ limit: 5 })).rejects.toThrow();
+    });
+  });
+});