0.1.1 pilna versija

Contents/Code/DumbTools.py

@@ -0,0 +1,184 @@
+# DumbTools for Plex v1.1 by Cory <babylonstudio@gmail.com>
+import urllib2
+
+
+class DumbKeyboard:
+    clients = ['Plex for iOS', 'Plex Media Player', 'Plex Web']
+    KEYS = list('abcdefghijklmnopqrstuvwxyz1234567890-=;[]\\\',./')
+    SHIFT_KEYS = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()_+:{}|\"<>?')
+
+    def __init__(self, prefix, oc, callback, dktitle=None, dkthumb=None,
+                 dkplaceholder=None, dksecure=False, **kwargs):
+        cb_hash = hash(str(callback)+str(kwargs))
+        Route.Connect(prefix+'/dumbkeyboard/%s'%cb_hash, self.Keyboard)
+        Route.Connect(prefix+'/dumbkeyboard/%s/submit'%cb_hash, self.Submit)
+        Route.Connect(prefix+'/dumbkeyboard/%s/history'%cb_hash, self.History)
+        Route.Connect(prefix+'/dumbkeyboard/%s/history/clear'%cb_hash, self.ClearHistory)
+        Route.Connect(prefix+'/dumbkeyboard/%s/history/add/{query}'%cb_hash, self.AddHistory)
+        # Add our directory item
+        oc.add(DirectoryObject(key=Callback(self.Keyboard, query=dkplaceholder),
+                               title=str(dktitle) if dktitle else \
+                                     u'%s'%L('DumbKeyboard Search'),
+                               thumb=dkthumb))
+        # establish our dict entry
+        if 'DumbKeyboard-History' not in Dict:
+            Dict['DumbKeyboard-History'] = []
+            Dict.Save()
+        self.Callback = callback
+        self.callback_args = kwargs
+        self.secure = dksecure
+
+    def Keyboard(self, query=None, shift=False):
+        if self.secure and query is not None:
+            string = ''.join(['*' for i in range(len(query[:-1]))]) + query[-1]
+        else:
+            string = query if query else ""
+
+        oc = ObjectContainer()
+        # Submit
+        oc.add(DirectoryObject(key=Callback(self.Submit, query=query),
+                               title=u'%s: %s'%(L('Submit'), string.replace(' ', '_'))))
+        # Search History
+        if Dict['DumbKeyboard-History']:
+            oc.add(DirectoryObject(key=Callback(self.History),
+                                   title=u'%s'%L('Search History')))
+        # Space
+        oc.add(DirectoryObject(key=Callback(self.Keyboard,
+                                            query=query+" " if query else " "),
+                               title='Space'))
+        # Backspace (not really needed since you can just hit back)
+        if query is not None:
+            oc.add(DirectoryObject(key=Callback(self.Keyboard, query=query[:-1]),
+                                   title='Backspace'))
+        # Shift
+        oc.add(DirectoryObject(key=Callback(self.Keyboard, query=query, shift=True),
+                               title='Shift'))
+        # Keys
+        for key in self.KEYS if not shift else self.SHIFT_KEYS:
+            oc.add(DirectoryObject(key=Callback(self.Keyboard,
+                                                query=query+key if query else key),
+                                   title=u'%s'%key))
+        return oc
+
+    def History(self):
+        oc = ObjectContainer()
+        if Dict['DumbKeyboard-History']:
+            oc.add(DirectoryObject(key=Callback(self.ClearHistory),
+                                   title=u'%s'%L('Clear History')))
+        for item in Dict['DumbKeyboard-History']:
+            oc.add(DirectoryObject(key=Callback(self.Submit, query=item),
+                                   title=u'%s'%item))
+        return oc
+
+    def ClearHistory(self):
+        Dict['DumbKeyboard-History'] = []
+        Dict.Save()
+        return self.History()
+
+    def AddHistory(self, query):
+        if query not in Dict['DumbKeyboard-History']:
+            Dict['DumbKeyboard-History'].append(query)
+            Dict.Save()
+
+    def Submit(self, query):
+        self.AddHistory(query)
+        kwargs = {'query': query}
+        kwargs.update(self.callback_args)
+        return self.Callback(**kwargs)
+
+
+class DumbPrefs:
+    clients = ['Plex for iOS', 'Plex Media Player', 'Plex Home Theater',
+               'OpenPHT', 'Plex for Roku']
+
+    def __init__(self, prefix, oc, title=None, thumb=None):
+        self.host = 'http://127.0.0.1:32400'
+        try:
+            self.CheckAuth()
+        except Exception as e:
+            Log.Error('DumbPrefs: this user cant access prefs: %s' % str(e))
+            return
+
+        Route.Connect(prefix+'/dumbprefs/list', self.ListPrefs)
+        Route.Connect(prefix+'/dumbprefs/listenum', self.ListEnum)
+        Route.Connect(prefix+'/dumbprefs/set', self.Set)
+        Route.Connect(prefix+'/dumbprefs/settext',  self.SetText)
+        oc.add(DirectoryObject(key=Callback(self.ListPrefs),
+                               title=title if title else L('Preferences'),
+                               thumb=thumb))
+        self.prefix = prefix
+        self.GetPrefs()
+
+    def GetHeaders(self):
+        headers = Request.Headers
+        headers['Connection'] = 'close'
+        return headers
+
+    def CheckAuth(self):
+        """ Only the main users token is accepted at /myplex/account """
+        headers = {'X-Plex-Token': Request.Headers.get('X-Plex-Token', '')}
+        req = urllib2.Request("%s/myplex/account" % self.host, headers=headers)
+        res = urllib2.urlopen(req)
+
+    def GetPrefs(self):
+        data = HTTP.Request("%s/:/plugins/%s/prefs" % (self.host, Plugin.Identifier),
+                            headers=self.GetHeaders())
+        prefs = XML.ElementFromString(data).xpath('/MediaContainer/Setting')
+
+        self.prefs = [{'id': pref.xpath("@id")[0],
+                       'type': pref.xpath("@type")[0],
+                       'label': pref.xpath("@label")[0],
+                       'default': pref.xpath("@default")[0],
+                       'secure': True if pref.xpath("@secure")[0] == "true" else False,
+                       'values': pref.xpath("@values")[0].split("|") \
+                                 if pref.xpath("@values") else None
+                      } for pref in prefs]
+
+    def Set(self, key, value):
+        HTTP.Request("%s/:/plugins/%s/prefs/set?%s=%s" % (self.host,
+                                                          Plugin.Identifier,
+                                                          key, value),
+                     headers=self.GetHeaders(),
+                     immediate=True)
+        return ObjectContainer()
+
+    def ListPrefs(self):
+        oc = ObjectContainer(no_cache=True)
+        for pref in self.prefs:
+            do = DirectoryObject()
+            value = Prefs[pref['id']] if not pref['secure'] else \
+                    ''.join(['*' for i in range(len(Prefs[pref['id']]))])
+            title = u'%s: %s = %s' % (L(pref['label']), pref['type'], L(value))
+            if pref['type'] == 'enum':
+                do.key = Callback(self.ListEnum, id=pref['id'])
+            elif pref['type'] == 'bool':
+                do.key = Callback(self.Set, key=pref['id'],
+                                  value=str(not Prefs[pref['id']]).lower())
+            elif pref['type'] == 'text':
+                if Client.Product in DumbKeyboard.clients:
+                    DumbKeyboard(self.prefix, oc, self.SetText,
+                                 id=pref['id'],
+                                 dktitle=title,
+                                 dkplaceholder=Prefs[pref['id']],
+                                 dksecure=pref['secure'])
+                else:
+                    oc.add(InputDirectoryObject(key=Callback(self.SetText, id=pref['id']),
+                                                title=title))
+                continue
+            else:
+                do.key = Callback(self.ListPrefs)
+            do.title = title
+            oc.add(do)
+        return oc
+
+    def ListEnum(self, id):
+        oc = ObjectContainer()
+        for pref in self.prefs:
+            if pref['id'] == id:
+                for i, option in enumerate(pref['values']):
+                    oc.add(DirectoryObject(key=Callback(self.Set, key=id, value=i),
+                                           title=u'%s'%option))
+        return oc
+
+    def SetText(self, query, id):
+        return self.Set(key=id, value=query)

Contents/Code/__init__.py

@@ -0,0 +1,257 @@
+VERSION = "0.1.1"
+CHANNEL_NAME = "PlayStream"
+PREFIX   = '/video/playstream'
+DEV = True if Platform.MachineIdentifier == 'Unit testing' else False
+
+ART = "art-default.jpg"
+ICON = "icon-default.png"
+BACK = "back.png"
+FOLDER = "folder.png"
+VIDEO = "video.png"
+SEARCH = "folder_search.png"
+PREFS = "prefs.png"
+
+import sys, os, re
+import traceback, glob, inspect, urllib
+import content
+from content.ContentSources import ContentSources
+from content import util
+
+import Framework
+#from Framework.api.objectkit import *
+from DumbTools import DumbKeyboard, DumbPrefs
+
+sources_directory = os.path.join(os.path.dirname(inspect.getsourcefile(content)), "sources")
+sources = ContentSources(sources_directory)
+data0 = None
+title0 = None
+history = []
+
+view_modes = {
+    "List": 65586, "InfoList": 65592, "MediaPreview": 458803, "Showcase": 458810, "Coverflow": 65591,
+    "PanelStream": 131124, "WallStream": 131125, "Songs": 65593, "Seasons": 65593, "Albums": 131123,
+    "Episodes": 65590,"ImageStream":458809,"Pictures":131123
+}
+'''
+for source in sources.plugins:
+  if not ("options" in dir(sources.plugins[source]) and sources.plugins[source].options): continue
+  options = sources.plugins[source].options
+  if not options: continue
+  for option in options:
+    key="%s_%s"%(source,option)
+    if key in ("viaplay_device"): continue # exception list,
+    value = plugin.get_setting(key)
+    options[option] = value
+  sources.plugins[source].options_write(options)
+prefix = ""
+'''
+
+###################################################################################################
+def Start():
+
+    ObjectContainer.title1 = CHANNEL_NAME
+    ObjectContainer.art = R(ART)
+    Plugin.AddViewGroup("InfoList", viewMode="InfoList", mediaType="items")
+    Plugin.AddViewGroup("List", viewMode="List", mediaType="items")
+
+    #DirectoryObject.thumb = R(ICON)
+    #DirectoryObject.art = R(ART)
+    #EpisodeObject.thumb = R(ICON)
+    #EpisodeObject.art = R(ART)
+    #VideoClipObject.thumb = R(ICON)
+    #VideoClipObject.art = R(ART)
+
+    #HTTP.CacheTime = CACHE_1DAY
+    #HTTP.Headers['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
+
+def ValidatePrefs():
+    #preferences =  Prefs._sandbox.preferences.get()
+    for source in sources.plugins:
+        if not ("options" in dir(sources.plugins[source]) and sources.plugins[source].options): continue
+        options = sources.plugins[source].options
+        if not options: continue
+        for option in options:
+            key="%s_%s"%(source,option)
+            if key in ("viaplay_device"): continue # exception list,
+            value = Prefs[key]
+            options[option] = value
+        if not DEV:
+            sources.plugins[source].options_write(options)
+
+####################################################################################################
+@handler(PREFIX, CHANNEL_NAME, art=ART, thumb=ICON)
+def Main():
+
+    data = "config::home"
+    oc = Menu(data, "Home")
+    oc.view_group = "InfoList"
+    ValidatePrefs()
+    return oc
+
+####################################################################################################
+@route(PREFIX+'/{data}/')
+def Menu2(data, title):
+    return Menu(data, title)
+
+@route(PREFIX+'/search')
+def Search(query, data, title):
+    #data = data.replace("%2F", "/")
+    Log("Search data="+data)
+    Log("Search query="+query)
+    data2 = data.format(query)
+    return Menu(data2, title)
+
+@route(PREFIX+'/{data}')
+def Menu(data, title, **kwargs):
+         #includeBandwidths=1, checkFiles=0, includeConcerts=0, includeExtras=0, includeOnDeck=0, includePopularLeaves=1&includeChapters=1&checkFiles=1):
+
+    global data0, title0, history
+    #sources.plugins["config"].read_streams()
+    Log("[playstream] ** Menu call: %s - %s" % ( data, title))
+    if not data:
+        data = u"config::home"
+
+    # Process history
+    if data == "back":
+        data = history[-1][0].replace("/", "%2F") if history and history[-1][0] else "config::home"
+        title = history[-1][1] if history and history[-1][0] else "Home"
+    if data == data0 or (len(history) > 2 and data == history[-2]):
+        # fake call, skipped
+        Log("history skipped")
+    else:
+        if history and history[-1][0] and data == history[-1][0]:
+            history.pop()
+            Log("history poped")
+        else:
+            history.append((data0, title0))
+            Log("history added %s" % data0)
+    data0 = data
+    title0 = title
+    data = data.replace("%2F", "/")
+    hst = ""
+    for h in history: hst += "\n%s" % h[0]
+    #Log("[playstream] history="+hst)
+
+    ### Processig call ###
+    Log("[playstream] processing data=%s"%data)
+    try:
+        is_video = sources.is_video(data)
+    except:
+        Log(traceback.format_exc())
+        return ObjectContainer(header="Error", message=unicode(e))
+
+    ### Video handling ###
+    if is_video:
+        try:
+            streams = sources.get_streams(data)
+        except Exception,e:
+            Log(traceback.format_exc())
+            return ObjectContainer(header="Error", message=unicode(e))
+        if streams:
+            data2 = data.replace("/", "%2F")
+            title = streams[0]["name"] if isinstance(streams[0]["name"] , unicode) else streams[0]["name"].decode("utf8")
+            if not title: title = "Title"
+            desc = streams[0]["desc"] if isinstance(streams[0]["desc"] , unicode) else streams[0]["desc"] .decode("utf8")
+            img = streams[0]["img"] if isinstance(streams[0]["img"] , unicode) else streams[0]["img"] .decode("utf8")
+            vco =  VideoClipObject(
+                key=Callback(Menu, data=data2, title=title ),
+                rating_key=data2,
+                title=title,
+                summary=desc,
+                thumb=thumb_data(img, video=True)
+            )
+            for stream in streams:
+                vco.add(MediaObject(
+                    #bitraate=0,
+                    #container=Container.MPEGTS
+                    optimized_for_streaming = True,
+                    parts=[PartObject(key=HTTPLiveStreamURL(stream["url"]))]
+                ))
+            include_container = True
+            return ObjectContainer(objects = [vco]) if include_container else vco
+        else:
+            return ObjectContainer(header="Error", message="No streams found!")
+
+
+    ### List handling ###
+    oc = ObjectContainer(title2=title)
+    oc.view_group = "InfoList"
+    try:
+        content = sources.get_content(data)
+    except Exception,e:
+        Log(traceback.format_exc())
+        return ObjectContainer(header="Error", message=unicode(e))
+    Log( "[playstream] %s items returned"%len(content))
+
+    for item in content:
+        data2 = item[1]
+        #data2 = urllib.quote(data2, safe="")
+        data2 = data2.replace("/", "%2F")
+        title = item[0] if isinstance(item[0], unicode) else item[0].decode("utf8")
+        if not title: title = "Title"
+        img = item[2]  #if isinstance(item[2], unicode) else item[2].decode("utf8")
+        desc = item[3] if isinstance(item[3], unicode) else item[3].decode("utf8")
+
+        # Search item #
+        if "{0}" in data2:
+            #q = "aaa"  # TODO InputDirectoryObject
+            ##data = data.format(q)
+            if Client.Product in DumbKeyboard.clients:
+                DumbKeyboard(PREFIX, oc, Search,
+                            dktitle = title,
+                            dkthumb = thumb_data(SEARCH),
+                            title=title,
+                            data=data2
+                            )
+            else:
+                oc.add(InputDirectoryObject(
+                    key=Callback(Search, data=data2, title=title),
+                    title = title,
+                    thumb = thumb_data(img), #Resource.ContentsOfURLWithFallback(img, fallback=R(ICON)),
+                    prompt=desc,
+                    summary =desc
+                ))
+
+        # Video item #
+        elif sources.is_video(item[1]):
+            oc.add(VideoClipObject(
+                key=Callback(Menu, data=data2, title=title),
+                title = title,
+                thumb = thumb_data(img, video=True),  #Resource.ContentsOfURLWithFallback(img, fallback=R(ICON)),
+                summary = desc,
+                rating_key=data2
+            ))
+
+        # List object #
+        else:
+            oc.add(DirectoryObject(
+                key=Callback(Menu, data=data2, title=title),
+                title = title,
+                thumb = thumb_data(img) if not data2=="back" else R(BACK),
+                summary =desc
+            ))
+
+    if data == "config::home":
+        if Client.Product in DumbPrefs.clients:
+            DumbPrefs(PREFIX, oc,
+                      title = "Plugin options",
+                      thumb = R(PREFS))
+        else:
+            oc.add(PrefsObject(
+                title="Plugin options",
+                summary="Update plugin options",
+                thumb=R(PREFS),
+                art=R(ART)
+            ))
+        ValidatePrefs()
+    return oc
+
+def thumb_data(img, video=False):
+    default =  R(VIDEO) if video else R(FOLDER)
+    if img.startswith('http'):
+        img2 = Resource.ContentsOfURLWithFallback(img, default)
+    elif img in ("default", ""):
+        img2 = default
+    else:
+        img2 = R(img)
+    return img2

Contents/DefaultPrefs.json

@@ -0,0 +1,24 @@
+[
+    { "id": "general_proxy", "label": "General: Launch stream proxy", "type": "bool", "default": "false" },
+    { "id": "general_port", "label": "General: Proxy port", "type": "number", "default": "8880" },
+    { "id": "general_proxy_url", "label": "General: Proxy URL", "type": "text", "default": "http://localhost:8880/" },
+
+    { "id": "ltc_user", "label": "Lattelecom.tv: User", "type": "text", "default": "change user" },
+    { "id": "ltc_password", "label": "Lattelecom.tv: Password", "type": "text", "default": "change password" },
+
+    { "id": "viaplay_user", "label": "Viaplay: User", "type": "text", "default": "change user" },
+    { "id": "viaplay_password", "label": "Viaplay: Password", "type": "text", "default": "change password" },
+
+    { "id": "tvdom_user", "label": "TVDom: User", "type": "text", "default": "change user" },
+    { "id": "tvdom_password", "label": "TVDom: User", "type": "text", "default": "change password" },
+    { "id": "tvdom_region", "label": "TVDom: Region", "type": "text", "default": "lv" },
+    { "id": "tvdom_lang", "label": "TVDom: Language", "type": "text", "default": "lv" },
+
+    { "id": "iplayer_user", "label": "iPLayer: User", "type": "text", "default": "change user" },
+    { "id": "iplayer_password", "label": "iPlayer: Password", "type": "text", "default": "change password" },
+
+    { "id": "euronews_language", "label": "Euronews: Language", "type": "text", "default": "en" },
+
+    { "id": "ustvnow_user", "label": "USTVNow: User", "type": "text", "default": "change user" },
+    { "id": "ustvnow_password", "label": "USTVNow: Password", "type": "text", "default": "change password" }
+]

