Combineを使ったコードのテストをSchedulerで操る方法とその仕組み

Combine
を使ったコードの

テストを Scheduler
で

操る方法とその仕組み
iOSDC Japan 2021

View Slide

自己紹介
アイカワ
iOS
アプリエンジニア &
社会人2
年目
Sansan
@kalupas0930
最近飼ったポメラニアンを溺愛
2

View Slide

アジェンダ
ViewModel + Combine
の基本的なコード
そのコードをテストするための基本的な方法
combine-schedulers
でテストコードの時間を操る方法
combine-schedulers
の仕組み
3
Combine
とテストについて、こちらの流れで話していきます

View Slide

説明で利用するアプリ
https://github.com/kalupas226/iOSDC2021SampleApp
4

View Slide

Search
ボタンをタップしたら検索するアプリ
5

View Slide

Model
のコード（ Response
の構造体）
6
GitHubRepository.swift / Response body
struct GitHubRepository: Decodable, Identifiable, Equatable {

let id: Int

let fullName: String

}

extension GitHubRepository {

private enum CodingKeys: String, CodingKey {

case id

case fullName = "full_name"

}

init(from decoder: Decoder) throws {

let container = try decoder.container(keyedBy: CodingKeys.self)

id = try container.decode(Int.self, forKey: .id)

fullName = try container.decode(String.self, forKey: .fullName)

}

}

struct GitHubRepositoryList: Decodable {

let items: [GitHubRepository]

}
{

"items": [

{

"id": 3081286,

"full_name": "iOSDC"

},

{

"id": 3081287,

"full_name": "iOSDC2021"
},

// ...

]

}

View Slide

Model
のコード（ API
通信部分）
7
GitHubAPIClient.swift
// interface

struct GitHubAPIClient {

var searchRepository: (String) -> AnyPublisher

}

//
実装部分

extension GitHubAPIClient {

// static
で作成することによって、GitHubAPIClient
を必要とするコード部分で `.live`
という形式で扱えるようになる

// ex) GitHubListView(viewModel: GitHubViewModel(gitHubAPIClient: .live))

static let live = Self(

searchRepository: { searchWord in

URLSession.shared.dataTaskPublisher(

for: URL(string: "https://api.github.com/search/repositories?q=\(searchWord)")!

)

.map { $0.data }

.decode(type: GitHubRepositoryList.self, decoder: JSONDecoder())

.replaceError(with: .init(items: [])) //
エラーハンドリングは本質ではないため、空の配列を返すようにする

.eraseToAnyPublisher()

}

)

}

View Slide

ViewModel
のコード
8
GitHubViewModel.swift
final class GitHubViewModel: ObservableObject {
private let gitHubAPIClient: GitHubAPIClient
private var cancellables: Set = []
@Published var searchWord = ""
@Published var repositories: [GitHubRepository] = []
init(gitHubAPIClient: GitHubAPIClient) {
self.gitHubAPIClient = gitHubAPIClient
}
func searchButtonTapped() {
gitHubAPIClient
.searchRepository(searchWord)
.sink { [weak self] in self?.repositories = $0.items }
.store(in: &cancellables)
}
}

View Slide

View
のコード
9
GitHubListView.swift
struct GitHubListView: View {
@ObservedObject private var viewModel: GitHubViewModel
init(viewModel: GitHubViewModel) {
self.viewModel = viewModel
}
var body: some View {
VStack { ... }
.padding()
}
}

View Slide

View
のコード（ body
部分）
10
var body: some View {
VStack {
HStack {
TextField("Search repository", text: $viewModel.searchWord)
.autocapitalization(.none)
.textFieldStyle(RoundedBorderTextFieldStyle())
Button("Search") {
viewModel.searchButtonTapped()
}
}
List {
ForEach(viewModel.repositories) { repository in
Text(repository.fullName)
}
}
Spacer()
}
.padding()
}

View Slide

SearchButton
を押した時のテストコード
11
iOSDC2021SampleAppTests.swift
func testSearchButtonTapped() throws {
var cancellables: Set = []
var actualRepositories: [GitHubRepository] = []
let expectedRepositories: [GitHubRepository] = (1...3).map { .init(id: $0, fullName: "Repository \($0)") }
let viewModel = GitHubViewModel(
gitHubAPIClient: .init(
searchRepository: { _ in
Just(
GitHubRepositoryList(items: expectedRepositories)
)
}
)
)
// assertion...
}

View Slide

SearchButton
を押した時のテストコード
12
let viewModel = GitHubViewModel(...)
// ViewModel
の @Published repositories
の変化を監視する
viewModel.$repositories
.sink { actualRepositories = $0 }
XCTAssertEqual(actualRepositories, [])
viewModel.searchWord = "search word"
XCTAssertEqual(actualRepositories, expectedRepositories)
}

View Slide

