296 lines
13 KiB
Swift
296 lines
13 KiB
Swift
//
|
|
// ServerListConverterTests.swift
|
|
// PrivadoTests
|
|
//
|
|
// Created by Lizaveta Malinouskaya on 22.02.22.
|
|
// Copyright © 2022 Privado LLC. All rights reserved.
|
|
//
|
|
|
|
import XCTest
|
|
@testable import PrivadoVPN
|
|
|
|
final class ServerListConverterTests: XCTestCase {
|
|
|
|
enum Constant {
|
|
static let allRecords = "ServerRecords"
|
|
static let overquota = "Overquota"
|
|
static let freemium = "Freemium"
|
|
static let premium = "Premium"
|
|
static let capacityGreater = "ServerRecordsCapacityGreater"
|
|
static let freemiumWithEmpty = "FreemiumEmptyFields"
|
|
static let freemiumNoEmpty = "FreemiumNoEmptyFields"
|
|
static let freemiumMaintenance = "FreemiumMaintenance"
|
|
static let capacityServers = "CapacityServers"
|
|
static let capacityServersResult = "CapacityServersResult"
|
|
static let lastServer = "LastServerSample"
|
|
static let lastServerResult = "LastServerResult"
|
|
static let currentServer = "CurrentServer"
|
|
static let randomServers = "RandomServers"
|
|
}
|
|
|
|
let sampleGeolocation = GeoLocation(country: "AU",
|
|
city: "Sydney",
|
|
ip: "93.115.35.61",
|
|
lat: "-33.946100000000001", long: "151.17699999999999")
|
|
|
|
func sampleRecords(for resourseName: String) -> [ServerRecord] {
|
|
let url = Bundle(for: CustomerRepoTests.self).url(forResource: resourseName, withExtension: "data")
|
|
let data = try! Data(contentsOf: url!)
|
|
let decoder = JSONDecoder()
|
|
return try! decoder.decode(Array<ServerRecord>.self, from: data)
|
|
}
|
|
|
|
class ServerListInteractorMockup: ServerListInteractorInput {
|
|
var preferredServer: PreferredServerType = .best
|
|
|
|
var isFreemium: Bool = false
|
|
|
|
var isOverquota: Bool = true
|
|
|
|
var lastServerIsNil: Bool = false
|
|
|
|
func fetchServers(completion: @escaping (Result<ServerListInteractorResult, Error>) -> Void) {
|
|
}
|
|
|
|
func cancelRequest() {
|
|
}
|
|
|
|
func storeServer(_ server: Server) {
|
|
}
|
|
|
|
func restoreServer() -> Server? {
|
|
lastServerIsNil ? nil : sampleRecords(for: Constant.lastServer).first?.server
|
|
}
|
|
|
|
func sampleRecords(for resourseName: String) -> [ServerRecord] {
|
|
let url = Bundle(for: CustomerRepoTests.self).url(forResource: resourseName, withExtension: "data")
|
|
let data = try! Data(contentsOf: url!)
|
|
let decoder = JSONDecoder()
|
|
return try! decoder.decode(Array<ServerRecord>.self, from: data)
|
|
}
|
|
|
|
func setUser(userType: Customer.Plan) {
|
|
switch userType {
|
|
case .overquota:
|
|
self.isFreemium = false
|
|
self.isOverquota = true
|
|
case .premium(value: ""):
|
|
self.isFreemium = false
|
|
self.isOverquota = false
|
|
case .freemium:
|
|
self.isFreemium = true
|
|
self.isOverquota = false
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func setPreffered(to type: PreferredServerType) {
|
|
self.preferredServer = type
|
|
}
|
|
}
|
|
|
|
let interactor = ServerListInteractorMockup()
|
|
|
|
// MARK: - FilterRecordsForCurrentUser func tests
|
|
|
|
func testFilterRecordsCapacityGreater() throws {
|
|
let records = self.sampleRecords(for: Constant.capacityGreater)
|
|
|
|
let result = ServerListConverter.filterRecords(records: records)
|
|
XCTAssertEqual(result, [])
|
|
}
|
|
|
|
func testFilterRecordsCapacityLess() throws {
|
|
let records = self.sampleRecords(for: Constant.allRecords)
|
|
|
|
let result = ServerListConverter.filterRecords(records: records)
|
|
XCTAssertEqual(result, records)
|
|
}
|
|
|
|
func testFilterRecordsEmptyStrings() throws {
|
|
// In sample data there is single record for each case, and normal records:
|
|
// server.name == ""
|
|
// server.ip == ""
|
|
// server.city == ""
|
|
// server.country == ""
|
|
|
|
let sampleEmptyRecords = self.sampleRecords(for: Constant.freemiumWithEmpty)
|
|
let sampleResult = self.sampleRecords(for: Constant.freemiumNoEmpty)
|
|
|
|
self.interactor.setUser(userType: .freemium)
|
|
|
|
let result = ServerListConverter.filterRecords(records: sampleEmptyRecords)
|
|
|
|
XCTAssertEqual(result, sampleResult)
|
|
}
|
|
|
|
func testFilterRecordsIsMaintenance() throws {
|
|
|
|
let sampleMaintenanceRecords = self.sampleRecords(for: Constant.freemiumMaintenance)
|
|
|
|
self.interactor.setUser(userType: .freemium)
|
|
|
|
let result = ServerListConverter.filterRecords(records: sampleMaintenanceRecords)
|
|
|
|
XCTAssertEqual(result, [])
|
|
}
|
|
|
|
// MARK: - selectLowCapacityCityRecords func tests
|
|
|
|
func testSelectLowCapacityCityRecords() throws {
|
|
|
|
let sampleCapacity = self.sampleRecords(for: Constant.capacityServers)
|
|
var sampleResult = self.sampleRecords(for: Constant.capacityServersResult)
|
|
|
|
var result = ServerListConverter.selectLowCapacityCityRecords(records: sampleCapacity)
|
|
result = result.sorted(by: {$0.city > $1.city})
|
|
sampleResult = sampleResult.sorted(by: {$0.city > $1.city})
|
|
XCTAssertEqual(sampleResult, result)
|
|
}
|
|
|
|
// MARK: - prepareContext func test
|
|
// Testing logic of selecting server
|
|
|
|
func testSelectOverquotaServer() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.allRecords)
|
|
self.interactor.setUser(userType: .overquota)
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: nil,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultContext.selectedRecord, resultContext.bestRecord)
|
|
}
|
|
|
|
func testSelectPrefferedLastIsInitialLoadingServer() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.allRecords)
|
|
let lastRecord = self.sampleRecords(for: Constant.lastServer)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .last)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: nil,
|
|
isInitialLoading: true,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultContext.selectedRecord, lastRecord.first)
|
|
}
|
|
|
|
func testSelectPrefferedRandomIsInitialLoadingServer() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.randomServers)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .random)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: nil,
|
|
isInitialLoading: true,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(sampleServers.first, resultContext.selectedRecord)
|
|
}
|
|
|
|
func testSelectCurrentServerNilLastServerNil() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.allRecords)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .none)
|
|
self.interactor.lastServerIsNil = true
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultContext.selectedRecord, resultContext.bestRecord)
|
|
|
|
}
|
|
|
|
func testSelectCurrentServerNilLastServerNotNil() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.allRecords)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .none)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultLastServer = self.sampleRecords(for: Constant.lastServer)
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: nil,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
|
|
}
|
|
|
|
func testSelectCurrentServerNilLastServerIsBest() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.lastServer)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .none)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultLastServer = self.sampleRecords(for: Constant.lastServer)
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: nil,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
|
|
}
|
|
|
|
func testSelectCurrentServerExistsCityExists() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.allRecords)
|
|
let current = self.sampleRecords(for: Constant.currentServer)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .none)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultLastServer = self.sampleRecords(for: Constant.lastServer)
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: nil,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: current.first,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
|
|
}
|
|
|
|
func testSelectCurrentServerExistsCityNil() throws {
|
|
let sampleServers = self.sampleRecords(for: Constant.randomServers)
|
|
let current = self.sampleRecords(for: Constant.currentServer)
|
|
self.interactor.setUser(userType: .freemium)
|
|
self.interactor.setPreffered(to: .none)
|
|
self.interactor.lastServerIsNil = false
|
|
|
|
let resultBestServer = self.sampleRecords(for: Constant.randomServers)
|
|
|
|
let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
|
|
isInitialLoading: false,
|
|
serverRecords: sampleServers,
|
|
preferred: self.interactor.preferredServer,
|
|
current: current.first,
|
|
interactor: self.interactor)
|
|
|
|
XCTAssertEqual(resultBestServer.first, resultContext.selectedRecord)
|
|
}
|
|
|
|
}
|
|
|
|
|