OperaSettingsCapabilitiesTest.java

/*
Copyright 2012 Opera Software ASA

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 com.opera.core.systems;

import com.google.common.collect.ImmutableMap;

import com.opera.core.systems.runner.launcher.OperaLauncherRunner;
import com.opera.core.systems.testing.NoDriver;
import com.opera.core.systems.testing.OperaDriverTestCase;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.openqa.selenium.Proxy;
import org.openqa.selenium.WebDriverException;

import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.logging.Level;

import static com.opera.core.systems.OperaProduct.DESKTOP;
import static com.opera.core.systems.OperaSettings.Capability.ARGUMENTS;
import static com.opera.core.systems.OperaSettings.Capability.AUTOSTART;
import static com.opera.core.systems.OperaSettings.Capability.BACKEND;
import static com.opera.core.systems.OperaSettings.Capability.BINARY;
import static com.opera.core.systems.OperaSettings.Capability.DETACH;
import static com.opera.core.systems.OperaSettings.Capability.DISPLAY;
import static com.opera.core.systems.OperaSettings.Capability.HOST;
import static com.opera.core.systems.OperaSettings.Capability.LAUNCHER;
import static com.opera.core.systems.OperaSettings.Capability.LOGGING_FILE;
import static com.opera.core.systems.OperaSettings.Capability.LOGGING_LEVEL;
import static com.opera.core.systems.OperaSettings.Capability.NO_QUIT;
import static com.opera.core.systems.OperaSettings.Capability.NO_RESTART;
import static com.opera.core.systems.OperaSettings.Capability.OPERAIDLE;
import static com.opera.core.systems.OperaSettings.Capability.PORT;
import static com.opera.core.systems.OperaSettings.Capability.PRODUCT;
import static com.opera.core.systems.OperaSettings.Capability.PROFILE;
import static com.opera.core.systems.OperaSettings.Capability.PROXY;
import static com.opera.core.systems.OperaSettings.Capability.RUNNER;
import static com.opera.core.systems.internal.OperaDefaults.SERVER_DEFAULT_PORT;
import static com.opera.core.systems.internal.OperaDefaults.SERVER_DEFAULT_PORT_IDENTIFIER;
import static com.opera.core.systems.internal.OperaDefaults.SERVER_RANDOM_PORT_IDENTIFIER;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.matchers.JUnitMatchers.containsString;

@NoDriver
public class OperaSettingsCapabilitiesTest extends OperaDriverTestCase {

  @Rule
  public TemporaryFolder tmp;

  @Before
  public void beforeEach() {
    tmp = new TemporaryFolder();
  }

  @Test
  public void loggingLevelHasLoggingLevelInfoAsDefaultValue() {
    assertEquals(Level.INFO, LOGGING_LEVEL.getDefaultValue());
  }

  @Test
  public void loggingLevelSanitizeNull() {
    assertNull(LOGGING_LEVEL.sanitize(null));
  }

  @Test
  public void loggingLevelSanitizeValidStringLevelUpperCase() {
    assertEquals(Level.WARNING, LOGGING_LEVEL.sanitize(Level.WARNING.toString()));
  }

  @Test
  public void loggingLevelSanitizeValidStringLevelLowerCase() {
    assertEquals(Level.WARNING, LOGGING_LEVEL.sanitize(Level.WARNING.toString().toLowerCase()));
  }

  @Test
  public void loggingLevelSanitizeValidStringLevelMixedCase() {
    assertEquals(Level.WARNING, LOGGING_LEVEL.sanitize("wArNiNg"));
  }

  @Test
  public void loggingLevelSanitizeLevelObject() {
    assertEquals(Level.CONFIG, LOGGING_LEVEL.sanitize(Level.CONFIG));
  }

  @Test
  public void loggingFileHasNullAsDefaultValue() {
    assertNull(LOGGING_FILE.getDefaultValue());
  }

  @Test
  public void loggingFileSanitizeNull() {
    assertNull(LOGGING_FILE.sanitize(null));
  }

  @Test
  public void loggingFileSanitizeValidStringPath() throws IOException {
    File logFile = tmp.newFile();
    Object sanitizedLogFile = LOGGING_FILE.sanitize(logFile.getPath());
    assertTrue("Expected log file to be of type File, got: " +
               sanitizedLogFile.getClass().getName(),
               sanitizedLogFile instanceof File);
    assertEquals(logFile.getCanonicalPath(), ((File) sanitizedLogFile).getCanonicalPath());
  }

  @Test
  public void loggingFileSanitizeInvalidStringPath() throws IOException {
    Object sanitizedLogFile = LOGGING_FILE.sanitize(resources.fakeFile().getPath());
    assertTrue("Expected log file to by of type File, got: " +
               sanitizedLogFile.getClass().getName(),
               sanitizedLogFile instanceof File);
    assertEquals(resources.fakeFile().getCanonicalPath(),
                 ((File) sanitizedLogFile).getCanonicalPath());
  }

  @Test
  public void binaryHasNullAsDefaultValue() {
    assertNull(BINARY.getDefaultValue());
  }

  @Test
  public void binarySanitizeNull() {
    assertNull(BINARY.sanitize(null));
  }

  @Test
  public void binarySanitizeValidStringPath() throws IOException {
    assertEquals(new OperaBinary(OperaProduct.DESKTOP).getFile().getCanonicalPath(),
                 ((File) BINARY.sanitize(OperaBinary.find(OperaProduct.DESKTOP)))
                     .getCanonicalPath());
  }

  @Test
  public void binarySanitizeInvalidStringPath() {
    Exception exception = null;

    try {
      BINARY.sanitize(resources.fakeFile());
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(IllegalStateException.class)));
    assertThat(exception.getMessage(), containsString("The executable does not exist"));
  }

  @Test
  public void argumentsHasOperaArgumentsObjectAsDefaultValue() {
    assertTrue(ARGUMENTS.getDefaultValue() instanceof OperaArguments);
  }

  @Test
  public void argumentsSanitizeNull() {
    Object arguments = ARGUMENTS.sanitize(null);
    assertNotNull(arguments);
    assertTrue(arguments instanceof OperaArguments);
    assertEquals(new OperaArguments().size(), ((OperaArguments) arguments).size());
  }

  @Test
  public void argumentsSanitizeStringList() {
    OperaArguments reference = new OperaArguments("-foo bar -bah");
    Object arguments = ARGUMENTS.sanitize(reference.toString());
    assertTrue(arguments instanceof OperaArguments);
    assertEquals(reference.size(), ((OperaArguments) arguments).size());
    assertEquals(reference.getArgumentsAsStringList(),
                 ((OperaArguments) arguments).getArgumentsAsStringList());
  }

  @Test
  public void argumentsSanitizeOperaArgumentsObject() {
    OperaArguments reference = new OperaArguments("-foo bar -bah");
    Object arguments = ARGUMENTS.sanitize(reference);
    assertTrue(arguments instanceof OperaArguments);
    assertEquals(reference.size(), ((OperaArguments) arguments).size());
  }

  @Test
  public void hostHasNonLoopbackAddressAsDefaultValue() {
    assertEquals("127.0.0.1", HOST.getDefaultValue());
  }

  @Test
  public void hostSanitizeNull() {
    assertNull(HOST.sanitize(null));
  }

  @Test
  public void hostSanitizeString() {
    assertEquals("1.2.3.4", HOST.sanitize("1.2.3.4"));
  }

  @Test
  public void hostSanitizeInteger() {
    assertEquals("1234", HOST.sanitize(1234));
  }

  @Test
  public void portHasRandomServerPortAsDefaultValue() {
    int port = (Integer) PORT.getDefaultValue();

    // In the highly unlikely case that it assigns the random port to 7001...
    if (port == SERVER_DEFAULT_PORT) {
      return;
    }

    assertNotSame(SERVER_DEFAULT_PORT, PORT.getDefaultValue());
  }

  @Test
  public void portSanitizeNull() {
    Exception exception = null;

    try {
      PORT.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void portSanitizeString() {
    assertEquals(1234, PORT.sanitize("1234"));
  }

  @Test
  public void portSanitizeInteger() {
    assertEquals(6543, PORT.sanitize(6543));
  }

  @Test
  public void portSanitizeRandomPortIdentifier() {
    assertNotSame(SERVER_RANDOM_PORT_IDENTIFIER,
                  PORT.sanitize(SERVER_RANDOM_PORT_IDENTIFIER));
  }

  @Test
  public void portSanitizeDefaultPortIdentifier() {
    assertEquals(SERVER_DEFAULT_PORT,
                 PORT.sanitize(SERVER_DEFAULT_PORT_IDENTIFIER));
  }

  @Test
  public void launcherHasDefaultLocationAsDefaultValue() {
    assertNotNull(LAUNCHER.getDefaultValue());
    assertEquals(OperaLauncherRunner.LAUNCHER_DEFAULT_LOCATION, LAUNCHER.getDefaultValue());
  }

  @Test
  public void launcherSanitizeNull() {
    assertNull(LAUNCHER.sanitize(null));
  }

  @Test
  public void launcherSanitizeStringPath() throws IOException {
    assertEquals(resources.executableBinary().getCanonicalPath(),
                 ((File) LAUNCHER.sanitize(resources.executableBinary().getCanonicalPath()))
                     .getCanonicalPath());
  }

  @Test
  public void launcherSanitizeFile() throws IOException {
    assertEquals(resources.executableBinary().getCanonicalPath(),
                 ((File) LAUNCHER.sanitize(resources.executableBinary())).getCanonicalPath());
  }

  @Test
  public void profileHasOperaProfileObjectAsDefaultValue() {
    assertTrue(PROFILE.getDefaultValue() instanceof OperaProfile);
  }

  @Test
  public void profileSanitizeStringPath() throws IOException {
    File path = tmp.newFolder();
    Object profile = PROFILE.sanitize(path.getPath());
    assertTrue(profile instanceof OperaProfile);
    assertEquals(path.getCanonicalPath(),
                 ((OperaProfile) profile).getDirectory().getCanonicalPath());
  }

  @Test
  public void profileSanitizeOperaProfileInstance() throws IOException {
    OperaProfile reference = new OperaProfile();
    Object profile = PROFILE.sanitize(reference);
    assertTrue(profile instanceof OperaProfile);
    assertEquals(reference.getDirectory().getCanonicalPath(),
                 ((OperaProfile) profile).getDirectory().getCanonicalPath());
  }

  @Test
  public void profileSanitizeNull() {
    try {
      PROFILE.sanitize(null);
      fail("Expected NullPointerException");
    } catch (RuntimeException e) {
      assertThat(e, is(instanceOf(NullPointerException.class)));
    }
  }

  @Test
  public void profileSanitizeEmptyString() {
    OperaProfile sanitized = (OperaProfile) PROFILE.sanitize("");
    assertThat(sanitized.getDirectory().getPath(), containsString("opera"));
    assertThat(sanitized.getDirectory().getPath(), containsString("profile"));
  }

  @Test
  public void operaIdleHasFalseAsDefaultValue() {
    assertTrue(OPERAIDLE.getDefaultValue() instanceof Boolean);
    assertFalse((Boolean) OPERAIDLE.getDefaultValue());
  }

  @Test
  public void operaIdleSanitizeNull() {
    try {
      OPERAIDLE.sanitize(null);
      fail("Expected NullPointerException");
    } catch (RuntimeException e) {
      assertThat(e, is(instanceOf(NullPointerException.class)));
    }
  }

  @Test
  public void operaIdleSanitizeBoolean() {
    assertTrue(OPERAIDLE.sanitize(true) instanceof Boolean);
    assertTrue((Boolean) OPERAIDLE.sanitize(true));
  }

  @Test
  public void operaIdleSanitizeString() {
    assertTrue((Boolean) OPERAIDLE.sanitize("true"));
  }

  @Test
  public void operaIdleSanitizeInteger() {
    assertTrue((Boolean) OPERAIDLE.sanitize(1));
  }

  @Test
  public void displayHasNullAsDefaultValue() {
    assertNull(DISPLAY.getDefaultValue());
  }

  @Test
  public void displaySanitizeNull() {
    Exception exception = null;

    try {
      DISPLAY.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void displaySanitizeString() {
    assertEquals(7, DISPLAY.sanitize("7"));
  }

  @Test
  public void displaySanitizeInteger() {
    assertEquals(7, DISPLAY.sanitize(7));
  }

  @Test
  public void autostartHasTrueAsDefaultValue() {
    assertTrue(AUTOSTART.getDefaultValue() instanceof Boolean);
    assertTrue((Boolean) AUTOSTART.getDefaultValue());
  }

  @Test
  public void autostartSanitizeNull() {
    Exception exception = null;

    try {
      AUTOSTART.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void autostartSanitizeBoolean() {
    assertTrue(AUTOSTART.sanitize(true) instanceof Boolean);
    assertTrue((Boolean) AUTOSTART.sanitize(true));
  }

  @Test
  public void autostartSanitizeString() {
    assertTrue((Boolean) AUTOSTART.sanitize("true"));
  }

  @Test
  public void proxySanitizeProxyObject() {
    Proxy proxy = new Proxy();
    proxy.setHttpProxy("4.4.4.4");

    Proxy sanitizedProxy = (Proxy) PROXY.sanitize(proxy);
    assertNotNull(sanitizedProxy);
    assertThat(sanitizedProxy, is(instanceOf(Proxy.class)));
    assertEquals(proxy, sanitizedProxy);
    assertEquals("4.4.4.4", sanitizedProxy.getHttpProxy());
  }

  @Test
  public void proxySanitizeMap() {
    Map<String, ?> jsonProxy = ImmutableMap.of("httpProxy", "4.4.4.4");

    Proxy sanitizedProxy = (Proxy) PROXY.sanitize(jsonProxy);
    assertNotNull(sanitizedProxy);
    assertThat(sanitizedProxy, is(instanceOf(Proxy.class)));
    assertEquals("4.4.4.4", sanitizedProxy.getHttpProxy());
  }

  @Test
  public void proxySanitizeNull() {
    assertNull(PROXY.sanitize(null));
  }

  @Test
  public void autostartSanitizeInteger() {
    assertTrue((Boolean) AUTOSTART.sanitize(1));
  }

  @Test
  public void runnerSanitizeValidClass() {
    assertEquals(OperaLauncherRunner.class, RUNNER.sanitize(OperaLauncherRunner.class));
  }

  @Test
  public void runnerSanitizeValidClassAsString() {
    assertEquals(OperaLauncherRunner.class, RUNNER.sanitize(OperaLauncherRunner.class.getName()));
  }

  @Test
  public void runnerSanitizeInvalidClassThrows() {
    try {
      RUNNER.sanitize("hoobaflooba");
      fail("Expected WebDriverException");
    } catch (RuntimeException e) {
      assertThat(e, is(instanceOf(WebDriverException.class)));
      assertThat(e.getMessage(), containsString("Unknown runner"));
    }
  }

  @Test
  public void noRestartHasFalseAsDefaultValue() {
    assertTrue(NO_RESTART.getDefaultValue() instanceof Boolean);
    assertFalse((Boolean) NO_RESTART.getDefaultValue());
  }

  @Test
  public void noRestartSanitizeNull() {
    Exception exception = null;

    try {
      NO_RESTART.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void noRestartSanitizeBoolean() {
    assertTrue(NO_RESTART.sanitize(true) instanceof Boolean);
    assertTrue((Boolean) NO_RESTART.sanitize(true));
  }

  @Test
  public void noRestartSanitizeString() {
    assertTrue((Boolean) NO_RESTART.sanitize("true"));
  }

  @Test
  public void noRestartSanitizeInteger() {
    assertTrue((Boolean) NO_RESTART.sanitize(1));
  }

  @Test
  public void noQuitHasFalseAsDefaultValue() {
    assertTrue(NO_QUIT.getDefaultValue() instanceof Boolean);
    assertFalse((Boolean) NO_QUIT.getDefaultValue());
  }

  @Test
  public void noQuitSanitizeNull() {
    Exception exception = null;

    try {
      NO_QUIT.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void noQuitSanitizeBoolean() {
    assertTrue(NO_QUIT.sanitize(true) instanceof Boolean);
    assertTrue((Boolean) NO_QUIT.sanitize(true));
  }

  @Test
  public void noQuitSanitizeString() {
    assertTrue((Boolean) NO_QUIT.sanitize("true"));
  }

  @Test
  public void noQuitSanitizeInteger() {
    assertTrue((Boolean) NO_QUIT.sanitize(1));
  }

  @Test
  public void detachHasFalseAsDefaultValue() {
    assertTrue(DETACH.getDefaultValue() instanceof Boolean);
    assertFalse((Boolean) DETACH.getDefaultValue());
  }

  @Test
  public void detachSanitizeNull() {
    Exception exception = null;

    try {
      DETACH.sanitize(null);
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(NullPointerException.class)));
  }

  @Test
  public void detachSanitizeBoolean() {
    assertTrue(DETACH.sanitize(true) instanceof Boolean);
    assertTrue((Boolean) DETACH.sanitize(true));
  }

  @Test
  public void detachSanitizeString() {
    assertTrue((Boolean) NO_QUIT.sanitize("true"));
  }

  @Test
  public void detachSanitizeInteger() {
    assertTrue((Boolean) NO_QUIT.sanitize("true"));
  }

  @Test
  public void productHasOperaProductDesktopAsDefaultValue() {
    assertEquals(DESKTOP, PRODUCT.getDefaultValue());
  }

  @Test
  public void productSanitizeNull() {
    assertNull(PRODUCT.sanitize(null));
  }

  @Test
  public void productSanitizeValidString() {
    Object product = PRODUCT.sanitize(OperaProduct.MOBILE.getDescriptionString());
    assertTrue(product instanceof OperaProduct);
    assertEquals(OperaProduct.MOBILE, product);
  }

  @Test
  public void productSanitizeInvalidString() {
    Exception exception = null;

    try {
      PRODUCT.sanitize("hoobaflooba");
    } catch (RuntimeException e) {
      exception = e;
    }

    assertThat(exception, is(instanceOf(WebDriverException.class)));
    // TODO(andreastt): Add more checks here
  }

  @Test
  public void productSanitizeOperaProductObject() {
    assertEquals(OperaProduct.MOBILE, PRODUCT.sanitize(OperaProduct.MOBILE));
  }

  @Test
  public void backendHasStringSoftwareAsDefaultValue() {
    assertEquals("software", BACKEND.getDefaultValue());
  }

  @Test
  public void backendSanitizeNull() {
    assertNull(BACKEND.sanitize(null));
  }

  @Test
  public void backendSanitizeString() {
    assertEquals("backend", BACKEND.sanitize("backend"));
  }

  @Test
  public void constructionOfSingleWord() {
    assertEquals("binary", BINARY.getIdentifier());
    assertEquals("opera.binary", BINARY.getCapability());
  }

  @Test
  public void constructionOfMultipleWords() {
    assertEquals("noRestart", NO_RESTART.getIdentifier());
    assertEquals("opera.no_restart", NO_RESTART.getCapability());
  }

  @Test
  public void constructionWithOverride() {
    assertEquals("operaidle", OPERAIDLE.getIdentifier());
    assertEquals("opera.idle", OPERAIDLE.getCapability());
  }

  @Test
  public void constructionWithHierarchicalOverride() {
    assertEquals("loggingLevel", LOGGING_LEVEL.getIdentifier());
    assertEquals("opera.logging.level", LOGGING_LEVEL.getCapability());
  }

  @Test
  public void stringRepresentation() {
    assertNotNull(LOGGING_LEVEL.toString());
  }

}