Contents/Info.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleIdentifier</key> 		<string>com.plexapp.plugins.playstream</string>
+	<key>PlexClientPlatforms</key> 		<string>*</string>
+	<key>PlexFrameworkVersion</key>		<string>2</string>
+	<key>PlexPluginCodePolicy</key>		<string>Elevated</string>
+</dict>
+</plist>

Contents/VERSION

@@ -0,0 +1 @@
+0.1.1

plex_test_case/.gitignore

@@ -0,0 +1 @@
+*.pyc

plex_test_case/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "mock"]
+	path = mock
+	url = https://github.com/testing-cabal/mock.git

plex_test_case/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License
+===============
+
+Copyright (c) 2016 by Korney Czukowski <carbofos@seznam.cz>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

plex_test_case/README.md

@@ -0,0 +1,154 @@
+Unit Tests for Plex Framework
+=============================
+
+This package is intended for [Plex][plex] channel developers and aims for recreating the Plex Framework environment
+for [unit testing][unittest] the channel code. The framework runs channel code in a restricted sandbox and subjects
+it to various restrictions making it hard to test the code independently. This package provides means to test the
+channel code within the original sandbox as if it was run by the Plex Media Server.
+
+Add to your channel
+-------------------
+
+The suggested place for the tests is a `Tests` subdirectory of the `Contents` directory, but it's not required.
+The most simple way to add this module to your channel is to install it as a git submodule:
+
+ 1. Create and navigate to the `Contents/Tests` directory of your channel.
+ 2. Add a submodule to your repo:
+    
+    `git submodule add https://bitbucket.org/czukowski/plex-test-case.git plex_test_case`
+    
+ 3. Initialize the submodule to have it download necessary code:
+    
+    `git submodule update --init --recursive`
+
+Running tests
+-------------
+
+We'll use Python bundled with Plex Media Server to run the tests. To have it set up correctly, quite a lot of paths
+need to be set up in `PYTHONPATH`. It helps to use an IDE that can help configure it more easily and also provide a
+test runner. The following setup is described for the [PyCharm IDE][PyCharm] (though know that PyCharm introduces a
+couple of its own obstacles to running tests).
+
+ 1. On Windows, the Python interpreter is a file named `PlexScriptHost.exe` located in the Plex folder in Program Files.
+    For some reason PyCharm doesn't want to take a file with such name as a Python interpreter, so making its copy named
+    `python.exe` may be necessary. It [might be fixed][PY-11992] somewhere in the future.
+    
+    For Plex on other operating systems things may be different.
+    
+    The interpreter is set in [Settings / Project Interpreter][PyCharm Interpreter] dialog.
+    
+ 2. Unit test runner that comes with PyCharm is not very well compatible with the Python version Plex Media Server
+    comes with. In PyCharm version 2017, a test runner tries to use a `discover` module which can not be found in
+    Plex distribution (see [PY-24057]). The workaround for now is, sadly, editing a test runner helper file named
+    [`_jb_unittest_runner.py`][_jb_unittest_runner.py], where you can add `import discover` module and skip the
+    highlighted lines on `ImportError`. In PyCharm versions before 2017, the test runner, [`utrunner.py`][utrunner.py]
+    [does not load modules from a ZIP file][PY-12072]. To fix it, [`pycharm_run_utils.py`][pycharm_run_utils.py]
+    needs to be patched as described in [PY-12072]. This is not good as the IDE updates will overwrite those files
+    and you'll need to do it again.
+    
+ 3. Python libraries and extensions must be included in `PYTHONPATH`. The easy way to do it is to add them as content
+    roots in [Settings / Project Structure][PyCharm Content Roots] dialog. The following files and directories are
+    needed (example again from Windows, other OS users should figure that on their own, sorry):
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\DLLs`
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\Exts`
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\python27.zip`
+    
+ 4. Plex Framework specific code also need to be included in `PYTHONPATH`. This is done the same way as above, but first
+    the actual base path has to be determined. It is located in a subfolder named `Plug-ins-???????` under the path
+    `%ProgramFiles(x86)%\Plex\Plex Media Server\Resources\` (question marks stand for a string that resembles a git
+    commit id) and may be different depending on the Plex Media Server version. Also it may change on PMS update and
+    the old folder deleted. A good idea may be to create a symbolic link named just `Plug-ins` and re-link it with each
+    server update instead of re-configuring a number of paths in all projects. The following directories need to be added
+    as content roots:
+    
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\Resources\Plug-ins-???????\Framework.bundle\Contents\Resources\Platforms\Shared\Libraries`
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\Resources\Plug-ins-???????\Framework.bundle\Contents\Resources\Versions\2\Python`
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\Resources\Plug-ins-???????\Framework.bundle\Contents\Resources\Versions\1\Python`
+     * `%ProgramFiles(x86)%\Plex\Plex Media Server\Resources\Plug-ins-???????\Framework.bundle\Contents\Resources\Versions\0\Python`
+    
+    Note the different framework versions in the list above, their load order is actually important, but PyCharm doesn't
+    seem to offer a way to add the Content Roots in a specific order. A workaround for that is implemented in `bootstrap.py`
+    to change the load order if needed.
+    
+ 5. A [run configuration][PyCharm Run Tests] for unit tests needs to be added for the project. Make sure 'Add content roots
+    to PYTHONPATH' is checked. There is also an option to set environment variables that could be used to add the folders
+    above to `PYTHONPATH`, but adding them as content roots has a benefit of offering some insight into the actual
+    Framework code during debugging as well as a (very) limited code completion.
+
+It should be possible to run the tests without any IDE and its test runners. The only thing necessary would be to configure
+`PYTHONPATH` to include all the paths mentioned above, perhaps by creating a batch file.
+
+Creating test cases
+-------------------
+
+Test case classes must extend the base test class, `PlexTestCase`. It provides the functionality to initialize the framework
+and import the tested module in its sandbox. See `__init__.py` file for the implementation details. Many of it may be still
+work in progress though.
+
+To test the module, create a test case module with the same name and a `_test` suffix, then the tested module may be
+accessed using `self.module` property. If you choose another naming convention, you'll need to set `module_name` attribute
+in the test case class beforehand. Note that the tested module must be imported from `Code/__init__.py` either directly
+or indirectly in order for it to be added to the sandboxed environment.
+
+It is possible to test request handling by the channel controllers, using `self.request()` method.
+
+HTTP requests made during testing will not send for real. The intention is to be able to mock these requests and return
+predefined responses. The desired response body and headers may be preset using `self.networking.http_response_body` and
+`self.networking.http_response_headers` in the test case class respectively.
+
+There is a shortcut method to load file contents, accessible via `self.get_file_contents()`. It takes a file name that
+is placed under the current module's subdirectory named after the current test case class.
+
+Example test case module:
+
+```python
+from plex_test_case import PlexTestCase
+from Framework.api.objectkit import ObjectContainer
+
+class MyChannelTest(PlexTestCase):
+
+    def test_main_menu(self):
+        # Load './MyChannelTest/MainMenuObjectContainer.xml' as expected XML generated by channel.
+        expected = self.get_file_contents('MainMenuObjectContainer.xml')
+        # Fix HTTP response from the './MyChannelTest/Index.html' file contents.
+        self.networking.http_response_body = self.get_file_contents('Index.html')
+        # Make a request to channel code (which makes a HTTP request mocked above).
+        status, headers, body = self.request('/video/mychannel')
+        # Check the return values against expected.
+        self.assertEquals(200, status)
+        self.assertEquals('application/xml', headers['Content-Type'])
+        self.assertEquals(expected, body)
+
+class ParserTest(PlexTestCase):
+
+    module_name = 'parser'
+
+    def test_parse(self):
+        # Load './ParserTest/Homepage.html' as input for parser.
+        contents = self.get_file_contents('Homepage.html')
+        # This is what the channel code would have called as 'HTML.ElementFromString(contents)'.
+        # Shared Code modules (*.pys) run in a separate sandbox and could be accessed as `self.shared_code_environment`.
+        nav = self.environment['HTML'].ElementFromString(contents)
+        # Invoke `parse_categories()` function in 'parser.py' module.
+        actual = self.module.parse_categories(nav)
+        # Check actual return value against expected data structure, etc...
+        ...
+```
+
+License
+-------
+
+This code is distributed under the MIT License.
+
+ [plex]: https://plex.tv/
+ [PY-11992]: https://youtrack.jetbrains.com/issue/PY-11992#comment=27-1259532
+ [PY-12072]: https://youtrack.jetbrains.com/issue/PY-12072#comment=27-1255005
+ [PY-24057]: https://youtrack.jetbrains.com/issue/PY-24057
+ [PyCharm]: https://www.jetbrains.com/pycharm/
+ [PyCharm Interpreter]: https://www.jetbrains.com/help/pycharm/configuring-python-interpreter-for-a-project.html
+ [PyCharm Content Roots]: https://www.jetbrains.com/pycharm/help/configuring-content-roots.html
+ [PyCharm Run Tests]: https://www.jetbrains.com/help/pycharm/creating-run-debug-configuration-for-tests.html
+ [pycharm_run_utils.py]: https://github.com/JetBrains/intellij-community/blob/a7ac25ffa1298dd8d53f807889662763e4791a4c/python/helpers/pycharm/pycharm_run_utils.py
+ [unittest]: https://docs.python.org/2/library/unittest.html
+ [utrunner.py]: https://github.com/JetBrains/intellij-community/blob/a7ac25ffa1298dd8d53f807889662763e4791a4c/python/helpers/pycharm/utrunner.py
+ [_jb_unittest_runner.py]: https://github.com/JetBrains/intellij-community/blob/b7d10af1bb03866f733d0712dcd9b31eee719f04/python/helpers/pycharm/_jb_unittest_runner.py#L20-L28

plex_test_case/__init__.py

@@ -0,0 +1,171 @@
+import inspect
+import os
+
+from unittest import TestCase
+from abc import ABCMeta
+
+import bootstrap
+from mock import mock
+from plex import BasicRequest, FrameworkCore, PreferenceManager, Runtime
+
+
+class PlexTestCase(TestCase):
+
+    __metaclass__ = ABCMeta
+
+    module_name = None
+
+    mock = mock
+
+    def __init__(self, methodName='runTest'):
+        TestCase.__init__(self, methodName)
+        # Get bundle and channel info for framework initialization.
+        self.bundle_directory = bootstrap.bundle_directory
+        self.config = bootstrap.config
+        self.framework_directory = bootstrap.framework_directory
+        # Autodetect module name if not defined explicitly.
+        if self.module_name is None:
+            self.module_name = self.__module__
+            if self.module_name[-5:] == '_test':
+                self.module_name = self.module_name[:-5]
+
+    def tearDown(self):
+        # Call teardown methods automatically if not called from the child classes.
+        if hasattr(self, '_core'):
+            self.teardown_framework()
+
+    def setup_framework(self):
+        # Setup framework core object, either call this from `setUp` method or it'll be called when first accessing
+        # the object's `core` property.
+        self._initialize_framework(self.bundle_directory, self.framework_directory, self.config)
+
+    def _initialize_framework(self, bundle_path, framework_dir, config):
+        # Check if the framework has already been initialized.
+        if hasattr(self, '_core'):
+            raise RuntimeError('Plex Framework already initialized.')
+        # Create Framework core object instance.
+        self._core = FrameworkCore(bundle_path, framework_dir, config)
+        # Force wait for shared code sandbox loaded event.
+        self._core.services.shared_code_sandbox
+        # Initialize framework code and start plugin (same as in framework's bootstrap method `run`).
+        if not self._core.load_code():
+            raise RuntimeError('Error loading bundle code.')
+        self._core.start()
+        default_prefs = {k: v.default_value for k, v in self._core.sandbox.preferences.get()._prefs.items()}
+        self._core.sandbox.preferences = PreferenceManager(default_prefs)
+
+    def teardown_framework(self):
+        # Tear down framework core object, call this from `tearDown` method.
+        if hasattr(self, '_core'):
+            self._core.runtime.taskpool.shutdown()
+            self._core.runtime.check_threads()
+            del self._core
+
+    @property
+    def core(self):
+        # Initialize framework automatically if not yet done.
+        if not hasattr(self, '_core'):
+            self.setup_framework()
+        return self._core
+
+    @property
+    def environment(self):
+        return self.core.sandbox.environment
+
+    @property
+    def module(self):
+        return self.environment[self.module_name]
+
+    @property
+    def networking(self):
+        return self.core.networking
+
+    @property
+    def preferences(self):
+        return self.core.sandbox.preferences.get()
+
+    @property
+    def shared_code_environment(self):
+        return self.core.services.shared_code_sandbox.environment
+
+    def get_file_contents(self, filename):
+        # Read file placed in a subdirectory named after the testcase class name.
+        test_path = os.path.dirname(inspect.getfile(self.__class__))
+        with open('%s/%s/%s' % (test_path, self.__class__.__name__, filename), 'r') as content_file:
+            content = content_file.read()
+        return content
+
+    def request(self, path, headers={}, method='GET', body=''):
+        # Make a request to the channel code.
+        request = BasicRequest(path, headers, method, body)
+        return self.core.runtime.handle_request(request)
+
+
+class PlexCall():
+
+    def __init__(self):
+        # Get bundle and channel info for framework initialization.
+        self.bundle_directory = bootstrap.bundle_directory
+        self.config = bootstrap.config
+        self.framework_directory = bootstrap.framework_directory
+
+    def tearDown(self):
+        # Call teardown methods automatically if not called from the child classes.
+        if hasattr(self, '_core'):
+            self.teardown_framework()
+
+    def setup_framework(self):
+        # Setup framework core object, either call this from `setUp` method or it'll be called when first accessing
+        # the object's `core` property.
+        self._initialize_framework(self.bundle_directory, self.framework_directory, self.config)
+
+    def _initialize_framework(self, bundle_path, framework_dir, config):
+        # Check if the framework has already been initialized.
+        if hasattr(self, '_core'):
+            raise RuntimeError('Plex Framework already initialized.')
+        # Create Framework core object instance.
+        self._core = FrameworkCore(bundle_path, framework_dir, config)
+        # Force wait for shared code sandbox loaded event.
+        self._core.services.shared_code_sandbox
+        # Initialize framework code and start plugin (same as in framework's bootstrap method `run`).
+        if not self._core.load_code():
+            raise RuntimeError('Error loading bundle code.')
+        self._core.start()
+        # TODO ielasa no xml faila prefences
+        default_prefs = {k: v.default_value for k, v in self._core.sandbox.preferences.get()._prefs.items()}
+        self._core.sandbox.preferences = PreferenceManager(default_prefs)
+
+    def teardown_framework(self):
+        # Tear down framework core object, call this from `tearDown` method.
+        if hasattr(self, '_core'):
+            self._core.runtime.taskpool.shutdown()
+            self._core.runtime.check_threads()
+            del self._core
+
+    @property
+    def core(self):
+        # Initialize framework automatically if not yet done.
+        if not hasattr(self, '_core'):
+            self.setup_framework()
+        return self._core
+
+    @property
+    def environment(self):
+        return self.core.sandbox.environment
+
+    @property
+    def networking(self):
+        return self.core.networking
+
+    @property
+    def preferences(self):
+        return self.core.sandbox.preferences.get()
+
+    @property
+    def shared_code_environment(self):
+        return self.core.services.shared_code_sandbox.environment
+
+    def request(self, path, headers={}, method='GET', body=''):
+        # Make a request to the channel code.
+        request = BasicRequest(path, headers, method, body)
+        return self.core.runtime.handle_request(request)

plex_test_case/bootstrap.py

