sauce 1.0.2 → 2.0.0

data/support/simplejson/ordered_dict.py

@@ -1,119 +0,0 @@
-"""Drop-in replacement for collections.OrderedDict by Raymond Hettinger
-
-http://code.activestate.com/recipes/576693/
-
-"""
-from UserDict import DictMixin
-
-# Modified from original to support Python 2.4, see
-# http://code.google.com/p/simplejson/issues/detail?id=53
-try:
-    all
-except NameError:
-    def all(seq):
-        for elem in seq:
-            if not elem:
-                return False
-        return True
-
-class OrderedDict(dict, DictMixin):
-
-    def __init__(self, *args, **kwds):
-        if len(args) > 1:
-            raise TypeError('expected at most 1 arguments, got %d' % len(args))
-        try:
-            self.__end
-        except AttributeError:
-            self.clear()
-        self.update(*args, **kwds)
-
-    def clear(self):
-        self.__end = end = []
-        end += [None, end, end]         # sentinel node for doubly linked list
-        self.__map = {}                 # key --> [key, prev, next]
-        dict.clear(self)
-
-    def __setitem__(self, key, value):
-        if key not in self:
-            end = self.__end
-            curr = end[1]
-            curr[2] = end[1] = self.__map[key] = [key, curr, end]
-        dict.__setitem__(self, key, value)
-
-    def __delitem__(self, key):
-        dict.__delitem__(self, key)
-        key, prev, next = self.__map.pop(key)
-        prev[2] = next
-        next[1] = prev
-
-    def __iter__(self):
-        end = self.__end
-        curr = end[2]
-        while curr is not end:
-            yield curr[0]
-            curr = curr[2]
-
-    def __reversed__(self):
-        end = self.__end
-        curr = end[1]
-        while curr is not end:
-            yield curr[0]
-            curr = curr[1]
-
-    def popitem(self, last=True):
-        if not self:
-            raise KeyError('dictionary is empty')
-        # Modified from original to support Python 2.4, see
-        # http://code.google.com/p/simplejson/issues/detail?id=53
-        if last:
-            key = reversed(self).next()
-        else:
-            key = iter(self).next()
-        value = self.pop(key)
-        return key, value
-
-    def __reduce__(self):
-        items = [[k, self[k]] for k in self]
-        tmp = self.__map, self.__end
-        del self.__map, self.__end
-        inst_dict = vars(self).copy()
-        self.__map, self.__end = tmp
-        if inst_dict:
-            return (self.__class__, (items,), inst_dict)
-        return self.__class__, (items,)
-
-    def keys(self):
-        return list(self)
-
-    setdefault = DictMixin.setdefault
-    update = DictMixin.update
-    pop = DictMixin.pop
-    values = DictMixin.values
-    items = DictMixin.items
-    iterkeys = DictMixin.iterkeys
-    itervalues = DictMixin.itervalues
-    iteritems = DictMixin.iteritems
-
-    def __repr__(self):
-        if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, self.items())
-
-    def copy(self):
-        return self.__class__(self)
-
-    @classmethod
-    def fromkeys(cls, iterable, value=None):
-        d = cls()
-        for key in iterable:
-            d[key] = value
-        return d
-
-    def __eq__(self, other):
-        if isinstance(other, OrderedDict):
-            return len(self)==len(other) and \
-                   all(p==q for p, q in  zip(self.items(), other.items()))
-        return dict.__eq__(self, other)
-
-    def __ne__(self, other):
-        return not self == other

data/support/simplejson/scanner.py

