| |
| // Copyright 2016 The Tulsi Authors. All rights reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| import XCTest |
| @testable import BazelIntegrationTestCase |
| @testable import TulsiGenerator |
| |
| |
| // Parent class for end to end tests that generate an xcodeproj with the Tulsi binary and verify the |
| // generated xcodeproj by running the projects unit tests. |
| class TulsiEndToEndTest: BazelIntegrationTestCase { |
| let fileManager = FileManager.default |
| var runfilesWorkspaceURL: URL! = nil |
| |
| override func setUp() { |
| super.setUp() |
| super.continueAfterFailure = false |
| runfilesWorkspaceURL = fakeBazelWorkspace.runfilesWorkspaceURL |
| XCTAssertNotNil(runfilesWorkspaceURL, "runfilesWorkspaceURL must be not be nil after setup.") |
| |
| // Unzip the Tulsi.app bundle to the temp space. |
| let semaphore = DispatchSemaphore(value: 0) |
| let tulsiZipPath = "tulsi.zip" |
| let tulsiZipURL = runfilesWorkspaceURL.appendingPathComponent(tulsiZipPath, isDirectory: false) |
| let process = TulsiProcessRunner.createProcess("/usr/bin/unzip", |
| arguments: [tulsiZipURL.path, |
| "-d", |
| workspaceRootURL.path]) { |
| completionInfo in |
| if let error = String(data: completionInfo.stderr, encoding: .utf8), !error.isEmpty { |
| XCTFail(error) |
| } |
| semaphore.signal() |
| } |
| process.launch() |
| _ = semaphore.wait(timeout: DispatchTime.distantFuture) |
| } |
| |
| // Takes a short path to data files and adds them to the fake Bazel workspace. |
| func copyDataToFakeWorkspace(_ path: String) -> Bool { |
| let sourceURL = runfilesWorkspaceURL.appendingPathComponent(path, isDirectory: false) |
| let destURL = workspaceRootURL.appendingPathComponent(path, isDirectory: false) |
| do { |
| if(!fileManager.fileExists(atPath: sourceURL.path)) { |
| XCTFail("Source file \(sourceURL.path) does not exist.") |
| } |
| if fileManager.fileExists(atPath: destURL.path) { |
| try fileManager.removeItem(at: destURL) |
| } |
| |
| // Symlinks cause issues with Tulsi and Storyboards so must deep copy any data files. |
| try fileManager.deepCopyItem(at: sourceURL, to: destURL) |
| return true |
| } catch let e as NSError { |
| print(e.localizedDescription) |
| return false |
| } |
| } |
| |
| // Runs the Tulsi binary with the given Tulsi project and config to generate an Xcode project. |
| func generateXcodeProject(tulsiProject path: String, config: String) -> URL{ |
| let tulsiBinURL = workspaceRootURL.appendingPathComponent("Tulsi.app/Contents/MacOS/Tulsi", isDirectory: false) |
| XCTAssert(fileManager.fileExists(atPath: tulsiBinURL.path), "Tulsi binary is missing.") |
| |
| let projectURL = workspaceRootURL.appendingPathComponent(path, isDirectory: true) |
| XCTAssert(fileManager.fileExists(atPath: projectURL.path), "Tulsi project is missing.") |
| let configPath = projectURL.path + ":" + config |
| |
| // Generate Xcode project with Tulsi. |
| let semaphore = DispatchSemaphore(value: 0) |
| let process = TulsiProcessRunner.createProcess(tulsiBinURL.path, |
| arguments: ["--", |
| "--genconfig", |
| configPath, |
| "--outputfolder", |
| workspaceRootURL.path, |
| "--bazel", |
| bazelURL.path, |
| "--no-open-xcode"]) { |
| completionInfo in |
| if let stdoutput = String(data: completionInfo.stdout, encoding: .utf8) { |
| print(stdoutput) |
| } |
| if let erroutput = String(data: completionInfo.stderr, encoding: .utf8) { |
| print(erroutput) |
| } |
| semaphore.signal() |
| } |
| process.launch() |
| _ = semaphore.wait(timeout: DispatchTime.distantFuture) |
| |
| let filename = TulsiGeneratorConfig.sanitizeFilename("\(config).xcodeproj") |
| let xcodeProjectURL = workspaceRootURL.appendingPathComponent(filename, isDirectory: true) |
| |
| // Remove Xcode project after each test method. |
| addTeardownBlock { |
| do { |
| if self.fileManager.fileExists(atPath: xcodeProjectURL.path) { |
| try self.fileManager.removeItem(at: xcodeProjectURL) |
| XCTAssertFalse(self.fileManager.fileExists(atPath: xcodeProjectURL.path)) |
| } |
| } catch { |
| XCTFail("Error while deleting generated Xcode project: \(error)") |
| } |
| } |
| |
| return xcodeProjectURL |
| } |
| |
| // Runs Xcode tests on the given Xcode project and scheme. |
| func testXcodeProject(_ xcodeProjectURL: URL, scheme: String) { |
| let semaphore = DispatchSemaphore(value: 0) |
| let xcodeTest = TulsiProcessRunner.createProcess("/usr/bin/xcodebuild", |
| arguments: ["test", |
| "-project", |
| xcodeProjectURL.path, |
| "-scheme", |
| scheme, |
| "-destination", |
| "platform=iOS Simulator,name=iPhone 8,OS=11.2"]) { |
| completionInfo in |
| if let stdoutput = String(data: completionInfo.stdout, encoding: .utf8), |
| let result = stdoutput.split(separator: "\n").last { |
| XCTAssertEqual(String(result), "** TEST SUCCEEDED **", "xcodebuild did not return test success.") |
| } else if let error = String(data: completionInfo.stderr, encoding: .utf8), !error.isEmpty { |
| XCTFail(error) |
| } else { |
| XCTFail("Xcode project tests did not return success.") |
| } |
| semaphore.signal() |
| } |
| xcodeTest.launch() |
| _ = semaphore.wait(timeout: DispatchTime.distantFuture) |
| } |
| } |
| |
| extension FileManager { |
| // Performs a deep copy of the item at sourceURL, resolving any symlinks along the way. |
| func deepCopyItem(at sourceURL: URL, to destURL: URL) throws { |
| do { |
| try self.createDirectory(atPath: destURL.deletingLastPathComponent().path, withIntermediateDirectories: true) |
| let rootPath = sourceURL.path |
| if let rootAttributes = try? self.attributesOfItem(atPath: rootPath) { |
| if rootAttributes[FileAttributeKey.type] as? FileAttributeType == FileAttributeType.typeSymbolicLink { |
| let resolvedRootPath = try self.destinationOfSymbolicLink(atPath: rootPath) |
| try self.copyItem(atPath: resolvedRootPath, toPath: destURL.path) |
| } else { |
| try self.copyItem(at: sourceURL, to: destURL) |
| } |
| } |
| |
| let path = destURL.path |
| if let paths = self.subpaths(atPath: path) { |
| for subpath in paths { |
| let fullSubpath = path + "/" + subpath |
| if let attributes = try? self.attributesOfItem(atPath: fullSubpath) { |
| // If a file is a symbolic link, find the original file, remove the symlink, and copy |
| // over the original file. |
| if attributes[FileAttributeKey.type] as? FileAttributeType == FileAttributeType.typeSymbolicLink { |
| let resolvedPath = try self.destinationOfSymbolicLink(atPath: fullSubpath) |
| try self.removeItem(atPath: fullSubpath) |
| try self.copyItem(atPath: resolvedPath, toPath: fullSubpath) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