@@ -0,0 +1,108 @@
+import errno
+import os
+
+import config
+
+BUNDLED_PLUGINS_PATH_KEY = 'PLEXBUNDLEDPLUGINSPATH'
+LOCAL_APP_DATA_KEY = 'PLEXLOCALAPPDATA'
+
+framework_dir_template = os.path.join('Framework.bundle', 'Contents')
+plugins_path_template = os.path.join(framework_dir_template, 'Resources', 'Versions', '%i', 'Python')
+shared_libs_path_template = os.path.join(framework_dir_template, 'Resources', 'Platforms', 'Shared', 'Libraries')
+framework_versions = [2, 1, 0]
+plugin_bundle_path_template = ['Plex Media Server', 'Plug-ins', '.bundle', 'Contents']
+plugin_bundle_key = 2
+
+
+# Raise error if in the environment variable key is not set or its value is not a directory.
+def validate_directory(key):
+    if not os.environ[key]:
+        raise ValueError('Environment variable %s is empty' % key)
+    elif not os.path.isdir(os.environ[key]):
+        raise OSError(errno.ENOTDIR, os.strerror(errno.ENOENT), os.environ[key])
+
+
+# Determine whether the path in the argument is a framework version path and returns it, or None.
+def pick_framework_path(path_arg):
+    if not path_arg.endswith('Python'):
+        return None
+    for version in framework_versions:
+        path = plugins_path_template % version
+        if path_arg.endswith(path):
+            return path
+    return None
+
+
+# Find the current plugin bundle directory based on assumption that the current file is in some of its subdirectories.
+def find_bundle_directory(path_arg):
+    if not __file__.startswith(path_arg):
+        raise ValueError('File path (%s) expected to start with %s' % (__file__, path_arg))
+    bundle_parts = [path_arg.rstrip(os.sep)]
+    parts = __file__[len(path_arg):].split(os.sep)
+    for index, actual_name in enumerate(parts):
+        if index >= len(plugin_bundle_path_template):
+            break
+        expected_name = plugin_bundle_path_template[index]
+        if index != plugin_bundle_key and actual_name != expected_name:
+            raise ValueError('Unexpected directory name in %s, expected %s' % (__file__, actual_name))
+        elif index == plugin_bundle_key and not actual_name.endswith(expected_name):
+            raise ValueError('Unexpected directory name in %s, expected to end with %s' % (__file__, actual_name))
+        if index <= plugin_bundle_key:
+            bundle_parts.append(actual_name)
+    return os.path.join(*bundle_parts)
+
+
+# Try autodetect `PLEXLOCALAPPDATA` environment variable if not already set.
+if LOCAL_APP_DATA_KEY not in os.environ:
+    def find_plex_local_app_data_path():
+        if 'LOCALAPPDATA' not in os.environ:
+            raise KeyError('Environment variable %s is not set' % 'LOCALAPPDATA')
+        return os.environ['LOCALAPPDATA'] + os.sep
+    os.environ[LOCAL_APP_DATA_KEY] = find_plex_local_app_data_path()
+validate_directory(LOCAL_APP_DATA_KEY)
+
+
+# Try autodetect `PLEXBUNDLEDPLUGINSPATH` environment variable if not already set.
+if BUNDLED_PLUGINS_PATH_KEY not in os.environ:
+    def find_plex_bundled_plugins_path():
+        for sys_path in os.sys.path:
+            path = pick_framework_path(sys_path)
+            if path is not None:
+                bundle_path = sys_path[:-len(path)]
+                return bundle_path.rstrip(os.sep)
+    os.environ[BUNDLED_PLUGINS_PATH_KEY] = find_plex_bundled_plugins_path()
+validate_directory(BUNDLED_PLUGINS_PATH_KEY)
+
+
+# Add shared libraries path if not already added.
+def setup_shared_libs_path(bundled_plugins_path):
+    path = os.path.join(bundled_plugins_path, shared_libs_path_template)
+    if path not in os.sys.path:
+        os.sys.path.append(path)
+setup_shared_libs_path(os.environ[BUNDLED_PLUGINS_PATH_KEY])
+
+
+# Remove and re-add framework paths in `sys.path` as they may have been added in the wrong order.
+def setup_framework_paths(bundled_plugins_path):
+    def make_framework_path(version):
+        return os.path.join(bundled_plugins_path, plugins_path_template) % version
+    version_index = 0
+    for path_index, sys_path in enumerate(os.sys.path):
+        if version_index not in framework_versions:
+            break
+        path = pick_framework_path(sys_path)
+        if path is not None:
+            os.sys.path[path_index] = make_framework_path(framework_versions[version_index])
+            version_index += 1
+    for version_index in range(version_index, len(framework_versions)):
+        os.sys.path.append(make_framework_path(framework_versions[version_index]))
+setup_framework_paths(os.environ[BUNDLED_PLUGINS_PATH_KEY])
+
+# Set module variables useful for framework initialization inside test case.
+#bbundle_directory = find_bundle_directory(os.environ[LOCAL_APP_DATA_KEY])
+bundle_directory = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+framework_directory = os.path.join(os.environ[BUNDLED_PLUGINS_PATH_KEY], plugins_path_template, '..')
+framework_directory = os.path.abspath(framework_directory) % 2
+
+# Import subsystem to install some built-ins required by framework.
+import subsystem

plex_test_case/bootstrap0.py

@@ -0,0 +1,219 @@
+#!/usr/bin/python
+#
+#  Plex Extension Framework
+#  Copyright (C) 2008-2012 Plex, Inc. (James Clarke, Elan Feingold). All Rights Reserved.
+#
+
+## CONFIGURE THE PYTHON ENVIRONMENT ##
+
+import sys
+reload(sys)
+sys.setdefaultencoding('utf-8')
+
+import subsystem
+
+import os
+import config
+
+if sys.platform == "win32":
+  # This is needed to ensure binary data transfer over stdio between PMS and plugins
+  import msvcrt
+  msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
+  msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+
+  # This is needed to prevent explosions when there's a system Python installed whose libraries conflict with our own
+  if 'PLEXLOCALAPPDATA' in os.environ:
+    key = 'PLEXLOCALAPPDATA'
+  else:
+    key = 'LOCALAPPDATA'
+  ourlocalappdata = os.path.join(os.environ[key], 'Plex Media Server')
+  for x in [x for x in sys.path if sys.prefix.lower() not in x.lower() and ourlocalappdata.lower() not in x.lower()]:
+    sys.path.remove(x)
+else:
+  import traceback
+  import sys
+  def dumpstacks(signal, frame):
+    code = []
+    for threadId, stack in sys._current_frames().items():
+      code.append("\n# Thread: %d" % (threadId))
+      for filename, lineno, name, line in traceback.extract_stack(stack):
+        code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
+        if line:
+          code.append("  %s" % (line.strip()))
+    print "\n".join(code)
+
+  import signal
+  signal.signal(signal.SIGUSR1, dumpstacks)
+
+PYTHON_DIR = os.path.dirname(os.path.abspath(sys.argv[0]))
+FRAMEWORK_DIR = os.path.abspath(os.path.join(PYTHON_DIR, '..'))
+
+# Redirect stdout to stderr
+sys.stdout = sys.stderr
+
+if sys.platform == "win32":
+  os_name = "Windows"
+  cpu_name = "i386"
+  #TODO - support Windows x64 (Win64)
+else:
+  uname = os.uname()
+  os_name = uname[0]
+  cpu_name = uname[4]
+
+mapped_cpu = config.cpu_map.get(cpu_name, cpu_name)
+
+# Special case for Linux/x64 (really should be special case for OS X...)
+if os_name == 'Linux' and cpu_name == 'x86_64':
+  mapped_cpu = 'x86_64'
+
+PLATFORM_DIR = os.path.abspath(os.path.join(FRAMEWORK_DIR, '..', '..', "Platforms", config.os_map[os_name], mapped_cpu))
+SHARED_DIR = os.path.abspath(os.path.join(FRAMEWORK_DIR, '..', '..', "Platforms", "Shared"))
+#TODO: Check for errors
+
+# If the environment variable PLEXBUNDLEDEXTS is set, this indicates a newer
+# server which comes bundled with its own binaries so we'll skip this step
+# completely.
+#
+if 'PLEXBUNDLEDEXTS' not in os.environ:
+  lib_path = os.path.join(PLATFORM_DIR, "Libraries")
+  # The binary lib path goes at the end on non-Mac platforms, because binary
+  # extensions should be picked up from the PMS Exts directory first.
+  #
+  if sys.platform != "darwin":
+    sys.path.append(lib_path)
+  else:
+    sys.path.insert(0, lib_path)
+
+# Insert the shared (Python-only) libraries.
+sys.path.insert(0, os.path.join(SHARED_DIR, "Libraries"))
+
+## LOAD AND CONFIGURE THE FRAMEWORK ##
+
+import Framework
+import Framework.constants as const
+from optparse import OptionParser
+
+parser = OptionParser()
+parser.add_option("-i", "--interface", dest="interface", default=config.default_interface)
+parser.add_option("-q", "--quiet", action="store_false", dest="verbose", default=True)
+parser.add_option("-p", "--socket-interface-port", dest="socket_interface_port", default=config.socket_interface_port)
+parser.add_option("-s", "--server-version", dest="server_version")
+parser.add_option("-d", "--daemon", dest="daemon_command")
+parser.add_option("-P", "--pid-file", dest="pid_file")
+parser.add_option("-l", "--log-file", dest="log_file")
+parser.add_option("-c", "--config-file", dest="config_file")
+(options, args) = parser.parse_args()
+
+bundle_path = args[0]
+
+del parser
+del OptionParser
+
+# Select the interface class to use
+if options.interface == const.interface.pipe:
+  interface_class = Framework.interfaces.PipeInterface
+elif options.interface == const.interface.socket:
+  interface_class = Framework.interfaces.SocketInterface
+  if int(options.socket_interface_port) != config.socket_interface_port:
+    config.socket_interface_port = int(options.socket_interface_port)
+else:
+  #TODO: Error info - no matching interface found
+  sys.stderr.write('No matching interface found.\n')
+  sys.exit(1)
+
+if options.server_version != None:
+  config.server_version = options.server_version
+
+# Configure the log_dir, if one was given
+if options.log_file:
+  config.log_file = os.path.abspath(options.log_file)
+
+# Configure the pid file, if one was given
+if options.pid_file:
+  config.pid_file = os.path.abspath(options.pid_file)
+
+# Load the config file if one was provided
+if options.config_file:
+  import simplejson
+  f = open(options.config_file, 'r')
+  json_config = simplejson.load(f)
+  f.close()
+  for key in json_config:
+    setattr(config, key, json_config[key])
+
+def run(daemonized=False):
+  # Copy the damonized attribute into config
+  setattr(config, 'daemonized', daemonized)
+
+  # Create a core object for the plug-in bundle
+  core = Framework.core.FrameworkCore(bundle_path, FRAMEWORK_DIR, config)
+
+  # Try to load the plug-in code
+  if not core.load_code():
+    sys.stderr.write('Error loading bundle code.\n')
+    sys.exit(2)
+
+  # Create an instance of the selected interface
+  interface = interface_class(core)
+
+  # Try to start the core
+  if not core.start():
+    sys.stderr.write('Error starting framework core for %s.\n' % bundle_path)
+    sys.exit(3)
+
+  # Start listening on the interface
+  interface.listen(daemonized)
+
+# If running normally, start the core in the current process
+if options.daemon_command == None:
+  run()
+
+# If issued a daemon command, check what we're supposed to do
+else:
+  import plistlib, daemon, tempfile
+
+  # Read the plist to get the identifier
+  plist_path = os.path.join(bundle_path, 'Contents', 'Info.plist')
+  ident = plistlib.readPlist(plist_path)['CFBundleIdentifier']
+
+  class PluginDaemon(daemon.Daemon):
+    def run(self):
+      run(True)
+
+  # Make sure we have a pid file for this daemon
+  pid_config = dict(identifier = ident, port = config.socket_interface_port)
+  pid_dir = os.path.join(config.root_path, config.pid_files_dir)
+
+  # Create the pid files dir if it doesn't exist
+  if not os.path.exists(pid_dir):
+    try:
+      os.makedirs(pid_dir)
+    except:
+      pass
+
+  if not config.pid_file:
+    pid_file = os.path.join(pid_dir, '%(identifier)s.%(port)d.pid' % pid_config)
+  else:
+    pid_file = config.pid_file % pid_config
+
+  # Create the daemon object
+  d = PluginDaemon(pid_file)
+
+  # Decide which action to perform
+  if options.daemon_command == 'start':
+    d.start()
+  elif options.daemon_command == 'restart':
+    d.restart()
+  elif options.daemon_command == 'stop':
+    # Wait up to 60 seconds for the interface to stop
+    port = 0
+    try:
+      port = pid_config['port']
+      urllib2.urlopen('http://127.0.0.1:%d/:/shutdownInterface' % port, timeout=60)
+    except:
+      print "Error shutting down interface on port %d" % port
+    # Kill the daemon process
+    d.stop()
+  else:
+    print "Unknown command '%s'" % options.daemon_command
+

plex_test_case/config.py

@@ -0,0 +1,113 @@
+#
+#  Plex Extension Framework
+#  Copyright (C) 2008-2012 Plex, Inc. (James Clarke, Elan Feingold). All Rights Reserved.
+#
+
+
+"""
+  Defaults
+"""
+
+default_locale                  = 'en-us'
+default_network_timeout         = 20.0
+module_whitelist                = ['re', 'string', 'datetime', 'time']
+
+
+
+"""
+  Framework config
+"""
+
+default_interface               = 'socket'
+log_level                       = 'Debug'
+console_logging                 = False
+enable_system_debugging         = False
+
+root_path                       = None
+plugin_support_dir_name         = None
+bundles_dir_name                = None
+
+# These variables are only used when app_support_path is defined
+pid_files_dir                   = 'pid'
+log_files_dir                   = 'log'
+plugin_support_files_dir        = 'support'
+bundle_files_dir                = 'bundle'
+
+# These variables override the app support path + individual dir variables if set
+pid_file                        = None
+log_file                        = None
+
+log_internal_component_usage    = False
+show_internal_traceback_frames  = True
+enable_external_debugging       = True
+
+messaging_keepalive_interval    = 20
+messaging_timeout               = 60
+
+taskpool_maximum_threads        = 8
+taskpool_priority_threads       = 2
+
+threadkit_parallel_limit        = 4
+agentservice_update_limit       = 3
+
+socket_interface_port           = 0
+
+http_cache_max_items            = 1024
+http_cache_max_items_grace      = 100
+http_cache_max_size             = 52428800
+
+flags                           = []
+
+ab_api_key = None
+
+cf_domain = None
+cf_token = None
+cf_rooms = {
+  'inc'   : '211292',
+  'dev'   : '213005',
+  'err'   : '521743',
+  'test'  : '442698',
+}
+
+
+"""
+  Platform config
+"""
+
+system_bundle_name              = 'System'
+system_bundle_identifier        = 'com.plexapp.system'
+services_bundle_name            = 'Services'
+services_bundle_identifier      = 'com.plexapp.system.services'
+services_bundle_path            = None
+framework_bundle_name           = 'Framework'
+framework_bundle_identifier     = 'com.plexapp.framework'
+use_node_for_url_lookups        = False
+
+server_version                  = None
+daemonized                      = None
+
+os_map = {
+  "Darwin"                      : "MacOSX",
+  "Linux"                       : "Linux",
+  "Windows"                     : "Windows",
+  "FreeBSD"                     : "FreeBSD",
+  "SunOS"                       : "SunOS",
+}
+
+cpu_map = {
+  "i386"                        : "i386",
+  "i686"                        : "i386",
+  "x86_64"                      : "i386",
+  "amd64"                       : "i386",
+  "3548b0-smp"                  : "MIPS",
+  "mips"                        : "MIPS",
+  "mips64"                      : "mips64",
+  "Win32"                       : "Win32",
+  "armv5tel"                    : "armv5tel",
+  "armv61"                      : "armv5tel",
+  "armv5tejl"                   : "armv5tel",
+  "armv6l"                      : "armv5tel",
+  "armv7l"                      : "armv5tel",
+  "ppc"                         : "ppc",
+  "sun4v"                       : "sun4v",
+}

plex_test_case/mock.py

@@ -0,0 +1,6 @@
+import imp
+import os
+
+mock_path = os.path.join(os.path.dirname(__file__), 'mock')
+f, filename, desc = imp.find_module('mock', [mock_path])
+mock = imp.load_module('mock', f, filename, desc)

plex_test_case/mock/.gitignore

@@ -0,0 +1,20 @@
+.*\.pyc
+*.rej
+html/
+mock\.egg-info/
+mock\.wpu
+\.tox/
+build
+dist
+latex
+.*\$py\.class
+runtox
+*~
+*.pyc
+.testrepository
+.*.swp
+AUTHORS
+ChangeLog
+.eggs
+README.saved
+README.html

plex_test_case/mock/.testr.conf

@@ -0,0 +1,4 @@
+[DEFAULT]
+test_command=${PYTHON:-python} -m subunit.run discover . $LISTOPT $IDOPTION
+test_id_option=--load-list $IDFILE
+test_list_option=--list

plex_test_case/mock/.travis.yml

@@ -0,0 +1,25 @@
+sudo: false
+language: python
+python:
+  - "2.6"
+  - "2.7"
+  - "3.3"
+  - "3.4"
+  - pypy
+  - pypy3
+matrix:
+  include:
+# Travis nightly look to be 3.5.0a4, b3 is out and the syntax error we see
+# doesn't happen in trunk.
+    - python: "nightly"
+      env: SKIP_DOCS=1
+install:
+ - pip install -U pip
+ - pip install -U wheel setuptools
+ - pip install -U .[docs,test]
+ - pip list
+ - python --version
+script:
+ - unit2
+ - if [ -z "$SKIP_DOCS" ]; then python setup.py build_sphinx; fi
+ - rst2html.py --strict README.rst README.html

plex_test_case/mock/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright (c) 2003-2013, Michael Foord & the mock team
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

plex_test_case/mock/NEWS

