dotSwift - From Problem to Solution

from 
problem
to
solution
soroush khanlou
dotSwift 2019
@khanlou

final class NetworkClient {
let session = URLSession.shared
func send<Output: Codable>(request: Request<Output>) -> Promise<Output> {
let urlRequest = URLRequestBuilder(request: request).urlRequest
return session.data(with: urlRequest)
.then({ data, response in
guard (200..<300).contains(response.statusCode) else {
throw StatusCodeError(statusCode: response.statusCode)
}
return try JSONDecoder().decode(Output.self, from: data)
})
}
}

how do we know it’s testable?

let session: URLSessionProtocol = URLSession.shared
}
})
}
}

let session: URLSessionProtocol
init(session: URLSessionProtocol = URLSession.shared) {
self.session = session
}
}
})
}
}

good code never
gets to stay good

what happens when we
try to add a feature?

var urlRequest = URLRequestBuilder(request: request).urlRequest
if let authToken = UserDefaults.standard.string(forKey: "authToken") {
urlRequest.addValue(authToken, forHTTPHeaderField: "X-Auth-Token")
}
}
})
}
}

}
var identifier: UIBackgroundTaskIdentifier?
identifier = UIApplication.shared.beginBackgroundTask(expirationHandler: {
if let identifier = identifier {
UIApplication.shared.endBackgroundTask(identifier)
}
})
}
})
.always({

}
}
})
}
})
.always({
}
})
}
}

class RequestCounter {
static let shared = RequestCounter()
var counter = 0 {
didSet {
UIApplication.shared.isNetworkActivityIndicatorVisible = counter == 0
}
}
}
}
}
})

}
}
})
RequestCounter.shared.counter += 1
}
})
.always({
}
RequestCounter.shared.counter -= 1
})
}
}

var counter = 0 {
didSet {
UIApplication.shared.isNetworkActivityIndicatorVisible = counter !== 0
}
}
}
func send<Output: Codable>(request: Request<Output>) !-> Promise<Output> {
}
}
})
guard (200!!..<300).contains(response.statusCode) else {
}
})
.always({
}
})
}
}
}
})
}
}

single responsibility principle

var counter = 0 {
didSet {
UIApplication.shared.isNetworkActivityIndicatorVisible = counter !== 0
}
}
}
}
}
})
}
})
.always({
}
})
}
}

}
}
})
}
})
.always({
}
})
}
}

let application = UIApplication.shared
}
identifier = application.beginBackgroundTask(expirationHandler: {
application.endBackgroundTask(identifier)
}
})
}
})
.always({
}
})
}
}

let defaults = UserDefaults.standard
if let authToken = defaults.string(forKey: "authToken") {
}
}
})
}
})
.always({
}
})
}
}

let counter = RequestCounter.shared
}
}
})
counter.counter += 1
}
})
.always({
}
counter.counter -= 1
})
}
}

}
}
})

let application: UIApplicationProtocol = UIApplication.shared
}
}
})

let defaults: UserDefaultsProtocol = UserDefaults.standard
}
}
})

let defaults: UserDefaultsProtocol = UserDefaults.standard
let counter: RequestCounterProtocol = RequestCounter.shared
}
}
})

let session: URLSessionProtocol
let application: UIApplicationProtocol
let defaults: UserDefaultsProtocol
let counter: RequestCounterProtocol
init(session: URLSessionProtocol = URLSession.shared, application:
UIApplicationProtocol = UIApplication.shared, defaults: UserDefaultsProtocol =
UserDefaults.standard, counter: RequestCounterProtocol = RequestCounter.shared) {
self.session = session
self.application = application
self.defaults = defaults
self.counter = counter
}
}

you don’t have to live like this!

step 1 - find the similarities in the problem
step 2 - develop the abstraction
step 3 - build commonalities and tools
step 4 - extract
step 5 - reap the benefits

}
}
})
}
})
.always({
}
})
}
}
by time

}
}
})
}
})
.always({
}
})
}
}
by time
headers - before - after

let headers = Headers()
let before = Before()
let after = After()
}
}
})
}
})
.always({
}
})
}
}
by time

let after = After()
headers.add(urlRequest)
}
})
}
})
.always({
}
})
}
}
by time

let after = After()
before.execute()
}
})
.always({
}
})
}
}
by time

let after = After()
before.execute()
}
})
.always({
after.execute()
})
}
}
by time

we have a problem here,
which is that before and after
rely on a piece of state, identifier

let after = After()
}
}
})
}
})
.always({
}
})
}
}
by time

what other ways can we slice up our code?

final class NetworkClient { // by time
}
}
})
}
})
.always({
}
})
}
}
by time

final class NetworkClient { // by time
}
}
})
}
})
.always({
}
})
}
}
final class NetworkClient { // by responsibility
}
}
})
}
})
.always({
}
})
}
}
by time by responsibility

}
}
})
}
})
.always({
}
})
}
}
by responsibility

}
}
})
}
})
.always({
}
})
}
}
by responsibility
auth token - backgrounding - counter

let authToken = AuthToken()
let counter = Counter()
let backgrounding = Backgrounding()
}
}
})
}
})
.always({
}
})
}
}
by responsibility

authToken.add(to: urlRequest)
}
})
}
})
.always({
}
})
}
}
by responsibility

backgrounding.prepare()
 
}
})
.always({
}
})
}
}
by responsibility

 
}
})
.always({
backgrounding.release()
})
}
}
by responsibility

 
counter.increment()
}
})
.always({
})
}
}
by responsibility

 
counter.increment()
}
})
.always({
counter.decrement()
})
}
}
by responsibility

