Python import_fresh_module Examples

Example #1

    def test_staging(self):
        with self.env:
            self.env.set('QUARK_ENV', 'staging')
            settings = import_fresh_module('quark.settings')

            self.assertFalse(settings.DEBUG)
            self.assertEqual(settings.DATABASES, STAGING_DB)

Example #2

    def test_unset(self):
        with self.env:
            self.env.set('QUARK_ENV', 'dev')
            settings = import_fresh_module('quark.settings')

            self.assertTrue(settings.DEBUG)
            self.assertEqual(settings.DATABASES, DEV_DB)

Example #3

    def test_production(self):
        with self.env:
            self.env.set('QUARK_ENV', 'production')
            settings = import_fresh_module('quark.settings')

            self.assertFalse(settings.DEBUG)
            self.assertEqual(settings.DATABASES, PROD_DB)

Example #4

File: tests.py Project: nbailey/quark

    def test_staging(self):
        with self.env:
            self.env.set("QUARK_ENV", "staging")
            settings = import_fresh_module("quark.settings")

            self.assertFalse(settings.DEBUG)
            self.assertEqual(settings.DATABASES, STAGING_DB)

Example #5

File: tests.py Project: nbailey/quark

    def test_production(self):
        with self.env:
            self.env.set("QUARK_ENV", "production")
            settings = import_fresh_module("quark.settings")

            self.assertFalse(settings.DEBUG)
            self.assertEqual(settings.DATABASES, PROD_DB)

Example #6

File: tests.py Project: nbailey/quark

    def test_unset(self):
        with self.env:
            self.env.set("QUARK_ENV", "dev")
            settings = import_fresh_module("quark.settings")

            self.assertTrue(settings.DEBUG)
            self.assertEqual(settings.DATABASES, DEV_DB)

Example #7

File: test_heapq.py Project: 89sos98/main

"""Unittests for heapq."""

import random
import unittest
from test import test_support
import sys

# We do a bit of trickery here to be able to test both the C implementation
# and the Python implementation of the module.
import heapq as c_heapq
py_heapq = test_support.import_fresh_module('heapq', blocked=['_heapq'])

class TestHeap(unittest.TestCase):
    module = None

    def test_push_pop(self):
        # 1) Push 256 random numbers and pop them off, verifying all's OK.
        heap = []
        data = []
        self.check_invariant(heap)
        for i in range(256):
            item = random.random()
            data.append(item)
            self.module.heappush(heap, item)
            self.check_invariant(heap)
        results = []
        while heap:
            item = self.module.heappop(heap)
            self.check_invariant(heap)
            results.append(item)
        data_sorted = data[:]

Example #8

File: __init__.py Project: drmingdrmer/drmingdrmer.github.io

import os
import sys
import doctest
import unittest

from test import test_support
from pykit import p3json

# import json with and without accelerations
cjson = test_support.import_fresh_module('json', fresh=['_json'])
# pyjson = test_support.import_fresh_module('json', blocked=['_json'])
pyjson = p3json

# create two base classes that will be used by the other tests
class PyTest(unittest.TestCase):
    json = pyjson
    loads = staticmethod(pyjson.loads)
    dumps = staticmethod(pyjson.dumps)

# test PyTest and CTest checking if the functions come from the right module
class TestPyTest(PyTest):
    def test_pyjson(self):
        self.assertEqual(self.json.scanner.make_scanner.__module__,
                         'json.scanner')
        self.assertEqual(self.json.decoder.scanstring.__module__,
                         'json.decoder')
        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
                         'json.encoder')


here = os.path.dirname(__file__)

Example #9

File: test_heapq.py Project: cimarieta/usp

"""Unittests for heapq."""

import sys
import random

from test import test_support
from unittest import TestCase, skipUnless

py_heapq = test_support.import_fresh_module("heapq", blocked=["_heapq"])
c_heapq = test_support.import_fresh_module("heapq", fresh=["_heapq"])

# _heapq.nlargest/nsmallest are saved in heapq._nlargest/_smallest when
# _heapq is imported, so check them there
func_names = ["heapify", "heappop", "heappush", "heappushpop", "heapreplace", "_nlargest", "_nsmallest"]


class TestModules(TestCase):
    def test_py_functions(self):
        for fname in func_names:
            self.assertEqual(getattr(py_heapq, fname).__module__, "heapq")

    @skipUnless(c_heapq, "requires _heapq")
    def test_c_functions(self):
        for fname in func_names:
            self.assertEqual(getattr(c_heapq, fname).__module__, "_heapq")


class TestHeap(TestCase):
    module = None

    def test_push_pop(self):