@@ -0,0 +1,79 @@
+Library
+-------
+
+- Issue #26323: Add Mock.assert_called() and Mock.assert_called_once()
+  methods to unittest.mock. Patch written by Amit Saha.
+
+- Issue #22138: Fix mock.patch behavior when patching descriptors. Restore
+  original values after patching. Patch contributed by Sean McCully.
+
+- Issue #24857: Comparing call_args to a long sequence now correctly returns a
+  boolean result instead of raising an exception.  Patch by A Kaptur.
+
+- Issue #23004: mock_open() now reads binary data correctly when the type of
+  read_data is bytes.  Initial patch by Aaron Hill.
+
+- Issue #21750: mock_open.read_data can now be read from each instance, as it
+  could in Python 3.3.
+
+- Issue #18622: unittest.mock.mock_open().reset_mock would recurse infinitely.
+  Patch from Nicola Palumbo and Laurent De Buyst.
+
+- Issue #23661: unittest.mock side_effects can now be exceptions again. This
+  was a regression vs Python 3.4. Patch from Ignacio Rossi
+
+- Issue #23310: Fix MagicMock's initializer to work with __methods__, just
+  like configure_mock().  Patch by Kasia Jachim.
+
+- Issue #23568: Add rdivmod support to MagicMock() objects.
+  Patch by Håkan Lövdahl.
+
+- Issue #23581: Add matmul support to MagicMock. Patch by Håkan Lövdahl.
+
+- Issue #23326: Removed __ne__ implementations.  Since fixing default __ne__
+  implementation in issue #21408 they are redundant. *** NOT BACKPORTED ***
+
+- Issue #21270: We now override tuple methods in mock.call objects so that
+  they can be used as normal call attributes.
+
+- Issue #21256: Printout of keyword args should be in deterministic order in
+  a mock function call. This will help to write better doctests.
+
+- Issue #21262: New method assert_not_called for Mock.
+  It raises AssertionError if the mock has been called.
+
+- Issue #21238: New keyword argument `unsafe` to Mock. It raises
+  `AttributeError` incase of an attribute startswith assert or assret.
+
+- Issue #21239: patch.stopall() didn't work deterministically when the same
+  name was patched more than once.
+
+- Issue #21222: Passing name keyword argument to mock.create_autospec now
+  works.
+
+- Issue #17826: setting an iterable side_effect on a mock function created by
+  create_autospec now works. Patch by Kushal Das.
+
+- Issue #17826: setting an iterable side_effect on a mock function created by
+  create_autospec now works. Patch by Kushal Das.
+
+- Issue #20968: unittest.mock.MagicMock now supports division.
+  Patch by Johannes Baiter.
+
+- Issue #20189: unittest.mock now no longer assumes that any object for
+  which it could get an inspect.Signature is a callable written in Python.
+  Fix courtesy of Michael Foord.
+
+- Issue #17467: add readline and readlines support to mock_open in
+  unittest.mock.
+
+- Issue #17015: When it has a spec, a Mock object now inspects its signature
+  when matching calls, so that arguments can be matched positionally or
+  by name.
+
+- Issue #15323: improve failure message of Mock.assert_called_once_with
+
+- Issue #14857: fix regression in references to PEP 3135 implicit __class__
+  closure variable (Reopens issue #12370)
+
+- Issue #14295: Add unittest.mock

plex_test_case/mock/README.rst

@@ -0,0 +1,29 @@
+mock is a library for testing in Python. It allows you to replace parts of
+your system under test with mock objects and make assertions about how they
+have been used.
+
+mock is now part of the Python standard library, available as `unittest.mock
+<https://docs.python.org/dev/library/unittest.mock.html>`_ in Python 3.3
+onwards.
+
+This package contains a rolling backport of the standard library mock code
+compatible with Python 2.6 and up, and 3.3 and up.
+
+Please see the standard library documentation for more details.
+
+:Homepage: `Mock Homepage`_
+:Download: `Mock on PyPI`_
+:Documentation: `Python Docs`_
+:License: `BSD License`_
+:Support: `Mailing list (testing-in-python@lists.idyll.org)
+ <http://lists.idyll.org/listinfo/testing-in-python>`_
+:Issue tracker: `Github Issues
+ <https://github.com/testing-cabal/mock/issues>`_
+:Build status:
+  .. image:: https://travis-ci.org/testing-cabal/mock.svg?branch=master
+      :target: https://travis-ci.org/testing-cabal/mock
+
+.. _Mock Homepage: https://github.com/testing-cabal/mock
+.. _BSD License: http://github.com/testing-cabal/mock/blob/master/LICENSE.txt
+.. _Python Docs: https://docs.python.org/dev/library/unittest.mock.html
+.. _mock on PyPI: http://pypi.python.org/pypi/mock

plex_test_case/mock/docs/changelog.txt

@@ -0,0 +1 @@
+../ChangeLog

plex_test_case/mock/docs/conf.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+#
+# Mock documentation build configuration file, created by
+# sphinx-quickstart on Mon Nov 17 18:12:00 2008.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# The contents of this file are pickled, so don't put values in the namespace
+# that aren't pickleable (module imports are okay, they're removed automatically).
+#
+# All configuration values have a default value; values that are commented out
+# serve to show the default value.
+
+import sys, os
+sys.path.insert(0, os.path.abspath('..'))
+
+import mock
+
+# If your extensions are in another directory, add it here. If the directory
+# is relative to the documentation root, use os.path.abspath to make it
+# absolute, like shown here.
+#sys.path.append(os.path.abspath('some/directory'))
+
+# General configuration
+# ---------------------
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.doctest']
+
+doctest_global_setup = """
+import os
+import sys
+import mock
+from mock import * # yeah, I know :-/
+import unittest2
+import __main__
+
+if os.getcwd() not in sys.path:
+    sys.path.append(os.getcwd())
+
+# keep a reference to __main__
+sys.modules['__main'] = __main__
+
+class ProxyModule(object):
+    def __init__(self):
+        self.__dict__ = globals()
+
+sys.modules['__main__'] = ProxyModule()
+"""
+
+doctest_global_cleanup = """
+sys.modules['__main__'] = sys.modules['__main']
+"""
+
+html_theme = 'nature'
+html_theme_options = {}
+
+# Add any paths that contain templates here, relative to this directory.
+#templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.txt'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General substitutions.
+project = u'Mock'
+copyright = u'2007-2015, Michael Foord & the mock team'
+
+# The default replacements for |version| and |release|, also used in various
+# other places throughout the built documents. Supplied by pbr.
+#
+# The short X.Y version.
+version = mock.mock._v.brief_string()
+# The full version, including alpha/beta/rc tags.
+release = mock.__version__
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used: (Set from pbr)
+today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of documents that shouldn't be included in the build.
+#unused_docs = []
+
+# List of directories, relative to source directories, that shouldn't be searched
+# for source files.
+exclude_trees = []
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+add_module_names = False
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'friendly'
+
+
+# Options for HTML output
+# -----------------------
+
+# The style sheet to use for HTML and HTML Help pages. A file of that name
+# must exist either in Sphinx' static/ path, or in one of the custom paths
+# given in html_static_path.
+#html_style = 'adctheme.css'
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+html_use_modindex = False
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, the reST sources are included in the HTML build as _sources/<name>.
+#html_copy_source = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = ''
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Mockdoc'
+
+
+# Options for LaTeX output
+# ------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+latex_font_size = '12pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = [
+  ('index', 'Mock.tex', u'Mock Documentation',
+   u'Michael Foord', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+latex_use_modindex = False

plex_test_case/mock/docs/index.txt

@@ -0,0 +1,189 @@
+====================================
+ Mock - Mocking and Testing Library
+====================================
+
+:Version: |release|
+:Date: |today|
+:Homepage: `Mock Homepage`_
+:Download: `Mock on PyPI`_
+:Documentation: `Python Docs`_
+:License: `BSD License`_
+:Support: `Mailing list (testing-in-python@lists.idyll.org)
+ <http://lists.idyll.org/listinfo/testing-in-python>`_
+:Issue tracker: `Github Issues
+ <https://github.com/testing-cabal/mock/issues>`_
+:Last sync: cb6aab1248c4aec4dd578bea717854505a6fb55d
+
+.. _Mock Homepage: https://github.com/testing-cabal/mock
+.. _BSD License: http://github.com/testing-cabal/mock/blob/master/LICENSE.txt
+.. _Python Docs: https://docs.python.org/dev/library/unittest.mock.html
+
+.. module:: mock
+   :synopsis: Mock object and testing library.
+
+.. index:: introduction
+
+TOC
++++
+
+.. toctree::
+   :maxdepth: 2
+
+   changelog
+
+Introduction
+++++++++++++
+
+mock is a library for testing in Python. It allows you to replace parts of
+your system under test with mock objects and make assertions about how they
+have been used.
+
+mock is now part of the Python standard library, available as
+``unittest.mock`` in Python 3.3 onwards. However, if you are writing code that
+runs on multiple versions of Python the ``mock`` package is better, as you get
+the newest features from the latest release of Python available for all
+Pythons.
+
+The ``mock`` package contains a rolling backport of the standard library mock
+code compatible with Python 2.6 and up, and 3.3 and up. Python 3.2 is supported
+by mock 1.3.0 and below - with pip no longer supporting 3.2, we cannot test
+against that version anymore.
+
+Please see the standard library documentation for usage details.
+
+.. index:: installing
+.. _installing:
+
+Installing
+++++++++++
+
+The current version is |release|. Mock is stable and widely used.
+
+* `mock on PyPI <http://pypi.python.org/pypi/mock>`_
+
+.. index:: repository
+.. index:: git
+
+You can checkout the latest development version from Github
+repository with the following command:
+
+    ``git clone https://github.com/testing-cabal/mock``
+
+
+.. index:: pip
+
+You can install mock with pip:
+
+    | ``pip install -U mock``
+
+Alternatively you can download the mock distribution from PyPI and after
+unpacking run:
+
+   ``python setup.py install``
+
+
+.. index:: bug reports
+
+Bug Reports
++++++++++++
+
+Mock uses `unittest2 <http://pypi.python.org/pypi/unittest2>`_ for its own
+Issues with the backport process, such as compatibility with a particular
+Python, should be reported to the `bug tracker
+<https://github.com/testing-cabal/mock/issues>`_. Feature requests and issues
+with Mock functionality should be reported to the `Python bug tracker
+<https://bugs.python.org>`_.
+
+.. index:: python changes
+
+Python Changes
+++++++++++++++
+
+Python NEWS entries from cPython:
+
+.. include:: ../NEWS
+
+.. index:: older versions
+
+Older Versions of Python
+++++++++++++++++++++++++
+
+Version 1.0.1 is the last version compatible with Python < 2.6.
+
+.. index:: maintainer notes
+
+Maintainer Notes
+++++++++++++++++
+
+Development
+===========
+
+Checkout from git (see :ref:`installing`) and submit pull requests.
+
+Committers can just push as desired: since all semantic development takes
+place in cPython, the backport process is as lightweight as we can make it.
+
+mock is CI tested using Travis-CI on Python versions 2.6, 2.7, 3.3, 3.4,
+3.5, nightly Python 3 builds, pypy, pypy3. Jython support is desired, if
+someone could contribute a patch to .travis.yml to support it that would be
+excellent.
+
+Releasing
+=========
+
+NB: please use semver. Bump the major component on API breaks, minor on all
+non-bugfix changes, patch on bugfix only changes.
+
+1. tag -s, push --tags origin master
+2. setup.py sdist bdist_wheel upload -s
+
+
+Backporting rules
+=================
+
+isinstance checks in cPython to ``type`` need to check ``ClassTypes``.
+Code calling ``obj.isidentifier`` needs to change to ``_isidentifier(obj)``.
+
+Backporting process
+===================
+
+1. Patch your git am with `my patch <https://github.com/rbtcollins/git>`_.
+2. Install the applypatch-transform hook from tools/ to your .git hooks dir.
+3. Configure a pre-applypatch hook to test at least all the cPython versions
+   we support on each patch that is applied. I use containers, and a sample
+   script is in tools/pre-applypatch.
+4. Pull down the cPython git mirror: https://github.com/python/cpython.git
+5. Export the new revisions since the ``Last sync`` at the top of this
+   document::
+
+     revs=${lastsync}
+     rm migrate-export
+     git log --pretty="format:%H " $revs.. -- Lib/unittest/mock.py \
+       Lib/unittest/test/testmock/ > migrate-revs
+     tac migrate-revs > migrate-sorted-revs
+     for rev in $(< migrate-sorted-revs); do
+           git format-patch -1 $rev -k --stdout >> migrate-export;
+           done
+     echo NEW SYNC POINT: $(git rev-parse HEAD)
+
+6. Import into mock::
+
+     git am -k --reject $path-to-cpython/migrate-export
+
+   This will transform the patches automatically. Currently it will error
+   on every NEWS change as I haven't gotten around to making those patches
+   automatic. Fixup any errors that occur. When the patch is ready, do a ``git
+   add -u`` to update the index and then ``git am --continue`` to move onto
+   the next patch. If the patch is inappropriate e.g. the patch removing
+   __ne__ which would break older pythons, then either do ``git reset --hard;
+   git am --skip`` to discard any partially applied changes and skip over it,
+   or, if it has a NEWS entry thats worth preserving, edit it down to just
+   that, with a note such as we have for the ``__ne__`` patch, and continue on
+   from there.
+
+   The goal is that every patch work at all times.
+
+7. After the import is complete, update this document with the new sync point.
+
+8. Push to a personal branch and propose a PR to the main repo. This will make
+   Travis-CI test it. If it works, push to the main repo.

plex_test_case/mock/extendmock.py

@@ -0,0 +1 @@
+# merged into mock.py in Mock 0.7

plex_test_case/mock/mock.wpr

@@ -0,0 +1,26 @@
+#!wing
+#!version=4.0
+##################################################################
+# Wing IDE project file                                          #
+##################################################################
+[project attributes]
+proj.directory-list = [{'dirloc': loc('.'),
+                        'excludes': [u'latex',
+                                     u'.hg',
+                                     u'.tox',
+                                     u'dist',
+                                     u'htmlcov',
+                                     u'extendmock.py',
+                                     u'__pycache__',
+                                     u'html',
+                                     u'build',
+                                     u'mock.egg-info',
+                                     u'tests/__pycache__',
+                                     u'.hgignore',
+                                     u'.hgtags'],
+                        'filter': '*',
+                        'include_hidden': 0,
+                        'recursive': 1,
+                        'watch_for_changes': 1}]
+proj.file-type = 'shared'
+testing.auto-test-file-specs = ('test*.py',)

plex_test_case/mock/mock/__init__.py

@@ -0,0 +1,4 @@
+from __future__ import absolute_import
+import mock.mock as _mock
+from mock.mock import *
+__all__ = _mock.__all__

plex_test_case/mock/mock/tests/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/

plex_test_case/mock/mock/tests/__main__.py

@@ -0,0 +1,18 @@
+import os
+import unittest
+
+
+def load_tests(loader, standard_tests, pattern):
+    # top level directory cached on loader instance
+    this_dir = os.path.dirname(__file__)
+    pattern = pattern or "test*.py"
+    # We are inside unittest.test.testmock, so the top-level is three notches up
+    top_level_dir = os.path.dirname(os.path.dirname(os.path.dirname(this_dir)))
+    package_tests = loader.discover(start_dir=this_dir, pattern=pattern,
+                                    top_level_dir=top_level_dir)
+    standard_tests.addTests(package_tests)
+    return standard_tests
+
+
+if __name__ == '__main__':
+    unittest.main()

plex_test_case/mock/mock/tests/support.py

@@ -0,0 +1,36 @@
+import sys
+
+info = sys.version_info
+import unittest2
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return hasattr(obj, '__call__')
+
+
+with_available = sys.version_info[:2] >= (2, 5)
+
+
+def is_instance(obj, klass):
+    """Version of is_instance that doesn't access __class__"""
+    return issubclass(type(obj), klass)
+
+
+class SomeClass(object):
+    class_attribute = None
+
+    def wibble(self):
+        pass
+
+
+class X(object):
+    pass
+
+try:
+    next = next
+except NameError:
+    def next(obj):
+        return obj.next()

plex_test_case/mock/mock/tests/testcallable.py

@@ -0,0 +1,158 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+import unittest2 as unittest
+from mock.tests.support import is_instance, X, SomeClass
+
+from mock import (
+    Mock, MagicMock, NonCallableMagicMock,
+    NonCallableMock, patch, create_autospec,
+    CallableMixin
+)
+
+
+
+class TestCallable(unittest.TestCase):
+
+    def assertNotCallable(self, mock):
+        self.assertTrue(is_instance(mock, NonCallableMagicMock))
+        self.assertFalse(is_instance(mock, CallableMixin))
+
+
+    def test_non_callable(self):
+        for mock in NonCallableMagicMock(), NonCallableMock():
+            self.assertRaises(TypeError, mock)
+            self.assertFalse(hasattr(mock, '__call__'))
+            self.assertIn(mock.__class__.__name__, repr(mock))
+
+
+    def test_heirarchy(self):
+        self.assertTrue(issubclass(MagicMock, Mock))
+        self.assertTrue(issubclass(NonCallableMagicMock, NonCallableMock))
+
+
+    def test_attributes(self):
+        one = NonCallableMock()
+        self.assertTrue(issubclass(type(one.one), Mock))
+
+        two = NonCallableMagicMock()
+        self.assertTrue(issubclass(type(two.two), MagicMock))
+
+
+    def test_subclasses(self):
+        class MockSub(Mock):
+            pass
+
+        one = MockSub()
+        self.assertTrue(issubclass(type(one.one), MockSub))
+
+        class MagicSub(MagicMock):
+            pass
+
+        two = MagicSub()
+        self.assertTrue(issubclass(type(two.two), MagicSub))
+
+
+    def test_patch_spec(self):
+        patcher = patch('%s.X' % __name__, spec=True)
+        mock = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        instance = mock()
+        mock.assert_called_once_with()
+
+        self.assertNotCallable(instance)
+        self.assertRaises(TypeError, instance)
+
+
+    def test_patch_spec_set(self):
+        patcher = patch('%s.X' % __name__, spec_set=True)
+        mock = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        instance = mock()
+        mock.assert_called_once_with()
+
+        self.assertNotCallable(instance)
+        self.assertRaises(TypeError, instance)
+
+
+    def test_patch_spec_instance(self):
+        patcher = patch('%s.X' % __name__, spec=X())
+        mock = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.assertNotCallable(mock)
+        self.assertRaises(TypeError, mock)
+
+
+    def test_patch_spec_set_instance(self):
+        patcher = patch('%s.X' % __name__, spec_set=X())
+        mock = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.assertNotCallable(mock)
+        self.assertRaises(TypeError, mock)
+
+
+    def test_patch_spec_callable_class(self):
+        class CallableX(X):
+            def __call__(self):
+                pass
+
+        class Sub(CallableX):
+            pass
+
+        class Multi(SomeClass, Sub):
+            pass
+
+        class OldStyle:
+            def __call__(self):
+                pass
+
+        class OldStyleSub(OldStyle):
+            pass
+
+        for arg in 'spec', 'spec_set':
+            for Klass in CallableX, Sub, Multi, OldStyle, OldStyleSub:
+                with patch('%s.X' % __name__, **{arg: Klass}) as mock:
+                    instance = mock()
+                    mock.assert_called_once_with()
+
+                    self.assertTrue(is_instance(instance, MagicMock))
+                    # inherited spec
+                    self.assertRaises(AttributeError, getattr, instance,
+                                      'foobarbaz')
+
+                    result = instance()
+                    # instance is callable, result has no spec
+                    instance.assert_called_once_with()
+
+                    result(3, 2, 1)
+                    result.assert_called_once_with(3, 2, 1)
+                    result.foo(3, 2, 1)
+                    result.foo.assert_called_once_with(3, 2, 1)
+
+
+    def test_create_autospec(self):
+        mock = create_autospec(X)
+        instance = mock()
+        self.assertRaises(TypeError, instance)
+
+        mock = create_autospec(X())
+        self.assertRaises(TypeError, mock)
+
+
+    def test_create_autospec_instance(self):
+        mock = create_autospec(SomeClass, instance=True)
+
+        self.assertRaises(TypeError, mock)
+        mock.wibble()
+        mock.wibble.assert_called_once_with()
+
+        self.assertRaises(TypeError, mock.wibble, 'some',  'args')
+
+
+if __name__ == "__main__":
+    unittest.main()

plex_test_case/mock/mock/tests/testhelpers.py

@@ -0,0 +1,975 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+import six
+import unittest2 as unittest
+
+from mock import (
+    call, create_autospec, MagicMock,
+    Mock, ANY, patch, PropertyMock
+)
+from mock.mock import _Call, _CallList
+
+from datetime import datetime
+
+class SomeClass(object):
+    def one(self, a, b):
+        pass
+    def two(self):
+        pass
+    def three(self, a=None):
+        pass
+
+
+
+class AnyTest(unittest.TestCase):
+
+    def test_any(self):
+        self.assertEqual(ANY, object())
+
+        mock = Mock()
+        mock(ANY)
+        mock.assert_called_with(ANY)
+
+        mock = Mock()
+        mock(foo=ANY)
+        mock.assert_called_with(foo=ANY)
+
+    def test_repr(self):
+        self.assertEqual(repr(ANY), '<ANY>')
+        self.assertEqual(str(ANY), '<ANY>')
+
+
+    def test_any_and_datetime(self):
+        mock = Mock()
+        mock(datetime.now(), foo=datetime.now())
+
+        mock.assert_called_with(ANY, foo=ANY)
+
+
+    def test_any_mock_calls_comparison_order(self):
+        mock = Mock()
+        d = datetime.now()
+        class Foo(object):
+            def __eq__(self, other):
+                return False
+            def __ne__(self, other):
+                return True
+
+        for d in datetime.now(), Foo():
+            mock.reset_mock()
+
+            mock(d, foo=d, bar=d)
+            mock.method(d, zinga=d, alpha=d)
+            mock().method(a1=d, z99=d)
+
+            expected = [
+                call(ANY, foo=ANY, bar=ANY),
+                call.method(ANY, zinga=ANY, alpha=ANY),
+                call(), call().method(a1=ANY, z99=ANY)
+            ]
+            self.assertEqual(expected, mock.mock_calls)
+            self.assertEqual(mock.mock_calls, expected)
+
+
+
+class CallTest(unittest.TestCase):
+
+    def test_call_with_call(self):
+        kall = _Call()
+        self.assertEqual(kall, _Call())
+        self.assertEqual(kall, _Call(('',)))
+        self.assertEqual(kall, _Call(((),)))
+        self.assertEqual(kall, _Call(({},)))
+        self.assertEqual(kall, _Call(('', ())))
+        self.assertEqual(kall, _Call(('', {})))
+        self.assertEqual(kall, _Call(('', (), {})))
+        self.assertEqual(kall, _Call(('foo',)))
+        self.assertEqual(kall, _Call(('bar', ())))
+        self.assertEqual(kall, _Call(('baz', {})))
+        self.assertEqual(kall, _Call(('spam', (), {})))
+
+        kall = _Call(((1, 2, 3),))
+        self.assertEqual(kall, _Call(((1, 2, 3),)))
+        self.assertEqual(kall, _Call(('', (1, 2, 3))))
+        self.assertEqual(kall, _Call(((1, 2, 3), {})))
+        self.assertEqual(kall, _Call(('', (1, 2, 3), {})))
+
+        kall = _Call(((1, 2, 4),))
+        self.assertNotEqual(kall, _Call(('', (1, 2, 3))))
+        self.assertNotEqual(kall, _Call(('', (1, 2, 3), {})))
+
+        kall = _Call(('foo', (1, 2, 4),))
+        self.assertNotEqual(kall, _Call(('', (1, 2, 4))))
+        self.assertNotEqual(kall, _Call(('', (1, 2, 4), {})))
+        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4))))
+        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4), {})))
+
+        kall = _Call(({'a': 3},))
+        self.assertEqual(kall, _Call(('', (), {'a': 3})))
+        self.assertEqual(kall, _Call(('', {'a': 3})))
+        self.assertEqual(kall, _Call(((), {'a': 3})))
+        self.assertEqual(kall, _Call(({'a': 3},)))
+
+
+    def test_empty__Call(self):
+        args = _Call()
+
+        self.assertEqual(args, ())
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(args, ((),))
+        self.assertEqual(args, ('foo', ()))
+        self.assertEqual(args, ('foo',(), {}))
+        self.assertEqual(args, ('foo', {}))
+        self.assertEqual(args, ({},))
+
+
+    def test_named_empty_call(self):
+        args = _Call(('foo', (), {}))
+
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(args, ('foo', ()))
+        self.assertEqual(args, ('foo',(), {}))
+        self.assertEqual(args, ('foo', {}))
+
+        self.assertNotEqual(args, ((),))
+        self.assertNotEqual(args, ())
+        self.assertNotEqual(args, ({},))
+        self.assertNotEqual(args, ('bar',))
+        self.assertNotEqual(args, ('bar', ()))
+        self.assertNotEqual(args, ('bar', {}))
+
+
+    def test_call_with_args(self):
+        args = _Call(((1, 2, 3), {}))
+
+        self.assertEqual(args, ((1, 2, 3),))
+        self.assertEqual(args, ('foo', (1, 2, 3)))
+        self.assertEqual(args, ('foo', (1, 2, 3), {}))
+        self.assertEqual(args, ((1, 2, 3), {}))
+
+
+    def test_named_call_with_args(self):
+        args = _Call(('foo', (1, 2, 3), {}))
+
+        self.assertEqual(args, ('foo', (1, 2, 3)))
+        self.assertEqual(args, ('foo', (1, 2, 3), {}))
+
+        self.assertNotEqual(args, ((1, 2, 3),))
+        self.assertNotEqual(args, ((1, 2, 3), {}))
+
+
+    def test_call_with_kwargs(self):
+        args = _Call(((), dict(a=3, b=4)))
+
+        self.assertEqual(args, (dict(a=3, b=4),))
+        self.assertEqual(args, ('foo', dict(a=3, b=4)))
+        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
+        self.assertEqual(args, ((), dict(a=3, b=4)))
+
+
+    def test_named_call_with_kwargs(self):
+        args = _Call(('foo', (), dict(a=3, b=4)))
+
+        self.assertEqual(args, ('foo', dict(a=3, b=4)))
+        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
+
+        self.assertNotEqual(args, (dict(a=3, b=4),))
+        self.assertNotEqual(args, ((), dict(a=3, b=4)))
+
+
+    def test_call_with_args_call_empty_name(self):
+        args = _Call(((1, 2, 3), {}))
+        self.assertEqual(args, call(1, 2, 3))
+        self.assertEqual(call(1, 2, 3), args)
+        self.assertIn(call(1, 2, 3), [args])
+
+
+    def test_call_ne(self):
+        self.assertNotEqual(_Call(((1, 2, 3),)), call(1, 2))
+        self.assertFalse(_Call(((1, 2, 3),)) != call(1, 2, 3))
+        self.assertTrue(_Call(((1, 2), {})) != call(1, 2, 3))
+
+
+    def test_call_non_tuples(self):
+        kall = _Call(((1, 2, 3),))
+        for value in 1, None, self, int:
+            self.assertNotEqual(kall, value)
+            self.assertFalse(kall == value)
+
+
+    def test_repr(self):
+        self.assertEqual(repr(_Call()), 'call()')
+        self.assertEqual(repr(_Call(('foo',))), 'call.foo()')
+
+        self.assertEqual(repr(_Call(((1, 2, 3), {'a': 'b'}))),
+                         "call(1, 2, 3, a='b')")
+        self.assertEqual(repr(_Call(('bar', (1, 2, 3), {'a': 'b'}))),
+                         "call.bar(1, 2, 3, a='b')")
+
+        self.assertEqual(repr(call), 'call')
+        self.assertEqual(str(call), 'call')
+
+        self.assertEqual(repr(call()), 'call()')
+        self.assertEqual(repr(call(1)), 'call(1)')
+        self.assertEqual(repr(call(zz='thing')), "call(zz='thing')")
+
+        self.assertEqual(repr(call().foo), 'call().foo')
+        self.assertEqual(repr(call(1).foo.bar(a=3).bing),
+                         'call().foo.bar().bing')
+        self.assertEqual(
+            repr(call().foo(1, 2, a=3)),
+            "call().foo(1, 2, a=3)"
+        )
+        self.assertEqual(repr(call()()), "call()()")
+        self.assertEqual(repr(call(1)(2)), "call()(2)")
+        self.assertEqual(
+            repr(call()().bar().baz.beep(1)),
+            "call()().bar().baz.beep(1)"
+        )
+
+
+    def test_call(self):
+        self.assertEqual(call(), ('', (), {}))
+        self.assertEqual(call('foo', 'bar', one=3, two=4),
+                         ('', ('foo', 'bar'), {'one': 3, 'two': 4}))
+
+        mock = Mock()
+        mock(1, 2, 3)
+        mock(a=3, b=6)
+        self.assertEqual(mock.call_args_list,
+                         [call(1, 2, 3), call(a=3, b=6)])
+
+    def test_attribute_call(self):
+        self.assertEqual(call.foo(1), ('foo', (1,), {}))
+        self.assertEqual(call.bar.baz(fish='eggs'),
+                         ('bar.baz', (), {'fish': 'eggs'}))
+
+        mock = Mock()
+        mock.foo(1, 2 ,3)
+        mock.bar.baz(a=3, b=6)
+        self.assertEqual(mock.method_calls,
+                         [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)])
+
+
+    def test_extended_call(self):
+        result = call(1).foo(2).bar(3, a=4)
+        self.assertEqual(result, ('().foo().bar', (3,), dict(a=4)))
+
+        mock = MagicMock()
+        mock(1, 2, a=3, b=4)
+        self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
+        self.assertNotEqual(mock.call_args, call(1, 2, 3))
+
+        self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
+        self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
+
+        mock = MagicMock()
+        mock.foo(1).bar()().baz.beep(a=6)
+
+        last_call = call.foo(1).bar()().baz.beep(a=6)
+        self.assertEqual(mock.mock_calls[-1], last_call)
+        self.assertEqual(mock.mock_calls, last_call.call_list())
+
+
+    def test_call_list(self):
+        mock = MagicMock()
+        mock(1)
+        self.assertEqual(call(1).call_list(), mock.mock_calls)
+
+        mock = MagicMock()
+        mock(1).method(2)
+        self.assertEqual(call(1).method(2).call_list(),
+                         mock.mock_calls)
+
+        mock = MagicMock()
+        mock(1).method(2)(3)
+        self.assertEqual(call(1).method(2)(3).call_list(),
+                         mock.mock_calls)
+
+        mock = MagicMock()
+        int(mock(1).method(2)(3).foo.bar.baz(4)(5))
+        kall = call(1).method(2)(3).foo.bar.baz(4)(5).__int__()
+        self.assertEqual(kall.call_list(), mock.mock_calls)
+
+
+    def test_call_any(self):
+        self.assertEqual(call, ANY)
+
+        m = MagicMock()
+        int(m)
+        self.assertEqual(m.mock_calls, [ANY])
+        self.assertEqual([ANY], m.mock_calls)
+
+
+    def test_two_args_call(self):
+        args = _Call(((1, 2), {'a': 3}), two=True)
+        self.assertEqual(len(args), 2)
+        self.assertEqual(args[0], (1, 2))
+        self.assertEqual(args[1], {'a': 3})
+
+        other_args = _Call(((1, 2), {'a': 3}))
+        self.assertEqual(args, other_args)
+
+
+class SpecSignatureTest(unittest.TestCase):
+
+    def _check_someclass_mock(self, mock):
+        self.assertRaises(AttributeError, getattr, mock, 'foo')
+        mock.one(1, 2)
+        mock.one.assert_called_with(1, 2)
+        self.assertRaises(AssertionError,
+                          mock.one.assert_called_with, 3, 4)
+        self.assertRaises(TypeError, mock.one, 1)
+
+        mock.two()
+        mock.two.assert_called_with()
+        self.assertRaises(AssertionError,
+                          mock.two.assert_called_with, 3)
+        self.assertRaises(TypeError, mock.two, 1)
+
+        mock.three()
+        mock.three.assert_called_with()
+        self.assertRaises(AssertionError,
+                          mock.three.assert_called_with, 3)
+        self.assertRaises(TypeError, mock.three, 3, 2)
+
+        mock.three(1)
+        mock.three.assert_called_with(1)
+
+        mock.three(a=1)
+        mock.three.assert_called_with(a=1)
+
+
+    def test_basic(self):
+        mock = create_autospec(SomeClass)
+        self._check_someclass_mock(mock)
+        mock = create_autospec(SomeClass())
+        self._check_someclass_mock(mock)
+
+
+    def test_create_autospec_return_value(self):
+        def f():
+            pass
+        mock = create_autospec(f, return_value='foo')
+        self.assertEqual(mock(), 'foo')
+
+        class Foo(object):
+            pass
+
+        mock = create_autospec(Foo, return_value='foo')
+        self.assertEqual(mock(), 'foo')
+
+
+    def test_autospec_reset_mock(self):
+        m = create_autospec(int)
+        int(m)
+        m.reset_mock()
+        self.assertEqual(m.__int__.call_count, 0)
+
+
+    def test_mocking_unbound_methods(self):
+        class Foo(object):
+            def foo(self, foo):
+                pass
+        p = patch.object(Foo, 'foo')
+        mock_foo = p.start()
+        Foo().foo(1)
+
+        mock_foo.assert_called_with(1)
+
+
+    @unittest.expectedFailure
+    def test_create_autospec_unbound_methods(self):
+        # see mock issue 128
+        class Foo(object):
+            def foo(self):
+                pass
+
+        klass = create_autospec(Foo)
+        instance = klass()
+        self.assertRaises(TypeError, instance.foo, 1)
+
+        # Note: no type checking on the "self" parameter
+        klass.foo(1)
+        klass.foo.assert_called_with(1)
+        self.assertRaises(TypeError, klass.foo)
+
+
+    def test_create_autospec_keyword_arguments(self):
+        class Foo(object):
+            a = 3
+        m = create_autospec(Foo, a='3')
+        self.assertEqual(m.a, '3')
+
+    @unittest.skipUnless(six.PY3, "Keyword only arguments Python 3 specific")
+    def test_create_autospec_keyword_only_arguments(self):
+        func_def = "def foo(a, *, b=None):\n    pass\n"
+        namespace = {}
+        exec (func_def, namespace)
+        foo = namespace['foo']
+
+        m = create_autospec(foo)
+        m(1)
+        m.assert_called_with(1)
+        self.assertRaises(TypeError, m, 1, 2)
+
+        m(2, b=3)
+        m.assert_called_with(2, b=3)
+
+    def test_function_as_instance_attribute(self):
+        obj = SomeClass()
+        def f(a):
+            pass
+        obj.f = f
+
+        mock = create_autospec(obj)
+        mock.f('bing')
+        mock.f.assert_called_with('bing')
+
+
+    def test_spec_as_list(self):
+        # because spec as a list of strings in the mock constructor means
+        # something very different we treat a list instance as the type.
+        mock = create_autospec([])
+        mock.append('foo')
+        mock.append.assert_called_with('foo')
+
+        self.assertRaises(AttributeError, getattr, mock, 'foo')
+
+        class Foo(object):
+            foo = []
+
+        mock = create_autospec(Foo)
+        mock.foo.append(3)
+        mock.foo.append.assert_called_with(3)
+        self.assertRaises(AttributeError, getattr, mock.foo, 'foo')
+
+
+    def test_attributes(self):
+        class Sub(SomeClass):
+            attr = SomeClass()
+
+        sub_mock = create_autospec(Sub)
+
+        for mock in (sub_mock, sub_mock.attr):
+            self._check_someclass_mock(mock)
+
+
+    def test_builtin_functions_types(self):
+        # we could replace builtin functions / methods with a function
+        # with *args / **kwargs signature. Using the builtin method type
+        # as a spec seems to work fairly well though.
+        class BuiltinSubclass(list):
+            def bar(self, arg):
+                pass
+            sorted = sorted
+            attr = {}
+
+        mock = create_autospec(BuiltinSubclass)
+        mock.append(3)
+        mock.append.assert_called_with(3)
+        self.assertRaises(AttributeError, getattr, mock.append, 'foo')
+
+        mock.bar('foo')
+        mock.bar.assert_called_with('foo')
+        self.assertRaises(TypeError, mock.bar, 'foo', 'bar')
+        self.assertRaises(AttributeError, getattr, mock.bar, 'foo')
+
+        mock.sorted([1, 2])
+        mock.sorted.assert_called_with([1, 2])
+        self.assertRaises(AttributeError, getattr, mock.sorted, 'foo')
+
+        mock.attr.pop(3)
+        mock.attr.pop.assert_called_with(3)
+        self.assertRaises(AttributeError, getattr, mock.attr, 'foo')
+
+
+    def test_method_calls(self):
+        class Sub(SomeClass):
+            attr = SomeClass()
+
+        mock = create_autospec(Sub)
+        mock.one(1, 2)
+        mock.two()
+        mock.three(3)
+
+        expected = [call.one(1, 2), call.two(), call.three(3)]
+        self.assertEqual(mock.method_calls, expected)
+
+        mock.attr.one(1, 2)
+        mock.attr.two()
+        mock.attr.three(3)
+
+        expected.extend(
+            [call.attr.one(1, 2), call.attr.two(), call.attr.three(3)]
+        )
+        self.assertEqual(mock.method_calls, expected)
+
+
+    def test_magic_methods(self):
+        class BuiltinSubclass(list):
+            attr = {}
+
+        mock = create_autospec(BuiltinSubclass)
+        self.assertEqual(list(mock), [])
+        self.assertRaises(TypeError, int, mock)
+        self.assertRaises(TypeError, int, mock.attr)
+        self.assertEqual(list(mock), [])
+
+        self.assertIsInstance(mock['foo'], MagicMock)
+        self.assertIsInstance(mock.attr['foo'], MagicMock)
+
+
+    def test_spec_set(self):
+        class Sub(SomeClass):
+            attr = SomeClass()
+
+        for spec in (Sub, Sub()):
+            mock = create_autospec(spec, spec_set=True)
+            self._check_someclass_mock(mock)
+
+            self.assertRaises(AttributeError, setattr, mock, 'foo', 'bar')
+            self.assertRaises(AttributeError, setattr, mock.attr, 'foo', 'bar')
+
+
+    def test_descriptors(self):
+        class Foo(object):
+            @classmethod
+            def f(cls, a, b):
+                pass
+            @staticmethod
+            def g(a, b):
+                pass
+
+        class Bar(Foo):
+            pass
+
+        class Baz(SomeClass, Bar):
+            pass
+
+        for spec in (Foo, Foo(), Bar, Bar(), Baz, Baz()):
+            mock = create_autospec(spec)
+            mock.f(1, 2)
+            mock.f.assert_called_once_with(1, 2)
+
+            mock.g(3, 4)
+            mock.g.assert_called_once_with(3, 4)
+
+
+    @unittest.skipIf(six.PY3, "No old style classes in Python 3")
+    def test_old_style_classes(self):
+        class Foo:
+            def f(self, a, b):
+                pass
+
+        class Bar(Foo):
+            g = Foo()
+
+        for spec in (Foo, Foo(), Bar, Bar()):
+            mock = create_autospec(spec)
+            mock.f(1, 2)
+            mock.f.assert_called_once_with(1, 2)
+
+            self.assertRaises(AttributeError, getattr, mock, 'foo')
+            self.assertRaises(AttributeError, getattr, mock.f, 'foo')
+
+        mock.g.f(1, 2)
+        mock.g.f.assert_called_once_with(1, 2)
+        self.assertRaises(AttributeError, getattr, mock.g, 'foo')
+
+
+    def test_recursive(self):
+        class A(object):
+            def a(self):
+                pass
+            foo = 'foo bar baz'
+            bar = foo
+
+        A.B = A
+        mock = create_autospec(A)
+
+        mock()
+        self.assertFalse(mock.B.called)
+
+        mock.a()
+        mock.B.a()
+        self.assertEqual(mock.method_calls, [call.a(), call.B.a()])
+
+        self.assertIs(A.foo, A.bar)
+        self.assertIsNot(mock.foo, mock.bar)
+        mock.foo.lower()
+        self.assertRaises(AssertionError, mock.bar.lower.assert_called_with)
+
+
+    def test_spec_inheritance_for_classes(self):
+        class Foo(object):
+            def a(self, x):
+                pass
+            class Bar(object):
+                def f(self, y):
+                    pass
+
+        class_mock = create_autospec(Foo)
+
+        self.assertIsNot(class_mock, class_mock())
+
+        for this_mock in class_mock, class_mock():
+            this_mock.a(x=5)
+            this_mock.a.assert_called_with(x=5)
+            this_mock.a.assert_called_with(5)
+            self.assertRaises(TypeError, this_mock.a, 'foo', 'bar')
+            self.assertRaises(AttributeError, getattr, this_mock, 'b')
+
+        instance_mock = create_autospec(Foo())
+        instance_mock.a(5)
+        instance_mock.a.assert_called_with(5)
+        instance_mock.a.assert_called_with(x=5)
+        self.assertRaises(TypeError, instance_mock.a, 'foo', 'bar')
+        self.assertRaises(AttributeError, getattr, instance_mock, 'b')
+
+        # The return value isn't isn't callable
+        self.assertRaises(TypeError, instance_mock)
+
+        instance_mock.Bar.f(6)
+        instance_mock.Bar.f.assert_called_with(6)
+        instance_mock.Bar.f.assert_called_with(y=6)
+        self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
+
+        instance_mock.Bar().f(6)
+        instance_mock.Bar().f.assert_called_with(6)
+        instance_mock.Bar().f.assert_called_with(y=6)
+        self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
+
+
+    def test_inherit(self):
+        class Foo(object):
+            a = 3
+
+        Foo.Foo = Foo
+
+        # class
+        mock = create_autospec(Foo)
+        instance = mock()
+        self.assertRaises(AttributeError, getattr, instance, 'b')
+
+        attr_instance = mock.Foo()
+        self.assertRaises(AttributeError, getattr, attr_instance, 'b')
+
+        # instance
+        mock = create_autospec(Foo())
+        self.assertRaises(AttributeError, getattr, mock, 'b')
+        self.assertRaises(TypeError, mock)
+
+        # attribute instance
+        call_result = mock.Foo()
+        self.assertRaises(AttributeError, getattr, call_result, 'b')
+
+
+    def test_builtins(self):
+        # used to fail with infinite recursion
+        create_autospec(1)
+
+        create_autospec(int)
+        create_autospec('foo')
+        create_autospec(str)
+        create_autospec({})
+        create_autospec(dict)
+        create_autospec([])
+        create_autospec(list)
+        create_autospec(set())
+        create_autospec(set)
+        create_autospec(1.0)
+        create_autospec(float)
+        create_autospec(1j)
+        create_autospec(complex)
+        create_autospec(False)
+        create_autospec(True)
+
+
+    def test_function(self):
+        def f(a, b):
+            pass
+
+        mock = create_autospec(f)
+        self.assertRaises(TypeError, mock)
+        mock(1, 2)
+        mock.assert_called_with(1, 2)
+        mock.assert_called_with(1, b=2)
+        mock.assert_called_with(a=1, b=2)
+
+        f.f = f
+        mock = create_autospec(f)
+        self.assertRaises(TypeError, mock.f)
+        mock.f(3, 4)
+        mock.f.assert_called_with(3, 4)
+        mock.f.assert_called_with(a=3, b=4)
+
+
+    def test_skip_attributeerrors(self):
+        class Raiser(object):
+            def __get__(self, obj, type=None):
+                if obj is None:
+                    raise AttributeError('Can only be accessed via an instance')
+
+        class RaiserClass(object):
+            raiser = Raiser()
+
+            @staticmethod
+            def existing(a, b):
+                return a + b
+
+        s = create_autospec(RaiserClass)
+        self.assertRaises(TypeError, lambda x: s.existing(1, 2, 3))
+        s.existing(1, 2)
+        self.assertRaises(AttributeError, lambda: s.nonexisting)
+
+        # check we can fetch the raiser attribute and it has no spec
+        obj = s.raiser
+        obj.foo, obj.bar
+
+
+    def test_signature_class(self):
+        class Foo(object):
+            def __init__(self, a, b=3):
+                pass
+
+        mock = create_autospec(Foo)
+
+        self.assertRaises(TypeError, mock)
+        mock(1)
+        mock.assert_called_once_with(1)
+
+        mock(4, 5)
+        mock.assert_called_with(4, 5)
+
+
+    @unittest.skipIf(six.PY3, 'no old style classes in Python 3')
+    def test_signature_old_style_class(self):
+        class Foo:
+            def __init__(self, a, b=3):
+                pass
+
+        mock = create_autospec(Foo)
+
+        self.assertRaises(TypeError, mock)
+        mock(1)
+        mock.assert_called_once_with(1)
+        mock.assert_called_once_with(a=1)
+        self.assertRaises(AssertionError, mock.assert_called_once_with, 2)
+
+        mock(4, 5)
+        mock.assert_called_with(4, 5)
+        mock.assert_called_with(a=4, b=5)
+        self.assertRaises(AssertionError, mock.assert_called_with, a=5, b=4)
+
+
+    def test_class_with_no_init(self):
+        # this used to raise an exception
+        # due to trying to get a signature from object.__init__
+        class Foo(object):
+            pass
+        create_autospec(Foo)
+
+
+    @unittest.skipIf(six.PY3, 'no old style classes in Python 3')
+    def test_old_style_class_with_no_init(self):
+        # this used to raise an exception
+        # due to Foo.__init__ raising an AttributeError
+        class Foo:
+            pass
+        create_autospec(Foo)
+
+
+    def test_signature_callable(self):
+        class Callable(object):
+            def __init__(self, x, y):
+                pass
+            def __call__(self, a):
+                pass
+
+        mock = create_autospec(Callable)
+        mock(1, 2)
+        mock.assert_called_once_with(1, 2)
+        mock.assert_called_once_with(x=1, y=2)
+        self.assertRaises(TypeError, mock, 'a')
+
+        instance = mock(1, 2)
+        self.assertRaises(TypeError, instance)
+        instance(a='a')
+        instance.assert_called_once_with('a')
+        instance.assert_called_once_with(a='a')
+        instance('a')
+        instance.assert_called_with('a')
+        instance.assert_called_with(a='a')
+
+        mock = create_autospec(Callable(1, 2))
+        mock(a='a')
+        mock.assert_called_once_with(a='a')
+        self.assertRaises(TypeError, mock)
+        mock('a')
+        mock.assert_called_with('a')
+
+
+    def test_signature_noncallable(self):
+        class NonCallable(object):
+            def __init__(self):
+                pass
+
+        mock = create_autospec(NonCallable)
+        instance = mock()
+        mock.assert_called_once_with()
+        self.assertRaises(TypeError, mock, 'a')
+        self.assertRaises(TypeError, instance)
+        self.assertRaises(TypeError, instance, 'a')
+
+        mock = create_autospec(NonCallable())
+        self.assertRaises(TypeError, mock)
+        self.assertRaises(TypeError, mock, 'a')
+
+
+    def test_create_autospec_none(self):
+        class Foo(object):
+            bar = None
+
+        mock = create_autospec(Foo)
+        none = mock.bar
+        self.assertNotIsInstance(none, type(None))
+
+        none.foo()
+        none.foo.assert_called_once_with()
+
+
+    def test_autospec_functions_with_self_in_odd_place(self):
+        class Foo(object):
+            def f(a, self):
+                pass
+
+        a = create_autospec(Foo)
+        a.f(10)
+        a.f.assert_called_with(10)
+        a.f.assert_called_with(self=10)
+        a.f(self=10)
+        a.f.assert_called_with(10)
+        a.f.assert_called_with(self=10)
+
+
+    def test_autospec_property(self):
+        class Foo(object):
+            @property
+            def foo(self):
+                return 3
+
+        foo = create_autospec(Foo)
+        mock_property = foo.foo
+
+        # no spec on properties
+        self.assertIsInstance(mock_property, MagicMock)
+        mock_property(1, 2, 3)
+        mock_property.abc(4, 5, 6)
+        mock_property.assert_called_once_with(1, 2, 3)
+        mock_property.abc.assert_called_once_with(4, 5, 6)
+
+
+    def test_autospec_slots(self):
+        class Foo(object):
+            __slots__ = ['a']
+
+        foo = create_autospec(Foo)
+        mock_slot = foo.a
+
+        # no spec on slots
+        mock_slot(1, 2, 3)
+        mock_slot.abc(4, 5, 6)
+        mock_slot.assert_called_once_with(1, 2, 3)
+        mock_slot.abc.assert_called_once_with(4, 5, 6)
+
+
+class TestCallList(unittest.TestCase):
+
+    def test_args_list_contains_call_list(self):
+        mock = Mock()
+        self.assertIsInstance(mock.call_args_list, _CallList)
+
+        mock(1, 2)
+        mock(a=3)
+        mock(3, 4)
+        mock(b=6)
+
+        for kall in call(1, 2), call(a=3), call(3, 4), call(b=6):
+            self.assertIn(kall, mock.call_args_list)
+
+        calls = [call(a=3), call(3, 4)]
+        self.assertIn(calls, mock.call_args_list)
+        calls = [call(1, 2), call(a=3)]
+        self.assertIn(calls, mock.call_args_list)
+        calls = [call(3, 4), call(b=6)]
+        self.assertIn(calls, mock.call_args_list)
+        calls = [call(3, 4)]
+        self.assertIn(calls, mock.call_args_list)
+
+        self.assertNotIn(call('fish'), mock.call_args_list)
+        self.assertNotIn([call('fish')], mock.call_args_list)
+
+
+    def test_call_list_str(self):
+        mock = Mock()
+        mock(1, 2)
+        mock.foo(a=3)
+        mock.foo.bar().baz('fish', cat='dog')
+
+        expected = (
+            "[call(1, 2),\n"
+            " call.foo(a=3),\n"
+            " call.foo.bar(),\n"
+            " call.foo.bar().baz('fish', cat='dog')]"
+        )
+        self.assertEqual(str(mock.mock_calls), expected)
+
+
+    @unittest.skipIf(six.PY3, "Unicode is properly handled with Python 3")
+    def test_call_list_unicode(self):
+        # See github issue #328
+        mock = Mock()
+
+        class NonAsciiRepr(object):
+            def __repr__(self):
+                return "\xe9"
+
+        mock(**{unicode("a"): NonAsciiRepr()})
+
+        self.assertEqual(str(mock.mock_calls), "[call(a=\xe9)]")
+
+
+    def test_propertymock(self):
+        p = patch('%s.SomeClass.one' % __name__, new_callable=PropertyMock)
+        mock = p.start()
+        try:
+            SomeClass.one
+            mock.assert_called_once_with()
+
+            s = SomeClass()
+            s.one
+            mock.assert_called_with()
+            self.assertEqual(mock.mock_calls, [call(), call()])
+
+            s.one = 3
+            self.assertEqual(mock.mock_calls, [call(), call(), call(3)])
+        finally:
+            p.stop()
+
+
+    def test_propertymock_returnvalue(self):
+        m = MagicMock()
+        p = PropertyMock()
+        type(m).foo = p
+
+        returned = m.foo
+        p.assert_called_once_with()
+        self.assertIsInstance(returned, MagicMock)
+        self.assertNotIsInstance(returned, PropertyMock)
+
+
+if __name__ == '__main__':
+    unittest.main()

