URLSession и сетевой слой — бесплатный тест онлайн

Вопрос 1 из 30

Определите не предполагаемое, а фактическое поведение примера «Формирование запроса». Здесь оценивается построение запроса без ручного экранирования.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
var request23 = URLRequest(url: URL(string: "https://example.com/items")!)
request23.httpMethod = "POST"
request23.setValue("application/json", forHTTPHeaderField: "Content-Type")

Запрос явно задаёт метод и тип тела; сам URLRequest ещё ничего не отправляет. Запрос явно задаёт метод и тип тела; сам URLSession ещё ничего не отправляет. Запрос явно не задаёт метод и тип тела; сам URLRequest ещё ничего не отправляет. Для этого примера достаточно учесть, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Запрос неявно задаёт метод и тип тела; сам URLRequest ещё ничего не отправляет.

Вопрос 2 из 30

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Важно учесть: разделение транспортного и протокольного успеха.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
func validate23(_ response: URLResponse) throws {
    guard let http = response as? HTTPURLResponse,
          (200..<300).contains(http.statusCode) else { throw URLError(.badServerResponse) }
}

Для этого примера достаточно учесть, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Успешное завершение транспорта ещё не означает успешный HTTP-статус; код проверяет оба условия. Наблюдаемый результат определяется тем, что повтор POST-запроса всегда безопасен после тайм-аута. Операция с `validate23` корректна, поскольку любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Успешное завершение транспорта ещё означает успешный HTTP-статус; код проверяет оба условия.

Вопрос 3 из 30

Как поведёт себя программа в этом коротком сценарии, связанном с «Асинхронная загрузка»? Важно учесть: неблокирующая загрузка и мост со старым API.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
enum HTTPError23: Error { case badStatus }
func validate23(_ response: URLResponse) throws {
    guard let http = response as? HTTPURLResponse,
          (200..<300).contains(http.statusCode) else {
        throw HTTPError23.badStatus
    }
}
func load23(_ request: URLRequest, session: URLSession) async throws -> Data {
    let (data, response) = try await session.data(for: request)
    try validate23(response)
    return data
}

Для этого примера достаточно учесть, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Функция естественно распространяет транспортную ошибку и проверяет HTTP-ответ до возврата Data. Операция с `load23` корректна, поскольку повтор POST-запроса всегда безопасен после тайм-аута. Функция естественно распространяет транспортную ошибку и не проверяет HTTP-ответ до возврата Data. Последняя строка ведёт себя именно так, потому что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.

Вопрос 4 из 30

Как поведёт себя программа в этом коротком сценарии, связанном с «Повтор и кеш»? Важно учесть: идемпотентность, backoff и валидность кеша.

import Foundation
func shouldRetry23(status: Int, attempt: Int) -> Bool {
    [429, 502, 503, 504].contains(status) && attempt < 3
}

Для этого примера достаточно учесть, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Последняя строка ведёт себя именно так, потому что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Повтор ограничен числом попыток и временными статусами; это ещё не требует задержки и учёта Retry-After. Повтор ограничен числом попыток и временными статусами; это ещё требует задержки и учёта Retry-After. Фрагмент не требует отдельного условия: кеш должен удерживать ответы бессрочно, пока процесс не завершится.

Вопрос 5 из 30

Определите не предполагаемое, а фактическое поведение примера «Управляемый сетевой транспорт». Проверяется управляемый транспорт и полезная наблюдаемость.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class StubProtocol23: URLProtocol {
    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
    override class func canInit(with request: URLRequest) -> Bool { true }
    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
    override func startLoading() {}
    override func stopLoading() {}
}

Собственный URLProtocol не позволяет контролировать запрос и ответ без реальной сети, если полноценно реализовать доставку данных клиенту. Последняя строка ведёт себя именно так, потому что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Собственный URLProtocol позволяет контролировать запрос и ответ без реальной сети, если полноценно реализовать доставку данных клиенту. Для этого примера достаточно учесть, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Операция с `StubProtocol23` корректна, поскольку повтор POST-запроса всегда безопасен после тайм-аута.