Example #10

File: test_warnings.py Project: rrd257r/Thruster

from contextlib import contextmanager
import linecache
import os
import StringIO
import sys
import unittest
import subprocess
from test import test_support
from test.script_helper import assert_python_ok

import warning_tests

import warnings as original_warnings

py_warnings = test_support.import_fresh_module('warnings',
                                               blocked=['_warnings'])
c_warnings = test_support.import_fresh_module('warnings', fresh=['_warnings'])


@contextmanager
def warnings_state(module):
    """Use a specific warnings implementation in warning_tests."""
    global __warningregistry__
    for to_clear in (sys, warning_tests):
        try:
            to_clear.__warningregistry__.clear()
        except AttributeError:
            pass
    try:
        __warningregistry__.clear()
    except NameError:

Example #11

File: __init__.py Project: webiumsk/WOT-0.9.14-CT

# 2016.02.14 12:48:45 Støední Evropa (bìžný èas)
# Embedded file name: scripts/common/Lib/json/tests/__init__.py
import os
import sys
import json
import doctest
import unittest
from test import test_support

cjson = test_support.import_fresh_module("json", fresh=["_json"])
pyjson = test_support.import_fresh_module("json", blocked=["_json"])


class PyTest(unittest.TestCase):
    json = pyjson
    loads = staticmethod(pyjson.loads)
    dumps = staticmethod(pyjson.dumps)


@unittest.skipUnless(cjson, "requires _json")
class CTest(unittest.TestCase):
    if cjson is not None:
        json = cjson
        loads = staticmethod(cjson.loads)
        dumps = staticmethod(cjson.dumps)


class TestPyTest(PyTest):
    def test_pyjson(self):
        self.assertEqual(self.json.scanner.make_scanner.__module__, "json.scanner")
        self.assertEqual(self.json.decoder.scanstring.__module__, "json.decoder")

Example #12

File: test_tcl.py Project: Darriall/pypy

import unittest
import sys
import os
from test import test_support
from subprocess import Popen, PIPE

# Skip this test if the _tkinter module wasn't built.
_tkinter = test_support.import_module('_tkinter')

# Make sure tkinter._fix runs to set up the environment
tkinter = test_support.import_fresh_module('Tkinter')

from Tkinter import Tcl
from _tkinter import TclError

try:
    from _testcapi import INT_MAX, PY_SSIZE_T_MAX
except ImportError:
    INT_MAX = PY_SSIZE_T_MAX = sys.maxsize

tcl_version = _tkinter.TCL_VERSION.split('.')
try:
    for i in range(len(tcl_version)):
        tcl_version[i] = int(tcl_version[i])
except ValueError:
    pass
tcl_version = tuple(tcl_version)

_tk_patchlevel = None
def get_tk_patchlevel():
    global _tk_patchlevel

Example #13

import unittest
import re
import sys
import os
from test import test_support
from subprocess import Popen, PIPE

# Skip this test if the _tkinter module wasn't built.
_tkinter = test_support.import_module('_tkinter')

# Make sure tkinter._fix runs to set up the environment
tkinter = test_support.import_fresh_module('Tkinter')

from Tkinter import Tcl
from _tkinter import TclError

try:
    from _testcapi import INT_MAX, PY_SSIZE_T_MAX
except ImportError:
    INT_MAX = PY_SSIZE_T_MAX = sys.maxsize

tcl_version = tuple(map(int, _tkinter.TCL_VERSION.split('.')))

_tk_patchlevel = None
def get_tk_patchlevel():
    global _tk_patchlevel
    if _tk_patchlevel is None:
        tcl = Tcl()
        patchlevel = tcl.call('info', 'patchlevel')
        m = re.match(r'(\d+)\.(\d+)([ab.])(\d+)$', patchlevel)
        major, minor, releaselevel, serial = m.groups()

Example #14

File: test_warnings.py Project: Logotrop/trida

from contextlib import contextmanager
import linecache
import os
import StringIO
import sys
import unittest
import subprocess
from test import test_support
from test.script_helper import assert_python_ok

import warning_tests

import warnings as original_warnings

py_warnings = test_support.import_fresh_module('warnings', blocked=['_warnings'])
c_warnings = test_support.import_fresh_module('warnings', fresh=['_warnings'])

@contextmanager
def warnings_state(module):
    """Use a specific warnings implementation in warning_tests."""
    global __warningregistry__
    for to_clear in (sys, warning_tests):
        try:
            to_clear.__warningregistry__.clear()
        except AttributeError:
            pass
    try:
        __warningregistry__.clear()
    except NameError:
        pass
    original_warnings = warning_tests.warnings