簡単なテストが成功しましたが、

コードに問題があるため修正します

View Slide

publish values from the main thread
の警告
14
}
gitHubAPIClient
// Publishing changes from background threads is not allowed;
// make sure to publish values from the main thread (via operators like receive(on:)) on model updates.
}
}

View Slide

DispatchQueue.main
で receive
するようにして修正
15
.receive(on: DispatchQueue.main)
}
gitHubAPIClient
}
}

View Slide

しかし、今度はテストが壊れてしまいます

View Slide

壊れてしまったテスト
17
// XCTAssertEqual failed: ("[]") is not equal to
// ("[GitHubRepository(id: 1, fullName: "Repository 1"), ...])
}

View Slide

一定時間 wait
するようにして修正
18
_ = XCTWaiter.wait(for: [XCTestExpectation()], timeout: 0.1) // 0.1
秒は適当
var repositories: [GitHubRepository] = []
.sink { repositories = $0 }
XCTAssertEqual(repositories, [])
XCTAssertEqual(repositories, expectedRepositories)
}

View Slide

現時点で微妙なテスト感が漂ってきましたが、

もう少しアプリの機能を実用的にしてみましょう

View Slide

インクリメンタルサーチ機能の追加
20
$searchWord //
イニシャライザ内で searchWord
を監視し、文字が入力されたら API
通信を行う
.sink { [weak self] in
guard let self = self else { return }
gitHubAPIClient
.searchRepository($0)
.sink { self.repositories = $0.items }
.store(in: &self.cancellables)
}
}
}

View Slide

ついでにローディングを検知するための状態も追加
21
//
この isLoading
を View
で利用して、true
の場合はローディング用の Text
を表示するようにする
@Published var isLoading = false
$searchWord
//
ここで isLoading
を変更する
}
}
}

View Slide

完成したインクリメンタルサーチ機能
22

View Slide

機能を変更したためテストコードで

エラーが発生します

View Slide

エラーが発生しているコード
24
viewModel.searchButtonTapped() // searchButtonTapped
を削除したためコンパイルエラーが発生
_ = XCTWaiter.wait(for: [XCTestExpectation()], timeout: 0.1)
}

View Slide

問題のある部分をコメントアウトして修正
25
func testInputSearchWords() throws { //
命名を修正
// viewModel.searchButtonTapped()
ここをコメントアウト
}

View Slide

0.3s
以上入力されなかったら検索するようにする
26
$searchWord
.debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
self.isLoading = true
gitHubAPIClient
.sink {
self.repositories = $0.items
self.isLoading = false
}
}

View Slide

この変更によって再びテストが壊れる
27
func testInputSearchWords() throws {
}

View Slide

wait
する秒数を伸ばすとテストが成功する
28
}

View Slide

テストの問題点😕
それらしい秒数を待つようにしていること
debounce
で 0.3s
、 receive(on: DispatchQueue.main)
も指定しているので、

とりあえず 0.33s
という適当な時間 wait
している
CI
など実行環境によっては、テストが失敗する可能性もある
wait
で指定している秒数は実際に時間を消費するものであること
0.33s wait
するのであれば、テストの実行時間も同じくらい増える
小さな問題かもしれないが、チリツモでテストの総実行時間が長くなる
29
` ` ` `
` `
` `

View Slide

combine-schedulers
を使って改善していきます
30

View Slide

combine-schedulers
とは？
Point-Free
が提供するライブラリ
Combine
の処理をよりテストしやすく、より汎用性の高いものにするための Scheduler
Combine
が提供する Scheduler protocol
に準拠する Scheduler
群が用意されている
AnyScheduler
TestScheduler
ImmediateScheduler
Animated schedulers
FailingScheduler
UIScheduler
Publishers.Timer
31
` `

View Slide

combine-schedulers
とは？
Point-Free
が提供するライブラリ
Combine
の処理をよりテストしやすく、より汎用性の高いものにするための Scheduler
Combine
が提供する Scheduler protocol
に準拠する Scheduler
群が用意されている
AnyScheduler
TestScheduler
ImmediateScheduler
Animated schedulers
FailingScheduler
UIScheduler
Publishers.Timer
32
` `

View Slide

先ほどのコードの ViewModel
に combine-
schedulers
を導入して、使い方を見ていきます

（ライブラリ自体の導入方法は省略します）

View Slide

元々の ViewModel
34
// ...
$searchWord
// API
通信処理など
}
}
}

View Slide

combine-schedulers
の Scheduler
を導入
35
import CombineSchedulers
// combine-schedulers
の AnyScheduler
については詳しく説明しないが、これにより不要な Generics
を導入する必要がなくなっている
private let scheduler: AnySchedulerOf
init(gitHubAPIClient: GitHubAPIClient, scheduler: AnySchedulerOf) {
self.scheduler = scheduler
$searchWord
// API
通信処理など
}
}
}