Вопрос 6 из 30

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Проверяется жизненный цикл задач, соединений и кеша.

import Foundation
actor ImageCache23 { private var data: [URL: Data] = [:]; func value(for url: URL) -> Data? { data[url] }; func insert(_ d: Data, for url: URL) { data[url] = d } }

Для этого примера достаточно учесть, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Операция с `ImageCache23` корректна, поскольку кеш должен удерживать ответы бессрочно, пока процесс не завершится. Actor защищает словарь, но без лимита стоимости кеш всё равно может занять неограниченную память. Наблюдаемый результат определяется тем, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Actor защищает словарь, но без лимита стоимости кеш всё равно не может занять неограниченную память.

Вопрос 7 из 30

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Важно учесть: построение запроса без ручного экранирования.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
var requestBad23 = URLRequest(url: URL(string: "https://example.com/search?q=a b")!)

Первой нарушенной гарантией здесь является предположение, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Наблюдаемый симптом объясняется тем, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Ручная строковая сборка URL хрупка: пробелы и параметры должны кодироваться через URLComponents/URLQueryItem. Ручная строковая сборка URL хрупка: пробелы и параметры не должны кодироваться через URLComponents/URLQueryItem. Причина сбоя в том, что повтор POST-запроса всегда безопасен после тайм-аута.

Вопрос 8 из 30

На проверку кода принесли этот фрагмент. Какой диагноз точнее всего объясняет проблему в части «Обработка ответа»? Проверяется разделение транспортного и протокольного успеха.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
let (data23, _) = try await URLSession.shared.data(from: URL(string: "https://example.com")!)
let model23 = try JSONDecoder().decode([String:Int].self, from: data23)

Игнорирование URLResponse может попытаться декодировать страницу ошибки или редирект как успешную модель. Первой нарушенной гарантией здесь является предположение, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Игнорирование URLResponse не может попытаться декодировать страницу ошибки или редирект как успешную модель. Причина сбоя в том, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Проблема возникает из-за правила: повтор POST-запроса всегда безопасен после тайм-аута.

Вопрос 9 из 30

Что именно делает этот фрагмент неверным или неочевидным с точки зрения «Асинхронная загрузка»? Проверяется неблокирующая загрузка и мост со старым API.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class DataBox23: @unchecked Sendable { var value: Data? }
func blocking23(_ url: URL) -> Data? {
    let semaphore = DispatchSemaphore(value: 0)
    let box = DataBox23()
    URLSession.shared.dataTask(with: url) { data, _, _ in
        box.value = data
        semaphore.signal()
    }.resume()
    semaphore.wait()
    return box.value
}

Синхронное ожидание блокирует поток и может привести к взаимной блокировке или зависанию интерфейса. Наблюдаемый симптом объясняется тем, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Причина сбоя в том, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Первой нарушенной гарантией здесь является предположение, что повтор POST-запроса всегда безопасен после тайм-аута. Синхронное ожидание блокирует поток и не может привести к взаимной блокировке или зависанию интерфейса.

Вопрос 10 из 30

Ожидаемое поведение не совпало с фактическим. В чём первая нарушенная гарантия? Здесь оценивается идемпотентность, backoff и валидность кеша.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
func load23(_ request: URLRequest, session: URLSession) async throws -> Data {
    let (data, _) = try await session.data(for: request)
    return data
}
func retryPost23(_ request: URLRequest) async throws -> Data {
    for _ in 0..<5 {
        if let data = try? await load23(request, session: .shared) { return data }
    }
    throw URLError(.cannotLoadFromNetwork)
}