plex_test_case/mock/mock/tests/testmagicmethods.py

@@ -0,0 +1,533 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+from __future__ import division
+
+try:
+    unicode
+except NameError:
+    # Python 3
+    unicode = str
+    long = int
+
+import inspect
+import sys
+import textwrap
+
+import six
+import unittest2 as unittest
+
+from mock import Mock, MagicMock
+from mock.mock import _magics
+
+
+
+class TestMockingMagicMethods(unittest.TestCase):
+
+    def test_deleting_magic_methods(self):
+        mock = Mock()
+        self.assertFalse(hasattr(mock, '__getitem__'))
+
+        mock.__getitem__ = Mock()
+        self.assertTrue(hasattr(mock, '__getitem__'))
+
+        del mock.__getitem__
+        self.assertFalse(hasattr(mock, '__getitem__'))
+
+
+    def test_magicmock_del(self):
+        mock = MagicMock()
+        # before using getitem
+        del mock.__getitem__
+        self.assertRaises(TypeError, lambda: mock['foo'])
+
+        mock = MagicMock()
+        # this time use it first
+        mock['foo']
+        del mock.__getitem__
+        self.assertRaises(TypeError, lambda: mock['foo'])
+
+
+    def test_magic_method_wrapping(self):
+        mock = Mock()
+        def f(self, name):
+            return self, 'fish'
+
+        mock.__getitem__ = f
+        self.assertIsNot(mock.__getitem__, f)
+        self.assertEqual(mock['foo'], (mock, 'fish'))
+        self.assertEqual(mock.__getitem__('foo'), (mock, 'fish'))
+
+        mock.__getitem__ = mock
+        self.assertIs(mock.__getitem__, mock)
+
+
+    def test_magic_methods_isolated_between_mocks(self):
+        mock1 = Mock()
+        mock2 = Mock()
+
+        mock1.__iter__ = Mock(return_value=iter([]))
+        self.assertEqual(list(mock1), [])
+        self.assertRaises(TypeError, lambda: list(mock2))
+
+
+    def test_repr(self):
+        mock = Mock()
+        self.assertEqual(repr(mock), "<Mock id='%s'>" % id(mock))
+        mock.__repr__ = lambda s: 'foo'
+        self.assertEqual(repr(mock), 'foo')
+
+
+    def test_str(self):
+        mock = Mock()
+        self.assertEqual(str(mock), object.__str__(mock))
+        mock.__str__ = lambda s: 'foo'
+        self.assertEqual(str(mock), 'foo')
+
+
+    @unittest.skipIf(six.PY3, "no unicode in Python 3")
+    def test_unicode(self):
+        mock = Mock()
+        self.assertEqual(unicode(mock), unicode(str(mock)))
+
+        mock.__unicode__ = lambda s: unicode('foo')
+        self.assertEqual(unicode(mock), unicode('foo'))
+
+
+    def test_dict_methods(self):
+        mock = Mock()
+
+        self.assertRaises(TypeError, lambda: mock['foo'])
+        def _del():
+            del mock['foo']
+        def _set():
+            mock['foo'] = 3
+        self.assertRaises(TypeError, _del)
+        self.assertRaises(TypeError, _set)
+
+        _dict = {}
+        def getitem(s, name):
+            return _dict[name]
+        def setitem(s, name, value):
+            _dict[name] = value
+        def delitem(s, name):
+            del _dict[name]
+
+        mock.__setitem__ = setitem
+        mock.__getitem__ = getitem
+        mock.__delitem__ = delitem
+
+        self.assertRaises(KeyError, lambda: mock['foo'])
+        mock['foo'] = 'bar'
+        self.assertEqual(_dict, {'foo': 'bar'})
+        self.assertEqual(mock['foo'], 'bar')
+        del mock['foo']
+        self.assertEqual(_dict, {})
+
+
+    def test_numeric(self):
+        original = mock = Mock()
+        mock.value = 0
+
+        self.assertRaises(TypeError, lambda: mock + 3)
+
+        def add(self, other):
+            mock.value += other
+            return self
+        mock.__add__ = add
+        self.assertEqual(mock + 3, mock)
+        self.assertEqual(mock.value, 3)
+
+        del mock.__add__
+        def iadd(mock):
+            mock += 3
+        self.assertRaises(TypeError, iadd, mock)
+        mock.__iadd__ = add
+        mock += 6
+        self.assertEqual(mock, original)
+        self.assertEqual(mock.value, 9)
+
+        self.assertRaises(TypeError, lambda: 3 + mock)
+        mock.__radd__ = add
+        self.assertEqual(7 + mock, mock)
+        self.assertEqual(mock.value, 16)
+
+    def test_division(self):
+        original = mock = Mock()
+        mock.value = 32
+        self.assertRaises(TypeError, lambda: mock / 2)
+
+        def truediv(self, other):
+            mock.value /= other
+            return self
+        mock.__truediv__ = truediv
+        self.assertEqual(mock / 2, mock)
+        self.assertEqual(mock.value, 16)
+
+        del mock.__truediv__
+        if six.PY3:
+            def itruediv(mock):
+                mock /= 4
+            self.assertRaises(TypeError, itruediv, mock)
+            mock.__itruediv__ = truediv
+            mock /= 8
+            self.assertEqual(mock, original)
+            self.assertEqual(mock.value, 2)
+        else:
+            mock.value = 2
+
+        self.assertRaises(TypeError, lambda: 8 / mock)
+        mock.__rtruediv__ = truediv
+        self.assertEqual(0.5 / mock, mock)
+        self.assertEqual(mock.value, 4)
+
+    def test_hash(self):
+        mock = Mock()
+        # test delegation
+        self.assertEqual(hash(mock), Mock.__hash__(mock))
+
+        def _hash(s):
+            return 3
+        mock.__hash__ = _hash
+        self.assertEqual(hash(mock), 3)
+
+
+    def test_nonzero(self):
+        m = Mock()
+        self.assertTrue(bool(m))
+
+        nonzero = lambda s: False
+        if six.PY2:
+            m.__nonzero__ = nonzero
+        else:
+            m.__bool__ = nonzero
+
+        self.assertFalse(bool(m))
+
+
+    def test_comparison(self):
+        mock = Mock()
+        def comp(s, o):
+            return True
+        mock.__lt__ = mock.__gt__ = mock.__le__ = mock.__ge__ = comp
+        self. assertTrue(mock < 3)
+        self. assertTrue(mock > 3)
+        self. assertTrue(mock <= 3)
+        self. assertTrue(mock >= 3)
+
+        if six.PY2:
+            # incomparable in Python 3
+            self.assertEqual(Mock() < 3, object() < 3)
+            self.assertEqual(Mock() > 3, object() > 3)
+            self.assertEqual(Mock() <= 3, object() <= 3)
+            self.assertEqual(Mock() >= 3, object() >= 3)
+        else:
+            self.assertRaises(TypeError, lambda: MagicMock() < object())
+            self.assertRaises(TypeError, lambda: object() < MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() < MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() > object())
+            self.assertRaises(TypeError, lambda: object() > MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() > MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() <= object())
+            self.assertRaises(TypeError, lambda: object() <= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() <= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() >= object())
+            self.assertRaises(TypeError, lambda: object() >= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() >= MagicMock())
+
+
+    def test_equality(self):
+        for mock in Mock(), MagicMock():
+            self.assertEqual(mock == mock, True)
+            self.assertIsInstance(mock == mock, bool)
+            self.assertEqual(mock != mock, False)
+            self.assertIsInstance(mock != mock, bool)
+            self.assertEqual(mock == object(), False)
+            self.assertEqual(mock != object(), True)
+
+            def eq(self, other):
+                return other == 3
+            mock.__eq__ = eq
+            self.assertTrue(mock == 3)
+            self.assertFalse(mock == 4)
+
+            def ne(self, other):
+                return other == 3
+            mock.__ne__ = ne
+            self.assertTrue(mock != 3)
+            self.assertFalse(mock != 4)
+
+        mock = MagicMock()
+        mock.__eq__.return_value = True
+        self.assertIsInstance(mock == 3, bool)
+        self.assertEqual(mock == 3, True)
+
+        mock.__ne__.return_value = False
+        self.assertIsInstance(mock != 3, bool)
+        self.assertEqual(mock != 3, False)
+
+
+    def test_len_contains_iter(self):
+        mock = Mock()
+
+        self.assertRaises(TypeError, len, mock)
+        self.assertRaises(TypeError, iter, mock)
+        self.assertRaises(TypeError, lambda: 'foo' in mock)
+
+        mock.__len__ = lambda s: 6
+        self.assertEqual(len(mock), 6)
+
+        mock.__contains__ = lambda s, o: o == 3
+        self.assertIn(3, mock)
+        self.assertNotIn(6, mock)
+
+        mock.__iter__ = lambda s: iter('foobarbaz')
+        self.assertEqual(list(mock), list('foobarbaz'))
+
+
+    def test_magicmock(self):
+        mock = MagicMock()
+
+        mock.__iter__.return_value = iter([1, 2, 3])
+        self.assertEqual(list(mock), [1, 2, 3])
+
+        name = '__nonzero__'
+        other = '__bool__'
+        if six.PY3:
+            name, other = other, name
+        getattr(mock, name).return_value = False
+        self.assertFalse(hasattr(mock, other))
+        self.assertFalse(bool(mock))
+
+        for entry in _magics:
+            self.assertTrue(hasattr(mock, entry))
+        self.assertFalse(hasattr(mock, '__imaginery__'))
+
+
+    def test_magic_mock_equality(self):
+        mock = MagicMock()
+        self.assertIsInstance(mock == object(), bool)
+        self.assertIsInstance(mock != object(), bool)
+
+        self.assertEqual(mock == object(), False)
+        self.assertEqual(mock != object(), True)
+        self.assertEqual(mock == mock, True)
+        self.assertEqual(mock != mock, False)
+
+
+    def test_magicmock_defaults(self):
+        mock = MagicMock()
+        self.assertEqual(int(mock), 1)
+        self.assertEqual(complex(mock), 1j)
+        self.assertEqual(float(mock), 1.0)
+        self.assertEqual(long(mock), long(1))
+        self.assertNotIn(object(), mock)
+        self.assertEqual(len(mock), 0)
+        self.assertEqual(list(mock), [])
+        self.assertEqual(hash(mock), object.__hash__(mock))
+        self.assertEqual(str(mock), object.__str__(mock))
+        self.assertEqual(unicode(mock), object.__str__(mock))
+        self.assertIsInstance(unicode(mock), unicode)
+        self.assertTrue(bool(mock))
+        if six.PY2:
+            self.assertEqual(oct(mock), '1')
+        else:
+            # in Python 3 oct and hex use __index__
+            # so these tests are for __index__ in py3k
+            self.assertEqual(oct(mock), '0o1')
+        self.assertEqual(hex(mock), '0x1')
+        # how to test __sizeof__ ?
+
+
+    @unittest.skipIf(six.PY3, "no __cmp__ in Python 3")
+    def test_non_default_magic_methods(self):
+        mock = MagicMock()
+        self.assertRaises(AttributeError, lambda: mock.__cmp__)
+
+        mock = Mock()
+        mock.__cmp__ = lambda s, o: 0
+
+        self.assertEqual(mock, object())
+
+
+    def test_magic_methods_and_spec(self):
+        class Iterable(object):
+            def __iter__(self):
+                pass
+
+        mock = Mock(spec=Iterable)
+        self.assertRaises(AttributeError, lambda: mock.__iter__)
+
+        mock.__iter__ = Mock(return_value=iter([]))
+        self.assertEqual(list(mock), [])
+
+        class NonIterable(object):
+            pass
+        mock = Mock(spec=NonIterable)
+        self.assertRaises(AttributeError, lambda: mock.__iter__)
+
+        def set_int():
+            mock.__int__ = Mock(return_value=iter([]))
+        self.assertRaises(AttributeError, set_int)
+
+        mock = MagicMock(spec=Iterable)
+        self.assertEqual(list(mock), [])
+        self.assertRaises(AttributeError, set_int)
+
+
+    def test_magic_methods_and_spec_set(self):
+        class Iterable(object):
+            def __iter__(self):
+                pass
+
+        mock = Mock(spec_set=Iterable)
+        self.assertRaises(AttributeError, lambda: mock.__iter__)
+
+        mock.__iter__ = Mock(return_value=iter([]))
+        self.assertEqual(list(mock), [])
+
+        class NonIterable(object):
+            pass
+        mock = Mock(spec_set=NonIterable)
+        self.assertRaises(AttributeError, lambda: mock.__iter__)
+
+        def set_int():
+            mock.__int__ = Mock(return_value=iter([]))
+        self.assertRaises(AttributeError, set_int)
+
+        mock = MagicMock(spec_set=Iterable)
+        self.assertEqual(list(mock), [])
+        self.assertRaises(AttributeError, set_int)
+
+
+    def test_setting_unsupported_magic_method(self):
+        mock = MagicMock()
+        def set_setattr():
+            mock.__setattr__ = lambda self, name: None
+        self.assertRaisesRegex(AttributeError,
+            "Attempting to set unsupported magic method '__setattr__'.",
+            set_setattr
+        )
+
+
+    def test_attributes_and_return_value(self):
+        mock = MagicMock()
+        attr = mock.foo
+        def _get_type(obj):
+            # the type of every mock (or magicmock) is a custom subclass
+            # so the real type is the second in the mro
+            return type(obj).__mro__[1]
+        self.assertEqual(_get_type(attr), MagicMock)
+
+        returned = mock()
+        self.assertEqual(_get_type(returned), MagicMock)
+
+
+    def test_magic_methods_are_magic_mocks(self):
+        mock = MagicMock()
+        self.assertIsInstance(mock.__getitem__, MagicMock)
+
+        mock[1][2].__getitem__.return_value = 3
+        self.assertEqual(mock[1][2][3], 3)
+
+
+    def test_magic_method_reset_mock(self):
+        mock = MagicMock()
+        str(mock)
+        self.assertTrue(mock.__str__.called)
+        mock.reset_mock()
+        self.assertFalse(mock.__str__.called)
+
+    def test_dir(self):
+        # overriding the default implementation
+        for mock in Mock(), MagicMock():
+            def _dir(self):
+                return ['foo']
+            mock.__dir__ = _dir
+            self.assertEqual(dir(mock), ['foo'])
+
+
+    @unittest.skipIf('PyPy' in sys.version, "This fails differently on pypy")
+    def test_bound_methods(self):
+        m = Mock()
+
+        # XXXX should this be an expected failure instead?
+
+        # this seems like it should work, but is hard to do without introducing
+        # other api inconsistencies. Failure message could be better though.
+        m.__iter__ = [3].__iter__
+        self.assertRaises(TypeError, iter, m)
+
+
+    def test_magic_method_type(self):
+        class Foo(MagicMock):
+            pass
+
+        foo = Foo()
+        self.assertIsInstance(foo.__int__, Foo)
+
+
+    def test_descriptor_from_class(self):
+        m = MagicMock()
+        type(m).__str__.return_value = 'foo'
+        self.assertEqual(str(m), 'foo')
+
+
+    def test_iterable_as_iter_return_value(self):
+        m = MagicMock()
+        m.__iter__.return_value = [1, 2, 3]
+        self.assertEqual(list(m), [1, 2, 3])
+        self.assertEqual(list(m), [1, 2, 3])
+
+        m.__iter__.return_value = iter([4, 5, 6])
+        self.assertEqual(list(m), [4, 5, 6])
+        self.assertEqual(list(m), [])
+
+    @unittest.skipIf(sys.version_info < (3, 5), "@ added in Python 3.5")
+    def test_matmul(self):
+        src = textwrap.dedent("""\
+            m = MagicMock()
+            self.assertIsInstance(m @ 1, MagicMock)
+            m.__matmul__.return_value = 42
+            m.__rmatmul__.return_value = 666
+            m.__imatmul__.return_value = 24
+            self.assertEqual(m @ 1, 42)
+            self.assertEqual(1 @ m, 666)
+            m @= 24
+            self.assertEqual(m, 24)
+        """)
+        exec(src)
+
+    def test_divmod_and_rdivmod(self):
+        m = MagicMock()
+        self.assertIsInstance(divmod(5, m), MagicMock)
+        m.__divmod__.return_value = (2, 1)
+        self.assertEqual(divmod(m, 2), (2, 1))
+        m = MagicMock()
+        foo = divmod(2, m)
+        self.assertIsInstance(foo, MagicMock)
+        foo_direct = m.__divmod__(2)
+        self.assertIsInstance(foo_direct, MagicMock)
+        bar = divmod(m, 2)
+        self.assertIsInstance(bar, MagicMock)
+        bar_direct = m.__rdivmod__(2)
+        self.assertIsInstance(bar_direct, MagicMock)
+
+    # http://bugs.python.org/issue23310
+    # Check if you can change behaviour of magic methds in MagicMock init
+    def test_magic_in_initialization(self):
+        m = MagicMock(**{'__str__.return_value': "12"})
+        self.assertEqual(str(m), "12")
+
+    def test_changing_magic_set_in_initialization(self):
+        m = MagicMock(**{'__str__.return_value': "12"})
+        m.__str__.return_value = "13"
+        self.assertEqual(str(m), "13")
+        m = MagicMock(**{'__str__.return_value': "12"})
+        m.configure_mock(**{'__str__.return_value': "14"})
+        self.assertEqual(str(m), "14")
+
+
+if __name__ == '__main__':
+    unittest.main()

