iOS测试开发：Swift中的TDD和BDD实践

需积分: 8 149 浏览量更新于2024-07-19 收藏 11.76MB PDF 举报

"iOS Code Testing.pdf 是一本面向iOS开发者的测试开发书籍，主要探讨了使用Swift进行测试驱动开发（TDD）和行为驱动开发（BDD）的实践方法。作者Abhishek Mishra通过本书分享了他的专业经验，旨在帮助开发者提高代码质量和应用程序的稳定性。在书中，作者首先介绍了测试在iOS应用开发中的重要性，强调了TDD和BDD作为最佳实践，如何能够帮助开发者编写出更健壮、可维护的代码。TDD是一种软件开发方法，其中编写测试用例是开发过程的第一步，代码则根据这些测试来编写，确保功能的正确性。BDD则更注重于业务需求和用户行为，通过定义预期的行为来驱动代码的设计和实现。 Abhishek Mishra详细阐述了如何在Swift环境中设置和执行单元测试，包括使用Xcode的内置测试框架，以及可能涉及到的第三方测试工具，如Specta和Expecta。他还讨论了模拟对象和依赖注入的概念，这些对于隔离测试和保持测试独立性至关重要。书中还深入讲解了集成测试和端到端测试，这是确保应用不同组件协同工作并满足整个用户体验的关键。此外，作者还涵盖了持续集成（CI）和持续部署（CD）的概念，这对于大型项目和团队协作的效率提升有着显著影响。行为驱动开发部分，作者介绍了Cucumber和Gherkin等工具，它们允许非技术人员（如产品经理或客户）以自然语言编写测试场景，提高了沟通效率并确保了开发目标的一致性。书中可能还会包含一些实战案例，通过具体的项目例子展示如何将TDD和BDD的理论应用到实际的iOS应用开发中。最后，作者可能会提供一些最佳实践和技巧，帮助开发者形成良好的测试习惯，避免常见的测试陷阱。 iOS Code Testing.pdf 是一本深入浅出的iOS测试指南，适合有一定Swift基础的iOS开发者阅读，它将帮助读者提升测试技能，打造更高品质的iOS应用。"

xix

Acknowledgments

This book would not have been possible without the support of the team at Apress

including Aaron Black and Jessica Vakili. I would also like to thank Chaim Krause for

taking the time to read the entire manuscript and his keen eye for detail. It has been my

privilege to work with you. Thank you.

A. Mishra, iOS Code Testing, DOI 10.1007/978-1-4842-2689-6_1

CHAPTER 1

Introduction to Test-Driven

Development

Well over a billion apps have been developed for the iOS platform since its inception.

Most of the early apps were rather simple and often developed by a single developer.

Over the years, iOS apps have become increasingly complex pieces of software that

often involve large, distributed teams of developers working in Agile environments with

complex build and release pipelines.

Modern apps often perform several complex operations including (but not limited to)

presenting a complex user interface, multithreading, storing data in local databases,

interfacing with multiple sensors, media recording and playback, and consuming

RESTful web API’s.

With such a complex interplay between components of an app and several thousand

lines of source code spread across several hundred classes, how do we know for certain

that the code we have written does what we think it does? How do we know that our

code can handle edge scenarios? And finally, how do we know that we have built the

right software that meets business requirements? The answer to the first two questions

is addressed by the practice of unit testing, and Behavior-Driven Development (BDD)

addresses the answer to the question of building the right software in the first place. BDD

is covered in Chapter 10. In this chapter and the next one you will learn about unit testing,

and the related discipline of Test-Driven Development (TDD).

What Is Test-Driven Development?

Test Driven Development (TDD) has its roots in a programming paradigm called Extreme

Programming

(XP), created by Kent Beck in 1996. The use of the word “extreme” signifies

a radical departure from standard programming practices of that time.

TDD is designed to provide developers with a tangible way to prove that the code

they have written does what they think it does, and to provide some confidence that the

new code that has been written does not cause any potential side effects with existing

code.

www.ebook3000.com

CHAPTER 1 ■ INTRODUCTION TO TEST-DRIVEN DEVELOPMENT

Central to the TDD approach is the concept that a developer not only writes actual

code to carry out the app’s functionality but also tests code that ensures his application’s

code does what it is supposed to do. The test code is not shipped with the product.

While writing test code in addition to code that carries out the app’s intended

functionality is indeed extra work, it should be seen as an up-front investment toward

improving the quality of the product that ships to customers. A team that practices TDD

techniques will, over time, observe a reduction in the number of regression defects.

■ Note TDD is often used interchangeably with the term Unit Test; however, these two

terms are not the same thing. TDD is an approach to software development where the test

code is written first: in essence, the tests drive development.

A unit test is just a piece of test code viewed in isolation. A unit test is one of the by-

products of adopting a TDD approach.

However, the mere existence of one or more unit tests does not necessarily imply