Без проверки идемпотентности повтор POST может создать несколько операций; try! также стирает причину и повторяет постоянные ошибки. Наблюдаемый симптом объясняется тем, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Первой нарушенной гарантией здесь является предположение, что повтор POST-запроса всегда безопасен после тайм-аута. Без проверки идемпотентности повтор POST не может создать несколько операций; try? также стирает причину и повторяет постоянные ошибки. Без проверки идемпотентности повтор POST может создать несколько операций; try? также стирает причину и повторяет постоянные ошибки.

Вопрос 11 из 30

Что в этом фрагменте нужно объяснить первым, чтобы дальнейшая правка не оказалась случайной? Важно учесть: управляемый транспорт и полезная наблюдаемость.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
func networkTest23() async throws {
    let data = try await URLSession.shared.data(from: URL(string: "https://example.com")!).0
    assert(!data.isEmpty)
}

Проблема возникает из-за правила: создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Тест не зависит от DNS, интернета и чужого сервера и не проверяет точный запрос детерминированно. Тест зависит от DNS, интернета и чужого сервера и не проверяет точный запрос детерминированно. Отчёт об ошибке должен указывать, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Тест зависит от DNS, интернета и чужого сервера и проверяет точный запрос детерминированно.

Вопрос 12 из 30

Какую причину стоит указать в отчёте об ошибке, прежде чем предлагать исправление? Проверяется жизненный цикл задач, соединений и кеша.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class Client23: @unchecked Sendable {
    func load(_ url: URL) {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            self.consume(data)
        }.resume()
    }
    func consume(_ data: Data?) {}
}

`URLSession` захватывает владельца слабо, поэтому замыкание не влияет на время жизни `Client23`. Соответствие `@unchecked Sendable` отменяет сильный захват `self` в `@Sendable`-замыкании. Клиент удерживается исключительно общим экземпляром `URLSession`, даже если замыкание не обращается к `self`. Сильный захват существует только во время вызова `dataTask(with:)` и исчезает до запуска задачи. Замыкание удерживает self до завершения задачи; это не всегда утечка, но может продлить жизнь клиента и крупных зависимостей.

Вопрос 13 из 30

Какое изменение устраняет именно показанную причину и сохраняет ясный контракт «Формирование запроса»? Сосредоточьтесь на следующем: построение запроса без ручного экранирования.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
var requestBad23 = URLRequest(url: URL(string: "https://example.com/search?q=a b")!)

Сигнатуру можно не менять, если считать, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Нужно адаптировать только вызов `requestBad23`, поскольку создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Собрать компоненты и queryItems структурно, проверить итоговый URL и помещать секреты в строку запроса без необходимости. Правка сводится к локальному обходу: реальная сеть делает модульный тест надёжнее управляемого транспорта. Собрать компоненты и queryItems структурно, проверить итоговый URL и не помещать секреты в строку запроса без необходимости.

Вопрос 14 из 30

Какое изменение устраняет именно показанную причину и сохраняет ясный контракт «Обработка ответа»? Здесь оценивается разделение транспортного и протокольного успеха.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
let (data23, _) = try await URLSession.shared.data(from: URL(string: "https://example.com")!)
let model23 = try JSONDecoder().decode([String:Int].self, from: data23)

Проверить тип ответа, статус, MIME при необходимости и только затем декодировать либо построить доменную ошибку. Достаточно изменить работу с `model23`, исходя из того, что повтор POST-запроса всегда безопасен после тайм-аута. Сигнатуру можно не менять, если считать, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Правка сводится к локальному обходу: реальная сеть делает модульный тест надёжнее управляемого транспорта. Нужно адаптировать только вызов `model23`, поскольку создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.

Вопрос 15 из 30

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Сосредоточьтесь на следующем: неблокирующая загрузка и мост со старым API.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class DataBox23: @unchecked Sendable { var value: Data? }
func blocking23(_ url: URL) -> Data? {
    let semaphore = DispatchSemaphore(value: 0)
    let box = DataBox23()
    URLSession.shared.dataTask(with: url) { data, _, _ in
        box.value = data
        semaphore.signal()
    }.resume()
    semaphore.wait()
    return box.value
}