plex_test_case/mock/mock/tests/testsentinel.py

@@ -0,0 +1,33 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+import unittest2 as unittest
+
+from mock import sentinel, DEFAULT
+
+
+class SentinelTest(unittest.TestCase):
+
+    def testSentinels(self):
+        self.assertEqual(sentinel.whatever, sentinel.whatever,
+                         'sentinel not stored')
+        self.assertNotEqual(sentinel.whatever, sentinel.whateverelse,
+                            'sentinel should be unique')
+
+
+    def testSentinelName(self):
+        self.assertEqual(str(sentinel.whatever), 'sentinel.whatever',
+                         'sentinel name incorrect')
+
+
+    def testDEFAULT(self):
+        self.assertIs(DEFAULT, sentinel.DEFAULT)
+
+    def testBases(self):
+        # If this doesn't raise an AttributeError then help(mock) is broken
+        self.assertRaises(AttributeError, lambda: sentinel.__bases__)
+
+
+if __name__ == '__main__':
+    unittest.main()

plex_test_case/mock/mock/tests/testwith.py

@@ -0,0 +1,306 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+from warnings import catch_warnings
+
+import unittest2 as unittest
+
+from mock.tests.support import is_instance
+from mock import MagicMock, Mock, patch, sentinel, mock_open, call
+
+
+something  = sentinel.Something
+something_else  = sentinel.SomethingElse
+
+
+
+class WithTest(unittest.TestCase):
+
+    def test_with_statement(self):
+        with patch('%s.something' % __name__, sentinel.Something2):
+            self.assertEqual(something, sentinel.Something2, "unpatched")
+        self.assertEqual(something, sentinel.Something)
+
+
+    def test_with_statement_exception(self):
+        try:
+            with patch('%s.something' % __name__, sentinel.Something2):
+                self.assertEqual(something, sentinel.Something2, "unpatched")
+                raise Exception('pow')
+        except Exception:
+            pass
+        else:
+            self.fail("patch swallowed exception")
+        self.assertEqual(something, sentinel.Something)
+
+
+    def test_with_statement_as(self):
+        with patch('%s.something' % __name__) as mock_something:
+            self.assertEqual(something, mock_something, "unpatched")
+            self.assertTrue(is_instance(mock_something, MagicMock),
+                            "patching wrong type")
+        self.assertEqual(something, sentinel.Something)
+
+
+    def test_patch_object_with_statement(self):
+        class Foo(object):
+            something = 'foo'
+        original = Foo.something
+        with patch.object(Foo, 'something'):
+            self.assertNotEqual(Foo.something, original, "unpatched")
+        self.assertEqual(Foo.something, original)
+
+
+    def test_with_statement_nested(self):
+        with catch_warnings(record=True):
+            with patch('%s.something' % __name__) as mock_something:
+                with patch('%s.something_else' % __name__) as mock_something_else:
+                    self.assertEqual(something, mock_something, "unpatched")
+                    self.assertEqual(something_else, mock_something_else,
+                                     "unpatched")
+
+        self.assertEqual(something, sentinel.Something)
+        self.assertEqual(something_else, sentinel.SomethingElse)
+
+
+    def test_with_statement_specified(self):
+        with patch('%s.something' % __name__, sentinel.Patched) as mock_something:
+            self.assertEqual(something, mock_something, "unpatched")
+            self.assertEqual(mock_something, sentinel.Patched, "wrong patch")
+        self.assertEqual(something, sentinel.Something)
+
+
+    def testContextManagerMocking(self):
+        mock = Mock()
+        mock.__enter__ = Mock()
+        mock.__exit__ = Mock()
+        mock.__exit__.return_value = False
+
+        with mock as m:
+            self.assertEqual(m, mock.__enter__.return_value)
+        mock.__enter__.assert_called_with()
+        mock.__exit__.assert_called_with(None, None, None)
+
+
+    def test_context_manager_with_magic_mock(self):
+        mock = MagicMock()
+
+        with self.assertRaises(TypeError):
+            with mock:
+                'foo' + 3
+        mock.__enter__.assert_called_with()
+        self.assertTrue(mock.__exit__.called)
+
+
+    def test_with_statement_same_attribute(self):
+        with patch('%s.something' % __name__, sentinel.Patched) as mock_something:
+            self.assertEqual(something, mock_something, "unpatched")
+
+            with patch('%s.something' % __name__) as mock_again:
+                self.assertEqual(something, mock_again, "unpatched")
+
+            self.assertEqual(something, mock_something,
+                             "restored with wrong instance")
+
+        self.assertEqual(something, sentinel.Something, "not restored")
+
+
+    def test_with_statement_imbricated(self):
+        with patch('%s.something' % __name__) as mock_something:
+            self.assertEqual(something, mock_something, "unpatched")
+
+            with patch('%s.something_else' % __name__) as mock_something_else:
+                self.assertEqual(something_else, mock_something_else,
+                                 "unpatched")
+
+        self.assertEqual(something, sentinel.Something)
+        self.assertEqual(something_else, sentinel.SomethingElse)
+
+
+    def test_dict_context_manager(self):
+        foo = {}
+        with patch.dict(foo, {'a': 'b'}):
+            self.assertEqual(foo, {'a': 'b'})
+        self.assertEqual(foo, {})
+
+        with self.assertRaises(NameError):
+            with patch.dict(foo, {'a': 'b'}):
+                self.assertEqual(foo, {'a': 'b'})
+                raise NameError('Konrad')
+
+        self.assertEqual(foo, {})
+
+
+
+class TestMockOpen(unittest.TestCase):
+
+    def test_mock_open(self):
+        mock = mock_open()
+        with patch('%s.open' % __name__, mock, create=True) as patched:
+            self.assertIs(patched, mock)
+            open('foo')
+
+        mock.assert_called_once_with('foo')
+
+
+    def test_mock_open_context_manager(self):
+        mock = mock_open()
+        handle = mock.return_value
+        with patch('%s.open' % __name__, mock, create=True):
+            with open('foo') as f:
+                f.read()
+
+        expected_calls = [call('foo'), call().__enter__(), call().read(),
+                          call().__exit__(None, None, None)]
+        self.assertEqual(mock.mock_calls, expected_calls)
+        self.assertIs(f, handle)
+
+    def test_mock_open_context_manager_multiple_times(self):
+        mock = mock_open()
+        with patch('%s.open' % __name__, mock, create=True):
+            with open('foo') as f:
+                f.read()
+            with open('bar') as f:
+                f.read()
+
+        expected_calls = [
+            call('foo'), call().__enter__(), call().read(),
+            call().__exit__(None, None, None),
+            call('bar'), call().__enter__(), call().read(),
+            call().__exit__(None, None, None)]
+        self.assertEqual(mock.mock_calls, expected_calls)
+
+    def test_explicit_mock(self):
+        mock = MagicMock()
+        mock_open(mock)
+
+        with patch('%s.open' % __name__, mock, create=True) as patched:
+            self.assertIs(patched, mock)
+            open('foo')
+
+        mock.assert_called_once_with('foo')
+
+
+    def test_read_data(self):
+        mock = mock_open(read_data='foo')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            result = h.read()
+
+        self.assertEqual(result, 'foo')
+
+
+    def test_readline_data(self):
+        # Check that readline will return all the lines from the fake file
+        mock = mock_open(read_data='foo\nbar\nbaz\n')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            line1 = h.readline()
+            line2 = h.readline()
+            line3 = h.readline()
+        self.assertEqual(line1, 'foo\n')
+        self.assertEqual(line2, 'bar\n')
+        self.assertEqual(line3, 'baz\n')
+
+        # Check that we properly emulate a file that doesn't end in a newline
+        mock = mock_open(read_data='foo')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            result = h.readline()
+        self.assertEqual(result, 'foo')
+
+
+    def test_readlines_data(self):
+        # Test that emulating a file that ends in a newline character works
+        mock = mock_open(read_data='foo\nbar\nbaz\n')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            result = h.readlines()
+        self.assertEqual(result, ['foo\n', 'bar\n', 'baz\n'])
+
+        # Test that files without a final newline will also be correctly
+        # emulated
+        mock = mock_open(read_data='foo\nbar\nbaz')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            result = h.readlines()
+
+        self.assertEqual(result, ['foo\n', 'bar\n', 'baz'])
+
+
+    def test_read_bytes(self):
+        mock = mock_open(read_data=b'\xc6')
+        with patch('%s.open' % __name__, mock, create=True):
+            with open('abc', 'rb') as f:
+                result = f.read()
+        self.assertEqual(result, b'\xc6')
+
+
+    def test_readline_bytes(self):
+        m = mock_open(read_data=b'abc\ndef\nghi\n')
+        with patch('%s.open' % __name__, m, create=True):
+            with open('abc', 'rb') as f:
+                line1 = f.readline()
+                line2 = f.readline()
+                line3 = f.readline()
+        self.assertEqual(line1, b'abc\n')
+        self.assertEqual(line2, b'def\n')
+        self.assertEqual(line3, b'ghi\n')
+
+
+    def test_readlines_bytes(self):
+        m = mock_open(read_data=b'abc\ndef\nghi\n')
+        with patch('%s.open' % __name__, m, create=True):
+            with open('abc', 'rb') as f:
+                result = f.readlines()
+        self.assertEqual(result, [b'abc\n', b'def\n', b'ghi\n'])
+
+
+    def test_mock_open_read_with_argument(self):
+        # At one point calling read with an argument was broken
+        # for mocks returned by mock_open
+        some_data = 'foo\nbar\nbaz'
+        mock = mock_open(read_data=some_data)
+        self.assertEqual(mock().read(10), some_data)
+
+
+    def test_interleaved_reads(self):
+        # Test that calling read, readline, and readlines pulls data
+        # sequentially from the data we preload with
+        mock = mock_open(read_data='foo\nbar\nbaz\n')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            line1 = h.readline()
+            rest = h.readlines()
+        self.assertEqual(line1, 'foo\n')
+        self.assertEqual(rest, ['bar\n', 'baz\n'])
+
+        mock = mock_open(read_data='foo\nbar\nbaz\n')
+        with patch('%s.open' % __name__, mock, create=True):
+            h = open('bar')
+            line1 = h.readline()
+            rest = h.read()
+        self.assertEqual(line1, 'foo\n')
+        self.assertEqual(rest, 'bar\nbaz\n')
+
+
+    def test_overriding_return_values(self):
+        mock = mock_open(read_data='foo')
+        handle = mock()
+
+        handle.read.return_value = 'bar'
+        handle.readline.return_value = 'bar'
+        handle.readlines.return_value = ['bar']
+
+        self.assertEqual(handle.read(), 'bar')
+        self.assertEqual(handle.readline(), 'bar')
+        self.assertEqual(handle.readlines(), ['bar'])
+
+        # call repeatedly to check that a StopIteration is not propagated
+        self.assertEqual(handle.readline(), 'bar')
+        self.assertEqual(handle.readline(), 'bar')
+
+
+if __name__ == '__main__':
+    unittest.main()

