More options

dotnet/DotnetCore.Test/PackageIntegration.cs

@@ -1,5 +1,4 @@
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Simple.Sauce;
 
 namespace DotnetCore.Test

dotnet/Simple.Sauce/Browser.cs

@@ -7,9 +7,18 @@ private Browser(string browserName)
             Value = browserName;
         }
 
-        public string Value { get; set; }
+        private string Value { get; set; }
 
-        public static Browser Chrome => new Browser("chrome");
-        public static Browser Firefox => new Browser("firefox");
+        public static Browser Chrome { get; } = new Browser("chrome");
+        public static Browser Firefox { get; } = new Browser("firefox");
+        public static Browser Safari { get; } = new Browser("safari");
+        public static Browser Edge { get; } = new Browser("MicrosoftEdge");
+        public static Browser IE { get; } = new Browser("internet explorer");
+
+
+        public override string ToString()
+        {
+            return Value;
+        }
     }
 }

dotnet/Simple.Sauce/DataCenter.cs

@@ -9,10 +9,10 @@ private DataCenter(string value)
 
         public string Value { get; set; }
 
-        public static DataCenter UsWest => new DataCenter("https://ondemand.saucelabs.com/wd/hub");
+        public static DataCenter UsWest => new DataCenter("ondemand.us-west-1.saucelabs.com");
 
-        public static DataCenter UsEast => new DataCenter("https://ondemand.us-east-1.saucelabs.com/wd/hub");
+        public static DataCenter UsEast => new DataCenter("ondemand.us-east-1.saucelabs.com");
 
-        public static object EuCental => new DataCenter("https://ondemand.eu-central-1.saucelabs.com/wd/hub");
+        public static object EuCental => new DataCenter("ondemand.eu-central-1.saucelabs.com");
     }
 }

dotnet/Simple.Sauce/ISauceRemoteDriver.cs

@@ -1,9 +1,11 @@
 using OpenQA.Selenium;
+using System;
 
 namespace Simple.Sauce
 {
     public interface ISauceRemoteDriver : IJavaScriptExecutor, IWebDriver
     {
         IWebDriver CreateRemoteWebDriver(DriverOptions options);
+        IWebDriver CreateRemoteWebDriver(Uri sauceUri, DriverOptions browserOptions);
     }
 }