View Slide

ViewModel
で scheduler
を利用している部分
36
` `
$searchWord
gitHubAPIClient
.sink {
}
}

View Slide

combine-shcedulers
の Scheduler
を適用
37
.debounce(for: .milliseconds(300), scheduler: scheduler)
.receive(on: scheduler)
$searchWord
gitHubAPIClient
.sink {
}
}

View Slide

Preview
の ViewModel initialize
部分を修正
38
struct GitHubListView_Previews: PreviewProvider {
static var previews: some View {
GitHubListView(
viewModel: GitHubViewModel(
Just(
GitHubRepositoryList(
items: (1...40).map { .init(id: $0, fullName: "Repository \($0)") }
)
)
}
),
// AnySchedulerOf
の型になるように eraseToAnyScheduler
する
// Combine
の eraseToAnyPublisher
などと同じようなもので、Scheduler
版の type eraser
だと思えば問題ない
scheduler: DispatchQueue.main.eraseToAnyScheduler()
)
)
}
}

View Slide

scheduler
指定部分をより簡潔なものに修正
39
` `
// combine-schedulers
に DispatchQueue.main.eraseToAnyScheduler()
を表す static
なプロパティがある
scheduler: .main
struct GitHubListView_Previews: PreviewProvider {
static var previews: some View {
GitHubListView(
viewModel: GitHubViewModel(
Just(
GitHubRepositoryList(
items: (1...40).map { .init(id: $0, fullName: "Repository \($0)") }
)
)
}
),
)
)
}
}

View Slide

これで今までと同じようにアプリ本体が動作します

（エントリーポイントのコードの修正は省略）

View Slide

次に combine-schedulers
を導入した

最大の目的であるテストを修正していきます

View Slide

修正前のテストコード
42
Just(
)
}
)
)
// ...
}

View Slide

引数不足によりテストが動作しなくなっている
43
Just(
)
}
) // Missing argument for parameter 'scheduler' in call
)
// ...
}

View Slide

テストコードに scheduler
を追加していく
44
` `
import CombineScheduler
let scheduler = DispatchQueue.test //
型は TestSchedulerOf
Just(
)
}
},
scheduler: scheduler.eraseToAnyScheduler // AnyScheduler
型になるように type eraser
する
)
// ...
}

View Slide

TestScheduler
を使ってテストコードを改善する
45
let scheduler = DispatchQueue.test
gitHubAPIClient: .init(...),
scheduler: scheduler.eraseToAnyScheduler()
)
}

View Slide

TestScheduler
を使ってテストコードを改善する
46
// _ = XCTWaiter.wait(for: [XCTestExpectation()], timeout: 0.33)
)
}

View Slide

scheduler.advance
で正確な秒数を進める
47
` `
scheduler.advance(by: 0.3) //
⏰ 正確な時間を指定することができる
)
}

View Slide

debounce(0.3s)
を満たせないようにする
48
` `
scheduler.advance(by: 0.29)
)
}

View Slide

テストの実行時間も改善🎉
49

View Slide

combine-schedulers
導入前のテストの問題点
debounce
で 0.3s

している
wait
0.33s wait
50
` ` ` `
` `
` `

View Slide

combine-schedulers
でテストの問題点が改善された
debounce
で 0.3s

している
scheduler.advance(by:)
で正確な時間を進めることができるようになった
wait
0.33s wait
scheduler.advance(by:)
でテストの実際の実行時間に影響を与えることなく時間を

進めることができるようになった
51
` ` ` `
` `
` `
` `
` `

View Slide

無事テストの問題点を改善できたので、

combine-schedulers
の仕組みを見ていきます

難しい部分も多いため、不明点はぜひ

ask the speaker
での質問もお待ちしています 🔈

View Slide

debounce , receive
の引数の scheduler
53
` ` ` ` ` `
いずれも Scheduler
に準拠した S
という型を scheduler
の引数としている
` ` ` ` ` `
func debounce(
scheduler: S,
) -> Publishers.Debounce where S : Scheduler
for dueTime: S.SchedulerTimeType.Stride,
options: S.SchedulerOptions? = nil
func receive(
on scheduler: S,
) -> Publishers.ReceiveOn where S : Scheduler
options: S.SchedulerOptions? = nil

View Slide

