public protocol 〇〇ViewModelInputs {
  func viewDidLoad()
}

public protocol 〇〇ViewModelOutputs {
}

public protocol 〇〇ViewModelType {
  var inputs: 〇〇ViewModelInputs { get }
  var outputs: 〇〇ViewModelOutputs { get }
}

public final class 〇〇ViewModel: 〇〇ViewModelType, 〇〇ViewModelInputs, 
   〇〇ViewModelOutputs {
}

class ViewModelTests: XCTestCase {
    let vm: MyViewModelType = MyViewModel()
    let submitButtonEnabled = TestObserver<Bool, NoError>()

    override func setUp() {
        super.setUp()
        self.vm.outputs.submitButtonEnabled.observe(self.submitButtonEnabled.observer)
    }
}

func testSubmitButtonEnabled() {
    self.vm.inputs.viewDidLoad()
    self.submitButtonEnabled.assertValues([false])

    self.vm.inputs.nameChanged(name: "Chris")
    self.submitButtonEnabled.assertValues([false])
}

fileprivate static var stack: [Environment] = [Environment()]

public static var current: Environment! {
  return stack.last
}

override func setUp() {
  super.setUp()

  UIView.doBadSwizzleStuff()
  UIViewController.doBadSwizzleStuff()

  var calendar = Calendar(identifier: .gregorian)
  calendar.timeZone = TimeZone(identifier: "GMT")!

  AppEnvironment.pushEnvironment(
    apiService: self.apiService,
    apiDelayInterval: .seconds(0),
    application: UIApplication.shared,
    assetImageGeneratorType: AVAssetImageGenerator.self,
    cache: self.cache,
    calendar: calendar,
    config: self.config,
    cookieStorage: self.cookieStorage,
    countryCode: "US",
    currentUser: nil,
    dateType: self.dateType,
    debounceInterval: .seconds(0),
    device: MockDevice(),
    is1PasswordSupported: { true },
    isVoiceOverRunning: { false },
    koala: Koala(client: self.trackingClient, loggedInUser: nil),
    language: .en,
    launchedCountries: .init(),
    locale: .init(identifier: "en_US"),
    mainBundle: self.mainBundle,
    pushRegistrationType: MockPushRegistration.self,
    reachability: self.reachability.producer,
    scheduler: self.scheduler,
    ubiquitousStore: self.ubiquitousStore,
    userDefaults: self.userDefaults
  )
}

protocol APIClientProtocol {
  var token: String? { get set }
  func fetchCurrentUser(_ completionHandler: (Result<User, Error>) -> Void)
}

extension APIClient: APIClientProtocol {}

class MockAPIClient: APIClientProtocol {
  var token: String?

  var currentUserResult: Result<User, Error>?
  func fetchCurrentUser(_ completionHandler: (Result<User, Error>) -> Void) {
    completionHandler(self.fetchCurrentUserResult!)
  }
}

struct Environment {
  var api: APIClientProtocol = APIClient.shared
}

protocol APIClientProtocol {
  func fetchItem(_ completionHandler: (Result<Item, Error>) -> Void) -> Void
}

extension APIClient: APIClientProtocol {}

class MockAPIClient: APIClientProtocol {
  var token: String?

  var itemResult: Result<Item, Error>?
  func fetchItem(_ completionHandler: (Result<Item, Error>) -> Void) {
    completionHandler(self.fetchItemResult!)
  }
}

struct Environment {
  var api: APIClientProtocol = APIClient.shared
}

struct API {
  var fetchItem = APIClient.shared.fetchItem
}

struct Environment {
  var api = API()
}

APIClient.shared.fetchItem(byId: Int) { result in
  ...
}

struct API {
  var fetchItemById = APIClient.shared.fetchItem(byId:)
  // …
}

AppEnvironment.current.fetchItemById(1)
// vs.
APIClient.shared.fetchItem(byId: 1)

APIClient.shared.register(
  withId: 1,
  name: "orange",
  price: 100
) { result in
  ...
}
// vs.
AppEnvironment.current.register(1, "orange", 100)

struct API {
  var registerWithIdNamePrice = APIClient.shared.register
  …
}

extension API {
  func register(
    withId id: Int,
    name: String,
    price: Int
    ) {

    self.registerWithIdNamePrice(
      id, name, price
    )
  }
}

AppEnvironment.current.register(withId: 1, name: "orange", price: 100)

