Adiciona controller do Ollama e reestrutura arquitetura

src/modules/auth/auth.service.spec.ts

@@ -0,0 +1,176 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UnauthorizedException } from '@nestjs/common';
+import axios, { AxiosInstance } from 'axios';
+import { AuthService } from './auth.service';
+import { LoginDto } from './dto/login.dto';
+
+jest.mock('axios');
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AuthService],
+    }).compile();
+
+    service = module.get<AuthService>(AuthService);
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getUrl', () => {
+    it('should return development URL when NODE_ENV is development', () => {
+      process.env.NODE_ENV = 'development';
+      expect(service['getUrl']()).toBe('https://auth.clipperia.com.br');
+    });
+
+    it('should return production URL when NODE_ENV is not development', () => {
+      process.env.NODE_ENV = 'production';
+      expect(service['getUrl']()).toBe('http://keycloak:8080');
+    });
+  });
+
+  describe('login', () => {
+    const loginDto: LoginDto = {
+      username: 'testuser',
+      password: 'testpass',
+    };
+
+    const mockTokenResponse = {
+      access_token: 'mock-access-token',
+      refresh_token: 'mock-refresh-token',
+      expires_in: 300,
+      refresh_expires_in: 1800,
+    };
+
+    it('should login successfully', async () => {
+      const mockPost = jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockTokenResponse });
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      const result = await service.login(loginDto);
+
+      expect(mockPost).toHaveBeenCalledWith(
+        '/token',
+        expect.any(URLSearchParams),
+      );
+      expect(result).toEqual(mockTokenResponse);
+    });
+
+    it('should throw UnauthorizedException when login fails', async () => {
+      const mockError = {
+        isAxiosError: true,
+        response: {
+          status: 401,
+          data: { error: 'invalid_grant' },
+        },
+      };
+
+      const mockPost = jest.fn().mockRejectedValueOnce(mockError);
+
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      await expect(service.login(loginDto)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+  });
+
+  describe('logout', () => {
+    const refreshToken = 'mock-refresh-token';
+
+    it('should logout successfully', async () => {
+      const mockPost = jest.fn().mockResolvedValueOnce({});
+
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      await service.logout(refreshToken);
+
+      expect(mockPost).toHaveBeenCalledWith(
+        '/logout',
+        expect.any(URLSearchParams),
+      );
+    });
+
+    it('should throw UnauthorizedException when logout fails', async () => {
+      const mockError = {
+        isAxiosError: true,
+        response: {
+          status: 400,
+          data: { error: 'invalid_token' },
+        },
+      };
+
+      const mockPost = jest.fn().mockRejectedValueOnce(mockError);
+
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      await expect(service.logout(refreshToken)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+  });
+
+  describe('refreshToken', () => {
+    const refreshToken = 'mock-refresh-token';
+    const mockTokenResponse = {
+      access_token: 'new-access-token',
+      refresh_token: 'new-refresh-token',
+      expires_in: 300,
+      refresh_expires_in: 1800,
+    };
+
+    it('should refresh token successfully', async () => {
+      const mockPost = jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockTokenResponse });
+
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      const result = await service.refreshToken(refreshToken);
+
+      expect(mockPost).toHaveBeenCalledWith(
+        '/token',
+        expect.any(URLSearchParams),
+      );
+      expect(result).toEqual(mockTokenResponse);
+    });
+
+    it('should throw UnauthorizedException when refresh token is invalid', async () => {
+      const mockError = {
+        isAxiosError: true,
+        response: {
+          status: 400,
+          data: { error: 'invalid_grant' },
+        },
+      };
+
+      const mockPost = jest.fn().mockRejectedValueOnce(mockError);
+
+      mockedAxios.create.mockReturnValueOnce({
+        post: mockPost,
+      } as unknown as AxiosInstance);
+
+      await expect(service.refreshToken(refreshToken)).rejects.toThrow(
+        UnauthorizedException,
+      );
+    });
+  });
+});