Scheduler
は多数の operator
で利用されている
54
` `
時間やスレッドを伴うような Combine operator
で利用されている
Just(1)
.subscribe(on: <#T##Scheduler#>)
.receive(on: <#T##Scheduler#>)
.delay(for: ..., scheduler: <#T##Scheduler#>)
.timeout(..., scheduler: <#T##Scheduler#>)
.throttle(for: ..., scheduler: <#T##Scheduler#>, latest: ...)
.debounce(for: ..., scheduler: <#T##Scheduler#>)

View Slide

Scheduler protocol
の中身
55
` `
public protocol Scheduler {
associatedtype SchedulerTimeType : Strideable
where Self.SchedulerTimeType.Stride : SchedulerTimeIntervalConvertible
associatedtype SchedulerOptions
var now: Self.SchedulerTimeType { get }
var minimumTolerance: Self.SchedulerTimeType.Stride { get }
func schedule(options: Self.SchedulerOptions?, _ action: @escaping () -> Void)
func schedule(
after date: Self.SchedulerTimeType,
tolerance: Self.SchedulerTimeType.Stride,
options: Self.SchedulerOptions?,
_ action: @escaping () -> Void
)
func schedule(
interval: Self.SchedulerTimeType.Stride,
) -> Cancellable
}

View Slide

SchedulerTimeType
と SchedulerOptions
SchedulerTimeType
Scheduler
で時間を測定するために利用される型
時間を操るために Strideable
に準拠している必要がある
Strideable
に準拠している型（例は Double
）は stride(from:to:by)
などで利用できる
stride(from: 0.0, to: .pi * 2, by: .pi / 2)
SchedulerOptions
Scheduler
が受け付ける option
を表すタイプ
Scheduler
ごとに自由に定義することができる
56
` ` ` `
` `
` `
` ` ` ` ` `
` `
` `

View Slide

Scheduler protocol
の中身
57
` `
func schedule(
)
func schedule(
) -> Cancellable
}

View Slide

now
と minimumTolerance
now
Scheduler
の現在の時間を表す
minimumTolerance
Scheduler
が行う処理のスケジューリングにどのくらいの余裕を持たせるかを表す
58
` ` ` `
` `
var minimumTolerance: Self.SchedulerTimeType.Stride
` `

View Slide

Scheduler protocol
の中身
59
` `
func schedule(
)
func schedule(
) -> Cancellable
}

View Slide

Scheduler
が保持する3
つの function
60
` `
//
受け取った処理をすぐにスケジューリングするためのもの
//
ある処理が遅れて実行されるようにスケジューリングするためのもの
func schedule(
)
//
繰り返しの interval
で実行される処理をスケジューリングするためのもの
func schedule(
) -> Cancellable

View Slide

これらを満たして Scheduler protocol
に準拠した

Scheduler
を作成すれば、 recevie(on:)
などで

独自の Scheduler
を利用できるようになる
` `
` `

View Slide

基本的には独自に Scheduler
は定義しない
DispatchQueue
ImmediateScheduler
RunLoop
OperationQueue
62
` `
Apple
が提供する Scheduler
に準拠する型
` `

View Slide

DispatchQueue
の例
63
利用方法
//
受け取った処理をすぐにスケジューリングする schedule()
DispatchQueue.main.schedule {
print("
できるだけ早く実行する function")
}
// //
ある処理が遅れて実行されるようにスケジューリングする schedule(after:)
DispatchQueue.main.schedule(after: .init(.now() + 1)) {
print("
少し遅らせて実行する function")
}
//
で実行される処理をスケジューリングする schedule(after:interval)
DispatchQueue.main.schedule(after: .init(.now()), interval: 1) {
print("interval
で実行する function")
}

View Slide

テストの時間を操れるような

独自の Scheduler
を定義して

combine-shcedulers
の仕組みを探っていく

View Slide

Test
用 Scheduler
作成の目標と道のり
どんな Scheduler
を作成したいか
Test
内の時間を自由に操れる combine-schedulers
のようなもの
道のり
Scheduler protocol
に準拠した MyTestScheduler
を作成する
2
つの associatedtype
2
つの property
を満たす
3
つの function
を満たす
65
` ` ` `

View Slide

Test
用 Scheduler
作成の目標と道のり
どんな Scheduler
を作成したいか
Test
内の時間を自由に操れる combine-schedulers
のようなもの
道のり
Scheduler protocol
に準拠した MyTestScheduler
を作成する
2
つの associatedtype
2
つの property
を満たす
3
つの function
を満たす
66
` ` ` `

View Slide

Scheduler
型に準拠する MyTestScheduler
を作成
Scheduler
に準拠させようとすると
、typealias
の定義を提案される
67
final class MyTestScheduler: Scheduler {
// #type#
には何を入れるべきなのか？
typealias SchedulerTimeType = <#type#>
typealias SchedulerOptions = <#type#>
//
以下2
つのプロパティは上記 typealias
が定義できれば自動的に満たすことができる
var minimumTolerance: Self.SchedulerTimeType.Stride
var now: Self.SchedulerTimeType
}

View Slide

Generics
で associatedtype
と property
を満たす
普段使う Scheduler
は様々なものがあるが、それらに依存するものにはしたくない
DispatchQueue
ImmediateScheduler
RunLoop
OperationQueue
様々な Scheduler
に対応する TestScheduler
を作れるように Generics
を導入する
68
final class MyTestScheduler: Scheduler
where SchedulerTimeType: Strideable,
SchedulerTimeType.Stride: SchedulerTimeIntervalConvertible {
var minimumTolerance: SchedulerTimeType.Stride
var now: SchedulerTimeType
}

View Slide

initializer
がないというエラーに対応する
69
MyTestScheduler.swift
final class MyTestScheduler: Scheduler
where SchedulerTimeType: Strideable,
SchedulerTimeType.Stride: SchedulerTimeIntervalConvertible {
// TestScheduler
ではどれくらいスケジューリングに余裕を持たせるかは考えなくて良いため 0
とすることができる
var minimumTolerance: SchedulerTimeType.Stride = 0
init(now: SchedulerTimeType) {
self.now = now
}
}

View Slide

1
つ目の function
の作成
1
つ目の function
はすぐに処理をスケジューリングできるようなものにしたい
70
//
わかりやすさのために簡潔にしています
final class MyTestScheduler {
func schedule(options: SchedulerOptions?, _ action: @escaping () -> Void) {
<#code#>
}
}

View Slide

不要な引数を省略できるようにする
71
// options
は特に使用しないため `_`
を内部引数名にして省略することができる
func schedule(options _: SchedulerOptions?, _ action: @escaping () -> Void) {
<#code#>
}
}

View Slide

すぐにスケジューリングするような処理を考えてみる
schedule(options:action:)
が呼ばれた瞬間に action
が実行されてしまう

->
これだと、開発者が任意のタイミングで schedule
された action
を実行させることができない
72
//
すぐにスケジューリングできるような function
にしたいため、すぐに action
を実行するようにすれば良さそう？
action()
}
}
` ` ` `
` `

View Slide

MyTestScheduler
で実現したいこと
実際には Combine
で流れてくる一連の処理を蓄積して、任意のタイミングで処理を実行できるようにしたい
73
//
処理を蓄積するための変数を用意
private var scheduled: [() -> Void] = []
// ...
// schedule
が呼ばれたら処理を蓄積していくようにする
scheduled.append(action)
}
//
任意のタイミングで scheduled
に蓄積された処理を実行するための function
func advance() {
// advance
が呼ばれたら蓄積された処理を全て実行して、削除する
for action in scheduled {
action()
}
scheduled.removeAll()
}
}

View Slide

早速定義した schedule
と advance
を使ってみる
74
func testImmediateScheduledAction() {
let testScheduler = MyTestScheduler(
// now: DispatchQueue.SchedulerTimeType(DispatchTime(uptimeNanoseconds: 1))
now: .init(.init(uptimeNanoseconds: 0))
)
var isExecuted = false
testScheduler.schedule {
isExecuted = true
}
XCTAssertEqual(isExecuted, false)
testScheduler.advance()
XCTAssertEqual(isExecuted, true)
}

View Slide

MyTestScheduler
を容易に利用できるようにする
75
// DispatchQueue
の extension
として定義することにより、利用側からは DispatchQueue.myTest
という形で利用できる
extension DispatchQueue {
// typealias
を利用し長い Generics
が簡潔になるようにしている
static var myTest: MyTestSchedulerOf {
// uptimeNanoseconds: 0
にすると .now()
扱いになってしまいテストが不安定になるため、
// 0
にできるだけ近い 1
という値を利用し、処理に一貫性がもたらされるように工夫している
.init(now: .init(.init(uptimeNanoseconds: 1)))
}
}
typealias MyTestSchedulerOf = MyTestScheduler<
Scheduler.SchedulerTimeType, Scheduler.SchedulerOptions
> where Scheduler: Combine.Scheduler

View Slide

作成した DispatchQueue.myTest
を利用してみる
76
let testScheduler = DispatchQueue.myTest
func testImmediateScheduledAction() {
testScheduler.schedule {
isExecuted = true
}
}

View Slide

Publisher
なコードを MyTestScheduler
でテストする
77
func testImmediatePublisherScheduledAction() {
var result: [Int] = []
Just(1)
.receive(on: testScheduler)
.sink { result.append($0) }
XCTAssertEqual(result, [])
XCTAssertEqual(result, [1])
}

View Slide

2
つ目の function
の作成
2
つ目の function
は、ある処理が遅れて実行されるようにスケジューリングできるようにしたい
78
func schedule(
after date: SchedulerTimeType,
tolerance: SchedulerTimeType.Stride,
options: SchedulerOptions?,
) {
<#code#>
}
}

View Slide

不要な引数の内部引数名を省略する
79
tolerance _: SchedulerTimeType.Stride,
options _: SchedulerOptions?,
func schedule(
) {
<#code#>
}
}