class ViewController: UIViewController {
  let api: APIClientProtocol
  let date: () -> Date
  let label = UILabel()

  init(_ api: APIClientProtocol, _ date: () -> Date) {
    self.api = api
    self.date = date
  }

  func explain() {
    self.api.fetchItem { result in
      if let item = result.success {
        self.label.text = "This item is, \(item.name)! Now \(self.date())."
      }
    }
  }
}

class ViewController: UIViewController {
  var api: APIClientProtocol!
  var date: (() -> Date)!
  @IBOutlet var label: UILabel!

  func explain() {
    self.api.fetchItem { result in
      if let item = result.success {
        self.label.text = "This item is, \(item.name)! Now \(self.date())."
      }
    }
  }
}

class ViewController: UIViewController {
  @IBOutlet var label: UILabel!

  func explain() {
    AppEnvironment.current.api.fetchItem { result in
      if let item = result.success {
        self.label.text = "This item is, \(item.name)! Now \(self.date())."
      }
    }
  }
}

func application(_ application: UIApplication,
                 open url: URL,
                 sourceApplication: String?,
                 annotation: Any) -> Bool {

    return self.viewModel.inputs.applicationOpenUrl(application: application,
                                                    url: url,
                                                    sourceApplication: sourceApplication,
                                                    annotation: annotation)
}

internal func application(_ application: UIApplication,
                          didReceiveRemoteNotification userInfo: [AnyHashable: Any]) {

    self.viewModel.inputs.didReceive(remoteNotification: userInfo,
                                     applicationIsActive: application.applicationState == .active)
}

internal func application(_ application: UIApplication,
                          performActionFor shortcutItem: UIApplicationShortcutItem,
                          completionHandler: @escaping (Bool) -> Void) {

    self.viewModel.inputs.applicationPerformActionForShortcutItem(shortcutItem)
    completionHandler(true)
}

import UIKit
import PlaygroundSupport

class MyViewController: UIViewController {
  let rootStackView = UIStackView()
  let submitButton = UIButton()

  override func viewDidLoad() {
    super.viewDidLoad()

    self.submitButton.setTitle("Submit", for: .normal)

    self.view.addSubview(self.rootStackView)
    self.rootStackView.addArrangedSubview(self.submitButton)

    NSLayoutConstraint.activate([
      self.rootStackView.leadingAnchor.constraint(equalTo: self.view.leadingAnchor),
      self.rootStackView.trailingAnchor.constraint(equalTo: self.view.trailingAnchor),
      self.rootStackView.topAnchor.constraint(equalTo: self.view.topAnchor),
      self.rootStackView.bottomAnchor.constraint(lessThanOrEqualTo: self.view.bottomAnchor),
      ])
  }
}

self.submitButton.backgroundColor = .blue
self.submitButton.layer.cornerRadius = 6
self.submitButton.layer.masksToBounds = true

public func playgroundControllers(
  device: Device = .phone4_7inch,
  orientation: Orientation = .portrait,
  child: UIViewController = UIViewController(),
  additionalTraits: UITraitCollection = .init()
)
  -> (parent: UIViewController, child: UIViewController) {
  let parent = UIViewController()
  parent.view.backgroundColor = .white

  child.view.backgroundColor = .white
  child.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]

  parent.addChild(child)
  parent.view.addSubview(child.view)
  child.didMove(toParent: parent)

  child.view.frame = parent.view.frame

  let traits: UITraitCollection
  switch (device, orientation) {
  case (.phone5_5inch, .portrait):
    parent.view.frame = .init(x: 0, y: 0, width: 414, height: 736)
    traits = .init(traitsFrom: [
      .init(horizontalSizeClass: .compact),
      .init(verticalSizeClass: .regular),
      .init(userInterfaceIdiom: .phone)
    ])
    ...
  }
  let allTraits = UITraitCollection.init(traitsFrom: [traits, additionalTraits])
  parent.setOverrideTraitCollection(allTraits, forChild: child)

  return (parent, child)
}

let controller = RewardPledgeViewController
  .configuredWith(project: project, reward: project.rewards.last!)

let (parent, _) = playgroundControllers(device: .phone4_7inch, orientation: .portrait, child: controller)

let frame = parent.view.frame |> CGRect.lens.size.height .~ 800
PlaygroundPage.current.liveView = parent
parent.view.frame = frame