Wrap Search Configs

SampleApp/AutocompleteTableVC.swift

@@ -52,15 +52,15 @@ class AutocompleteTableVC: SampleTableViewController, UISearchResultsUpdating, U
 
   func updateSearchResults(for searchController: UISearchController) {
     if let searchText = searchController.searchBar.text, searchController.searchBar.text?.isEmpty == false {
-      var geoPoint = GeoPoint(latitude: 40.7312973034393, longitude: -73.99896644276561)
+      var geoPoint = Pelias.GeoPoint(latitude: 40.7312973034393, longitude: -73.99896644276561)
       if let location = currentLocation {
-        geoPoint = GeoPoint(latitude: location.coordinate.latitude, longitude: location.coordinate.longitude)
+        geoPoint = Pelias.GeoPoint(latitude: location.coordinate.latitude, longitude: location.coordinate.longitude)
       }
       let config = PeliasAutocompleteConfig(searchText: searchText, focusPoint: geoPoint, completionHandler: { (autocompleteResponse) -> Void in
         self.results = autocompleteResponse.parsedMapItems()
         self.tableView.reloadData()
       })
-      PeliasSearchManager.sharedInstance.autocompleteQuery(config)
+      _ = PeliasSearchManager.sharedInstance.autocompleteQuery(config)
     }
   }
 

SampleApp/RoutingViewController.swift