counter.increment()
}
})
.always({
counter.decrement()
})
}
}

counter.increment()
}
})
.always({
counter.decrement()
})
}
}
headers

counter.increment()
}
})
.always({
counter.decrement()
})
}
}
headers
before

counter.increment()
}
})
.always({
counter.decrement()
})
}
}
headers
before
after

authToken.addHeaders(to: urlRequest)
counter.increment()
}
})
.always({
counter.decrement()
})
}
}
headers
before
after

backgrounding.before()
counter.increment()
}
})
.always({
counter.decrement()
})
}
}
headers
before
after

counter.before()
}
})
.always({
counter.decrement()
})
}
}
headers
before
after

counter.before()
}
})
.always({
backgrounding.after()
counter.decrement()
})
}
}
headers
before
after

counter.before()
}
})
.always({
counter.after()
})
}
}
headers
before
after

counter.before()
}
})
.always({
counter.after()
})
}
}

protocol RequestSideEffect {
func addHeaders(to request: URLRequest)
func before()
func after()
}

protocol RequestBehavior {
func addHeaders(to request: URLRequest)
func before()
func after()
}

let authToken: RequestBehavior = AuthToken()
let counter: RequestBehavior = Counter()
let backgrounding: RequestBehavior = Backgrounding()
counter.before()
}
})
.always({
counter.after()
})
}
}

let behaviors: [RequestBehavior] = [AuthToken(), Counter(), Backgrounding()]
counter.before()
}
})
.always({
counter.after()
})
}
}

behaviors.forEach({ $0.addHeaders(to: urlRequest) })
counter.before()
}
})
.always({
counter.after()
})
}
}

behaviors.forEach({ $0.before() })
}
})
.always({
counter.after()
})
}
}

behaviors.forEach({ $0.before() })
}
})
.always({
behaviors.forEach({ $0.after() })
})
}
}

var additionalHeaders: [String: String] { get }
func before()
func after()
}

func beforeSend()
func after()
}

func beforeSend()
func afterSuccess(result: AnyResponse)
func afterFailure(error: Error)
} // comment

extension RequestBehavior {
}
func beforeSend()
} // comment

var additionalHeaders: [String: String] { return [:] }
}
func beforeSend()
} // comment

func beforeSend() { }
}
func beforeSend()
} // comment

func afterSuccess(result: AnyResponse) { }
}
func beforeSend()
} // comment

func afterSuccess(result: AnyResponse) { }
func afterFailure(error: Error) { }
}
func beforeSend()
} // comment

a word on “don’t repeat yourself”

similar code dissimilar code
similar underlying
concepts
dissimilar underlying
concepts

similar underlying
concepts
concepts
most code

similar underlying
concepts
probably already
“abstracted”
concepts
most code

similar underlying
concepts
probably already
“abstracted”
concepts
a world of pain
(false positive)
most code

similar underlying
concepts
probably already
“abstracted”
ripe for abstraction 
(false negative)
concepts
a world of pain
(false positive)
most code

– sandi metz
“duplication is far cheaper than
the wrong abstraction”

struct CombinedRequestBehavior: RequestBehavior {
let behaviors: [RequestBehavior]
var additionalHeaders: [String : String] {
return behaviors.reduce([String: String](), { sum, behavior in
return sum.merging(behavior.additionalHeaders, uniquingKeysWith: { $0 })
})
}
func beforeSend() {
behaviors.forEach({ $0.beforeSend() })
}
func afterSuccess(result: AnyResponse) {
behaviors.forEach({ $0.afterSuccess(result: result) })
}
func afterFailure(error: Error) {
behaviors.forEach({ $0.afterFailure(error: error) })
}
}

with CombinedRequestBehavior,
you can treat arrays like regular objects

}
let result = try JSONDecoder().decode(Output.self, from: data)
behaviors.forEach({ $0.afterSuccess(result) })
return result
})
.catch({ error in
behaviors.forEach({ $0.afterFailure(error) })
})
}
}

let behavior = CombinedRequestBehavior([AuthToken(), Counter(), Backgrounding()])
}
return result
})
.catch({ error in
})
}
}

behavior.addHeaders(to: urlRequest)
}
return result
})
.catch({ error in
})
}
}

behavior.beforeSend()
}
return result
})
.catch({ error in
})
}
}

}
behavior.afterSuccess(result)
return result
})
.catch({ error in
})
}
}

}
behavior.afterSuccess(result)
return result
})
.catch({ error in
behavior.afterFailure(error)
})
}
}

final class AuthTokenHeaderBehavior: RequestBehavior {
let userDefaults = UserDefaults.standard
var additionalHeaders: [String: String] {
if let token = userDefaults.string(forKey: "authToken") {
return ["X-Auth-Token": token]
} else {
return [:]
}
}
}

final class NetworkActivityIndicatorBehavior: RequestBehavior {
// ...
}

final class BackgroundTaskBehavior: RequestBehavior {
// ...
}

decoupling
decoupling is important because it allows you to
build strong boundaries, which allows you to
handle separate components separately

what do i mean 
by “handle”?

final class ErrorLogger: RequestBehavior {
let logger = Logger.default
func afterFailure(error: Error) {
logger.error(“Request failed: (error)")
}
}

“There is no abstract art. You must
always start with something.
Afterward you can remove all
traces of reality.” – Pablo Picasso

dotSwift - From Problem to Solution

dotSwift - From Problem to Solution

More Related Content

What's hot

Similar to dotSwift - From Problem to Solution

Recently uploaded

dotSwift - From Problem to Solution