plex_test_case/mock/requirements.txt

@@ -0,0 +1,6 @@
+funcsigs>=1;python_version<"3.3"
+# For runtime needs this is correct. For setup_requires needs, 1.2.0 is needed
+# but setuptools can't cope with conflicts in setup_requires, so thats
+# unversioned.
+pbr>=0.11
+six>=1.9

plex_test_case/mock/setup.cfg

@@ -0,0 +1,45 @@
+[metadata]
+name = mock
+summary = Rolling backport of unittest.mock for all Pythons
+home-page = https://github.com/testing-cabal/mock
+description-file = README.rst
+author = Testing Cabal
+author-email = testing-in-python@lists.idyll.org
+classifier = 
+    Development Status :: 5 - Production/Stable
+    Environment :: Console
+    Intended Audience :: Developers
+    License :: OSI Approved :: BSD License
+    Operating System :: OS Independent
+    Programming Language :: Python
+    Programming Language :: Python :: 2
+    Programming Language :: Python :: 2.6
+    Programming Language :: Python :: 2.7
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.2
+    Programming Language :: Python :: 3.3
+    Programming Language :: Python :: 3.4
+    Programming Language :: Python :: 3.5
+    Programming Language :: Python :: Implementation :: CPython
+    Programming Language :: Python :: Implementation :: Jython
+    Programming Language :: Python :: Implementation :: PyPy
+    Topic :: Software Development :: Libraries
+    Topic :: Software Development :: Libraries :: Python Modules
+    Topic :: Software Development :: Testing
+keyword =
+    testing, test, mock, mocking, unittest, patching, stubs, fakes, doubles
+
+[extras]
+test =
+  unittest2>=1.1.0
+docs =
+  jinja2<2.7:python_version<"3.3" and python_version>="3"
+  Pygments<2:python_version<"3.3" and python_version>="3"
+  sphinx<1.3:python_version<"3.3" and python_version>="3"
+  sphinx:python_version<"3" or python_version>="3.3"
+
+[files]
+packages = mock
+
+[bdist_wheel]
+universal = 1