Example #15

File: __init__.py Project: Pavel3333/WorldOfTanks-Decompiled

# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/common/Lib/json/tests/__init__.py
import os
import sys
import json
import doctest
import unittest
from test import test_support
cjson = test_support.import_fresh_module('json', fresh=['_json'])
pyjson = test_support.import_fresh_module('json', blocked=['_json'])


class PyTest(unittest.TestCase):
    json = pyjson
    loads = staticmethod(pyjson.loads)
    dumps = staticmethod(pyjson.dumps)


@unittest.skipUnless(cjson, 'requires _json')
class CTest(unittest.TestCase):
    if cjson is not None:
        json = cjson
        loads = staticmethod(cjson.loads)
        dumps = staticmethod(cjson.dumps)


class TestPyTest(PyTest):
    def test_pyjson(self):
        self.assertEqual(self.json.scanner.make_scanner.__module__,
                         'json.scanner')
        self.assertEqual(self.json.decoder.scanstring.__module__,

Example #16

"""Unittests for heapq."""

import random
import unittest
from test import test_support
import sys

# We do a bit of trickery here to be able to test both the C implementation
# and the Python implementation of the module.
import heapq as c_heapq
py_heapq = test_support.import_fresh_module('heapq', blocked=['_heapq'])


class TestHeap(unittest.TestCase):
    module = None

    def test_push_pop(self):
        # 1) Push 256 random numbers and pop them off, verifying all's OK.
        heap = []
        data = []
        self.check_invariant(heap)
        for i in range(256):
            item = random.random()
            data.append(item)
            self.module.heappush(heap, item)
            self.check_invariant(heap)
        results = []
        while heap:
            item = self.module.heappop(heap)
            self.check_invariant(heap)
            results.append(item)

Example #17

File: test_warnings.py Project: mlab-upenn/arch-apex

from contextlib import contextmanager
import linecache
import os
import StringIO
import sys
import unittest
import subprocess
from test import test_support
from test.script_helper import assert_python_ok

import warning_tests

import warnings as original_warnings

py_warnings = test_support.import_fresh_module("warnings", blocked=["_warnings"])
c_warnings = test_support.import_fresh_module("warnings", fresh=["_warnings"])


@contextmanager
def warnings_state(module):
    """Use a specific warnings implementation in warning_tests."""
    global __warningregistry__
    for to_clear in (sys, warning_tests):
        try:
            to_clear.__warningregistry__.clear()
        except AttributeError:
            pass
    try:
        __warningregistry__.clear()
    except NameError:
        pass

Example #18

File: __init__.py Project: webiumsk/WOT-0.9.12-CT

# 2015.11.10 21:36:31 Støední Evropa (bìžný èas)
# Embedded file name: scripts/common/Lib/json/tests/__init__.py
import os
import sys
import json
import doctest
import unittest
from test import test_support
cjson = test_support.import_fresh_module('json', fresh=['_json'])
pyjson = test_support.import_fresh_module('json', blocked=['_json'])

class PyTest(unittest.TestCase):
    json = pyjson
    loads = staticmethod(pyjson.loads)
    dumps = staticmethod(pyjson.dumps)


@unittest.skipUnless(cjson, 'requires _json')

class CTest(unittest.TestCase):
    if cjson is not None:
        json = cjson
        loads = staticmethod(cjson.loads)
        dumps = staticmethod(cjson.dumps)


class TestPyTest(PyTest):

    def test_pyjson(self):
        self.assertEqual(self.json.scanner.make_scanner.__module__, 'json.scanner')
        self.assertEqual(self.json.decoder.scanstring.__module__, 'json.decoder')

Example #19

File: __init__.py Project: wenbobuaa/pykit

import os
import sys
import doctest
import unittest

from test import test_support
from pykit import p3json

# import json with and without accelerations
cjson = test_support.import_fresh_module('json', fresh=['_json'])
# pyjson = test_support.import_fresh_module('json', blocked=['_json'])
pyjson = p3json


# create two base classes that will be used by the other tests
class PyTest(unittest.TestCase):
    json = pyjson
    loads = staticmethod(pyjson.loads)
    dumps = staticmethod(pyjson.dumps)


# test PyTest and CTest checking if the functions come from the right module
class TestPyTest(PyTest):
    def test_pyjson(self):
        self.assertEqual(self.json.scanner.make_scanner.__module__,
                         'json.scanner')
        self.assertEqual(self.json.decoder.scanstring.__module__,
                         'json.decoder')
        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
                         'json.encoder')