View Slide

date
を有効活用できるようにコードを修正する
80
private var scheduled: [(action: () -> Void, date: SchedulerTimeType)] = []
func schedule(
) {
//
受け取った処理をすぐにスケジューリングする function
は now
（今すぐ）を利用すれば修正できる
scheduled.append((action, now))
}
func schedule(
) {
//
引数の date
を使えば、指定された時間にスケジューリングされる挙動を実現できる
scheduled.append((action, date))
}
}

View Slide

advance
も date
を活用できる形に修正する
81
//
どれくらい時間を進めるかを表す stride
は SchedulerTimeType
が Strideable
なので SchedulerTimeType.Stride
で表す
//
デフォルト引数として .zero
を取ることによって、単に現在時間(now)
と比較した際の処理を行うことができるようになる
func advance(by stride: SchedulerTimeType.Stride = .zero) {
// MyTestScheduler
の現在時間 (now)
を stride
分進める
now = now.advanced(by: stride)
// date
が現在時間 (now)
よりも過去の時間であれば実行すべき処理なので、action
を実行する
for (action, date) in scheduled {
if date <= now {
action()
}
}
//
実行し終わったものは削除しておく
scheduled.removeAll(where: { $0.date <= now })
}
}

View Slide

2
つ目の function
を利用したテストを書いてみる
82
func testDelayScheduledAction() {
testScheduler.schedule(after: testScheduler.now.advanced(by: 1)) {
isExecuted = true
}
testScheduler.advance(by: .milliseconds(500))
}

