Filamenteka/__tests__/filament-crud.test.ts

// Mock axios before importing services
jest.mock('axios', () => ({
  create: jest.fn(() => ({
    interceptors: {
      request: { use: jest.fn() },
      response: { use: jest.fn() }
    },
    get: jest.fn(),
    post: jest.fn(),
    put: jest.fn(),
    delete: jest.fn()
  }))
}));

import { filamentService, authService } from '../src/services/api';

describe('Filament CRUD Operations', () => {
  let authToken: string;

  beforeAll(async () => {
    // Mock successful login
    jest.spyOn(authService, 'login').mockResolvedValue({ token: 'test-token' });
    const loginResponse = await authService.login('admin', 'admin123');
    authToken = loginResponse.token;
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  describe('Create Filament', () => {
    it('should create a new filament without brand field', async () => {
      const newFilament = {
        tip: 'PLA',
        finish: 'Basic',
        boja: 'Black',
        bojaHex: '#000000',
        refill: '2',
        vakum: '1 vakuum',
        otvoreno: 'Ne',
        kolicina: '3',
        cena: '3999'
      };

      const mockResponse = {
        id: '123',
        ...newFilament,
        boja_hex: '#000000',
        created_at: new Date().toISOString(),
        updated_at: new Date().toISOString()
      };

      jest.spyOn(filamentService, 'create').mockResolvedValue(mockResponse);

      const result = await filamentService.create(newFilament);

      expect(result).toEqual(mockResponse);
      expect(filamentService.create).toHaveBeenCalledWith(newFilament);
      
      // Verify no brand field was sent
      const callArg = (filamentService.create as jest.Mock).mock.calls[0][0];
      expect(callArg).not.toHaveProperty('brand');
    });

    it('should transform bojaHex to boja_hex for backend', async () => {
      const filamentWithHex = {
        tip: 'PETG',
        finish: 'Silk',
        boja: 'Red',
        bojaHex: '#FF0000',
        refill: 'Ne',
        vakum: 'Ne',
        otvoreno: 'Ne',
        kolicina: '1',
        cena: '4500'
      };

      // Spy on the actual implementation
      const createSpy = jest.spyOn(filamentService, 'create');
      
      // We can't test the actual transformation without a real axios call,
      // but we can verify the method is called correctly
      await expect(async () => {
        await filamentService.create(filamentWithHex);
      }).not.toThrow();

      expect(createSpy).toHaveBeenCalledWith(filamentWithHex);
    });
  });

  describe('Update Filament', () => {
    it('should update a filament without brand field', async () => {
      const filamentId = '123';
      const updateData = {
        tip: 'ABS',
        finish: 'Matte',
        boja: 'Blue',
        bojaHex: '#0000FF',
        refill: '1',
        vakum: '2 vakuum',
        otvoreno: '1 otvorena',
        kolicina: '4',
        cena: '5000'
      };

      const mockResponse = {
        id: filamentId,
        ...updateData,
        boja_hex: '#0000FF',
        updated_at: new Date().toISOString()
      };

      jest.spyOn(filamentService, 'update').mockResolvedValue(mockResponse);

      const result = await filamentService.update(filamentId, updateData);

      expect(result).toEqual(mockResponse);
      expect(filamentService.update).toHaveBeenCalledWith(filamentId, updateData);
      
      // Verify no brand field was sent
      const callArgs = (filamentService.update as jest.Mock).mock.calls[0];
      expect(callArgs[1]).not.toHaveProperty('brand');
    });
  });

  describe('Delete Filament', () => {
    it('should delete a filament by ID', async () => {
      const filamentId = '123';
      const mockResponse = { success: true };

      jest.spyOn(filamentService, 'delete').mockResolvedValue(mockResponse);

      const result = await filamentService.delete(filamentId);

      expect(result).toEqual(mockResponse);
      expect(filamentService.delete).toHaveBeenCalledWith(filamentId);
    });
  });

  describe('Get All Filaments', () => {
    it('should retrieve all filaments and transform boja_hex to bojaHex', async () => {
      const mockFilaments = [
        {
          id: '1',
          tip: 'PLA',
          finish: 'Basic',
          boja: 'Black',
          boja_hex: '#000000',
          refill: '2',
          vakum: '1 vakuum',
          otvoreno: 'Ne',
          kolicina: '3',
          cena: '3999'
        },
        {
          id: '2',
          tip: 'PETG',
          finish: 'Silk',
          boja: 'Red',
          boja_hex: '#FF0000',
          refill: 'Ne',
          vakum: 'Ne',
          otvoreno: 'Ne',
          kolicina: '1',
          cena: '4500'
        }
      ];

      const expectedTransformed = mockFilaments.map(f => ({
        ...f,
        bojaHex: f.boja_hex
      }));

      jest.spyOn(filamentService, 'getAll').mockResolvedValue(expectedTransformed);

      const result = await filamentService.getAll();

      expect(result).toEqual(expectedTransformed);
      expect(result[0]).toHaveProperty('bojaHex', '#000000');
      expect(result[1]).toHaveProperty('bojaHex', '#FF0000');
    });
  });

  describe('Quantity Calculations', () => {
    it('should correctly calculate total quantity from refill, vakuum, and otvoreno', () => {
      const testCases = [
        { refill: '2', vakum: '1 vakuum', otvoreno: 'Ne', expected: 3 },
        { refill: 'Ne', vakum: '3 vakuum', otvoreno: '2 otvorena', expected: 5 },
        { refill: '1', vakum: 'Ne', otvoreno: 'Ne', expected: 1 },
        { refill: 'Da', vakum: 'vakuum', otvoreno: 'otvorena', expected: 3 }
      ];

      testCases.forEach(({ refill, vakum, otvoreno, expected }) => {
        // Parse refill
        const refillCount = parseInt(refill) || (refill?.toLowerCase() === 'da' ? 1 : 0);
        
        // Parse vakuum
        const vakuumMatch = vakum?.match(/^(\d+)\s*vakuum/);
        const vakuumCount = vakuumMatch ? parseInt(vakuumMatch[1]) : (vakum?.toLowerCase().includes('vakuum') ? 1 : 0);
        
        // Parse otvoreno
        const otvorenMatch = otvoreno?.match(/^(\d+)\s*otvorena/);
        const otvorenCount = otvorenMatch ? parseInt(otvorenMatch[1]) : (otvoreno?.toLowerCase().includes('otvorena') ? 1 : 0);
        
        const total = refillCount + vakuumCount + otvorenCount;
        
        expect(total).toBe(expected);
      });
    });
  });
});