@@ -112,7 +112,7 @@ class RoutingViewController: UIViewController, RoutingSearchDelegate {
   }
 
   private func requestRoute() {
-    guard let routingController = try? MapzenRoutingController.controller() else { return }
+    guard let routingController = try? RoutingController.controller() else { return }
     routingController.updateLocale(routingLocale)
 
     guard let currentLocation = LocationManager.sharedManager.currentLocation, let destination = destination else { return }

SampleApp/SearchPinsViewController.swift

@@ -29,7 +29,7 @@ class SearchPinsViewController: SampleMapViewController, UITextFieldDelegate {
   }
 
   func textFieldDidEndEditing(_ textField: UITextField) {
-    let geopoint = GeoPoint(location: LocationManager.sharedManager.currentLocation)
+    let geopoint = Pelias.GeoPoint(location: LocationManager.sharedManager.currentLocation)
     var searchConfig = PeliasSearchConfig(searchText: textField.text!) { [unowned self] (response) in
       guard let newAnnotations = response.parsedMapItems(target: self, action: #selector(self.annotationClicked(annotation:))) else { return }
       do {

ios-sdkTests/MapzenManagerTests.swift

@@ -45,7 +45,7 @@ class MapzenManagerTests: XCTestCase {
     MapzenManager.sharedManager.apiKey = nil
 
     //Tests
-    XCTAssertThrowsError(try MapzenRoutingController.controller()) { (error) -> Void in
+    XCTAssertThrowsError(try RoutingController.controller()) { (error) -> Void in
       let error = error as NSError
       XCTAssertTrue(error.code == MZError.apiKeyNotSet.rawValue)
     }
@@ -57,7 +57,7 @@ class MapzenManagerTests: XCTestCase {
 
     //Tests
     do {
-      let _ = try MapzenRoutingController.controller()
+      let _ = try RoutingController.controller()
     } catch {
       XCTFail()
     }

ios-sdkTests/MapzenRoutingControllerTests.swift → ios-sdkTests/RoutingControllerTests.swift

@@ -1,5 +1,5 @@
 //
-//  MapzenRoutingControllerTests.swift
+//  RoutingControllerTests.swift
 //  ios-sdk
 //
 //  Created by Sarah Lensing on 3/13/17.
@@ -10,14 +10,14 @@ import XCTest
 @testable import ios_sdk
 @testable import OnTheRoad
 
-class MapzenRoutingControllerTests : XCTestCase {
+class RoutingControllerTests : XCTestCase {
 
   let testSessionManager : TestUrlSession = TestUrlSession()
-  var router : MapzenRoutingController? = nil
+  var router : RoutingController? = nil
 
   override func setUp() {
     MapzenManager.sharedManager.apiKey = "testKey"
-    try? router = MapzenRoutingController.controller(sessionManager: testSessionManager)
+    try? router = RoutingController.controller(sessionManager: testSessionManager)
   }
 
   func testRouterSendCurrentLocaleLanguageByDefault() {

ios-sdkTests/SearchConfigsTests.swift

@@ -0,0 +1,111 @@
+//
+//  SearchConfigsTests.swift
+//  ios-sdk
+//
+//  Created by Sarah Lensing on 3/23/17.
+//  Copyright © 2017 Mapzen. All rights reserved.
+//
+
+import XCTest
+@testable import ios_sdk
+
+class AutocompleteConfigTests: XCTestCase {
+
+  var config: AutocompleteConfig = AutocompleteConfig.init(searchText: "test", focusPoint: GeoPoint.init(latitude: 70.0, longitude: 40.0), completionHandler: { (response) in })
+
+  func testFocusPointIsCorrect() {
+    XCTAssertEqual(GeoPoint(latitude: 70.0, longitude: 40.0), config.focusPoint)
+  }
+
+  func testSearchTestIsCorrect() {
+    XCTAssertEqual("test", config.searchText)
+  }
+
+}
+
+class PlaceConfigTests: XCTestCase {
+
+  var config: PlaceConfig = PlaceConfig.init(places: [PlaceQueryItem.init(placeId: "123", dataSource: .openStreetMap, layer: .address)], completionHandler: { (response) in })
+
+  func testPlacesAreCorrect() {
+    XCTAssertEqual(config.places.count, 1)
+    XCTAssertEqual(PlaceQueryItem.init(placeId: "123", dataSource: .openStreetMap, layer: .address), config.places.first)
+  }
+}
+
+class ReverseConfigTests: XCTestCase {
+
+  var config: ReverseConfig = ReverseConfig.init(point: GeoPoint.init(latitude: 70.0, longitude: 40.0), completionHandler: { (response) in })
+
+  func testPointIsCorrect() {
+    XCTAssertEqual(GeoPoint(latitude: 70.0, longitude: 40.0), config.point)
+  }
+
+  func testNumOfResults() {
+    config.numberOfResults = 8
+    XCTAssertEqual(8, config.numberOfResults)
+  }
+
+  func testBoundaryCountry() {
+    config.boundaryCountry = "US"
+    XCTAssertEqual("US", config.boundaryCountry)
+  }
+
+  func testDataSources() {
+    config.dataSources = [.geoNames, .openAddresses]
+    XCTAssertEqual([.geoNames, .openAddresses], config.dataSources!)
+  }
+
+  func testLayers() {
+    config.layers = [.address, .country]
+    XCTAssertEqual([.address, .country], config.layers!)
+  }
+}
+
+class SearchConfigTests: XCTestCase {
+
+  var config: SearchConfig = SearchConfig.init(searchText: "test", completionHandler: { (response) in })
+
+  func testSearchTextIsCorrect() {
+    XCTAssertEqual("test", config.searchText)
+  }
+
+  func testNumOfResults() {
+    config.numberOfResults = 8
+    XCTAssertEqual(8, config.numberOfResults)
+  }
+
+  func testBoundaryCountry() {
+    config.boundaryCountry = "US"
+    XCTAssertEqual("US", config.boundaryCountry)
+  }
+
+  func testBoundaryRect() {
+    let rect = SearchRect(minLatLong: GeoPoint(latitude: 70.0, longitude: 40.0), maxLatLong: GeoPoint(latitude: 75.0, longitude: 40.0))
+    config.boundaryRect = rect
+    XCTAssertEqual(rect, config.boundaryRect)
+  }
+
+  func testBoundaryCircle() {
+    let circle = SearchCircle(center: GeoPoint(latitude: 70.0, longitude: 40.0), radius: 10)
+    config.boundaryCircle = circle
+    XCTAssertEqual(circle, config.boundaryCircle)
+  }
+
+  func testFocusPoint() {
+    let point = GeoPoint(latitude: 70.0, longitude: 40.0)
+    config.focusPoint = point
+    XCTAssertEqual(point, config.focusPoint)
+  }
+
+  func testDataSources() {
+    config.dataSources = [.geoNames, .openAddresses]
+    XCTAssertEqual([.geoNames, .openAddresses], config.dataSources!)
+  }
+
+  func testLayers() {
+    config.layers = [.address, .country]
+    XCTAssertEqual([.address, .country], config.layers!)
+  }
+}
+

ios-sdkTests/SearchDataConverterTests.swift

@@ -0,0 +1,154 @@
+//
+//  SearchDataConverterTests.swift
+//  ios-sdk
+//
+//  Created by Sarah Lensing on 3/21/17.
+//  Copyright © 2017 Mapzen. All rights reserved.
+//
+
+import XCTest
+@testable import ios_sdk
+import Pelias
+
+class SearchDataConverterTests: XCTestCase {
+
+  func testUnwrapSearchSources() {
+    let sources = [SearchSource.geoNames, SearchSource.openAddresses, SearchSource.openStreetMap, SearchSource.quattroshapes]
+    let unwrapped = SearchDataConverter.unwrapSearchSources(sources)
+    XCTAssertTrue(unwrapped.contains(.GeoNames))
+    XCTAssertTrue(unwrapped.contains(.OpenAddresses))
+    XCTAssertTrue(unwrapped.contains(.OpenStreetMap))
+    XCTAssertTrue(unwrapped.contains(.Quattroshapes))
+    XCTAssertEqual(unwrapped.count, 4)
+  }
+
+  func testUnwrapSearchSource() {
+    XCTAssertEqual(SearchDataConverter.unwrapSearchSource(.openStreetMap), .OpenStreetMap)
+    XCTAssertEqual(SearchDataConverter.unwrapSearchSource(.openAddresses), .OpenAddresses)
+    XCTAssertEqual(SearchDataConverter.unwrapSearchSource(.quattroshapes), .Quattroshapes)
+    XCTAssertEqual(SearchDataConverter.unwrapSearchSource(.geoNames), .GeoNames)
+  }
+
+  func testWrapSearchSources() {
+    let sources = [Pelias.SearchSource.GeoNames, Pelias.SearchSource.OpenAddresses, Pelias.SearchSource.OpenStreetMap, Pelias.SearchSource.Quattroshapes]
+    let wrapped = SearchDataConverter.wrapSearchSources(sources)
+    XCTAssertTrue(wrapped.contains(.geoNames))
+    XCTAssertTrue(wrapped.contains(.openAddresses))
+    XCTAssertTrue(wrapped.contains(.openStreetMap))
+    XCTAssertTrue(wrapped.contains(.quattroshapes))
+    XCTAssertEqual(wrapped.count, 4)
+
+  }
+
+  func testWrapSearchSource() {
+    XCTAssertEqual(SearchDataConverter.wrapSearchSource(.OpenStreetMap), .openStreetMap)
+    XCTAssertEqual(SearchDataConverter.wrapSearchSource(.OpenAddresses), .openAddresses)
+    XCTAssertEqual(SearchDataConverter.wrapSearchSource(.Quattroshapes), .quattroshapes)
+    XCTAssertEqual(SearchDataConverter.wrapSearchSource(.GeoNames), .geoNames)
+  }
+
+  func testUnwrapLayerFilters() {
+    let layers = [ios_sdk.LayerFilter.venue, LayerFilter.address, LayerFilter.country, LayerFilter.region, LayerFilter.locality, LayerFilter.localadmin, LayerFilter.neighbourhood, LayerFilter.coarse]
+    let unwrapped = SearchDataConverter.unwrapLayerFilters(layers)
+    XCTAssertTrue(unwrapped.contains(.venue))
+    XCTAssertTrue(unwrapped.contains(.address))
+    XCTAssertTrue(unwrapped.contains(.country))
+    XCTAssertTrue(unwrapped.contains(.region))
+    XCTAssertTrue(unwrapped.contains(.locality))
+    XCTAssertTrue(unwrapped.contains(.localadmin))
+    XCTAssertTrue(unwrapped.contains(.neighbourhood))
+    XCTAssertTrue(unwrapped.contains(.coarse))
+    XCTAssertEqual(unwrapped.count, 8)
+  }
+
+  func testUnwrapLayerFilter() {
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.venue), .venue)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.address), .address)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.country), .country)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.region), .region)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.locality), .locality)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.localadmin), .localadmin)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.neighbourhood), .neighbourhood)
+    XCTAssertEqual(SearchDataConverter.unwrapLayerFilter(.coarse), .coarse)
+  }
+
+  func testWrapLayerFilters() {
+    let layers = [Pelias.LayerFilter.venue, LayerFilter.address, LayerFilter.country, LayerFilter.region, LayerFilter.locality, LayerFilter.localadmin, LayerFilter.neighbourhood, LayerFilter.coarse]
+    let wrapped = SearchDataConverter.wrapLayerFilters(layers)
+    XCTAssertTrue(wrapped.contains(.venue))
+    XCTAssertTrue(wrapped.contains(.address))
+    XCTAssertTrue(wrapped.contains(.country))
+    XCTAssertTrue(wrapped.contains(.region))
+    XCTAssertTrue(wrapped.contains(.locality))
+    XCTAssertTrue(wrapped.contains(.localadmin))
+    XCTAssertTrue(wrapped.contains(.neighbourhood))
+    XCTAssertTrue(wrapped.contains(.coarse))
+    XCTAssertEqual(wrapped.count, 8)
+  }
+
+  func testWrapLayerFilter() {
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.venue), .venue)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.address), .address)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.country), .country)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.region), .region)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.locality), .locality)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.localadmin), .localadmin)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.neighbourhood), .neighbourhood)
+    XCTAssertEqual(SearchDataConverter.wrapLayerFilter(.coarse), .coarse)
+  }
+
+  func testWrapPoint() {
+    let point = Pelias.GeoPoint(latitude: 70.0, longitude: 40.0)
+    let wrapped = SearchDataConverter.wrapPoint(point)
+    XCTAssertEqual(point, wrapped.point)
+  }
+
+  func testUnwrapPoint() {
+    let point = ios_sdk.GeoPoint(latitude: 70.0, longitude: 40.0)
+    let unwrapped = SearchDataConverter.unwrapPoint(point)
+    XCTAssertEqual(point.point, unwrapped)
+  }
+
+  func testUnwrapQueryItems() {
+    let items = [PlaceQueryItem.init(placeId: "id", dataSource: .geoNames, layer: .address),
+                 PlaceQueryItem.init(placeId: "anotherid", dataSource: .quattroshapes, layer: .region)]
+    let unwrapped = SearchDataConverter.unwrapQueryItems(items)
+    XCTAssertEqual(unwrapped[0].placeId, "id")
+    XCTAssertEqual(unwrapped[0].dataSource, .GeoNames)
+    XCTAssertEqual(unwrapped[0].layer, .address)
+    XCTAssertEqual(unwrapped[1].placeId, "anotherid")
+    XCTAssertEqual(unwrapped[1].dataSource, .Quattroshapes)
+    XCTAssertEqual(unwrapped[1].layer, .region)
+    XCTAssertEqual(unwrapped.count, 2)
+  }
+
+  func testUnwrapQueryItem() {
+    let item = PlaceQueryItem.init(placeId: "id", dataSource: .openStreetMap, layer: .venue)
+    let unwrapped = SearchDataConverter.unwrapQueryItem(item)
+    XCTAssertEqual(unwrapped.placeId, "id")
+    XCTAssertEqual(unwrapped.dataSource, .OpenStreetMap)
+    XCTAssertEqual(unwrapped.layer, .venue)
+  }
+
+  func testWrapQueryItems() {
+    let items = [PeliasPlaceQueryItem.init(placeId: "id", dataSource: .GeoNames, layer: .address),
+                 PeliasPlaceQueryItem.init(placeId: "anotherid", dataSource: .Quattroshapes, layer: .region)]
+    let wrapped = SearchDataConverter.wrapQueryItems(items)
+    XCTAssertEqual(wrapped[0].placeId, "id")
+    XCTAssertEqual(wrapped[0].dataSource, .geoNames)
+    XCTAssertEqual(wrapped[0].layer, .address)
+    XCTAssertEqual(wrapped[1].placeId, "anotherid")
+    XCTAssertEqual(wrapped[1].dataSource, .quattroshapes)
+    XCTAssertEqual(wrapped[1].layer, .region)
+    XCTAssertEqual(wrapped.count, 2)
+  }
+
+  func testWrapQueryItem() {
+    let item = PeliasPlaceQueryItem.init(placeId: "id", dataSource: .OpenStreetMap, layer: .venue)
+    let wrapped = SearchDataConverter.wrapQueryItem(item)
+    XCTAssertEqual(wrapped.placeId, "id")
+    XCTAssertEqual(wrapped.dataSource, .openStreetMap)
+    XCTAssertEqual(wrapped.layer, .venue)
+  }
+
+}