that the developer followed a TDD approach. The unit tests could, for instance, have been

fitted retrospectively to existing code.

If you find working on large problems overwhelming, you may find TDD to be a

useful technique to break down a problem into smaller ones, use tests to solve the smaller

problems, and in the process end up solving the larger problem. You will soon realize that

large problems are not as overwhelming once you approach them with a TDD mindset.

TDD Terminology

This section examines some of the common terminology associated with Test-Driven

Development.

Subject under Test

This is usually a piece of code, or unit of functionality you wish to test. In most situations

the subject under test is usually a single method of a Swift class. However, you may

encounter scenarios where a small group of methods or classes are being tested together.

In such cases, the subject under test usually represents a complete functionality or user

journey. The subject under test is sometimes also known as the system under test.

Unit Test

This is the piece of code that tests the subject under test. A unit test is also known as a

“test case.” Unit tests work by calling the subject under test under controlled conditions,

and verifying some kind of expected behavior. It is common for an application to have

hundreds of unit tests with each test testing a very small piece of the functionality.

Individual unit tests are implemented as independent methods of a Swift class that

derives from an XCTestCase. This Swift class is also commonly referred to as a test class.

CHAPTER 1 ■ INTRODUCTION TO TEST-DRIVEN DEVELOPMENT

In most cases you will create one test class for each class you wish to test. The XCTestCase

class is part of the XCTest framework, and the framework must be imported with an import

statement. The following code listing contains a simple test class with one unit test:

import XCTest

@testable import LoginService

class LoginServiceTests: XCTestCase {

func testExample() {

// insert test code here.

}

■ Note The code that forms these unit tests is not part of the code base that will ship

to the clients. Unit tests are typically executed every time a developer attempts to create a

build, with the build being created only if all tests pass.

The method signature of a unit test is similar to that of a method that takes no

arguments and does not return a value. However, the name of a unit test method always

begins with the keyword “test.” There are usually strict naming conventions followed for

unit test methods; these will be discussed in the next lesson.

State Verification Test

A state verification test is a type of unit test that calls methods on an object (subject under

test) and verifies the state of the object after calling the method. Such tests do not care

about implementation detail and will continue to pass even if the internal workings of

the methods being tested are changed in the future. State verification tests usually rely on

assertions to carry out the actual verification. Assertions are covered later in this lesson.

Interaction Test

An interaction test is a type of unit test that attempts to verify a specific sequence of

interactions between objects when a method is called. Such tests are also known as

behavior verification tests. Interaction tests do not necessarily have to involve multiple

objects. You could also use an interaction test to verify the sequence of calls to methods of

the same object.

In a complex object-oriented system, a single object may need to interact with several

other objects when a method is called. When it comes to interaction tests, the subject under

www.ebook3000.com

CHAPTER 1 ■ INTRODUCTION TO TEST-DRIVEN DEVELOPMENT

test is still a single class, and not the entire group of classes. One typically instantiates the

subject under test and uses special mock or stub versions of all the other objects involved in

the scope of the interaction test. Mock and stub objects are covered later in this lesson.

■ Note Since interaction tests verify the behavior of a group of classes, they are inherently

more fragile than state verification tests. For instance, a change in the order in which

methods are called could easily break an interaction test. One way to make interaction tests

less brittle is by reducing the number of classes covered by the scope of the test.

Negative Test

A negative unit test is one that verifies something did not happen. This can be useful in

some cases. However, one must never solely rely on negative tests. This is because while

a negative test can verify that something did not happen, it is immune to any number of

things that did happen. The code base could change considerably without have a single

negative test fail. If all your unit tests were negative tests, then your tests collectively are

providing limited value.

Negative unit tests in Swift are almost always state verification tests. Although it is

possible to create negative unit tests that are interaction tests, the relevant setup required

is quite complicated and often outweighs the value of writing the negative test.

As an example of a negative unit test in action, consider the following Swift class that

could be used to represent a bank account:

enum AccountType {

case currentAccount

case savingsAccount

}

class BankAccount {

var accountName:String

var accountNumber:String

var accountType:AccountType

private var transactions:[Transaction]

init(accountName:String,

accountNumber:String,

accountType:AccountType) {

self.accountName = accountName

self.accountNumber = accountNumber

self.accountType = accountType

self.transactions = [Transaction]()

}

剩余448页未读，继续阅读

架构小生

粉丝: 12
资源: 11

iOS测试开发：Swift中的TDD和BDD实践

iOS Code Testing

DevOps技术学习路线图.pdf

ebook-flutter-revolution.pdf

Xcode使用教程详细讲解参考.pdf

Ray Wenderlich - iOS 11 Tutorials

Test-Driven iOS Development with Swift

Mastering Mobile Test Automation pdf

Xcode.7.Essentials.2nd.Editio

Swift.High.Performance.1785282204

python小爬虫.zip

最新资源