// orderService.js
class OrderService {
  constructor(paymentService) {
    this.paymentService = paymentService;
  }

  placeOrder(order) {
    if (this.paymentService.processPayment(order)) {
      return 'Order placed';
    } else {
      return 'Payment failed';
    }
  }
}

// paymentService.js
class PaymentService {
  processPayment(order) {
    // Логика обработки платежа
    return true; // Или false в случае ошибки
  }
}

test('placeOrder returns "Order placed" when payment is successful', () => {
  const paymentService = new PaymentService();
  const orderService = new OrderService(paymentService);
  const order = { amount: 100 };

  const result = orderService.placeOrder(order);

  expect(result).toBe('Order placed');
});

test('placeOrder returns "Order placed" when payment is successful', () => {
  const paymentService = { processPayment: jest.fn().mockReturnValue(true) };
  const orderService = new OrderService(paymentService);
  const order = { amount: 100 };

  const result = orderService.placeOrder(order);

  expect(result).toBe('Order placed');
  expect(paymentService.processPayment).toHaveBeenCalledWith(order);
});

const evaluate = (x) => {
    if (x > 10) {
        return "Greater";
    } else {
        return "Lesser";
    }
};

// Тесты
assert(evaluate(5) == "Lesser");

const evaluateRefactor = (x) => (x > 10) ? "Greater" : "Lesser";

// Тесты
assert(evaluateRefactor(5) == "Lesser");

const evaluate = (x) => {
    if (x > 10) {
        return "Greater";
    } else if (x < 5) {
        return "Lesser";
    } else {
        return "Equal";
    }
};

// Тесты
assert(evaluate(15) == "Greater");
assert(evaluate(3) == "Lesser");
assert(evaluate(7) == "Equal");

Access to fetch at 'https://api.example.com/data' from origin 'https://myapp.com' 
has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present 
on the requested resource.

test('Track network request and verify payload', async ({ page }) => {
  await page.goto('https://your-website.com');

  // Перехват и проверка сетевых запросов
  const [response] = await Promise.all([
    page.waitForResponse(response => response.url().includes('www.google-analytics.com/collect') && response.status() === 200),
    // Выполняем действие на странице, которое должно вызвать запрос
    page.click('button')
  ]);

  const requestPayload = JSON.parse(response.request().postData());

  expect(requestPayload).toHaveProperty('event', 'yourExpectedEvent');
  expect(requestPayload).toHaveProperty('gtm', 'expectedGtmId');
});

test('Check dataLayer for specific event', async ({ page }) => {
  await page.goto('https://your-website.com');

  // Выполняем действие на странице
  await page.click('button#yourButton');

  // Получаем значение dataLayer из контекста страницы
  const dataLayer = await page.evaluate(() => window.dataLayer);

  // Проверка, что dataLayer содержит ожидаемое событие
  const eventData = dataLayer.find(event => event.event === 'yourExpectedEvent');

  expect(eventData).not.toBeNull();
  expect(eventData).toHaveProperty('gtm', 'yourExpectedGtm');
});

setInterval(()=> {
  $('#gift').click()
}, 150)

const countElement = $$('[class^="_ObjectsListCard"]').length;
console.log(`Количество проектов: ${countElement}`);

const links = [...document.querySelectorAll('a')].map(link => link.href);
console.log('Все ссылки на странице:', links);

const tableRows = [...document.querySelectorAll('table tbody tr')];
const data = tableRows.map(row => {
  const columns = row.querySelectorAll('td');
  return {
    column1: columns[0].innerText,
    column2: columns[1].innerText,
    column3: columns[2].innerText,
  };
});
console.log('Данные из таблицы:', data);

const tableRows = [...document.querySelectorAll('table tbody tr')];
const total = tableRows.reduce((sum, row) => {
  const value = parseFloat(row.querySelector('td:nth-child(3)').innerText);
  return sum + (isNaN(value) ? 0 : value);
}, 0);
console.log(`Сумма значений в третьей колонке: ${total}`);

fetch('<https://example.com/api/data>', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ key: 'value' }),
})
.then(response => response.json())
.then(data => console.log('Ответ от сервера:', data))
.catch(error => console.error('Ошибка:', error));

const socket = new WebSocket('wss://example.com/socket');

socket.onopen = () => {
  console.log('Соединение установлено');
  socket.send(JSON.stringify({ action: 'subscribe', channel: 'updates' }));
};

//далее отправляем различные запросы

document.querySelector('#name').value = 'Тестовое имя';
document.querySelector('#email').value = 'test@example.com';
document.querySelector('form').submit();
console.log('Форма заполнена и отправлена'); 

const nameInput = document.querySelector('#name');
nameInput.value = 'Тестовое имя';
nameInput.dispatchEvent(new Event('input', { bubbles: true }));
nameInput.dispatchEvent(new Event('change', { bubbles: true }));

    javanoscript:(function(){
        // Ваш код здесь
        const countElement = $$('[class^="_ObjectsListCard"]').length;
        console.log(`Количество проектов: ${countElement}`);
    })();

{ 
  "noscripts": { 
    "lint": "eslint .",
    "format": "prettier . --write",
    "test": "jest" 
  } 
}

 npx husky init

echo "npm prettier && npm lint && npm test" > .husky/pre-commit

git commit -m "..." -n