ios-sdkTests/SearchDataObjectsTests.swift

@@ -0,0 +1,47 @@
+//
+//  MapzenSearchDataObjectsTests.swift
+//  ios-sdk
+//
+//  Created by Sarah Lensing on 3/21/17.
+//  Copyright © 2017 Mapzen. All rights reserved.
+//
+
+import XCTest
+@testable import ios_sdk
+import Pelias
+
+class MapzenSearchDataObjectsTests: XCTestCase {
+
+  func testSearchRect() {
+    let min = ios_sdk.GeoPoint(latitude: 70.0, longitude: 40.0)
+    let max = ios_sdk.GeoPoint(latitude: 80.0, longitude: 50.0)
+    let searchRect = SearchRect(minLatLong: min, maxLatLong: max)
+    let rect = SearchBoundaryRect(minLatLong: SearchDataConverter.unwrapPoint(min), maxLatLong: SearchDataConverter.unwrapPoint(max))
+    XCTAssertEqual(searchRect.rect, rect)
+    XCTAssertEqual(searchRect, SearchRect(minLatLong: min, maxLatLong: max))
+  }
+
+  func testSearchCircle() {
+    let center = ios_sdk.GeoPoint(latitude: 70.0, longitude: 40.0)
+    let searchCircle = SearchCircle(center: center, radius: 8)
+    let circle = SearchBoundaryCircle(center: SearchDataConverter.unwrapPoint(center), radius: 8)
+    XCTAssertEqual(searchCircle.circle, circle)
+    XCTAssertEqual(searchCircle, SearchCircle(center: center, radius: 8))
+  }
+
+  func testGeoPoint() {
+    let point = ios_sdk.GeoPoint(latitude: 70.0, longitude: 40.0)
+    let peliasPoint = Pelias.GeoPoint(latitude: 70.0, longitude: 40.0)
+    XCTAssertEqual(point.point, peliasPoint)
+    XCTAssertEqual(point, GeoPoint(latitude: 70.0, longitude: 40.0))
+  }
+
+  func testPlaceQueryItem() {
+    let item = PlaceQueryItem(placeId: "id", dataSource: .geoNames, layer: .address)
+    let peliasItem = PeliasPlaceQueryItem(placeId: "id", dataSource: .GeoNames, layer: .address)
+    XCTAssertEqual(item.peliasItem.placeId, peliasItem.placeId)
+    XCTAssertEqual(item.peliasItem.dataSource, peliasItem.dataSource)
+    XCTAssertEqual(item.peliasItem.layer, peliasItem.layer)
+    XCTAssertEqual(item, PlaceQueryItem(placeId: "id", dataSource: .geoNames, layer: .address))
+  }
+}