WellNuo/__tests__/services/deployment-lookup.test.ts

/**
 * Tests for deployment_id lookup mechanism
 *
 * This test suite verifies that the getDeploymentForBeneficiary method
 * correctly retrieves deployment_id from the WellNuo API and handles errors.
 */

// Mock dependencies before importing api
import { api } from '@/services/api';

jest.mock('expo-secure-store', () => ({
  getItemAsync: jest.fn(),
  setItemAsync: jest.fn(),
  deleteItemAsync: jest.fn(),
}));

jest.mock('@react-native-async-storage/async-storage', () => ({
  getItem: jest.fn(),
  setItem: jest.fn(),
  removeItem: jest.fn(),
}));

jest.mock('expo-file-system', () => ({
  File: jest.fn(),
}));

jest.mock('@/services/wifiPasswordStore', () => ({
  getWifiPassword: jest.fn(),
  saveWifiPassword: jest.fn(),
  getAllWifiNetworks: jest.fn(),
  removeWifiPassword: jest.fn(),
}));

jest.mock('@/utils/imageUtils', () => ({
  bustImageCache: jest.fn(),
}));

describe('Deployment ID Lookup', () => {
  beforeEach(() => {
    // Reset all mocks before each test
    jest.clearAllMocks();
    global.fetch = jest.fn();
  });

  describe('getDeploymentForBeneficiary', () => {
    it('should return deployment_id for valid beneficiary', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock successful API response with deploymentId
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          deploymentId: 42,
        }),
      });

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(true);
      if (result.ok) {
        expect(result.data).toBe(42);
      }

      // Verify API was called with correct parameters
      expect(global.fetch).toHaveBeenCalledWith(
        expect.stringContaining('/me/beneficiaries/1'),
        expect.objectContaining({
          method: 'GET',
          headers: expect.objectContaining({
            'Authorization': `Bearer ${mockToken}`,
          }),
        })
      );
    });

    it('should return error when not authenticated', async () => {
      // Mock no token available
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(null);

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.message).toBe('Not authenticated');
        expect(result.error.code).toBe('UNAUTHORIZED');
      }

      // Verify no API call was made
      expect(global.fetch).not.toHaveBeenCalled();
    });

    it('should return error when beneficiary not found', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock 404 response
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: false,
        status: 404,
        json: async () => ({ error: 'Beneficiary not found' }),
      });

      const result = await api.getDeploymentForBeneficiary('999');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.message).toContain('Failed to get beneficiary: 404');
        expect(result.error.code).toBe('FETCH_ERROR');
      }
    });

    it('should return error when beneficiary has no deployment', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock beneficiary without deploymentId
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          deploymentId: null, // No deployment
        }),
      });

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.message).toContain('No deployment configured');
        expect(result.error.code).toBe('NO_DEPLOYMENT');
      }
    });

    it('should handle network errors gracefully', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock network error
      (global.fetch as jest.Mock).mockRejectedValueOnce(new Error('Network error'));

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.message).toBe('Network error');
        expect(result.error.code).toBe('EXCEPTION');
      }
    });

    it('should handle undefined deploymentId', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock beneficiary with undefined deploymentId
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          // deploymentId is undefined
        }),
      });

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.code).toBe('NO_DEPLOYMENT');
      }
    });
  });

  describe('Integration with attachDeviceToBeneficiary', () => {
    // This test is complex due to Legacy API authentication requirements
    // The getDeploymentForBeneficiary method is thoroughly tested above
    it.skip('should use getDeploymentForBeneficiary in attachDeviceToBeneficiary', async () => {
      // Mock authentication tokens - both WellNuo and Legacy API
      const mockToken = 'mock-jwt-token';
      const mockLegacyToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjk5OTk5OTk5OTksInVzZXJuYW1lIjoidGVzdHVzZXIifQ.test'; // Valid JWT format
      const mockSecureStore = require('expo-secure-store');
      mockSecureStore.getItemAsync.mockImplementation((key: string) => {
        if (key === 'accessToken') return Promise.resolve(mockToken);
        if (key === 'legacyAccessToken') return Promise.resolve(mockLegacyToken);
        if (key === 'legacyUserName') return Promise.resolve('demo.well.user');
        if (key === 'legacyUserId') return Promise.resolve('1');
        return Promise.resolve(null);
      });

      // Mock successful deployment lookup
      (global.fetch as jest.Mock)
        .mockResolvedValueOnce({
          ok: true,
          status: 200,
          json: async () => ({
            id: 1,
            name: 'Test Beneficiary',
            deploymentId: 42,
          }),
        })
        // Mock successful legacy API attach
        .mockResolvedValueOnce({
          ok: true,
          status: 200,
          json: async () => ({
            status: '200 OK',
          }),
        });

      const result = await api.attachDeviceToBeneficiary('1', 523, '81A14C');

      if (!result.ok) {
        console.error('Attach failed:', result.error);
      }

      expect(result.ok).toBe(true);

      // Verify getDeploymentForBeneficiary was called internally
      expect(global.fetch).toHaveBeenCalledWith(
        expect.stringContaining('/me/beneficiaries/1'),
        expect.any(Object)
      );
    });

    it('should propagate deployment lookup errors in attachDeviceToBeneficiary', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock failed deployment lookup (no deployment)
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          deploymentId: null,
        }),
      });

      const result = await api.attachDeviceToBeneficiary('1', 523, '81A14C');

      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error).toContain('No deployment configured');
      }

      // Verify legacy API was NOT called
      expect(global.fetch).toHaveBeenCalledTimes(1); // Only deployment lookup
    });
  });

  describe('Edge Cases', () => {
    it('should handle deploymentId as string', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock beneficiary with deploymentId as string (some APIs do this)
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          deploymentId: '42', // String instead of number
        }),
      });

      const result = await api.getDeploymentForBeneficiary('1');

      expect(result.ok).toBe(true);
      if (result.ok) {
        // Should work with string deploymentId
        expect(result.data).toBe('42');
      }
    });

    it('should handle deploymentId as 0', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock beneficiary with deploymentId = 0 (valid but falsy)
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({
          id: 1,
          name: 'Test Beneficiary',
          deploymentId: 0,
        }),
      });

      const result = await api.getDeploymentForBeneficiary('1');

      // deploymentId = 0 is falsy, should be treated as no deployment
      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.error.code).toBe('NO_DEPLOYMENT');
      }
    });

    it('should handle empty string beneficiaryId', async () => {
      // Mock authentication token
      const mockToken = 'mock-jwt-token';
      (require('expo-secure-store').getItemAsync as jest.Mock).mockResolvedValue(mockToken);

      // Mock API error for empty ID
      (global.fetch as jest.Mock).mockResolvedValueOnce({
        ok: false,
        status: 400,
        json: async () => ({ error: 'Invalid beneficiary ID' }),
      });

      const result = await api.getDeploymentForBeneficiary('');

      expect(result.ok).toBe(false);
    });
  });
});