plex_test_case/mock/setup.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+import setuptools
+
+setuptools.setup(
+    setup_requires=['pbr>=1.3', 'setuptools>=17.1'],
+    pbr=True)

plex_test_case/mock/tools/applypatch-transform

@@ -0,0 +1,38 @@
+#!/bin/sh
+#
+# An example hook script to transform a patch taken from an email
+# by git am.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the patch file.
+#
+# To enable this hook, rename this file to "applypatch-transform".
+#
+# This example changes the path of Lib/unittest/mock.py to mock.py
+# Lib/unittest/tests/testmock to tests and Misc/NEWS to NEWS, and
+# finally skips any patches that did not alter mock.py or its tests.
+
+set -eux
+
+patch_path=$1
+
+# Pull out mock.py
+filterdiff --clean --strip 3 --addprefix=a/mock/ -i 'a/Lib/unittest/mock.py' -i 'b/Lib/unittest/mock.py' $patch_path > $patch_path.mock
+# And the tests
+filterdiff --clean --strip 5 --addprefix=a/mock/tests/ -i 'a/Lib/unittest/test/testmock/*.py' -i 'b/Lib/unittest/test/testmock/*.py' $patch_path > $patch_path.tests
+# Lastly we want to pick up any NEWS entries.
+filterdiff --strip 2 --addprefix=a/ -i a/Misc/NEWS -i b/Misc/NEWS $patch_path > $patch_path.NEWS
+cp $patch_path $patch_path.orig
+# bash
+cat $patch_path.mock $patch_path.tests > $patch_path
+filtered=$(cat $patch_path)
+if [ -n "${filtered}" ]; then
+  cat $patch_path.NEWS >> $patch_path
+  exitcode=0
+else
+  exitcode=1
+fi
+
+rm $patch_path.mock $patch_path.tests $patch_path.NEWS
+exit $exitcode

plex_test_case/mock/tools/pre-applypatch

@@ -0,0 +1,37 @@
+#!/bin/bash
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+set -eu
+
+#. git-sh-setup
+echo "** in hook **"
+
+function test_version {
+  version=$1
+  host=$(ls ~/.virtualenvs/mock-$version-* -d | sed -e "s/^.*mock-$version-//")
+  if [ -z "$host" ]; then
+    echo "No host found for $version"
+    return 1
+  fi
+  echo testing $version in virtualenv mock-$version-$host on ssh host $host
+  ssh $host "cd work/mock && . ~/.virtualenvs/mock-$version-$host/bin/activate && pip install .[test] && unit2"
+}
+
+find . -name "*.pyc" -exec rm "{}" \;
+
+test_version 2.6
+test_version 2.7
+test_version 3.3
+test_version 3.4
+test_version 3.5
+test_version cpython
+test_version pypy
+
+echo '** pre-apply complete and successful **'

plex_test_case/mock/tox.ini

@@ -0,0 +1,40 @@
+[tox]
+envlist = py25,py26,py27,py31,pypy,py32,py33,jython
+
+[testenv]
+deps=unittest2
+commands={envbindir}/unit2 discover []
+
+[testenv:py26]
+commands=
+    {envbindir}/unit2 discover []
+    {envbindir}/sphinx-build -E -b doctest docs html
+    {envbindir}/sphinx-build -E docs html
+deps =
+    unittest2
+    sphinx
+
+[testenv:py27]
+commands=
+    {envbindir}/unit2 discover []
+    {envbindir}/sphinx-build -E -b doctest docs html
+deps =
+    unittest2
+    sphinx
+
+[testenv:py31]
+deps =
+    unittest2py3k
+
+[testenv:py32]
+commands=
+    {envbindir}/python -m unittest discover []
+deps =
+
+[testenv:py33]
+commands=
+    {envbindir}/python -m unittest discover []
+deps =
+
+# note for jython. Execute in tests directory:
+# rm `find . -name '*$py.class'`

plex_test_case/mock/unittest.cfg

@@ -0,0 +1,95 @@
+
+[unittest]
+plugins = 
+    unittest2.plugins.debugger
+    unittest2.plugins.checker
+    unittest2.plugins.doctestloader
+    unittest2.plugins.matchregexp
+    unittest2.plugins.moduleloading
+    unittest2.plugins.testcoverage
+    unittest2.plugins.growl
+    unittest2.plugins.filtertests
+    unittest2.plugins.junitxml
+    unittest2.plugins.timed
+    unittest2.plugins.counttests
+    unittest2.plugins.logchannels
+
+excluded-plugins =
+
+# 0, 1 or 2 (default is 1)
+# quiet, normal or verbose
+# can be overriden at command line
+verbosity = normal
+
+# true or false
+# even if false can be switched on at command line
+catch =
+buffer =
+failfast =
+
+
+[matchregexp]
+always-on = False
+full-path = True
+
+[debugger]
+always-on = False
+errors-only = True
+
+[coverage]
+always-on = False
+config =
+report-html = False
+# only used if report-html is false
+annotate = False
+# defaults to './htmlcov/'
+html-directory =
+# if unset will output to console
+text-file =
+branch = False
+timid = False
+cover-pylib = False
+exclude-lines = 
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.
+    
+ignore-errors = False
+modules =
+
+[growl]
+always-on = False
+
+[doctest]
+always-on = False
+
+[module-loading]
+always-on = False
+
+[checker]
+always-on = False
+pep8 = False
+pyflakes = True
+
+[junit-xml]
+always-on = False
+path = junit.xml
+
+[timed]
+always-on = True
+threshold = 0.01
+
+[count]
+always-on = True
+enhanced = False

plex_test_case/plex.py

@@ -0,0 +1,186 @@
+import httplib
+import inspect
+import logging
+import os
+import sys
+import urllib2
+from Framework import components, core
+from StringIO import StringIO
+
+
+GLOBAL_DEFAULT_TIMEOUT = components.networking.GLOBAL_DEFAULT_TIMEOUT
+
+class BasicRequest(object):
+
+    def __init__(self, uri, headers={}, method='GET', body=''):
+        self.uri = uri
+        self.headers = headers
+        self.method = method
+        self.body = body
+
+
+class FrameworkCore(core.FrameworkCore):
+    """
+        Framework core class extension to modify components in testing environment.
+    """
+    def _setup_storage(self):
+        # Don't configure output into real log file.
+        logging.basicConfig(level=logging.INFO)
+        #logging.setLoggerClass(core.FrameworkLogger)
+        logger = logging.getLogger()
+        #logger.handlers[0].addFilter(core.LogFilter())
+        #self.log = logging.getLogger(self.identifier)
+        self.log = logging.getLogger()
+        self._start_component(components.Storage)
+        self._values = {}
+        #self._values_file_path = os.path.join(self.plugin_support_path, 'Data', self.identifier, 'StoredValues')
+        self._values_file_path = os.path.join(self.bundle_path, 'Data', 'StoredValues')
+
+
+    def get_server_info(self):
+        # Don't do actual request to Plex server and return dummy values.
+        self.attributes['machineIdentifier'] = 'Unit testing'
+        self.attributes['serverVersion'] = None
+
+    def start(self):
+        # Same implementation as in parent class, just without error handling, to allow us to see what went wrong.
+        if self.init_code:
+            self.sandbox.execute(self.init_code)
+        self.sandbox.call_named_function(core.START_FUNCTION_NAME)
+
+    def log_exception(self, fmt, *args):
+        error = sys.exc_info()
+        if error:
+            # Catch a special case in the original `Runtime.handle_request`. If error is allowed to raise here, then
+            # the local variable `body` will not be set and the code fail on `UnboundLocalError` in `finally` later.
+            (frame, _, _, function_name, _, _) = inspect.getouterframes(inspect.currentframe())[1]
+            if function_name == 'handle_request' and frame.f_locals['self'].__class__ == Runtime:
+                self.runtime.request_error = error
+                return
+            # In general case, just raise the error.
+            raise error[0], error[1], error[2]
+
+    def _start_component(self, component):
+        # Replace runtime and networking components with our implementations.
+        if component == components.Runtime:
+            component = Runtime
+        elif component == components.Networking:
+            component = Networking
+        super(FrameworkCore, self)._start_component(component)
+
+
+class PreferenceManager(object):
+
+    def __init__(self, values={}):
+        #TODO ielasa no xml faila ja ir
+        self._dict = values
+
+    def get(self):
+        return self._dict
+
+
+class ResponseHeaders(object):
+
+    def __init__(self, headers):
+        self.dict = {k: v.lower() for k, v in headers.iteritems()}
+
+    def get(self, header, default=None):
+        lowercase = header.lower()
+        return self.dict[lowercase] if lowercase in self.dict else default
+
+
+class ResponseBody(StringIO):
+
+    def __init__(self, string):
+        StringIO.__init__(self, string)
+        self.recv = None
+
+    @property
+    def _sock(self):
+        return self
+
+
+class MockNetworkingHandler(object):
+
+    def __init__(self, networking):
+        self._networking = networking
+
+    def get_mock_response(self, req):
+        if self._networking.http_response_body is not None:
+            response = urllib2.addinfourl(ResponseBody(self._networking.http_response_body),
+                                          ResponseHeaders(self._networking.http_response_headers),
+                                          req.get_full_url())
+            response.code = 200
+            response.msg = "OK"
+            return response
+        raise RuntimeError('Unhandled HTTP request: %s' % req.get_full_url())
+
+
+class HTTPHandler(urllib2.HTTPHandler, MockNetworkingHandler):
+
+    def __init__(self, networking):
+        MockNetworkingHandler.__init__(self, networking)
+
+    def http_open(self, req):
+        return self.get_mock_response(req)
+
+
+if hasattr(httplib, 'HTTPS'):
+    class HTTPSHandler(urllib2.HTTPSHandler, MockNetworkingHandler):
+
+        def __init__(self, networking):
+            MockNetworkingHandler.__init__(self, networking)
+
+        def https_open(self, req):
+            return self.get_mock_response(req)
+
+
+class Networking(components.Networking):
+    """
+        Networking class extension to avoid sending actual requests in tests.
+    """
+    def _init(self):
+        super(Networking, self)._init()
+        self.http_response_body = None
+        self.http_response_headers = {}
+        self._core.policy.enable_http_caching = False
+
+    def build_opener(self, cookie_jar=None):
+        return urllib2.build_opener(HTTPHandler(self), HTTPSHandler(self))
+
+
+class Runtime(components.Runtime):
+    """
+        Runtime class extension to keep track of the framework's threads and locks.
+    """
+    def _init(self):
+        self._threads = []
+        super(Runtime, self)._init()
+
+    def create_thread(self, f, log=True, sandbox=None, globalize=True, *args, **kwargs):
+        # Store the created threads so that their status can be checked after tests have run.
+        thread = super(Runtime, self).create_thread(f, log, sandbox, globalize, *args, **kwargs)
+        self._threads.append(thread)
+        return thread
+
+    def check_threads(self):
+        # Check for alive non-daemon threads and throw error if found.
+        # Ignored threads are just slow but they don't run in a loop so they'll finish eventually.
+        ignored = ['_setup_shared_code_sandbox']
+        for thread in self._threads:
+            if thread.is_alive() and not thread.daemon and thread.name not in ignored:
+                raise RuntimeError('Alive non-daemon thread %s found, this will prevent shutdown.' % str(thread))
+
+    def handle_request(self, request):
+        # In case the parent method encounters an error reported using `_report_error` method, we'll raise it here.
+        self.request_error = None
+        status, headers, body = super(Runtime, self).handle_request(request)
+        if self.request_error is not None:
+            raise self.request_error[0], self.request_error[1], self.request_error[2]
+        return status, headers, body
+
+    def _report_error(self, request, controller, kwargs, e):
+        return
+
+    def get_resource_hashes(self):
+        return