Сигнатуру можно не менять, если считать, что повтор POST-запроса всегда безопасен после тайм-аута. Сделать API async и передать ожидание вверх по стеку; для legacy обратный вызов создать checked continuation с единственным resume. Нужно адаптировать только вызов `blocking23`, поскольку реальная сеть делает модульный тест надёжнее управляемого транспорта. Исправление — оставить контракт прежним и учитывать, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Сделать API throws и передать ожидание вверх по стеку; для legacy обратный вызов создать checked continuation с единственным resume.

Вопрос 16 из 30

Какое решение одновременно исправляет код и оставляет понятную границу для дальнейших изменений? Важно учесть: идемпотентность, backoff и валидность кеша.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
func load23(_ request: URLRequest, session: URLSession) async throws -> Data {
    let (data, _) = try await session.data(for: request)
    return data
}
func retryPost23(_ request: URLRequest) async throws -> Data {
    for _ in 0..<5 {
        if let data = try? await load23(request, session: .shared) { return data }
    }
    throw URLError(.cannotLoadFromNetwork)
}

Правка сводится к локальному обходу: реальная сеть делает модульный тест надёжнее управляемого транспорта. Исправление — оставить контракт прежним и учитывать, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Достаточно изменить работу с `retryPost23`, исходя из того, что повтор POST-запроса всегда безопасен после тайм-аута. Повторять только безопасные/идемпотентные операции либо использовать идемпотентный ключ, экспоненциальную задержку с jitter и классификацию ошибок. Нужно адаптировать только вызов `retryPost23`, поскольку создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.

Вопрос 17 из 30

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Не упускайте из виду следующее: управляемый транспорт и полезная наблюдаемость.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
func networkTest23() async throws {
    let data = try await URLSession.shared.data(from: URL(string: "https://example.com")!).0
    assert(!data.isEmpty)
}

Внедрить URLSession с тестовой configuration и URLProtocol/абстракцию транспорта; отдельно оставить малое число интеграционных проверок. Достаточно изменить работу с `networkTest23`, исходя из того, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Внедрить URLRequest с тестовой configuration и URLProtocol/абстракцию транспорта; отдельно оставить малое число интеграционных проверок. Нужно адаптировать только вызов `networkTest23`, поскольку кеш должен удерживать ответы бессрочно, пока процесс не завершится. Исправление — оставить контракт прежним и учитывать, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.

Вопрос 18 из 30

Какой вариант ремонта вы бы приняли после содержательной проверки кода? Сосредоточьтесь на следующем: жизненный цикл задач, соединений и кеша.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class Client23: @unchecked Sendable {
    func load(_ url: URL) {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            self.consume(data)
        }.resume()
    }
    func consume(_ data: Data?) {}
}

Сигнатуру можно не менять, если считать, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Правка сводится к локальному обходу: реальная сеть делает модульный тест надёжнее управляемого транспорта. Определить владение запросом, отменять его с владельцем, ограничивать кеш по стоимости и декодировать большие данные внутри главного исполнителя. Определить владение запросом, отменять его с владельцем, ограничивать кеш по стоимости и декодировать большие данные вне главного исполнителя. Достаточно изменить работу с `Client23`, исходя из того, что повтор POST-запроса всегда безопасен после тайм-аута.

Вопрос 19 из 30

Какое ограничение темы «Формирование запроса» обязательно проверить отдельным граничным тестом? Важно учесть: построение запроса без ручного экранирования.

Заголовки регистронезависимы по HTTP, но дублирование через разные методы установки может дать несколько значений. Заголовки регистронезависимы по HTTP, но дублирование через разные методы установки не может дать несколько значений. Контрпример появляется, когда кеш должен удерживать ответы бессрочно, пока процесс не завершится. Ограничение определяется предположением, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Правило меняется только в ситуации, где повтор POST-запроса всегда безопасен после тайм-аута.