test('Закрывает Drawer при вызове onClose', () => {
// Arrange
render(<Comments />);
const closeButton = screen.getByRole('button', { name: 'close' });

// Act
fireEvent.click(closeButton);
TypeScript
// Assert
expect(mockedUseStore().services.comments.close).toHaveBeenCalled();
});

 test('Закрывает и открывает Drawer при вызове onClose', () => {
  // Arrange
    render(<Comments />);
    const closeButton = screen.getByRole('button', { name: 'close' });

    // Act
    fireEvent.click(closeButton);

    // Assert
    expect(mockedUseStore().services.comments.close).toHaveBeenCalled();
  
    // Arrange
    const openCommentButton = screen.getByRole('button', { name: 'Комментарии' });
  
    // Act
    fireEvent.click(openCommentButton);
  
  // Assert
  expect(modal).toBeVisible();
  });

npx playwright test --tsconfig tsconfig.test.json

const response = await request.get('url', { params: 'userId=1' });

class PaymentProcessor {
  private validateTransaction(transaction: Transaction): boolean {
    // сложная логика
    return transaction.amount > 0 && transaction.currency === 'USD';
  }

  processPayment(transaction: Transaction): string {
    if (this.validateTransaction(transaction)) {
      return 'Payment processed';
    } else {
      return 'Invalid transaction';
    }
  }
}

class Inventory {
  private items: Item[] = [];

  addItem(item: Item): void {
    this.items.push(item);
  }
  getItems(): ReadonlyArray<Item> {
    return this.items;
  }

  // Другие методы...
}

class TaxCalculator {
  calculateTax(product: Product): number {
    if (product.category === 'Food') {
      return product.price * 0.05;
    } else if (product.category === 'Electronics') {
      return product.price * 0.2;
    }
    return product.price * 0.1;
  }
}

describe('TaxCalculator', () => {
  it('should calculate tax for food category', () => {
    const calculator = new TaxCalculator();
    const product = { price: 100, category: 'Food' };
    // тут дублируется логика
    const expectedTax = product.price * 0.05;
    const tax = calculator.calculateTax(product);
    expect(tax).toBe(expectedTax);
  });
});

describe('TaxCalculator', () => {
  it('should calculate 5% tax for food category', () => {
    const calculator = new TaxCalculator();
    const product = { price: 100, category: 'Food' };
    const tax = calculator.calculateTax(product);
    expect(tax).toBe(5);
  });

  it('should calculate 20% tax for electronics category', () => {
    const calculator = new TaxCalculator();
    const product = { price: 200, category: 'Electronics' };
    const tax = calculator.calculateTax(product);
    expect(tax).toBe(40);
  });
});

class SmsService {
  sendSms(number: string, message: string): void {
    // Логика отправки SMS
  }
}

class NotificationManager {
  constructor(private smsService: SmsService) {}

  notifyUser(user: User, message: string): void {
    this.smsService.sendSms(user.phoneNumber, message);
  }
}

describe('NotificationManager', () => {
  it('should send SMS notification', () => {
    const smsService = new SmsService();
    spyOn(smsService, 'sendSms');
    const manager = new NotificationManager(smsService);
    manager.notifyUser({ phoneNumber: '1234567890' }, 'Test Message');
    expect(smsService.sendSms).toHaveBeenCalledWith('1234567890', 'Test Message');
  });
});

interface IMessageService {
  sendMessage(recipient: string, message: string): void;
}

class SmsService implements IMessageService {
  sendMessage(recipient: string, message: string): void {
    // Логика отправки SMS
  }
}

class NotificationManager {
  constructor(private messageService: IMessageService) {}

  notifyUser(user: User, message: string): void {
    this.messageService.sendMessage(user.phoneNumber, message);
  }
}

🔎Тестирование с мокированием интерфейса:

describe('NotificationManager', () => {
  it('should send message notification', () => {
    const messageService: IMessageService = {
      sendMessage: jasmine.createSpy('sendMessage'),
    };
    const manager = new NotificationManager(messageService);
    manager.notifyUser({ phoneNumber: '1234567890' }, 'Test Message');
    expect(messageService.sendMessage).toHaveBeenCalledWith('1234567890', 'Test Message');
  });
});

test('Закрытие оверлея с noWaitAfter: true', async ({ page }) => {
    await page.goto('http://localhost:3000');
    
    // Локатор для оверлея
    const overlayLocator = page.locator('#overlay');
    
    // Добавляем обработчик локатора для закрытия оверлея
    await page.addLocatorHandler(overlayLocator, async overlay => {
        await overlay.locator('#closeButton').click(); // Закрытие оверлея
    }, { times: 3, noWaitAfter: true }); // Макс. 3 раза, без ожидания после клика
    
    // Взаимодействие с кнопкой после закрытия оверлея
    await page.click('#fetchWeatherButton');
    
    // Проверка отображения прогноза погоды
    await page.waitForSelector('#weatherDisplay:has-text("Прогноз погоды для Chennai")');
});

test('Получение данных погоды с noWaitAfter: false', async ({ page }) => {
  await page.goto('http://localhost:3000');
  
  // Клик по кнопке "Получить прогноз погоды" и ожидание завершения запроса
  await page.click('#fetchWeatherButton', { noWaitAfter: false });
  
  // Проверка отображения данных после загрузки
  await page.waitForSelector('#weatherDisplay:has-text("Прогноз погоды для Chennai")');
  const weatherText = await page.textContent('#weatherDisplay');
  console.log(weatherText);
});

test('UI-манипуляции с noWaitAfter: true', async ({ page }) => {
  await page.goto('http://localhost:3000');
  
  // Клик по кнопке без ожидания
  await page.click('#toggleButton', { noWaitAfter: true });
  await page.waitForSelector('#toggleElement.visible');
  
  // Симуляция быстрых кликов без ожидания
  await page.click('.rapidButton', { noWaitAfter: true });
  
  // Кастомное действие, активируемое таймером
  await page.click('#customActionButton', { noWaitAfter: true });
  await page.waitForSelector('#customActionResult:has-text("Действие завершено!")');
});