Skip to main content

Retain cycles unit test


Trong quá trình phát triển ứng dụng, chúng ta rất khó tránh khỏi việc tạo ra retain cycles kể cả với những lập trình viên giàu kinh nghiệm. Retain cycles không phải lúc nào cũng dễ dàng để phát hiện và có thể dẫn đến hàng giờ để debug. Tất nhiên có những công cụ tuyệt vời giúp chúng ta thực hiện debug dễ dàng hơn (như: memory graph debugger,...) nhưng quá trình debug vẫn khá là vất vả và mất thời gian.
Điều quan trọng để fix retain cycles là cần phát hiện ra chúng. Bài viết này sẽ trình bày một số đoạn code mà bạn có thể đưa vào unit test giúp việc phát hiện ra retain cycles dễ dàng hơn.

Ý tưởng đơn giản

Một quy tắc khá đơn giản trong ARC: một đối tượng sẽ được giữ lại nếu vẫn còn ít nhất 1 tham chiếu mạnh đến nó.
class NoisyDeinit {
    deinit {
        print("I'm in deinit")
    }
}

var example: NoisyDeinit? = .init()

// Setting `example` (the only reference to the `NoisyDeinit` instance) to `nil`
// causes the instance to be deallocated and it's `deinit` will be invoked.
example = nil
Tương tự, chúng ta đều biết rằng một tham chiếu yếu (weak) đến một đối tượng sẽ không làm tăng retain count và đối tượng sẽ giải phóng khi tham chiếu mạnh cuối cùng kết thúc.
var example: NoisyDeinit? = .init()
weak var weakReference = example

assert(weakReference != nil)

// Setting `example` (the only reference to the `NoisyDeinit` instance) to `nil`
// also causes `weakReference` to be set to `nil`.
example = nil
assert(weakReference == nil)
Nắm được những điều cơ bản trên, chúng ta có thể viết unit tests theo cách mà chúng ta có cả tham chiếu mạnh và tham chiếu yếu đến đối tượng cần test. Sau khi hoàn thành sử dụng đối tượng, chúng ta sẽ set tham chiếu mạnh thành nil và xác minh rằng tham chiếu yếu cũng là nil. Nếu tham chiếu yếu không phải nil tại thời điểm này thì chúng ta cần tìm ra nguyên nhân khiến đối tượng tồn tại (đây có thể là 1 retain cycle).
Chúng ta hãy xem nó trông như thế nào. Đây là một unit test mà không cần kiểm tra cycle:
final class SampleTests: XCTestCase {    
    func testGreeting() {
        let sut = Greeter()
        XCTAssertEqual(sut.greet("Paul"), "Hello Paul")
    }
}
Để thêm bài test này cho một đối tượng, chúng ta làm như sau:
 1 final class SampleTests: XCTestCase {
 2     func testGreeting() {
 3         var sut: Greeter? = .init()
 4         weak var weakSut = sut
 5 
 6         XCTAssertEqual(sut?.greet("Paul"), "Hello Paul")
 7 
 8         sut = nil
 9         XCTAssertNil(weakSut)
10     }
11 }
  1. Một biến weak var để giữ tham chiếu yếu đến đối tượng mà chúng ta đang cần kiểm tra vòng đời.
  2. Set nil để loại bỏ tham chiếu mạnh (line 8)
  3. Kiểm tra weakSut sẽ trở thành nil (line 9)

Chúng ta có thể đơn giản hóa?

Thêm 3 dòng như trên cho mỗi đối tượng là một công việc khá tẻ nhạt và dễ bị lỗi. Ví dụ, bạn có thể vô tình quên bất kỳ một trong các bước này và xác thực sẽ không còn hoạt động. Chúng ta có thể viết một vài helper functions mà chúng ta có thể thêm dưới dạng extension trên XCTestCase cho phép chúng ta chỉ cần thêm một dòng cho mỗi đối tượng mà chúng ta muốn test vòng đời. Trước tiên, hãy thêm một function cho phép chúng ta xác thực rằng một đối tượng được giải phóng sau khi chúng ta thực thi một block mà caller cung cấp. Điều này sẽ hữu ích cho các tình huống trong đó bạn có một thuộc tính instance đang giữ đối tượng của bạn.
 1 extension XCTestCase {
 2     func assertNil(_ subject: AnyObject?, after: @escaping () -> Void, file: StaticString = #file, line: UInt = #line) {
 3         guard let value = subject else {
 4             return XCTFail("Argument must not be nil", file: file, line: line)
 5         }
 6 
 7         addTeardownBlock { [weak value] in
 8             after()
 9             XCTAssert(value == nil, "Expected subject to be nil after test! Retain cycle?", file: file, line: line)
10         }
11     }
12 }
Dòng 3-5 thực hiện một chút kiểm tra. Nếu đối tượng subject truyền vào nil thì sẽ trả ra thất bại. Các dòng 7-9 là một closure được gọi sau khi test đã được chạy Dòng 7 là nơi tham chiếu yếu đến đối tượng value Dòng 8 là nơi chúng ta thực hiện closure after() Dòng 9 là nơi chúng ta thực hiện xác nhận rằng tham chiếu yếu của chúng tôi không có
Khi sử dụng helper function, unit test của chúng ta trở thành:
final class SampleTests: XCTestCase {
    var sut: Greeter!