Вопрос 20 из 30

Какое уточнение защищает решение от слишком широкого толкования? Здесь оценивается разделение транспортного и протокольного успеха.

URLRequest обычно не считает HTTP 404 транспортной ошибкой; data(for:) может вернуть данные и response без throw. URLSession обычно не считает HTTP 404 транспортной ошибкой; data(for:) может вернуть данные и response без throw. URLSession обычно не считает HTTP 405 транспортной ошибкой; data(for:) может вернуть данные и response без throw. URLSession обычно не считает HTTP 404 транспортной ошибкой; data(for:) не может вернуть данные и response без throw. Граница применимости проходит там, где любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода.

Вопрос 21 из 30

Что нужно учесть, прежде чем объявлять найденное правило универсальным? Не упускайте из виду следующее: неблокирующая загрузка и мост со старым API.

Граница применимости проходит там, где любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Отмена Task может распространяться на поддерживающий её URLRequest-вызов, но пользовательский обратный вызов-мост обязан корректно связать отмену сам. Отмена Task может распространяться на поддерживающий её URLSession-вызов, но пользовательский обратный вызов-мост обязан корректно связать отмену сам. Отмена Task не может распространяться на поддерживающий её URLSession-вызов, но пользовательский обратный вызов-мост обязан корректно связать отмену сам. Контрпример появляется, когда создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.

Вопрос 22 из 30

Какой отрицательный сценарий лучше всего проверяет предел применимости этого механизма? Проверяется идемпотентность, backoff и валидность кеша.

Пограничный случай связан с тем, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Контрпример появляется, когда любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Граница применимости проходит там, где повтор POST-запроса всегда безопасен после тайм-аута. URLCache учитывает политику и HTTP-заголовки, но является гарантией офлайн-доступа или вечной свежести. URLCache учитывает политику и HTTP-заголовки, но не является гарантией офлайн-доступа или вечной свежести.

Вопрос 23 из 30

Где заканчивается гарантия, продемонстрированная в обычном примере «Управляемый сетевой транспорт»? Проверяется управляемый транспорт и полезная наблюдаемость.

Контрпример появляется, когда реальная сеть делает модульный тест надёжнее управляемого транспорта. Ограничение определяется предположением, что повтор POST-запроса всегда безопасен после тайм-аута. Мок, который сразу возвращает модель, не проверяет URL, заголовки, статус и декодирование — то есть обходит половину сетевого слоя. Граница применимости проходит там, где кеш должен удерживать ответы бессрочно, пока процесс не завершится. Мок, который сразу возвращает модель, проверяет URL, заголовки, статус и декодирование — то есть обходит половину сетевого слоя.

Вопрос 24 из 30

Какое уточнение защищает решение от слишком широкого толкования? Сосредоточьтесь на следующем: жизненный цикл задач, соединений и кеша.

Один общий `URLSession` с единой политикой подходит всем подсистемам и не создаёт скрытой связанности. Время жизни сетевого слоя определяется только `URLCache`; владение задачами и конфигурацией сессии роли не играет. Создание отдельного `URLSession` для каждого запроса не влияет ни на пул соединений, ни на стоимость ресурсов. Новый URLSession на каждый запрос разрушает повторное использование соединений; один вечный общий экземпляр с общей политикой тоже может быть слишком жёстким. Новый `URLRequest` на каждый вызов разрушает повторное использование соединений так же, как новый `URLSession`.

Вопрос 25 из 30

Какое замечание на проверке кода поможет предотвратить повторение такого дефекта? Не упускайте из виду следующее: построение запроса без ручного экранирования.

