org.jboss.arquillian.drone.webdriver.utils.Validate Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of arquillian-drone-webdriver Show documentation
Show all versions of arquillian-drone-webdriver Show documentation
Extension for functional testing based on web view layer (Ajocado, Selenium, WebDriver)
/*
* JBoss, Home of Professional Open Source
* Copyright 2011, Red Hat Middleware LLC, and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* 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.
*/
package org.jboss.arquillian.drone.webdriver.utils;
import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableSet;
import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.logging.Logger;
import org.openqa.selenium.Platform;
import static org.openqa.selenium.Platform.WINDOWS;
/**
*
*/
public class Validate {
private static final Logger log = Logger.getLogger(Validate.class.getName());
private static final FileExecutableChecker fileExecutableChecker = new FileExecutableChecker();
private static final ImmutableSet ENDINGS = Platform.getCurrent().is(WINDOWS) ?
ImmutableSet.of("", ".cmd", ".exe", ".com", ".bat") : ImmutableSet.of("");
public static boolean empty(Object object) {
return object == null;
}
public static boolean empty(String object) {
return object == null || object.length() == 0;
}
public static boolean nonEmpty(String object) {
return !empty(object);
}
public static void isEmpty(Object object, String message) throws IllegalArgumentException {
if (empty(object)) {
throw new IllegalArgumentException(message);
}
}
public static void isEmpty(String object, String message) throws IllegalArgumentException {
if (empty(object)) {
throw new IllegalArgumentException(message);
}
}
public static void isValidPath(String path, String message) throws IllegalArgumentException {
isEmpty(path, message);
File file = new File(path);
if (!file.exists() || !file.canRead()) {
throw new IllegalArgumentException(message);
}
}
public static void isValidUrl(URL url, String message) throws IllegalArgumentException {
if (url == null) {
throw new IllegalArgumentException(message);
}
}
public static void isValidUrl(String url, String message) throws IllegalArgumentException {
isEmpty(url, message);
try {
new URL(url);
} catch (MalformedURLException e) {
throw new IllegalArgumentException(message, e);
}
}
public static void isExecutable(String path, String message) throws IllegalArgumentException {
if (!executable(path)) {
throw new IllegalArgumentException(message);
}
}
/**
* Find the executable by scanning the file system and the PATH. In the case of Windows this
* method allows common executable endings (".com", ".bat" and ".exe") to be omitted.
*
* @param command
* The name of the executable to find
*
* @return Whether the command is executable or not.
*/
public static boolean isCommandExecutable(String command) throws IllegalArgumentException {
File file = new File(command);
if (fileExecutableChecker.canExecute(file)) {
return true;
}
if (Platform.getCurrent().is(WINDOWS)) {
file = new File(command + ".exe");
if (fileExecutableChecker.canExecute(file)) {
return true;
}
}
final ImmutableSet.Builder pathSegmentBuilder = new ImmutableSet.Builder<>();
addPathFromEnvironment(pathSegmentBuilder);
if (Platform.getCurrent().is(Platform.MAC)) {
addMacSpecificPath(pathSegmentBuilder);
}
for (String pathSegment : pathSegmentBuilder.build()) {
for (String ending : ENDINGS) {
file = new File(pathSegment, command + ending);
if (fileExecutableChecker.canExecute(file)) {
return true;
}
}
}
return false;
}
private static void addPathFromEnvironment(final ImmutableSet.Builder pathSegmentBuilder) {
String pathName = "PATH";
Map env = System.getenv();
if (!env.containsKey(pathName)) {
for (String key : env.keySet()) {
if (pathName.equalsIgnoreCase(key)) {
pathName = key;
break;
}
}
}
String path = env.get(pathName);
if (path != null) {
pathSegmentBuilder.add(path.split(File.pathSeparator));
}
}
private static void addMacSpecificPath(final ImmutableSet.Builder pathSegmentBuilder) {
File pathFile = new File("/etc/paths");
if (pathFile.exists()) {
try {
pathSegmentBuilder.addAll(Files.readLines(pathFile, Charsets.UTF_8));
} catch (IOException e) {
log.warning(
String.format("There was an error when the file %s was being read: %s", pathFile, e.getMessage()));
}
}
}
public static boolean executable(String path) {
if (empty(path)) {
return false;
}
File file = new File(path);
if (!file.exists()) {
throw new IllegalArgumentException(String.format("The file %s does not exist", path));
}
return fileExecutableChecker.canExecute(file);
}
/**
* Checker if a file can be executed. It requires Java 6 to do that. If anything goes wrong, it supposes that a file
* can be
* executed.
*/
private static final class FileExecutableChecker {
private static final Logger log = Logger.getLogger(FileExecutableChecker.class.getName());
private final Method isExecutableMethod;
FileExecutableChecker() {
Method m = null;
try {
m = File.class.getMethod("canExecute");
} catch (SecurityException e) {
log.warning(
"Unable to verify executable bits for files, will consider them all executable. " + e.getMessage());
} catch (NoSuchMethodException e) {
log.warning(
"Unable to verify executable bits for files, will consider them all executable. " + e.getMessage());
}
this.isExecutableMethod = m;
}
public boolean canExecute(File file) {
if (isExecutableMethod == null) {
return true;
}
Boolean result = true;
try {
result = (Boolean) isExecutableMethod.invoke(file);
} catch (IllegalArgumentException e) {
log.warning(
"Unable to check if " + file.getAbsolutePath() + " can be executed, will consider it executable."
+ e.getMessage());
} catch (IllegalAccessException e) {
log.warning(
"Unable to check if " + file.getAbsolutePath() + " can be executed, will consider it executable."
+ e.getMessage());
} catch (InvocationTargetException e) {
log.warning(
"Unable to check if " + file.getAbsolutePath() + " can be executed, will consider it executable."
+ e.getMessage());
}
return result;
}
}
}