@@ -1,77 +0,0 @@
-"""JSON token scanner
-"""
-import re
-def _import_c_make_scanner():
-    try:
-        from simplejson._speedups import make_scanner
-        return make_scanner
-    except ImportError:
-        return None
-c_make_scanner = _import_c_make_scanner()
-
-__all__ = ['make_scanner']
-
-NUMBER_RE = re.compile(
-    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
-    (re.VERBOSE | re.MULTILINE | re.DOTALL))
-
-def py_make_scanner(context):
-    parse_object = context.parse_object
-    parse_array = context.parse_array
-    parse_string = context.parse_string
-    match_number = NUMBER_RE.match
-    encoding = context.encoding
-    strict = context.strict
-    parse_float = context.parse_float
-    parse_int = context.parse_int
-    parse_constant = context.parse_constant
-    object_hook = context.object_hook
-    object_pairs_hook = context.object_pairs_hook
-    memo = context.memo
-
-    def _scan_once(string, idx):
-        try:
-            nextchar = string[idx]
-        except IndexError:
-            raise StopIteration
-
-        if nextchar == '"':
-            return parse_string(string, idx + 1, encoding, strict)
-        elif nextchar == '{':
-            return parse_object((string, idx + 1), encoding, strict,
-                _scan_once, object_hook, object_pairs_hook, memo)
-        elif nextchar == '[':
-            return parse_array((string, idx + 1), _scan_once)
-        elif nextchar == 'n' and string[idx:idx + 4] == 'null':
-            return None, idx + 4
-        elif nextchar == 't' and string[idx:idx + 4] == 'true':
-            return True, idx + 4
-        elif nextchar == 'f' and string[idx:idx + 5] == 'false':
-            return False, idx + 5
-
-        m = match_number(string, idx)
-        if m is not None:
-            integer, frac, exp = m.groups()
-            if frac or exp:
-                res = parse_float(integer + (frac or '') + (exp or ''))
-            else:
-                res = parse_int(integer)
-            return res, m.end()
-        elif nextchar == 'N' and string[idx:idx + 3] == 'NaN':
-            return parse_constant('NaN'), idx + 3
-        elif nextchar == 'I' and string[idx:idx + 8] == 'Infinity':
-            return parse_constant('Infinity'), idx + 8
-        elif nextchar == '-' and string[idx:idx + 9] == '-Infinity':
-            return parse_constant('-Infinity'), idx + 9
-        else:
-            raise StopIteration
-
-    def scan_once(string, idx):
-        try:
-            return _scan_once(string, idx)
-        finally:
-            memo.clear()
-
-    return scan_once
-
-make_scanner = c_make_scanner or py_make_scanner

data/support/simplejson/tool.py

@@ -1,39 +0,0 @@
-r"""Command-line tool to validate and pretty-print JSON
-
-Usage::
-
-    $ echo '{"json":"obj"}' | python -m simplejson.tool
-    {
-        "json": "obj"
-    }
-    $ echo '{ 1.2:3.4}' | python -m simplejson.tool
-    Expecting property name: line 1 column 2 (char 2)
-
-"""
-import sys
-import simplejson as json
-
-def main():
-    if len(sys.argv) == 1:
-        infile = sys.stdin
-        outfile = sys.stdout
-    elif len(sys.argv) == 2:
-        infile = open(sys.argv[1], 'rb')
-        outfile = sys.stdout
-    elif len(sys.argv) == 3:
-        infile = open(sys.argv[1], 'rb')
-        outfile = open(sys.argv[2], 'wb')
-    else:
-        raise SystemExit(sys.argv[0] + " [infile [outfile]]")
-    try:
-        obj = json.load(infile,
-                        object_pairs_hook=json.OrderedDict,
-                        use_decimal=True)
-    except ValueError, e:
-        raise SystemExit(e)
-    json.dump(obj, outfile, sort_keys=True, indent='    ', use_decimal=True)
-    outfile.write('\n')
-
-
-if __name__ == '__main__':
-    main()

data/test/test_config.rb