View Slide

非常に長い時間(5000s)
を伴うテストも書いてみる
83
func testLongLongDelayScheduledAction() {
testScheduler.schedule(after: testScheduler.now.advanced(by: 5000)) {
isExecuted = true
}
testScheduler.advance(by: 4999)
}

View Slide

テスト時間はもちろん一瞬 👏
84

View Slide

3
つ目の function
の作成
3
つ目の function
は、キャンセルされるまでの間繰り返しの interval
で処理を実行できるものにしたい
85
func schedule(
interval: SchedulerTimeType.Stride,
) -> Cancellable {
<#code#>
}
}

View Slide

こちらも同様に不要な引数は省略できるようにする
86
//
正しい引数の順番ではないが、簡潔にするため使用する引数と使用しない引数で改行しておいた
func schedule(
after date: SchedulerTimeType, interval: SchedulerTimeType.Stride, _ action: @escaping () -> Void,
tolerance _: SchedulerTimeType.Stride, options _: SchedulerOptions?
) -> Cancellable {
<#code#>
}
}

View Slide

再帰的な処理によって interval
な処理を実現する
87
func schedule(
after date: SchedulerTimeType, interval: SchedulerTimeType.Stride, _ action: @escaping () -> Void,
tolerance _: SchedulerTimeType.Stride, options _: SchedulerOptions?
) -> Cancellable {
//
再帰的な処理を行うための function
を定義
func scheduleAction(for date: SchedulerTimeType) -> () -> Void {
return { [weak self] in
// interval
分空いた時間を取得しておく
let nextDate = date.advanced(by: interval)
// interval
分空いた時間(nextDate)
に実行される予定の処理 (scheduleAction =
自分自身)
を append
する
self?.scheduled.append((scheduleAction(for: nextDate), nextDate))
// schedule(after:interval:action)
の引数として指定されている action
を実行
action()
}
}
//
これを実行することによって、interval
間隔で無限に実行されることになる scheduleAction
が append
される
scheduled.append((scheduleAction(for: date), date))
//
不完全な実装とはなるが、一気に説明すると話が複雑になるため一旦空の AnyCancellable
を返却しておく
return AnyCancellable {}
}
}

View Slide

schedule(after:interval)
実行時の流れを追う
MyTestScheduler.scheduled
の流れ
s.schedule(after: scheduler.now, interval: 1)
s.advance()
s.advance(.milliseconds(500))
[]
[scheduleAction(for: now), now)]
[scheduleAction(for: now + 1), now + 1)]
88
` `
func schedule(
_ action: @escaping () -> Void,
options _: SchedulerOptions?
) -> Cancellable {
action()
}
}
}
}
//
利用コード
scheduler.schedule(after: scheduler.now, interval: 1) { ... }

View Slide

schedule(after: now, interval: 1)
の実行前
の流れ
s.advance()
[]
89
` `
func schedule(
) -> Cancellable {
action()
}
}
}
}
//
利用コード

View Slide

scheduled
に再帰的な関数が append
される
の流れ
s.advance()
[]
90
` ` ` `
func schedule(
) -> Cancellable {
action()
}
}
}
}
//
利用コード

View Slide

advance
により scheduled
に append
される
の流れ
s.advance()
[]
91
` ` ` ` ` `
action()
func schedule(
) -> Cancellable {
}
}
}
}
//
利用コード

View Slide

