[Tests] Migrate from Quick and Nimble to Swift Testing

AsyncImageViewTests/AsyncImageSchedulerTests.swift

@@ -0,0 +1,68 @@
+import UIKit
+
+import ReactiveSwift
+import Testing
+
+import AsyncImageView
+
+@Suite @MainActor
+struct AsyncImageSchedulerTests {
+	@Test
+	func schedulesImageCreationOncePerRequest() {
+		let imageCreationScheduler = CountingScheduler()
+		let renderer = SchedulerCheckingRenderer(scheduler: imageCreationScheduler)
+		let view = AsyncImageView<
+			TestRenderData,
+			TestData,
+			SchedulerCheckingRenderer,
+			SchedulerCheckingRenderer
+		>(
+			initialFrame: CGRect(origin: .zero, size: CGSize(width: 10, height: 10)),
+			renderer: renderer,
+			placeholderRenderer: nil,
+			uiScheduler: ImmediateScheduler(),
+			imageCreationScheduler: imageCreationScheduler
+		)
+		let window = UIWindow()
+		window.addSubview(view)
+		imageCreationScheduler.reset()
+
+		view.data = .a
+
+		#expect(imageCreationScheduler.scheduleCount.value == 1)
+		#expect(renderer.startedOnScheduler.value)
+	}
+}
+
+private final class CountingScheduler: Scheduler {
+	let scheduleCount = Atomic(0)
+	let isExecuting = Atomic(false)
+
+	func schedule(_ action: @escaping () -> Void) -> Disposable? {
+		self.scheduleCount.modify { $0 += 1 }
+		self.isExecuting.modify { $0 = true }
+		action()
+		self.isExecuting.modify { $0 = false }
+
+		return nil
+	}
+
+	func reset() {
+		self.scheduleCount.modify { $0 = 0 }
+	}
+}
+
+private final class SchedulerCheckingRenderer: RendererType {
+	let startedOnScheduler = Atomic(false)
+	private let scheduler: CountingScheduler
+
+	init(scheduler: CountingScheduler) {
+		self.scheduler = scheduler
+	}
+
+	func renderImageWithData(_ data: TestRenderData) -> SignalProducer<UIImage, Never> {
+		self.startedOnScheduler.modify { $0 = self.scheduler.isExecuting.value }
+
+		return SignalProducer(value: UIImage())
+	}
+}

AsyncImageViewTests/AsyncImageViewRequestTests.swift

@@ -0,0 +1,87 @@
+import UIKit
+
+import ReactiveSwift
+import Testing
+
+import AsyncImageView
+
+@Suite @MainActor
+struct AsyncImageViewRequestTests {
+	private let fixture = RequestFixture()
+
+	@Test
+	func frameOriginChangesDoNotCreateRenderData() {
+		for offset in 1...10 {
+			self.fixture.view.frame.origin.x = CGFloat(offset)
+		}
+
+		#expect(self.fixture.requestCount == 1)
+	}
+
+	@Test
+	func boundsOriginChangesDoNotCreateRenderData() {
+		for offset in 1...10 {
+			self.fixture.view.bounds.origin.x = CGFloat(offset)
+		}
+
+		#expect(self.fixture.requestCount == 1)
+	}
+
+	@Test
+	func sizeChangesCreateRenderData() {
+		self.fixture.view.frame.size = CGSize(width: 20, height: 20)
+		self.fixture.view.bounds.size = CGSize(width: 30, height: 30)
+
+		#expect(self.fixture.requestCount == 3)
+	}
+}
+
+@MainActor
+private final class RequestFixture {
+	typealias ViewType = AsyncImageView<
+		RequestTestRenderData,
+		RequestTestViewData,
+		RequestTestRenderer,
+		RequestTestRenderer
+	>
+
+	let counter = Atomic(0)
+	let view: ViewType
+	private let window = UIWindow()
+
+	var requestCount: Int {
+		self.counter.value
+	}
+
+	init() {
+		self.view = ViewType(
+			initialFrame: CGRect(origin: .zero, size: CGSize(width: 10, height: 10)),
+			renderer: RequestTestRenderer(),
+			placeholderRenderer: nil,
+			uiScheduler: ImmediateScheduler(),
+			imageCreationScheduler: ImmediateScheduler()
+		)
+		self.window.addSubview(self.view)
+		self.view.data = RequestTestViewData(counter: self.counter)
+	}
+}
+
+private struct RequestTestViewData: ImageViewDataType {
+	let counter: Atomic<Int>
+
+	func renderDataWithSize(_ size: CGSize) -> RequestTestRenderData {
+		self.counter.modify { $0 += 1 }
+
+		return RequestTestRenderData(size: size)
+	}
+}
+
+private struct RequestTestRenderData: RenderDataType {
+	let size: CGSize
+}
+
+private final class RequestTestRenderer: RendererType {
+	func renderImageWithData(_ data: RequestTestRenderData) -> SignalProducer<UIImage, Never> {
+		SignalProducer(value: UIImage())
+	}
+}