Swift Language
प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग के साथ शुरुआत करना

टिप्पणियों

यूनिट टेस्टिंग के लिए लीवरेजिंग प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग

प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग हमारे कोड के लिए बेहतर यूनिट टेस्ट आसानी से लिखने के लिए एक उपयोगी उपकरण है।

मान लें कि हम एक UIViewController का परीक्षण करना चाहते हैं जो एक ViewModel वर्ग पर निर्भर करता है।

उत्पादन कोड पर आवश्यक कदम हैं:

1. एक प्रोटोकॉल को परिभाषित करें जो यूविविओट्रोलर द्वारा आवश्यक सभी गुणों और विधियों के साथ वर्ग ViewModel के सार्वजनिक इंटरफ़ेस को उजागर करता है।
2. उस प्रोटोकॉल के अनुरूप वास्तविक ViewModel वर्ग को लागू करें।
3. एक नियंत्रक इंजेक्शन तकनीक का प्रयोग करें ताकि हम उस दृश्य नियंत्रक का उपयोग कर सकें जो हम चाहते हैं कि इसे प्रोटोकॉल के रूप में पारित किया जाए और ठोस उदाहरण नहीं।

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")

फिर, इकाई परीक्षण पर:

1. एक नकली ViewModel को लागू करें जो एक ही प्रोटोकॉल के अनुरूप है
2. वास्तविक उदाहरण के बजाय, निर्भरता इंजेक्शन का उपयोग करके परीक्षण के तहत इसे UIViewController को पास करें।
3. परीक्षा!

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)
    }
}

प्रथम श्रेणी प्रकार के रूप में प्रोटोकॉल का उपयोग करना

प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग का उपयोग कोर स्विफ्ट डिज़ाइन पैटर्न के रूप में किया जा सकता है।

विभिन्न प्रकार एक ही प्रोटोकॉल के अनुरूप करने में सक्षम हैं, मूल्य प्रकार भी कई प्रोटोकॉल के अनुरूप हो सकते हैं और यहां तक कि डिफ़ॉल्ट विधि कार्यान्वयन भी प्रदान कर सकते हैं।

प्रारंभ में प्रोटोकॉल परिभाषित किए गए हैं जो आमतौर पर उपयोग किए गए गुणों और / या विशिष्ट या सामान्य प्रकारों के साथ विधियों का प्रतिनिधित्व कर सकते हैं।

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)
}

प्राप्त विधि के लिए एक डिफ़ॉल्ट कार्यान्वयन बनाया जा सकता है, हालांकि यदि वांछित अनुरूप प्रकार कार्यान्वयन को ओवरराइड कर सकते हैं।

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 { }

एक मान प्रकार जो आइटमडेटा प्रोटोकॉल के अनुरूप है, यह मान प्रकार भी अन्य प्रोटोकॉल के अनुरूप है।

struct Item: ItemData {
    
    let title: String
    let description: String
    let thumbnailURL: NSURL
    let created: NSDate
    let updated: NSDate
    
}

यहां आइटम संरचना को प्रदर्शन आइटम के अनुरूप बढ़ाया जाता है।

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())
    }
}

स्थैतिक पाने की विधि का उपयोग करने के लिए एक उदाहरण कॉल साइट।

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
    })
    
}

विभिन्न उपयोग के मामलों को अलग-अलग कार्यान्वयन की आवश्यकता होगी। यहां मुख्य विचार विभिन्न प्रकारों से अनुरूपता दिखाना है जहां प्रोटोकॉल डिजाइन में फोकस का मुख्य बिंदु है। इस उदाहरण में शायद एपीआई डेटा को कोर डेटा इकाई के लिए सशर्त रूप से सहेजा गया है।

// 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
}

यहां कोर डेटा समर्थित वर्ग भी 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)
        }
        
    }
}