0.5s
だけ advance
しても1s
に満たないため変化な
し
の流れ
s.advance()
[]
[scheduleAction(for: now + 2), now + 2)] 92
` `
func schedule(
) -> Cancellable {
action()
}
}
}
}
//
利用コード

View Slide

1s
の interval
が経過すると再度 append
される
の流れ
s.advance()
[]
93
` ` ` `
action()
func schedule(
) -> Cancellable {
}
}
}
}
//
利用コード

View Slide

説明したものをコードで表すと以下のようになる
94
func testIntervalScheduledAction() {
var executeCount = 0
testScheduler.schedule(after: testScheduler.now, interval: 1) {
executeCount += 1
}
XCTAssertEqual(executeCount, 0)
}

View Slide

しかし一気に秒数を進めると失敗してしまう
95
XCTAssertEqual(executeCount, 6) // 4
秒経過しているので、count
も2
から6
になっていて欲しいが失敗する（結果は3
）
executeCount += 1
}
}

View Slide

interval
のテストが失敗する原因は advance
にある
96
` `
// schedule(after:interval)
の場合、action
が実行されることによって scheduled
に新たな scheduleAction
が追加されていく
//
ここでは scheduled
に全ての action
が追加されていないタイミングのものでループを回してしまっているため、意図した結果にならない
for (action, date) in scheduled {
if date <= now {
action() //
この action
が実行されることによって、scheduled
に新たな scheduleAction
が追加されていく
}
}
scheduled.removeAll(where: { $0.date <= now })
}
}

View Slide

scheduled
を追跡する index
を用意して修正
97
` ` ` `
// ...
var index = 0
// index
で scheduled
の配列の先頭から走査していくことによって、
// interval action
により scheduled
に追加されていく action
にも対応できる
while index < scheduled.count {
let work = scheduled[index]
if work.date <= now {
work.action()
scheduled.remove(at: index)
} else {
index += 1
}
}
}
}

View Slide

一気に秒数を進める interval
テストは通るようになる
98
executeCount += 1
}
}

View Slide

同時実行の interval
では失敗してしまう
実行した順序（ ["frist", "first", "second"]
）になっていて欲しいが、順序が保証されていない
99
func testTwoIntervalsScheduledAction() {
var values: [String] = []
// 0s --> 1s:
実行 --> 2s:
実行
let firstInterval = testScheduler.schedule(after: testScheduler.now.advanced(by: 1), interval: 1) {
values.append("first")
}
// 0s --> 2s:
実行 --> 4s:
実行
let secondInterval = testScheduler.schedule(after: testScheduler.now.advanced(by: 2), interval: 2) {
values.append("second")
}
XCTAssertEqual(values, [])
// XCTAssertEqual failed: ("["first", "second", "first"]") is not equal to ("["first", "first", "second"]")
XCTAssertEqual(values, ["first", "first", "second"])
}
` `

View Slide

順序が保証されない理由を異なるテストで探ってみる
testScheduler.now
の値がどの時点で実行しても最終的な値（ 3_000_000_001
）になってしまっている
100
func testScheduleNow() {
var times: [UInt64] = []
let interval = testScheduler.schedule(after: testScheduler.now, interval: 1) {
// testScheduler
実行時の `now.dispatchTime.uptimeNanoseconds`(
ナノ秒)
を蓄積していく
times.append(testScheduler.now.dispatchTime.uptimeNanoseconds)
}
XCTAssertEqual(times, [])
// XCTAssertEqual failed: ("[3_000_000_001, 3_000_000_001, 3_000_000_001, 3_000_000_001]")
// is not equal to ("[1, 1_000_000_001, 2_000_000_001, 3_000_000_001]")
XCTAssertEqual(times, [1, 1_000_000_001, 2_000_000_001, 3_000_000_001])
}
` ` ` `

View Slide

この理由は advance
の実装内容から明らかである
101
` `
//
即座に指定された最終的な値まで now
を進めてしまっている
var index = 0
while index < scheduled.count {
let work = scheduled[index]
if work.date <= now {
work.action()
scheduled.remove(at: index)
} else {
index += 1
}
}
}
}

View Slide

時間を徐々に進められる advance
に修正する
102
` `
//
最終的に advance
される Date
をあらかじめ取得しておく
let finalDate = now.advanced(by: stride)
// finalDate
より now
が過去である限り処理を行う
while now <= finalDate {
// date
順で scheduled
を sort
する
scheduled.sort { $0.date < $1.date }
// scheduled
の先頭の date
を nextDate
として格納し、nextDate
が finalDate
より過去のものであれば guard
を抜ける
guard let nextDate = scheduled.first?.date, nextDate <= finalDate
else {
// nextDate
が finalDate
より未来である場合は、実行する action
がないため早期 return
する
now = finalDate
return
}
now = nextDate
// scheduled
の先頭を取り出し続けて、date
と nextDate
が一致する action
を実行していく（削除も行う）
while let (action, date) = scheduled.first, date == nextDate {
scheduled.removeFirst()
action()
}
}
}