Сетевой слой не должен принимать типизированное описание запроса и централизовать кодирование, авторизацию и идентификатор трассировки. Архитектуру стоит строить из предположения, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Главным проектным принципом здесь является утверждение, что реальная сеть делает модульный тест надёжнее управляемого транспорта. Сетевой слой должен принимать типизированное описание запроса и централизовать кодирование, авторизацию и идентификатор трассировки. При расширении системы нужно опираться на то, что кеш должен удерживать ответы бессрочно, пока процесс не завершится.

Вопрос 26 из 30

Что стоит закрепить в типах или API, а не оставлять устной договорённостью? Сосредоточьтесь на следующем: разделение транспортного и протокольного успеха.

Сохранять ограниченный фрагмент безопасного тела ошибки и request ID полезнее, чем заменять все статусы одним «не удалось загрузить». Сохранять ограниченный фрагмент безопасного тела ошибки и request ID полезнее, чем заменять все статусы одним «удалось загрузить». Для устойчивого решения достаточно принять, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Архитектуру стоит строить из предположения, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. В API и тестах следует исходить из правила: любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода.

Вопрос 27 из 30

Какое замечание на проверке кода поможет предотвратить повторение такого дефекта? Важно учесть: неблокирующая загрузка и мост со старым API.

Одна async-функция на запрос упрощает композицию; скрытый DispatchQueue внутри слоя является заменой структурной конкурентности. Одна async-функция на запрос упрощает композицию; скрытый DispatchQueue внутри слоя не является заменой структурной конкурентности. Главным проектным принципом здесь является утверждение, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Одна async-функция на запрос упрощает композицию; скрытый DispatchQueue вне слоя не является заменой структурной конкурентности. Одна throws-функция на запрос упрощает композицию; скрытый DispatchQueue внутри слоя не является заменой структурной конкурентности.

Вопрос 28 из 30

Какой принцип важнее локальной красоты синтаксиса в рабочем приложении? Не упускайте из виду следующее: идемпотентность, backoff и валидность кеша.

Архитектуру стоит строить из предположения, что повтор POST-запроса всегда безопасен после тайм-аута. Политика повтора и кеша должна быть частью конкретной операции, а не одинаковым глобальным правилом для всех запросов. Для устойчивого решения достаточно принять, что реальная сеть делает модульный тест надёжнее управляемого транспорта. При расширении системы нужно опираться на то, что любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Политика повтора и кеша не должна быть частью конкретной операции, а не одинаковым глобальным правилом для всех запросов.

Вопрос 29 из 30

Какое решение уменьшит число скрытых состояний и упростит расследование следующего сбоя? Сосредоточьтесь на следующем: управляемый транспорт и полезная наблюдаемость.

В API и тестах следует исходить из правила: любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Архитектуру стоит строить из предположения, что кеш должен удерживать ответы бессрочно, пока процесс не завершится. Для устойчивого решения достаточно принять, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`. Диагностика не должна связывать метод, нормализованный URL, статус, длительность и request ID, исключая токены и персональные данные. Диагностика должна связывать метод, нормализованный URL, статус, длительность и request ID, исключая токены и персональные данные.

Вопрос 30 из 30

Что должно определять архитектуру этого участка, когда появятся новые входы и владельцы? Не упускайте из виду следующее: жизненный цикл задач, соединений и кеша.

Разделить транспорт, кодирование, политику повтора, кеш и доменное отображение ошибок — так каждую часть можно тестировать и заменять отдельно. Разделить транспорт, кодирование, политику повтора, кеш и доменное отображение ошибок — не так каждую часть можно тестировать и заменять отдельно. Разделить транспорт, кодирование, политику повтора, кеш и доменное отображение ошибок — так каждую часть нельзя тестировать и заменять отдельно. В API и тестах следует исходить из правила: любой ответ без транспортной ошибки считается успешным независимо от HTTP-кода. Для устойчивого решения достаточно принять, что создание `URLSessionDataTask` автоматически запускает запрос без `resume()`.