gronod
5390bbf615
Build and Push Docker Image / build (push) Successful in 2m6s
Docs Check / Markdown lint (push) Successful in 1m58s
Licence Check / Licence compatibility and copyright header verification (push) Successful in 2m4s
Docs Check / Mermaid diagram parse check (push) Successful in 1m58s
CI / Security audit (push) Successful in 1m48s
CI / Tests & coverage (push) Successful in 1m59s
CI / Swagger Validation & Coverage (push) Successful in 1m47s
836 lines
24 KiB
JavaScript
836 lines
24 KiB
JavaScript
// Copyright (c) 2026 Gordon Bolton. MIT License.
|
|
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
|
import nock from 'nock';
|
|
|
|
// Mock the logger before importing the retriever
|
|
vi.mock('../../../server/utils/logger', () => ({
|
|
logToFile: vi.fn()
|
|
}));
|
|
|
|
// Import OmbiRetriever after mocking
|
|
const OmbiRetriever = require('../../../server/clients/OmbiRetriever');
|
|
const ArrRetriever = require('../../../server/clients/ArrRetriever');
|
|
|
|
describe('OmbiRetriever', () => {
|
|
const baseUrl = 'http://localhost:5000';
|
|
const apiKey = 'test-api-key-12345';
|
|
const instanceConfig = {
|
|
id: 'test-ombi-1',
|
|
name: 'Test Ombi Instance',
|
|
url: baseUrl,
|
|
apiKey: apiKey
|
|
};
|
|
|
|
beforeEach(() => {
|
|
nock.cleanAll();
|
|
vi.useFakeTimers();
|
|
});
|
|
|
|
afterEach(() => {
|
|
nock.cleanAll();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
describe('constructor', () => {
|
|
it('should extend ArrRetriever base class', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever).toBeInstanceOf(ArrRetriever);
|
|
});
|
|
|
|
it('should initialize with correct properties', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.id).toBe('test-ombi-1');
|
|
expect(retriever.name).toBe('Test Ombi Instance');
|
|
expect(retriever.url).toBe(baseUrl);
|
|
expect(retriever.apiKey).toBe(apiKey);
|
|
expect(retriever.baseUrl).toBe(baseUrl);
|
|
});
|
|
|
|
it('should initialize cache with empty arrays and maps', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.cache.movieRequests).toEqual([]);
|
|
expect(retriever.cache.tvRequests).toEqual([]);
|
|
expect(retriever.cache.movieMap).toBeInstanceOf(Map);
|
|
expect(retriever.cache.tvMap).toBeInstanceOf(Map);
|
|
});
|
|
|
|
it('should set cache TTL to 5 minutes', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.cache.ttl).toBe(5 * 60 * 1000); // 5 minutes in ms
|
|
});
|
|
});
|
|
|
|
describe('getRetrieverType', () => {
|
|
it('should return "ombi"', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.getRetrieverType()).toBe('ombi');
|
|
});
|
|
});
|
|
|
|
describe('getInstanceId', () => {
|
|
it('should return configured instance ID', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.getInstanceId()).toBe('test-ombi-1');
|
|
});
|
|
});
|
|
|
|
describe('getTags', () => {
|
|
it('should return empty array', async () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getTags();
|
|
|
|
expect(result).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('getQueue', () => {
|
|
it('should return combined movie and TV requests', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', theMovieDbId: '12345' },
|
|
{ id: 2, title: 'Movie 2', theMovieDbId: '67890' }
|
|
];
|
|
const mockTvShows = [
|
|
{ id: 3, title: 'Show 1', theTvDbId: '11111' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getQueue();
|
|
|
|
expect(result.records).toHaveLength(3);
|
|
expect(result.records[0].title).toBe('Movie 1');
|
|
expect(result.records[2].title).toBe('Show 1');
|
|
});
|
|
});
|
|
|
|
describe('getHistory', () => {
|
|
it('should return empty records array', async () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getHistory();
|
|
|
|
expect(result).toEqual({ records: [] });
|
|
});
|
|
|
|
it('should return empty records even with options', async () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getHistory({ pageSize: 10, sortKey: 'date' });
|
|
|
|
expect(result).toEqual({ records: [] });
|
|
});
|
|
});
|
|
|
|
describe('testConnection', () => {
|
|
it('should return true for successful connection', async () => {
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, []);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.testConnection();
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should return false for failed connection', async () => {
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(401, { error: 'Unauthorized' });
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.testConnection();
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('isCacheExpired', () => {
|
|
it('should return true when cache is fresh (never fetched)', () => {
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
expect(retriever.isCacheExpired()).toBe(true);
|
|
});
|
|
|
|
it('should return false when cache is within TTL', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
expect(retriever.isCacheExpired()).toBe(false);
|
|
});
|
|
|
|
it('should return true when cache is beyond TTL', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
// Advance time by 6 minutes (beyond 5-minute TTL)
|
|
vi.advanceTimersByTime(6 * 60 * 1000);
|
|
|
|
expect(retriever.isCacheExpired()).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('refreshCache', () => {
|
|
it('should not refresh if cache is not expired', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
// First refresh
|
|
await retriever.refreshCache();
|
|
expect(retriever.cache.movieRequests).toHaveLength(1);
|
|
|
|
// Reset nock to verify no new calls are made
|
|
nock.cleanAll();
|
|
|
|
// Second refresh should not make API calls
|
|
await retriever.refreshCache();
|
|
expect(retriever.cache.movieRequests).toHaveLength(1);
|
|
});
|
|
|
|
it('should refresh when cache is expired', async () => {
|
|
const mockMovies1 = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockMovies2 = [{ id: 1, title: 'Movie 1' }, { id: 2, title: 'Movie 2', theMovieDbId: '67890' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies1);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
// First refresh
|
|
await retriever.refreshCache();
|
|
expect(retriever.cache.movieRequests).toHaveLength(1);
|
|
|
|
// Advance time beyond TTL
|
|
vi.advanceTimersByTime(6 * 60 * 1000);
|
|
|
|
// Set up new mocks for second refresh
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies2);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
// Second refresh should make API calls
|
|
await retriever.refreshCache();
|
|
expect(retriever.cache.movieRequests).toHaveLength(2);
|
|
});
|
|
|
|
it('should refresh if cache is not expired but force is true', async () => {
|
|
const mockMovies1 = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockMovies2 = [{ id: 1, title: 'Movie 1' }, { id: 2, title: 'Movie 2', theMovieDbId: '67890' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies1);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
// First refresh
|
|
await retriever.refreshCache();
|
|
expect(retriever.cache.movieRequests).toHaveLength(1);
|
|
|
|
// Set up new mocks for second refresh without advancing time
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies2);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
// Second refresh with force=true should make API calls
|
|
await retriever.refreshCache(true);
|
|
expect(retriever.cache.movieRequests).toHaveLength(2);
|
|
});
|
|
|
|
it('should build movie map with TMDB and IMDB IDs', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', theMovieDbId: '12345', imdbId: 'tt12345' },
|
|
{ id: 2, title: 'Movie 2', theMovieDbId: '67890' }
|
|
];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
expect(retriever.cache.movieMap.get('12345')).toEqual(mockMovies[0]);
|
|
expect(retriever.cache.movieMap.get('tt12345')).toEqual(mockMovies[0]);
|
|
expect(retriever.cache.movieMap.get('67890')).toEqual(mockMovies[1]);
|
|
});
|
|
|
|
it('should build TV map with TVDB and TMDB IDs', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [
|
|
{ id: 1, title: 'Show 1', theTvDbId: '11111', theMovieDbId: '22222' },
|
|
{ id: 2, title: 'Show 2', theTvDbId: '33333' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
expect(retriever.cache.tvMap.get('11111')).toEqual(mockTvShows[0]);
|
|
expect(retriever.cache.tvMap.get('22222')).toEqual(mockTvShows[0]);
|
|
expect(retriever.cache.tvMap.get('33333')).toEqual(mockTvShows[1]);
|
|
});
|
|
|
|
it('should handle API errors gracefully', async () => {
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(500, { error: 'Server Error' });
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(500, { error: 'Server Error' });
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
|
|
// Should not throw error
|
|
await expect(retriever.refreshCache()).resolves.not.toThrow();
|
|
|
|
// Cache should remain empty but not crash
|
|
expect(retriever.cache.movieRequests).toEqual([]);
|
|
expect(retriever.cache.tvRequests).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('getMovieRequests', () => {
|
|
it('should return cached movie requests on cache hit', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
// Reset nock to ensure no new API calls
|
|
nock.cleanAll();
|
|
|
|
const result = await retriever.getMovieRequests();
|
|
expect(result).toEqual(mockMovies);
|
|
});
|
|
|
|
it('should fetch and return movie requests on cache miss', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getMovieRequests();
|
|
|
|
expect(result).toEqual(mockMovies);
|
|
});
|
|
|
|
it('should force refresh and return movie requests even when cache is not expired if force is true', async () => {
|
|
const mockMovies1 = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockMovies2 = [{ id: 1, title: 'Movie 1' }, { id: 2, title: 'Movie 2', theMovieDbId: '67890' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies1);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
// Set up new mocks for second fetch
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies2);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const result = await retriever.getMovieRequests(true);
|
|
expect(result).toEqual(mockMovies2);
|
|
});
|
|
});
|
|
|
|
describe('getTvRequests', () => {
|
|
it('should return cached TV requests on cache hit', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [{ id: 1, title: 'Show 1', theTvDbId: '11111' }];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
// Reset nock to ensure no new API calls
|
|
nock.cleanAll();
|
|
|
|
const result = await retriever.getTvRequests();
|
|
expect(result).toEqual(mockTvShows);
|
|
});
|
|
|
|
it('should fetch and return TV requests on cache miss', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [{ id: 1, title: 'Show 1', theTvDbId: '11111' }];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getTvRequests();
|
|
|
|
expect(result).toEqual(mockTvShows);
|
|
});
|
|
|
|
it('should force refresh and return TV requests even when cache is not expired if force is true', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows1 = [{ id: 1, title: 'Show 1', theTvDbId: '11111' }];
|
|
const mockTvShows2 = [{ id: 1, title: 'Show 1' }, { id: 2, title: 'Show 2', theTvDbId: '22222' }];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows1);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
// Set up new mocks for second fetch
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows2);
|
|
|
|
const result = await retriever.getTvRequests(true);
|
|
expect(result).toEqual(mockTvShows2);
|
|
});
|
|
});
|
|
|
|
describe('findMovieRequest', () => {
|
|
it('should find movie by TMDB ID from cache', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', theMovieDbId: '12345', imdbId: 'tt12345' }
|
|
];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findMovieRequest('12345');
|
|
|
|
expect(result).toEqual(mockMovies[0]);
|
|
});
|
|
|
|
it('should find movie by IMDB ID when TMDB ID not found', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', theMovieDbId: '12345', imdbId: 'tt12345' }
|
|
];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findMovieRequest('99999', 'tt12345');
|
|
|
|
expect(result).toEqual(mockMovies[0]);
|
|
});
|
|
|
|
it('should return null when movie not found', async () => {
|
|
const mockMovies = [{ id: 1, title: 'Movie 1', theMovieDbId: '12345' }];
|
|
const mockTvShows = [];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findMovieRequest('99999');
|
|
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('findTvRequest', () => {
|
|
it('should find TV show by TVDB ID from cache', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [
|
|
{ id: 1, title: 'Show 1', theTvDbId: '11111', theMovieDbId: '22222' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findTvRequest('11111');
|
|
|
|
expect(result).toEqual(mockTvShows[0]);
|
|
});
|
|
|
|
it('should find TV show by TMDB ID when TVDB ID not found', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [
|
|
{ id: 1, title: 'Show 1', theTvDbId: '11111', theMovieDbId: '22222' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findTvRequest('99999', '22222');
|
|
|
|
expect(result).toEqual(mockTvShows[0]);
|
|
});
|
|
|
|
it('should return null when TV show not found', async () => {
|
|
const mockMovies = [];
|
|
const mockTvShows = [{ id: 1, title: 'Show 1', theTvDbId: '11111' }];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.findTvRequest('99999');
|
|
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('searchMovie', () => {
|
|
it('should search by TMDB ID first', async () => {
|
|
const mockSearchResult = {
|
|
id: 12345,
|
|
title: 'Searched Movie',
|
|
theMovieDbId: '12345'
|
|
};
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/movie/12345')
|
|
.reply(200, mockSearchResult);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchMovie('12345');
|
|
|
|
expect(result).toEqual(mockSearchResult);
|
|
});
|
|
|
|
it('should fall back to IMDB ID when TMDB search fails', async () => {
|
|
const mockSearchResult = {
|
|
id: 12345,
|
|
title: 'Searched Movie',
|
|
imdbId: 'tt12345'
|
|
};
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/movie/12345')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/movie/imdb/tt12345')
|
|
.reply(200, mockSearchResult);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchMovie('12345', 'tt12345');
|
|
|
|
expect(result).toEqual(mockSearchResult);
|
|
});
|
|
|
|
it('should return null when both searches fail', async () => {
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/movie/12345')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/movie/imdb/tt12345')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchMovie('12345', 'tt12345');
|
|
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('searchTv', () => {
|
|
it('should search by TVDB ID first', async () => {
|
|
const mockSearchResult = {
|
|
id: 11111,
|
|
title: 'Searched Show',
|
|
theTvDbId: '11111'
|
|
};
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/tv/11111')
|
|
.reply(200, mockSearchResult);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchTv('11111');
|
|
|
|
expect(result).toEqual(mockSearchResult);
|
|
});
|
|
|
|
it('should fall back to TMDB ID when TVDB search fails', async () => {
|
|
const mockSearchResult = {
|
|
id: 11111,
|
|
title: 'Searched Show',
|
|
theMovieDbId: '22222'
|
|
};
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/tv/11111')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/tv/tmdb/22222')
|
|
.reply(200, mockSearchResult);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchTv('11111', '22222');
|
|
|
|
expect(result).toEqual(mockSearchResult);
|
|
});
|
|
|
|
it('should return null when both searches fail', async () => {
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/tv/11111')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Search/tv/tmdb/22222')
|
|
.reply(404, { error: 'Not Found' });
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.searchTv('11111', '22222');
|
|
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('getCacheStats', () => {
|
|
it('should return cache statistics', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', theMovieDbId: '12345' },
|
|
{ id: 2, title: 'Movie 2', theMovieDbId: '67890' }
|
|
];
|
|
const mockTvShows = [{ id: 3, title: 'Show 1', theTvDbId: '11111' }];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
await retriever.refreshCache();
|
|
|
|
const stats = retriever.getCacheStats();
|
|
|
|
expect(stats.movieRequests).toBe(2);
|
|
expect(stats.tvRequests).toBe(1);
|
|
expect(stats.movieMapSize).toBe(2);
|
|
expect(stats.tvMapSize).toBe(1);
|
|
expect(stats.lastFetch).toBeGreaterThan(0);
|
|
expect(stats.age).toBeGreaterThanOrEqual(0);
|
|
});
|
|
});
|
|
|
|
describe('hydration logic', () => {
|
|
it('should hydrate requestedUser when missing but requestedUserId is present', async () => {
|
|
const mockMovies = [
|
|
{ id: 1, title: 'Movie 1', requestedUserId: 'gordon-id', requestedUser: null }
|
|
];
|
|
const mockTvShows = [];
|
|
const mockUsers = [
|
|
{ id: 'gordon-id', userName: 'Gordon', alias: 'G-Man' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Identity/Users')
|
|
.reply(200, mockUsers);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getMovieRequests();
|
|
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].requestedUser).toBeDefined();
|
|
expect(result[0].requestedUser.userName).toBe('Gordon');
|
|
expect(result[0].requestedUser.alias).toBe('G-Man');
|
|
});
|
|
|
|
it('should not overwrite non-empty requestedUser object', async () => {
|
|
const mockMovies = [
|
|
{
|
|
id: 1,
|
|
title: 'Movie 1',
|
|
requestedUserId: 'gordon-id',
|
|
requestedUser: { userName: 'ExistingGordon', alias: 'ExistingG' }
|
|
}
|
|
];
|
|
const mockTvShows = [];
|
|
const mockUsers = [
|
|
{ id: 'gordon-id', userName: 'Gordon', alias: 'G-Man' }
|
|
];
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/movie')
|
|
.reply(200, mockMovies);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Request/tv')
|
|
.reply(200, mockTvShows);
|
|
|
|
nock(baseUrl)
|
|
.get('/api/v1/Identity/Users')
|
|
.reply(200, mockUsers);
|
|
|
|
const retriever = new OmbiRetriever(instanceConfig);
|
|
const result = await retriever.getMovieRequests();
|
|
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].requestedUser.userName).toBe('ExistingGordon');
|
|
expect(result[0].requestedUser.alias).toBe('ExistingG');
|
|
});
|
|
});
|
|
});
|