View Slide

times
に append
するテストは通るようになる
103
` ` ` `
func testScheduleNow() {
var times: [UInt64] = []
let interval = testScheduler.schedule(after: testScheduler.now, interval: 1) {
times.append(testScheduler.now.dispatchTime.uptimeNanoseconds)
}
XCTAssertEqual(times, [])
XCTAssertEqual(times, [1, 1_000_000_001, 2_000_000_001, 3_000_000_001])
}

View Slide

同時実行の interval
は失敗したまま
失敗している原因は、 advance
内で実行順序を決める際に Date
のみでソートしており、

interval
な schedule function
の実行順序は考慮されていないこと
104
}
}
}
` `

View Slide

sequence
を scheduled
に持たせて順序を保証
105
` ` ` `
private var lastSequence: UInt = 0
private var scheduled: [(sequence: UInt, action: () -> Void, date: SchedulerTimeType)] = []
//
これを3
つの function
内の scheduled
に append
している部分で利用する
// ex) scheduled.append((nextSequence(), action, now))
private func nextSequence() -> UInt {
lastSequence += 1
return lastSequence
}
let finalDate = now.advanced(by: stride)
while now <= finalDate {
// date
と sequence
で sort
することによって、date
と sequence(append
タイミング)
が先のものが先頭に来るようになる
scheduled.sort { ($0.date, $0.sequence) < ($1.date, $1.sequence) }
//
他の処理に変更はないため省略
}
}
}

View Slide

1
つ目、2
つ目の function
で sequence
を利用する
106
` `
func schedule(
) {
scheduled.append((nextSequence(), action, now))
}
func schedule(
) {
scheduled.append((nextSequence(), action, date))
}

View Slide

3
つ目の function
でも sequence
を利用する
107
` `
func schedule(
) -> Cancellable {
let sequence = nextSequence()
self?.scheduled.append((sequence, scheduleAction(for: nextDate), nextDate))
action()
}
}
self.scheduled.append((sequence, scheduleAction(for: date), date))
}

View Slide

追加された順序が保証されるようになる
108
}
}
}

View Slide

interval
実行をキャンセルできない最後のバグ
109
func testCancelSchedule() {
executeCount += 1
}.store(in: &cancellables)
// cancellables
を全て削除
cancellables.removeAll()
// cancellables
を全て削除しているため interval
分の1
秒が進んでも executeCount
は2
のままでいて欲しい
}

View Slide

interval
実行をキャンセルできない最後のバグ
110
// XCTAssertEqual failed: ("3") is not equal to ("2")
executeCount += 1
cancellables.removeAll()
}

View Slide

原因は適当な AnyCancellable
を返却していること
111
func schedule(
) -> Cancellable {
action()
}
}
}

View Slide

sequence
を利用すれば簡単に修正できる
112
` `
return AnyCancellable {
self.scheduled.removeAll(where: { $0.sequence == sequence })
}
func schedule(
) -> Cancellable {
action()
}
}
}

View Slide

テストが無事に通るようになる
113
executeCount += 1
cancellables.removeAll() //
正常な AnyCancellable
を削除できるようになった
}

View Slide

以上が combine-schedulers
の実装方法になります。

複雑な実装はありましたが、ライブラリの実装が

そこまで厚いものではないことを

理解して頂けていたら嬉しいです🙏

View Slide

まとめ
Combine
は時間を伴うような operator
を使い始めるとテストがしにくくなる
delay , timeout , throttle , debounce
など…
XCTWaiter
など一定時間経過するのを待ってテストを成功させる方法はあるが、デメリットがある
何となくそれっぽい秒数 wait
しなければならない
wait
した分だけテスト実行時間が増加する
combine-schedulers
を利用すると上記の問題を解決できる
combine-schedulers
の実装は薄いものであるため、ライブラリ依存の心配もある程度緩和される（はず）
Scheduler Protocol
に準拠させた TestScheduler
その他いくつかの Scheduler
Test
を便利にするものや animation
を制御できるもの
Generics
を複雑にしないようにするための AnyScheduler
115
` ` ` ` ` ` ` `
` `
` ` ` `
` `

View Slide

参考
GitHub
pointfreeco / combine-schedulers
tcldr / Entwine
Point-Free
Combine Schedulers: Testing Time
Combine Schedulers: Controlling Time
Combine Schedulers: Erasing Time
Apple Developer Documentation
Scheduler
116

View Slide

117

View Slide

Combineを使ったコードのテストをSchedulerで操る方法とその仕組み

Combineを使ったコードのテストをSchedulerで操る方法とその仕組み

Aikawa

More Decks by Aikawa

Other Decks in Technology

Featured

Transcript