Unit Tests Memory Leaks in Swift. Write readable tests for mem leaks easily with these Quick and Nimble extensions.
Clone or download
leandromperez Updated pods, fixed test (#6)
0.1.2 Updated Pods, Fixed test
Latest commit e42feb1 Nov 29, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Example Updated pods, fixed test (#6) Nov 28, 2018
SpecLeaks 0.1.1 Hotfix: Added missing files Aug 2, 2018
.gitignore Added project Apr 29, 2018
LICENSE Added project Apr 29, 2018
README.md Added project Apr 29, 2018
SpecLeaks.podspec Updated pods, fixed test (#6) Nov 28, 2018
_Pods.xcodeproj Added project Apr 29, 2018

README.md

SpecLeaks

Version License Platform

Create Unit Tests for Memory Leaks in Swift.

  • SpecLeaks allows you to create tests using Quick and Nimble.
  • Write readable tests for mem leaks easily with these Quick and Nimble extensions.

Quick and Nimble is a Unit Testing framework that allows you to write tests in a more humanly readable fashion.

What can you Test?

  • Test if an object is leaking when it is initialized.
  • Test if a ViewController is leaking when its view is loaded.
  • Test if a particular method is leaking

Installation

SpecLeaks is available through CocoaPods. To install it, simply add the following line to your Podfile:

pod 'SpecLeaks'

Example Project

The example project contains a few Unit Tests that will let you understand how to use SpecLeaks.

To run the example project, clone the repo, and run pod install from the Example directory first.

Command+U to run the sample tests.

How to Write Tests

  1. Create a Spec
  2. Define a it("action") block
  3. Create a LeakTest passing a block that returns the object you want to test
  4. Write your expectations using toNot(leak()) or toNot(leakWhen())

Memory Leaks in initialization of plain Objects

class SomeObject {}

class SomeOjectTests: QuickSpec {
    override func spec() {
        describe("SomeObject") {
            describe("init") {
                it("must not leak"){
                    let someObject = LeakTest{
                        return SomeObject()
                    }

                    expect(someObject).toNot(leak())
                }
            }
        }
    }
}

Memory Leaks in viewDidLoad or init of a a UIViewController

class SomeViewController : UIViewController {}

class SomeViewControllerTests: QuickSpec {

    override func spec() {
        describe("SomeViewController"){
            describe("viewDidLoad") {
                let vc = LeakTest{
                    return SomeViewController()
                }
                it("must not leak"){
                    expect(vc).toNot(leak())
                }
            }
        }
    }
}

Memory Leaks when an action is called

class SomeObject{
    func doSomething(){

    }
}

class SomeOjectTests: QuickSpec {
    override func spec() {
        describe("SomeObject") {
            describe("doSomething") {
                it("must not leak"){

                    let someObject = LeakTest{
                        return SomeObject()
                    }

                    let doSomethingIsCalled : (SomeObject) -> ()  = {obj in
                         obj.doSomething()
                    }

                    expect(someObject).toNot(leakWhen(doSomethingIsCalled))
                }
            }
        }
    }
}

Author

leandromperez@gmail.com, leandromperez@gmail.com

License

SpecLeaks is available under the MIT license. See the LICENSE file for more info.