dotnet/Simple.Sauce/Platforms.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Simple.Sauce
 {
     public class Platforms

dotnet/Simple.Sauce/SauceDriver.cs

@@ -1,23 +1,30 @@
-using System;
-using System.Collections.ObjectModel;
-using OpenQA.Selenium;
+using OpenQA.Selenium;
 using OpenQA.Selenium.Remote;
+using System;
+using System.Collections.ObjectModel;
 
 namespace Simple.Sauce
 {
     public class SauceDriver : ISauceRemoteDriver
     {
-        private IWebDriver _driver; 
+        private IWebDriver _driver;
         public IWebDriver CreateRemoteWebDriver(DriverOptions browserOptions)
         {
             _driver = new RemoteWebDriver(new Uri("https://ondemand.saucelabs.com/wd/hub"),
-                browserOptions.ToCapabilities(), TimeSpan.FromSeconds(600));
+                browserOptions.ToCapabilities(), TimeSpan.FromSeconds(30));
+            return _driver;
+        }
+
+        public IWebDriver CreateRemoteWebDriver(Uri sauceUri, DriverOptions browserOptions)
+        {
+            _driver = new RemoteWebDriver(sauceUri,
+                browserOptions.ToCapabilities(), TimeSpan.FromSeconds(30));
             return _driver;
         }
 
         public object ExecuteScript(string script, params object[] args)
         {
-            return ((IJavaScriptExecutor) _driver).ExecuteScript(script, args);
+            return ((IJavaScriptExecutor)_driver).ExecuteScript(script, args);
         }
 
         public object ExecuteAsyncScript(string script, params object[] args)

dotnet/Simple.Sauce/SauceOptions.cs

@@ -4,28 +4,96 @@
 using OpenQA.Selenium.Chrome;
 using OpenQA.Selenium.Edge;
 using OpenQA.Selenium.Firefox;
+using OpenQA.Selenium.IE;
 using OpenQA.Selenium.Safari;
+
 // ReSharper disable InconsistentNaming
 
 namespace Simple.Sauce
 {
     public class SauceOptions
     {
         private const string DEFAULT_BROWSER_VERSION = "latest";
+
         private const string DEFAULT_PLATFORM = "Windows 10";
 
+        //TODO not fond of this name
+        public static List<string> W3CAllowedOptionsList = new List<string>(new[]
+            {
+                "BrowserName",
+                "BrowserVersion",
+                "PlatformName",
+                "PageLoadStrategy",
+                "AcceptInsecureCerts",
+                "Proxy",
+                "SetWindowRect",
+                "Timeouts",
+                "StrictFileInteractability",
+                "UnhandledPromptBehavior"
+            }
+        );
+
+        private static readonly List<string> _sauceAllowedOptions = new List<string>(new[]
+            {
+                "AvoidProxy",
+                "Build",
+                "CapturePerformance",
+                "ChromedriverVersion",
+                "CommandTimeout",
+                "CustomData",
+                "ExtendedDebugging",
+                "IdleTimeout",
+                "IedriverVersion",
+                "MaxDuration",
+                "Name",
+                "ParentTunnel",
+                "Prerun",
+                "Priority",
+                // public, do not use, reserved keyword, using jobVisibility
+                "RecordLogs",
+                "RecordScreenshots",
+                "RecordVideo",
+                "ScreenResolution",
+                "SeleniumVersion",
+                "Tags",
+                "TimeZone",
+                "TunnelIdentifier",
+                "VideoUploadOnPass"
+            }
+        );
+
+        //TODO could probably store this into an enum
+        private readonly Dictionary<string, string> knownCITools = new Dictionary<string, string>
+        {
+            {"Jenkins", "BUILD_TAG"},
+            {"Bamboo", "bamboo_agentId"},
+            {"Travis", "TRAVIS_JOB_ID"},
+            {"Circle", "CIRCLE_JOB"},
+            {"GitLab", "CI"},
+            {"TeamCity", "TEAMCITY_PROJECT_NAME"},
+            {"ADO", "NEEDS_DEFINITION"}
+        };
+
+        private string _buildName;
+
         public SauceOptions()
         {
-            WithChrome();
             Timeout = new Timeout();
         }
 
-        public EdgeOptions ConfiguredEdgeOptions { get; set; } = new EdgeOptions();
-        public ChromeOptions ConfiguredChromeOptions { get; private set; } = new ChromeOptions();
+        public SauceOptions(DriverOptions options)
+        {
+            SeleniumOptions = options;
+            Timeout = new Timeout();
+            if (options.BrowserName != null) BrowserName = ToBrowserEnum(options.BrowserName);
+        }
+
+        public ChromeOptions ConfiguredChromeOptions { get; } = new ChromeOptions();
         public SafariOptions ConfiguredSafariOptions { get; set; } = new SafariOptions();
+
         public FirefoxOptions ConfiguredFirefoxOptions { get; set; } = new FirefoxOptions();
-        public Browser BrowserName { get; set; } = Browser.Chrome;
-        public String BrowserVersion { get; set; } = DEFAULT_BROWSER_VERSION;
+
+        public string BrowserVersion { get; set; } = DEFAULT_BROWSER_VERSION;
         public Platforms PlatformName { get; set; } = Platforms.Windows10;
         public PageLoadStrategy PageLoadStrategy { get; set; }
         public bool AcceptInsecureCerts { get; set; }
@@ -36,10 +104,36 @@ public SauceOptions()
         public bool StrictFileInteractability { get; set; }
         public UnhandledPromptBehavior UnhandledPromptBehavior { get; set; }
         public bool AvoidProxy { get; set; }
-        public string BuildName { get; set; }
+
+        public string BuildName
+        {
+            get
+            {
+                if (_buildName != null)
+                    return _buildName;
+                if (GetEnvironmentVariable(knownCITools["Jenkins"]) != null)
+                    return GetEnvironmentVariable("BUILD_NAME") + ": " + GetEnvironmentVariable("BUILD_NUMBER");
+                if (GetEnvironmentVariable(knownCITools["Bamboo"]) != null)
+                    return GetEnvironmentVariable("bamboo_shortJobName") + ": " +
+                           GetEnvironmentVariable("bamboo_buildNumber");
+                if (GetEnvironmentVariable(knownCITools["Travis"]) != null)
+                    return GetEnvironmentVariable("TRAVIS_JOB_NAME") + ": " +
+                           GetEnvironmentVariable("TRAVIS_JOB_NUMBER");
+                if (GetEnvironmentVariable(knownCITools["Circle"]) != null)
+                    return GetEnvironmentVariable("CIRCLE_JOB") + ": " + GetEnvironmentVariable("CIRCLE_BUILD_NUM");
+                if (GetEnvironmentVariable(knownCITools["GitLab"]) != null)
+                    return GetEnvironmentVariable("CI_JOB_NAME") + ": " + GetEnvironmentVariable("CI_JOB_ID");
+                if (GetEnvironmentVariable(knownCITools["TeamCity"]) != null)
+                    return GetEnvironmentVariable("TEAMCITY_PROJECT_NAME") + ": " +
+                           GetEnvironmentVariable("BUILD_NUMBER");
+                return "Build Time: " + DateTime.Now;
+            }
+            set => _buildName = value;
+        }
+
         public bool CapturePerformance { get; set; }
         public string ChromedriverVersion { get; set; }
-        public Dictionary<string,string> CustomData { get; set; }
+        public Dictionary<string, string> CustomData { get; set; }
         public bool ExtendedDebugging { get; set; }
         public string IeDriverVersion { get; set; }
         public string TestName { get; set; }
@@ -56,19 +150,97 @@ public SauceOptions()
         public string TimeZone { get; set; }
         public string TunnelIdentifier { get; set; }
         public bool VideoUploadOnPass { get; set; }
+        public DriverOptions SeleniumOptions { get; set; }
+        public Browser BrowserName { get; set; } = Browser.Chrome;
+
+        public DriverOptions ToDriverOptions()
+        {
+            //TODO temporary solution to get the code working
+            var sauceConfiguration = new Dictionary<string, object>
+            {
+                ["username"] = Environment.GetEnvironmentVariable("SAUCE_USERNAME"),
+                ["accessKey"] = Environment.GetEnvironmentVariable("SAUCE_ACCESS_KEY")
+            };
+            //TODO add if logic from the toCapabilities() in Java
+
+            SetDriverOptions();
+            W3CAllowedOptionsList.ForEach(AppendCapabilityToSeleniumOptions);
+
+            SeleniumOptions.AddAdditionalOption("sauce:options", sauceConfiguration);
+            return SeleniumOptions;
+        }
+
+        private void SetDriverOptions()
+        {
+            if (BrowserName == Browser.Edge)
+                SeleniumOptions = new EdgeOptions();
+            else if (BrowserName == Browser.Firefox)
+                SeleniumOptions = new FirefoxOptions();
+            else if(BrowserName == Browser.Chrome)
+                SeleniumOptions = new ChromeOptions();
+            else if(BrowserName == Browser.IE)
+                SeleniumOptions = new InternetExplorerOptions();
+            else if(BrowserName == Browser.Safari)
+                SeleniumOptions = new SafariOptions();
+            else
+                throw new ArgumentOutOfRangeException("The desired browser configuration is not yet set.");
+        }
+
+        private void AppendCapabilityToSeleniumOptions(string capability)
+        {
+            var capabilityValue = TryToGetCapabilityValue(capability);
+            if (capabilityValue != null)
+            {
+                SeleniumOptions.AddAdditionalOption(capability, capabilityValue);
+            }
+        }
 
-        public void WithEdge()
+        private object TryToGetCapabilityValue(string capability)
         {
-            WithEdge(EdgeVersion.Latest);
+            try
+            {
+                return GetType().GetProperty(capability)?.GetValue(this);
+            }
+            catch (NullReferenceException)
+            {
+                return null;
+            }
+
+            //PropertyInfo pinfo = typeof(SauceOptions).GetProperty(capability);
+            //return  pinfo.GetValue(YourInstantiatedObject, null);
         }
 
-        public void WithEdge(EdgeVersion edgeVersion)
+
+        protected string GetEnvironmentVariable(string key)
         {
-            if (edgeVersion == null)
-                throw new ArgumentNullException("Please supply a valid EdgeVersion. You suplied an invalid value=>" +
-                                                edgeVersion);
-            ConfiguredEdgeOptions.BrowserVersion = edgeVersion.Value;
-            ConfiguredEdgeOptions.PlatformName = DEFAULT_PLATFORM;
+            return Environment.GetEnvironmentVariable(key);
+        }
+
+        private Browser ToBrowserEnum(string browserName)
+        {
+            Browser browser;
+            switch (browserName)
+            {
+                case "chrome":
+                    browser = Browser.Chrome;
+                    break;
+                case "MicrosoftEdge":
+                    browser = Browser.Edge;
+                    break;
+                case "firefox":
+                    browser = Browser.Firefox;
+                    break;
+                case "safari":
+                    browser = Browser.Safari;
+                    break;
+                case "internet explorer":
+                    browser = Browser.IE;
+                    break;
+                default:
+                    throw new ArgumentException("No such browser exists.");
+            }
+
+            return browser;
         }
 
         public void WithChrome()