    override func setUp() {
        super.setUp()
        sut = Greeter()
        assertNil(sut, after: { self.sut = nil })
    }

    func testGreeting() {
        XCTAssertEqual(sut.greet("Paul"), "Hello Paul")
    }
}
Trong các trường hợp chúng ta không có thuộc tính instance giữ đối tượng của mình, chúng ta có thể viết một hàm đơn giản hơn:
extension XCTestCase {
    func assertNilAfterTest(_ subject: AnyObject?, file: StaticString = #file, line: UInt = #line) {
        assertNil(subject, after: {}, file: file, line: line)
    }
}
Đoạn code trên hoạt động vì nếu không có gì giữ đối tượng của chúng ta bên ngoài scope của test function, nó sẽ tự động được giải phóng bởi thực tế là tham chiếu mạnh duy nhất đã được giải phóng khi kết thúc scope. Điều này cho phép việc test thậm chí còn đơn giản hơn:
final class SampleTests: XCTestCase {
    func testGreeting() {
        let sut = Greeter()
        assertNilAfterTest(sut)
        XCTAssertEqual(sut.greet("Paul"), "Hello Paul")
    }
}

Kết luận

Hai helper functions trên tạo nên một API đơn giản, hy vọng sẽ hữu ích trong việc giúp phát hiện retain cycle trước khi chúng trở thành một vấn đề thực sự. Đoạn code trên hy vọng đủ đơn giản để hiểu và không cần chỉnh sửa quá nhiều các bài test hiện có (no subclassing etc).
Hy vọng bài viết trên sẽ hữu ích với bạn, bài viết được dịch từ: https://paul-samuels.com/blog/2018/11/20/unit-testing-retain-cycles/

Comments

Popular posts from this blog

RxSwift - Giới thiệu

Bạn có nghe qua về Reactive Programming chưa, đây là một khái niệm lập trình hoàn toàn mới. “Reactive Programming là lập trình theo hướng bất đồng bộ các dòng chảy dữ liệu(data streams)” Sau khi đọc khái niệm các bạn có lẽ rất mơ hồ, vậy các data streams là gì. Vậy để mình ví dụ cho các bạn: - Trong lập trình bình thường ( imperative programming ) a = b + c , tức a được gắn với kết quả cộng của b và c .Khi b với c thay đổi thì tất nhiên sẽ không ảnh hưởng tới a, nhưng trong Reactive Programming này a sẽ tự động thay đổi khi b hoặc c thay đổi, kết quả của a sẽ lập tức thay đổi theo. Vậy tại sao nên dùng RXSwift: + Giúp ứng dụng của bạn hoạt động 1 cách như là real time update ui khi có thay đổi data flow, mang đến trải nghiệm tuyệt vời cho User. + Dễ dàng lập trình bất đồng bộ (Async) thay vì phải dùng : callbacks, delegates, notifications, kvo… Bạn phải dùng nhiều thứ gây ra ứng dụng của bạn phức tạp, khó kiểm soát. + Chuyển đổi các thread khi thực hiện 1 cách...

Swift GCD part 1: Thread safe singletons

Preview Singletons are entities, referenced to the same instance of a class from everywhere in your code. It doesn't matter if you like them or not, you will definitely meet them, so it's better to understand how they work. Constructing and handling a set of data doesn't seem to be a big challenge at first glance. The problems appear when you try to optimise the user experience with background work and your app starts acting weird. ??‍♂️ After decades of watching your display mostly with a blank face, you finally realize that your data isn't handled consistently by the manager because you're accessing it (running tasks on it) from multiple threads at the same time. So you really do have to deal with making your singletons thread safe. This article series is dedicated to thread handling using Swift. In the first part below you will get a comprehensive insight into som...

Enum Initializers

In Swift Talk 45 , we wrote a small library for parsing routes. We represented routes as enums, and added a custom initializer to parse routes: enum Route { case home case users(id: Int ) } extension Route { init ?(path: String ) { if path == "/" { self = .home } else if path.hasPrefix( "/users" ) { self = .users(id: 1 ) } else { return nil } } } Of course, this code isn’t complete (see the full public episode for that). Today, we want to focus on assigning to self inside the initializer. In the initializer of any struct or enum we can treat self as a mutable variable (as if it were declared using inout ). This is why we can do the following: enum Result < A > { case success( A ) case error( Error ) } extension Result { init ( _ value: A ) { self = .success(value) } } We can even do this in a struct, although it’s easie...