Swift Language
Comenzando con la Programación Orientada al Protocolo
Buscar..
Observaciones
Para obtener más información sobre este tema, consulte la Programación orientada a protocolos de WWDC 2015 talk en Swift .
También hay una gran guía escrita sobre el mismo: Introducción a la programación orientada a protocolos en Swift 2 .
Aprovechamiento de la programación orientada al protocolo para pruebas unitarias
La programación orientada al protocolo es una herramienta útil para escribir fácilmente mejores pruebas unitarias para nuestro código.
Digamos que queremos probar un UIViewController que se basa en una clase ViewModel.
Los pasos necesarios en el código de producción son:
- Defina un protocolo que exponga la interfaz pública de la clase ViewModel, con todas las propiedades y métodos que necesita el UIViewController.
- Implementar la clase de ViewModel real, de acuerdo con ese protocolo.
- Use una técnica de inyección de dependencia para permitir que el controlador de vista use la implementación que queremos, pasándola como protocolo y no como instancia concreta.
protocol ViewModelType {
var title : String {get}
func confirm()
}
class ViewModel : ViewModelType {
let title : String
init(title: String) {
self.title = title
}
func confirm() { ... }
}
class ViewController : UIViewController {
// We declare the viewModel property as an object conforming to the protocol
// so we can swap the implementations without any friction.
var viewModel : ViewModelType!
@IBOutlet var titleLabel : UILabel!
override func viewDidLoad() {
super.viewDidLoad()
titleLabel.text = viewModel.title
}
@IBAction func didTapOnButton(sender: UIButton) {
viewModel.confirm()
}
}
// With DI we setup the view controller and assign the view model.
// The view controller doesn't know the concrete class of the view model,
// but just relies on the declared interface on the protocol.
let viewController = //... Instantiate view controller
viewController.viewModel = ViewModel(title: "MyTitle")
Luego, en la prueba de la unidad:
- Implementar un modelo de vista simulado que se ajuste al mismo protocolo.
- Páselo al UIViewController en prueba utilizando la inyección de dependencia, en lugar de la instancia real.
- ¡Prueba!
class FakeViewModel : ViewModelType {
let title : String = "FakeTitle"
var didConfirm = false
func confirm() {
didConfirm = true
}
}
class ViewControllerTest : XCTestCase {
var sut : ViewController!
var viewModel : FakeViewModel!
override func setUp() {
super.setUp()
viewModel = FakeViewModel()
sut = // ... initialization for view controller
sut.viewModel = viewModel
XCTAssertNotNil(self.sut.view) // Needed to trigger view loading
}
func testTitleLabel() {
XCTAssertEqual(self.sut.titleLabel.text, "FakeTitle")
}
func testTapOnButton() {
sut.didTapOnButton(UIButton())
XCTAssertTrue(self.viewModel.didConfirm)
}
}
Usando protocolos como tipos de primera clase.
La programación orientada a protocolos se puede utilizar como un patrón de diseño Swift central.
Los diferentes tipos pueden ajustarse al mismo protocolo, los tipos de valor pueden incluso adaptarse a múltiples protocolos e incluso proporcionar la implementación del método predeterminado.
Inicialmente, se definen protocolos que pueden representar propiedades y / o métodos de uso común con tipos específicos o genéricos.
protocol ItemData {
var title: String { get }
var description: String { get }
var thumbnailURL: NSURL { get }
var created: NSDate { get }
var updated: NSDate { get }
}
protocol DisplayItem {
func hasBeenUpdated() -> Bool
func getFormattedTitle() -> String
func getFormattedDescription() -> String
}
protocol GetAPIItemDataOperation {
static func get(url: NSURL, completed: ([ItemData]) -> Void)
}
Se puede crear una implementación predeterminada para el método get, aunque si se desea, los tipos conformes pueden anular la implementación.
extension GetAPIItemDataOperation {
static func get(url: NSURL, completed: ([ItemData]) -> Void) {
let date = NSDate(
timeIntervalSinceNow: NSDate().timeIntervalSince1970
+ 5000)
// get data from url
let urlData: [String: AnyObject] = [
"title": "Red Camaro",
"desc": "A fast red car.",
"thumb":"http://cars.images.com/red-camaro.png",
"created": NSDate(), "updated": date]
// in this example forced unwrapping is used
// forced unwrapping should never be used in practice
// instead conditional unwrapping should be used (guard or if/let)
let item = Item(
title: urlData["title"] as! String,
description: urlData["desc"] as! String,
thumbnailURL: NSURL(string: urlData["thumb"] as! String)!,
created: urlData["created"] as! NSDate,
updated: urlData["updated"] as! NSDate)
completed([item])
}
}
struct ItemOperation: GetAPIItemDataOperation { }
Un tipo de valor que se ajusta al protocolo ItemData, este tipo de valor también puede ajustarse a otros protocolos.
struct Item: ItemData {
let title: String
let description: String
let thumbnailURL: NSURL
let created: NSDate
let updated: NSDate
}
Aquí la estructura del elemento se amplía para ajustarse a un elemento de visualización.
extension Item: DisplayItem {
func hasBeenUpdated() -> Bool {
return updated.timeIntervalSince1970 >
created.timeIntervalSince1970
}
func getFormattedTitle() -> String {
return title.stringByTrimmingCharactersInSet(
.whitespaceAndNewlineCharacterSet())
}
func getFormattedDescription() -> String {
return description.stringByTrimmingCharactersInSet(
.whitespaceAndNewlineCharacterSet())
}
}
Un sitio de llamada de ejemplo para usar el método estático de obtención.
ItemOperation.get(NSURL()) { (itemData) in
// perhaps inform a view of new data
// or parse the data for user requested info, etc.
dispatch_async(dispatch_get_main_queue(), {
// self.items = itemData
})
}
Diferentes casos de uso requerirán diferentes implementaciones. La idea principal aquí es mostrar la conformidad de diversos tipos en los que el protocolo es el punto principal del enfoque en el diseño. En este ejemplo, tal vez los datos de la API se guardan condicionalmente en una entidad de Datos Core.
// the default core data created classes + extension
class LocalItem: NSManagedObject { }
extension LocalItem {
@NSManaged var title: String
@NSManaged var itemDescription: String
@NSManaged var thumbnailURLStr: String
@NSManaged var createdAt: NSDate
@NSManaged var updatedAt: NSDate
}
Aquí, la clase respaldada por Core Data también puede ajustarse al protocolo DisplayItem.
extension LocalItem: DisplayItem {
func hasBeenUpdated() -> Bool {
return updatedAt.timeIntervalSince1970 >
createdAt.timeIntervalSince1970
}
func getFormattedTitle() -> String {
return title.stringByTrimmingCharactersInSet(
.whitespaceAndNewlineCharacterSet())
}
func getFormattedDescription() -> String {
return itemDescription.stringByTrimmingCharactersInSet(
.whitespaceAndNewlineCharacterSet())
}
}
// In use, the core data results can be
// conditionally casts as a protocol
class MyController: UIViewController {
override func viewDidLoad() {
let fr: NSFetchRequest = NSFetchRequest(
entityName: "Items")
let context = NSManagedObjectContext(
concurrencyType: .MainQueueConcurrencyType)
do {
let items: AnyObject = try context.executeFetchRequest(fr)
if let displayItems = items as? [DisplayItem] {
print(displayItems)
}
} catch let error as NSError {
print(error.localizedDescription)
}
}
}