@@ -1,112 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class TestConfig < Test::Unit::TestCase
-  def test_generates_reasonable_browser_string_from_envrionment
-    preserved_env = {}
-    Sauce::Config::ENVIRONMENT_VARIABLES.each do |key|
-      preserved_env[key] = ENV[key] if ENV[key]
-    end
-    begin
-
-      ENV['SAUCE_USERNAME'] = "test_user"
-      ENV['SAUCE_ACCESS_KEY'] = "test_access"
-      ENV['SAUCE_OS'] = "Linux"
-      ENV['SAUCE_BROWSER'] = "firefox"
-      ENV['SAUCE_BROWSER_VERSION'] = "3."
-
-      config = Sauce::Config.new
-      assert_equal "{\"name\":\"Unnamed Ruby job\",\"access-key\":\"test_access\",\"os\":\"Linux\",\"username\":\"test_user\",\"browser-version\":\"3.\",\"browser\":\"firefox\"}", config.to_browser_string
-    ensure
-      Sauce::Config::ENVIRONMENT_VARIABLES.each do |key|
-        ENV[key] = preserved_env[key]
-      end
-    end
-  end
-
-  def test_generates_browser_string_from_parameters
-    config = Sauce::Config.new(:username => "test_user", :access_key => "test_access",
-                               :os => "Linux", :browser => "firefox", :browser_version => "3.")
-    assert_equal "{\"name\":\"Unnamed Ruby job\",\"access-key\":\"test_access\",\"os\":\"Linux\",\"username\":\"test_user\",\"browser-version\":\"3.\",\"browser\":\"firefox\"}", config.to_browser_string
-  end
-
-  def test_generates_optional_parameters
-    # dashes need to work for backward compatibility
-    config = Sauce::Config.new(:username => "test_user", :access_key => "test_access",
-                               :os => "Linux", :browser => "firefox", :browser_version => "3.",
-                               :"user-extensions-url" => "testing")
-    assert_equal "{\"name\":\"Unnamed Ruby job\",\"access-key\":\"test_access\",\"user-extensions-url\":\"testing\",\"os\":\"Linux\",\"username\":\"test_user\",\"browser-version\":\"3.\",\"browser\":\"firefox\"}", config.to_browser_string
-
-    # underscores are more natural
-    config = Sauce::Config.new(:username => "test_user", :access_key => "test_access",
-                               :os => "Linux", :browser => "firefox", :browser_version => "3.",
-                               :user_extensions_url => "testing")
-    assert_equal "{\"name\":\"Unnamed Ruby job\",\"access-key\":\"test_access\",\"user-extensions-url\":\"testing\",\"os\":\"Linux\",\"username\":\"test_user\",\"browser-version\":\"3.\",\"browser\":\"firefox\"}", config.to_browser_string
-  end
-
-  def test_convenience_accessors
-    config = Sauce::Config.new
-    assert_equal "ondemand.saucelabs.com", config.host
-  end
-
-  def test_gracefully_degrades_browsers_field
-    Sauce.config {|c|}
-    config = Sauce::Config.new
-    config.os = "A"
-    config.browser = "B"
-    config.browser_version = "C"
-
-    assert_equal [["A", "B", "C"]], config.browsers
-  end
-
-  def test_default_to_first_item_in_browsers
-    Sauce.config {|c| c.browsers = [["OS_FOO", "BROWSER_FOO", "VERSION_FOO"]] }
-    config = Sauce::Config.new
-    assert_equal "OS_FOO", config.os
-    assert_equal "BROWSER_FOO", config.browser
-    assert_equal "VERSION_FOO", config.browser_version
-  end
-
-  def test_boolean_flags
-    config = Sauce::Config.new
-    config.foo = true
-    assert config.foo?
-  end
-
-  def test_sauce_config_default_os
-    Sauce.config {|c| c.os = "TEST_OS" }
-    begin
-      config = Sauce::Config.new
-      assert_equal "TEST_OS", config.os
-    ensure
-      Sauce.config {|c|}
-    end
-  end
-
-  def test_can_call_sauce_config_twice
-    Sauce.config {|c| c.os = "A"}
-    assert_equal "A", Sauce::Config.new.os
-    Sauce.config {|c|}
-    assert_not_equal "A", Sauce::Config.new.os
-  end
-
-  def test_override
-    Sauce.config {|c| c.browsers = [["OS_FOO", "BROWSER_FOO", "VERSION_FOO"]] }
-    config = Sauce::Config.new(:os => "OS_BAR", :browser => "BROWSER_BAR", :browser_version => "VERSION_BAR")
-    assert_equal "OS_BAR", config.os
-    assert_equal "BROWSER_BAR", config.browser
-    assert_equal "VERSION_BAR", config.browser_version
-  end
-
-  def test_clears_config
-    Sauce.config {|c|}
-    assert_equal [["Windows 2003", "firefox", "3.6."]], Sauce::Config.new.browsers
-  end
-
-  def test_platforms
-    config = Sauce::Config.new(:os => "Windows 2003")
-    assert_equal "WINDOWS", config.to_desired_capabilities[:platform]
-
-    config = Sauce::Config.new(:os => "Windows 2008")
-    assert_equal "VISTA", config.to_desired_capabilities[:platform]
-  end
-end

data/test/test_connect.rb

@@ -1,45 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class TestConnect < Test::Unit::TestCase
-  def test_running_when_ready
-    connect = Sauce::Connect.new(:host => "saucelabs.com", :port => 80)
-    assert_equal "uninitialized", connect.status
-    connect.wait_until_ready
-    assert_equal "running", connect.status 
-    connect.disconnect
-  end
-
-  def test_error_flag
-    connect = Sauce::Connect.new(:host => "saucelabs.com", :port => 80, :username => 'fail')
-    start = Time.now
-    while Time.now-start < 20 && !connect.error
-      sleep 1
-    end
-
-    assert connect.error
-    connect.disconnect
-  end
-
-  def test_fails_fast_with_no_username
-    Sauce.config {|c| c.username = nil; c.access_key = nil}
-    username = ENV['SAUCE_USERNAME']
-    access_key = ENV['SAUCE_ACCESS_KEY']
-
-    begin
-      ENV['SAUCE_USERNAME'] = nil
-      assert_raises ArgumentError do
-        connect = Sauce::Connect.new(:host => "saucelabs.com", :port => 80)
-      end
-
-      ENV['SAUCE_USERNAME'] = username
-      ENV['SAUCE_ACCESS_KEY'] = nil
-      assert_raises ArgumentError do
-        connect = Sauce::Connect.new(:host => "saucelabs.com", :port => 80)
-      end
-    ensure
-      ENV['SAUCE_USERNAME'] = username
-      ENV['SAUCE_ACCESS_KEY'] = access_key
-      Sauce.config {|c|}
-    end
-  end
-end

data/test/test_job.rb

@@ -1,13 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class TestJob < Test::Unit::TestCase
-  def test_running_a_job_creates_a_reasonable_job_object
-    selenium = Sauce::Selenium.new(:name => "test_running_a_job_creates_a_job_object")
-    selenium.start
-    session_id = selenium.session_id
-    selenium.stop
-
-    job = Sauce::Job.find(session_id)
-    assert_equal "test_running_a_job_creates_a_job_object", job.name
-  end
-end

data/test/test_selenium.rb

@@ -1,50 +0,0 @@
-require File.expand_path("../helper", __FILE__)
-
-class TestSelenium < Test::Unit::TestCase
-  def test_successful_connection_from_environment
-    selenium = Sauce::Selenium.new(:job_name => "Sauce gem test suite: test_selenium.rb",
-                                   :browser_url => "http://www.google.com/")
-    selenium.start
-    selenium.open "/"
-    selenium.stop
-  end
-
-  def test_passed
-    selenium = Sauce::Selenium.new(:job_name => "This test should be marked as passed",
-                                   :browser_url => "http://www.google.com/")
-    selenium.start
-    job_id = selenium.session_id
-    begin
-      selenium.passed!
-    ensure
-      selenium.stop
-    end
-
-    job = Sauce::Job.find(job_id)
-    while job.status == "in progress"
-      sleep 0.5
-      job.refresh!
-    end
-
-    assert job.passed, job
-  end
-
-  def test_failed
-    selenium = Sauce::Selenium.new(:job_name => "This test should be marked as failed",
-                                   :browser_url => "http://www.google.com/")
-    selenium.start
-    job_id = selenium.session_id
-    begin
-      selenium.failed!
-    ensure
-      selenium.stop
-    end
-
-    job = Sauce::Job.find(job_id)
-    while job.status == "in progress"
-      sleep 0.5
-      job.refresh!
-    end
-    assert !job.passed, job
-  end
-end