class TestCommandTaskWithMockPopen(MockLoggerMixin, unittest.TestCase):
""" Run command tasks with a mocked popen """
def setUp(self):
self.global_config = BaseGlobalConfig()
self.project_config = BaseProjectConfig(
self.global_config, config={"noyaml": True}
)
self.task_config = TaskConfig()
self._task_log_handler.reset()
self.task_log = self._task_log_handler.messages
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace("cumulusci.tasks.command.subprocess.Popen", self.Popen)
self.addCleanup(self.r.restore)
def test_functional_mock_command(self):
""" Functional test that runs a command with mocked
popen results and checks the log.
"""
self.task_config.config["options"] = {"command": "ls -la"}
self.Popen.set_command("ls -la", stdout=b"testing testing 123", stderr=b"e")
task = Command(self.project_config, self.task_config)
task()
self.assertTrue(any("testing testing" in s for s in self.task_log["info"]))
def set_time(self, dt):
r = Replacer()
r.replace(
'testfixtures.tests.sample1.datetime',
test_datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute,
dt.second))
return r
def setUp(self):
log.setLevel('CRITICAL')
self.Popen = MockPopen()
replacer = Replacer()
replacer.replace('popper.runner_host.Popen', self.Popen)
self.addCleanup(replacer.restore)
self.repo = tempfile.mkdtemp()
def test_replacer_del(self):
r = Replacer()
r.replace('testfixtures.tests.sample1.left_behind', object(), strict=False)
with catch_warnings(record=True) as w:
del r
self.assertTrue(len(w), 1)
compare(str(w[0].message), "Replacer deleted without being restored, originals left: {'testfixtures.tests.sample1.left_behind': <not_there>}")
class TestCommandTaskWithMockPopen(MockLoggerMixin, unittest.TestCase):
""" Run command tasks with a mocked popen """
def setUp(self):
self.global_config = BaseGlobalConfig()
self.project_config = BaseProjectConfig(
self.global_config, config={"noyaml": True}
)
self.task_config = TaskConfig()
self._task_log_handler.reset()
self.task_log = self._task_log_handler.messages
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace("cumulusci.tasks.command.subprocess.Popen", self.Popen)
self.addCleanup(self.r.restore)
def test_functional_mock_command(self):
""" Functional test that runs a command with mocked
popen results and checks the log.
"""
self.task_config.config["options"] = {"command": "ls -la"}
self.Popen.set_command("ls -la", stdout=b"testing testing 123", stderr=b"e")
task = Command(self.project_config, self.task_config)
task()
self.assertTrue(any("testing testing" in s for s in self.task_log["info"]))
def test_cleanup_properly(self):
r = Replacer()
try:
m = Mock()
d = mkdtemp()
m.return_value = d
r.replace('testfixtures.tempdirectory.mkdtemp',m)
self.failUnless(os.path.exists(d))
self.assertFalse(m.called)
@tempdir()
def test_method(d):
d.write('something', b'stuff')
d.check('something', )
self.assertFalse(m.called)
compare(os.listdir(d),[])
test_method()
self.assertTrue(m.called)
self.failIf(os.path.exists(d))
finally:
r.restore()
if os.path.exists(d):
# only runs if the test fails!
rmtree(d) # pragma: no cover
def test_cleanup_properly(self):
r = Replacer()
try:
m = Mock()
d = mkdtemp()
m.return_value = d
r.replace('testfixtures.tempdirectory.mkdtemp',m)
self.failUnless(os.path.exists(d))
self.assertFalse(m.called)
@tempdir()
def test_method(d):
d.write('something', b'stuff')
d.check('something', )
self.assertFalse(m.called)
compare(os.listdir(d),[])
test_method()
self.assertTrue(m.called)
self.failIf(os.path.exists(d))
finally:
r.restore()
if os.path.exists(d):
# only runs if the test fails!
rmtree(d) # pragma: no cover
def setUp(self):
self.dir = TempDirectory()
self.addCleanup(self.dir.cleanup)
self.Popen = MockPopen()
r = Replacer()
r.replace('archivist.helpers.Popen', self.Popen)
self.addCleanup(r.restore)
class SavedSearchFormTests(TestCase):
def setUp(self):
super(SavedSearchFormTests, self).setUp()
self.user = UserFactory()
self.data = {
'url': 'http://www.my.jobs/jobs',
'feed': 'http://www.my.jobs/jobs/feed/rss?',
'email': '*****@*****.**',
'frequency': 'D',
'label': 'All jobs from www.my.jobs',
'sort_by': 'Relevance'
}
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def tearDown(self):
self.r.restore()
def test_successful_form(self):
form = SavedSearchForm(user=self.user, data=self.data)
self.assertTrue(form.is_valid())
def test_invalid_url(self):
self.data['url'] = 'http://google.com'
form = SavedSearchForm(user=self.user, data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['url'][0], 'This URL is not valid.')
def test_day_of_week(self):
self.data['frequency'] = 'W'
form = SavedSearchForm(user=self.user, data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['day_of_week'][0],
'This field is required.')
self.data['day_of_week'] = '1'
form = SavedSearchForm(user=self.user, data=self.data)
self.assertTrue(form.is_valid())
def test_day_of_month(self):
self.data['frequency'] = 'M'
form = SavedSearchForm(user=self.user, data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['day_of_month'][0],
'This field is required.')
self.data['day_of_month'] = '1'
form = SavedSearchForm(user=self.user, data=self.data)
self.assertTrue(form.is_valid())
def test_duplicate_url(self):
original = SavedSearchFactory(user=self.user)
form = SavedSearchForm(user=self.user, data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['url'][0], 'URL must be unique.')
def test_replacer_del(self):
r = Replacer()
r.replace('testfixtures.tests.sample1.left_behind',
object(), strict=False)
with catch_warnings(record=True) as w:
del r
self.assertTrue(len(w), 1)
compare(str(w[0].message),
"Replacer deleted without being restored, ""originals left:"
" {'testfixtures.tests.sample1.left_behind': <not_there>}")
class SourceMixin(object):
def setUp(self):
def get_source(level=''):
return 'default_source'+str(level)
self.r = Replacer()
self.r.replace('configurator._api.get_source', get_source)
self.r.replace('configurator.section.get_source', get_source)
def tearDown(self):
self.r.restore()
def setUp(self):
self.Popen = MockPopen()
replacer = Replacer()
replacer.replace("popper.runner_host.Popen", self.Popen)
assert_replacer = Replacer()
assert_replacer.replace(
"popper.runner_slurm.assert_executable_exists",
mock_assert_executable_exists,
)
self.addCleanup(replacer.restore)
self.addCleanup(assert_replacer.restore)
class SavedSearchFormTests(TestCase):
def setUp(self):
super(SavedSearchFormTests, self).setUp()
self.user = UserFactory()
self.data = {'url': 'http://www.my.jobs/jobs',
'feed': 'http://www.my.jobs/jobs/feed/rss?',
'email': '*****@*****.**',
'frequency': 'D',
'label': 'All jobs from www.my.jobs',
'sort_by': 'Relevance'}
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def tearDown(self):
self.r.restore()
def test_successful_form(self):
form = SavedSearchForm(user=self.user,data=self.data)
self.assertTrue(form.is_valid())
def test_invalid_url(self):
self.data['url'] = 'http://google.com'
form = SavedSearchForm(user=self.user,data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['url'][0], 'This URL is not valid.')
def test_day_of_week(self):
self.data['frequency'] = 'W'
form = SavedSearchForm(user=self.user,data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['day_of_week'][0], 'This field is required.')
self.data['day_of_week'] = '1'
form = SavedSearchForm(user=self.user,data=self.data)
self.assertTrue(form.is_valid())
def test_day_of_month(self):
self.data['frequency'] = 'M'
form = SavedSearchForm(user=self.user,data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['day_of_month'][0], 'This field is required.')
self.data['day_of_month'] = '1'
form = SavedSearchForm(user=self.user,data=self.data)
self.assertTrue(form.is_valid())
def test_duplicate_url(self):
original = SavedSearchFactory(user=self.user)
form = SavedSearchForm(user=self.user,data=self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['url'][0], 'URL must be unique.')
def test_import_and_obtain_with_lists(self):
t = test_datetime(None)
t.add(2002, 1, 1, 1, 0, 0)
t.add(2002, 1, 1, 2, 0, 0)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.now', t.now)
try:
compare(sample1.str_now_2(), '2002-01-01 01:00:00')
compare(sample1.str_now_2(), '2002-01-01 02:00:00')
finally:
r.restore()
def test_import_and_obtain_with_lists(self):
t = test_date(None)
t.add(2002, 1, 1)
t.add(2002, 1, 2)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.today', t.today)
try:
compare(sample1.str_today_2(), '2002-01-01')
compare(sample1.str_today_2(), '2002-01-02')
finally:
r.restore()
def test_remove_called_twice(self):
from testfixtures.tests import sample1
def test_z(): pass
r = Replacer()
r.replace('testfixtures.tests.sample1.z',test_z)
r.restore()
assert sample1.z() == 'original z'
r.restore()
assert sample1.z() == 'original z'
def setUp(self):
r = Replacer()
self.addCleanup(r.restore)
self.mock = Mock()
self.mock.input.return_value = 'u'
self.mock.getpass.return_value = 'p'
r.replace('workfront.get_api_key.input', self.mock.input)
r.replace('getpass.getpass', self.mock.getpass)
r.replace('logging.basicConfig', self.mock.logging)
r.replace('sys.argv', ['x'])
self.server = MockOpen(
'https://api-cl01.attask-ondemand.com/attask/api/unsupported')
r.replace('workfront.six.moves.urllib.request.urlopen', self.server)
class BasicMockedPopen:
"""Class with a mocked popen for system calls.
use self.popen.set_command(command, stdout=b'returned value')
"""
@pytest.fixture(autouse=True)
def mock_popen_clear_env(self):
"""Mock Popen around each test."""
self.popen = MockPopen()
self.replacer = Replacer()
self.replacer.replace("universions._exec.Popen", self.popen)
yield
self.replacer.restore()
def test_import_and_obtain_with_lists(self):
t = test_datetime(None)
t.add(2002, 1, 1, 1, 0, 0)
t.add(2002, 1, 1, 2, 0, 0)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.now', t.now)
try:
compare(sample1.str_now_2(), '2002-01-01 01:00:00')
compare(sample1.str_now_2(), '2002-01-01 02:00:00')
finally:
r.restore()
def test_import_and_obtain_with_lists(self):
t = test_date(None)
t.add(2002, 1, 1)
t.add(2002, 1, 2)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.today', t.today)
try:
compare(sample1.str_today_2(), '2002-01-01')
compare(sample1.str_today_2(), '2002-01-02')
finally:
r.restore()
def setUp(self):
r = Replacer()
self.addCleanup(r.restore)
self.mock = Mock()
self.mock.input.return_value = 'u'
self.mock.getpass.return_value = 'p'
r.replace('workfront.get_api_key.input', self.mock.input)
r.replace('getpass.getpass', self.mock.getpass)
r.replace('logging.basicConfig', self.mock.logging)
r.replace('sys.argv', ['x'])
self.server = MockOpen(
'https://api-cl01.attask-ondemand.com/attask/api/unsupported'
)
r.replace('workfront.six.moves.urllib.request.urlopen', self.server)
class PopenCommandsTest(unittest.TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace('swabbie.utils.command.subprocess.Popen', self.Popen)
self.addCleanup(self.r.restore)
def test_call_cmd(self):
self.Popen.set_command('cmd1', stdout='foo')
command_result = Command._call_cmd('cmd1')
expected_command_result = CommandResult(output='foo', return_code=0)
self.assertEqual(command_result.output, expected_command_result.output)
self.assertEqual(command_result.return_code, expected_command_result.return_code)
self.assertFalse(command_result.err)
def test_method(self):
from testfixtures.tests import sample1
assert sample1.X().y() == 'original y'
def test_y(self):
return 'replacement y'
r = Replacer()
r.replace('testfixtures.tests.sample1.X.y',test_y)
assert sample1.X().y()[:38] == 'replacement y'
r.restore()
assert sample1.X().y() == 'original y'
def test_function(self):
from testfixtures.tests import sample1
assert sample1.z() == 'original z'
def test_z():
return 'replacement z'
r = Replacer()
r.replace('testfixtures.tests.sample1.z',test_z)
assert sample1.z() == 'replacement z'
r.restore()
assert sample1.z() == 'original z'
class TestCheck(TestCase):
def setUp(self):
self.r = Replacer()
self.l = LogCapture()
def tearDown(self):
self.l.uninstall()
self.r.restore()
def checker_returns(self,output):
resolve = Mock()
self.r.replace('checker.resolve',resolve)
def the_checker(config_folder,param):
return output
resolve.return_value = the_checker
return resolve
def test_bad_checker(self):
from checker import check
check = should_raise(check,ImportError('No module named unknown'))
check('/config','unknown',None)
def test_normal(self):
m = self.checker_returns('some output')
check('/config','achecker',None)
compare(m.call_args_list,[
(('checker.checkers.achecker.check',), {})
])
def test_log_newline(self):
self.checker_returns('some output\n')
check('/config','achecker','aparam')
self.l.check(
('root', 'INFO', 'some output'),
)
def test_log_no_newline(self):
self.checker_returns('some output')
check('/config','achecker','aparam')
self.l.check(
('root', 'INFO', 'some output'),
)
def test_no_log_empty(self):
self.checker_returns('')
check('/config','achecker','aparam')
self.l.check()
def test_class_method(self):
from testfixtures.tests import sample1
c = sample1.X
assert sample1.X.aMethod() is c
def rMethod(cls):
return cls, 1
r = Replacer()
r.replace('testfixtures.tests.sample1.X.aMethod',rMethod)
sample1.X.aMethod()
assert sample1.X.aMethod() == (c, 1)
r.restore()
sample1.X.aMethod()
assert sample1.X.aMethod() is c
def test_class(self):
from testfixtures.tests import sample1
x = sample1.X()
assert x.__class__.__name__ == 'X'
class XReplacement(sample1.X): pass
r = Replacer()
r.replace('testfixtures.tests.sample1.X', XReplacement)
x = sample1.X()
assert x.__class__.__name__ == 'XReplacement'
assert sample1.X().y() == 'original y'
r.restore()
x = sample1.X()
assert x.__class__.__name__ == 'X'
class TestEditPageController(unittest.TestCase):
def setUp(self):
self.r = Replacer()
self.r.replace('opencore.views.forms.get_current_request',
lambda: self.request)
self.r.replace('opencore.views.forms.authenticated_userid',
lambda request: 'auth_user_id')
testing.cleanUp()
context = testing.DummyModel()
context.title = 'title'
context.text = 'content text'
context.__name__ = 'my-page'
self.context = context
request = testing.DummyRequest()
request.api = get_template_api(context, request)
request.context = context
self.request = request
def tearDown(self):
testing.cleanUp()
self.r.restore()
def _makeOne(self):
return EditPageController(self.context, self.request)
def test_get(self):
controller = self._makeOne()
info = controller()
self.assertTrue('api' in info)
self.assertTrue(info['form'].startswith('<form id="deform"'))
def test_post(self):
self.request.POST = MultiDict([
('title', u'New Title'),
('text', u'Lorem Ipsum'),
('save', u'save'),
])
controller = self._makeOne()
info = controller()
self.assertEquals(self.context.title, "New Title")
self.assertEquals(self.context.text, "Lorem Ipsum")
class TestCheck(TestCase):
def setUp(self):
self.r = Replacer()
self.l = LogCapture()
def tearDown(self):
self.l.uninstall()
self.r.restore()
def checker_returns(self, output):
resolve = Mock()
self.r.replace('checker.check.resolve', resolve)
def the_checker(config_folder, param):
return output
resolve.return_value = the_checker
return resolve
def test_bad_checker(self):
with ShouldRaise(ImportError('No module named unknown')):
check('/config', 'unknown', None)
def test_normal(self):
m = self.checker_returns('some output')
check('/config', 'achecker', None)
compare(m.call_args_list,
[(('checker.checkers.achecker.check', ), {})])
def test_log_newline(self):
self.checker_returns('some output\n')
check('/config', 'achecker', 'aparam')
self.l.check(('root', 'INFO', 'some output'), )
def test_log_no_newline(self):
self.checker_returns('some output')
check('/config', 'achecker', 'aparam')
self.l.check(('root', 'INFO', 'some output'), )
def test_no_log_empty(self):
self.checker_returns('')
check('/config', 'achecker', 'aparam')
self.l.check()
class TestCheck(TestCase):
def setUp(self):
self.r = Replacer()
self.l = LogCapture()
def tearDown(self):
self.l.uninstall()
self.r.restore()
def checker_returns(self, output):
resolve = Mock()
self.r.replace("checker.check.resolve", resolve)
def the_checker(config_folder, param):
return output
resolve.return_value = the_checker
return resolve
def test_bad_checker(self):
with ShouldRaise(ImportError("No module named unknown")):
check("/config", "unknown", None)
def test_normal(self):
m = self.checker_returns("some output")
check("/config", "achecker", None)
compare(m.call_args_list, [(("checker.checkers.achecker.check",), {})])
def test_log_newline(self):
self.checker_returns("some output\n")
check("/config", "achecker", "aparam")
self.l.check(("root", "INFO", "some output"))
def test_log_no_newline(self):
self.checker_returns("some output")
check("/config", "achecker", "aparam")
self.l.check(("root", "INFO", "some output"))
def test_no_log_empty(self):
self.checker_returns("")
check("/config", "achecker", "aparam")
self.l.check()
def test_gotcha(self):
# Just because you replace an object in one context:
from testfixtures.tests import sample1
from testfixtures.tests import sample2
assert sample1.z() == 'original z'
def test_z():
return 'replacement z'
r = Replacer()
r.replace('testfixtures.tests.sample1.z',test_z)
assert sample1.z() == 'replacement z'
# Doesn't meant that it's replaced in all contexts:
assert sample2.z() == 'original z'
r.restore()
class TestCommandTaskWithMockPopen(unittest.TestCase):
""" Run command tasks with a mocked popen """
@classmethod
def setUpClass(cls):
super(TestCommandTaskWithMockPopen, cls).setUpClass()
logger = logging.getLogger(cumulusci.core.tasks.__name__)
logger.setLevel(logging.DEBUG)
cls._task_log_handler = MockLoggingHandler(logging.DEBUG)
logger.addHandler(cls._task_log_handler)
def setUp(self):
self.global_config = BaseGlobalConfig()
self.project_config = BaseProjectConfig(self.global_config)
self.task_config = TaskConfig()
self._task_log_handler.reset()
self.task_log = self._task_log_handler.messages
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace('cumulusci.tasks.command.subprocess.Popen', self.Popen)
self.addCleanup(self.r.restore)
def test_functional_mock_command(self):
""" Functional test that runs a command with mocked
popen results and checks the log.
"""
self.task_config.config['options'] = {
'command': 'ls -la',
}
self.Popen.set_command('ls -la',
stdout=b'testing testing 123',
stderr=b'e')
task = Command(self.project_config, self.task_config)
task()
self.assertTrue(
any("testing testing" in s for s in self.task_log['info']))
class Test_handle_photo_upload(TestCase):
def setUp(self):
testing.cleanUp()
registerContentFactory(DummyImageFile,ICommunityFile)
self.cstruct = {
'fp': StringIO('some image data'),
'mimetype': 'image/jpeg',
'filename': u'test.jpg',
}
self.context = DummyProfile()
self.authenticated_userid = Mock()
self.authenticated_userid.return_value = 'auser'
self.r = Replacer()
self.r.replace('opencore.views.utils.authenticated_userid',
self.authenticated_userid)
def tearDown(self):
self.r.restore()
testing.cleanUp()
def test_no_cstruct(self):
handle_photo_upload(self.context,None,None)
self.assertFalse(self.context.get('photo'))
def test_no_existing_photo(self):
handle_photo_upload(self.context,None,self.cstruct)
content = self.context['photo']
compare(content.title,'Photo of firstname lastname')
compare(content.mimetype,'image/jpeg')
compare(content.filename,'test.jpg')
compare(content.creator,'auser')
def test_existing_photo(self):
self.context['photo']=testing.DummyModel()
handle_photo_upload(self.context,None,self.cstruct)
content = self.context['photo']
compare(content.title,'Photo of firstname lastname')
compare(content.mimetype,'image/jpeg')
compare(content.filename,'test.jpg')
compare(content.creator,'auser')
def _setUp(d, stdout=True):
removeHandlers()
DummySMTP.install(stdout=stdout)
atexit_handlers = []
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace('atexit.register', atexit_handlers.append)
r.replace('mailinglogger.MailingLogger.now', datetime.now)
r.replace('mailinglogger.common.gethostname', Dummy('host.example.com'))
r.replace('time.time', time)
r.replace('os.environ.TZ', 'GMT', strict=False)
tzset()
d['atexit_handlers'] = atexit_handlers
d['r'] = r
d['smtp'] = DummySMTP
d['datetime'] = datetime
d['time'] = time
d['removeHandlers'] = removeHandlers
def test_multiple_replace(self):
from testfixtures.tests import sample1
assert sample1.z() == 'original z'
assert sample1.X().y() == 'original y'
def test_y(self):
return self.__class__.__name__
def test_z():
return 'replacement z'
r = Replacer()
r.replace('testfixtures.tests.sample1.z',test_z)
r.replace('testfixtures.tests.sample1.X.y',test_y)
assert sample1.z() == 'replacement z'
assert sample1.X().y() == 'X'
r.restore()
assert sample1.z() == 'original z'
assert sample1.X().y() == 'original y'
def _setUp(d, stdout=True):
removeHandlers()
DummySMTP.install(stdout=stdout)
atexit_handlers = []
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace('atexit.register', atexit_handlers.append)
r.replace('mailinglogger.MailingLogger.now', datetime.now)
r.replace('mailinglogger.common.gethostname', Dummy('host.example.com'))
r.replace('time.time', time)
r.replace('os.environ.TZ', 'GMT', strict=False)
tzset()
d['atexit_handlers'] = atexit_handlers
d['r'] = r
d['smtp'] = DummySMTP
d['datetime'] = datetime
d['time'] = time
d['removeHandlers'] = removeHandlers
class TestReplacerXUnit(unittest.TestCase):
def setUp(self):
self.replacer = Replacer()
self.mock_a = MagicMock()
self.mock_b = MagicMock()
self.replacer.replace('test_hello.RealClassA', self.mock_a)
self.replacer.replace('test_hello.RealClassB', self.mock_b)
def tearDown(self):
self.replacer.restore()
def test_mock(self):
instance_a = RealClassA()
instance_b = RealClassB()
instance_a.say.return_value = 'FakeClassA'
instance_b.say.return_value = 'FakeClassB'
self.assertEqual(instance_a.say(), 'FakeClassA')
self.assertEqual(instance_b.say(), 'FakeClassB')
def _setUp(d):
removeHandlers()
DummySMTP.install()
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace('mailinglogger.MailingLogger.now', datetime.now)
r.replace('mailinglogger.common.gethostname', Dummy('host.example.com'))
r.replace('time.time', time)
r.replace('os.environ.TZ', 'GMT', strict=False)
tzset()
d['r'] = r
d['smtp'] = DummySMTP
d['datetime'] = datetime
d['time'] = time
d['removeHandlers'] = removeHandlers
def _setUp(test, self=None, stdout=True):
if self is None:
d = test.globs
else:
d = self.__dict__
removeHandlers()
DummySMTP.install(stdout=stdout)
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace('mailinglogger.MailingLogger.now', datetime.now)
r.replace('mailinglogger.common.gethostname', Dummy('host.example.com'))
r.replace('time.time', time)
r.replace('os.environ.TZ', 'GMT', strict=False)
tzset()
d['r'] = r
d['smtp'] = DummySMTP
d['datetime'] = datetime
d['time'] = time
d['removeHandlers'] = removeHandlers
def _setUp(test, self=None, stdout=True):
if self is None:
d = test.globs
else:
d = self.__dict__
removeHandlers()
DummySMTP.install(stdout=stdout)
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace('mailinglogger.MailingLogger.now', datetime.now)
r.replace('mailinglogger.common.gethostname', Dummy('host.example.com'))
r.replace('time.time', time)
r.replace('os.environ.TZ', 'GMT', strict=False)
tzset()
d['r'] = r
d['smtp']=DummySMTP
d['datetime']=datetime
d['time']=time
d['removeHandlers']=removeHandlers
def setUp(test, self=None, stdout=True):
if self is None:
d = test.globs
else:
d = self.__dict__
removeHandlers()
DummySMTP.install(stdout=stdout)
datetime = test_datetime(2007, 1, 1, 10, delta=0)
time = test_time(2007, 1, 1, 10, delta=0)
r = Replacer()
r.replace("mailinglogger.MailingLogger.now", datetime.now)
r.replace("mailinglogger.common.gethostname", Dummy("host.example.com"))
r.replace("time.time", time)
r.replace("os.environ.TZ", "GMT", strict=False)
tzset()
d["r"] = r
d["smtp"] = DummySMTP
d["datetime"] = datetime
d["time"] = time
d["removeHandlers"] = removeHandlers
def setUp(self):
self.popen = MockPopen()
replacer = Replacer()
replacer.replace('testfixtures.tests.test_popen.subprocess.Popen',
self.popen)
self.addCleanup(replacer.restore)
class SavedSearchHelperTests(TestCase):
def setUp(self):
super(SavedSearchHelperTests, self).setUp()
self.user = UserFactory()
self.valid_url = 'http://www.my.jobs/search?location=chicago&q=nurse'
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def tearDown(self):
self.r.restore()
def test_valid_dotjobs_url(self):
url, soup = validate_dotjobs_url(self.valid_url)
self.assertIsNotNone(url)
self.assertIsNotNone(soup)
no_netloc = 'www.my.jobs/search?location=chicago&q=nurse'
title, url = validate_dotjobs_url(no_netloc)
self.assertIsNotNone(title)
self.assertIsNotNone(url)
self.assertEquals(title, 'Jobs - nurse Jobs in Chicago')
valid_filter_url = 'www.my.jobs/chicago/illinois/usa/jobs/mcdonalds/careers/'
title, url = validate_dotjobs_url(valid_filter_url)
self.assertIsNotNone(title)
self.assertIsNotNone(url)
def test_invalid_dotjobs_url(self):
urls = [ 'http://google.com', # url does not contain a feed
'', # url not provided
'http://'] # invalid url provided
for url in urls:
title, url = validate_dotjobs_url(url)
self.assertIsNone(title)
self.assertIsNone(url)
def test_date_in_range(self):
start = datetime.date(month=1,day=1,year=2013)
end = datetime.date(month=12,day=1,year=2013)
x = datetime.date(month=6,day=1,year=2013)
is_in_range = date_in_range(start, end, x)
self.assertTrue(is_in_range)
start = datetime.date(month=1,day=1,year=2013)
end = datetime.date(month=12,day=1,year=2013)
x = datetime.date(month=6,day=1,year=2010)
is_in_range = date_in_range(start, end, x)
self.assertFalse(is_in_range)
def test_parse_rss(self):
feed_url = 'http://www.my.jobs/feed/rss'
items = parse_rss(feed_url)
self.assertTrue(len(items) <= 20)
def test_url_sort_options(self):
feed = 'http://www.my.jobs/jobs/feed/rss?date_sort=False'
# Test to make sure sort by "Relevance" has '&date_sort=False' added
# a single time
feed_url = url_sort_options(feed, "Relevance")
parsed = urlparse(feed_url)
query = parse_qs(parsed.query)
self.assertEquals(parsed.path, "/jobs/feed/rss")
self.assertEquals(query['date_sort'], [u'False'])
int(query['days_ago'][0])
# Test to make sure sort by "Date" doesn't have anything added
feed_url = url_sort_options(feed, "Date")
self.assertEquals(feed_url, "http://www.my.jobs/jobs/feed/rss")
def test_unicode_in_search(self):
search = SavedSearch(url=u"http://www.my.jobs/search?q=%E2%80%93",
user=self.user,
feed=u"http://www.my.jobs/search/feed/rss?q=%E2%80%93",
sort_by=u'Relevance')
search.save()
feed_url = url_sort_options(search.feed, search.sort_by)
old = parse_qs(urlparse(search.feed).query)
new = parse_qs(urlparse(feed_url).query)
self.assertFalse(old.get('date_sort'))
self.assertFalse(old.get('days_ago'))
self.assertTrue(new['date_sort'][0])
self.assertTrue(new['days_ago'][0])
del new['date_sort']
del new['days_ago']
self.assertEqual(new, old)
class CppInsightsTestCase(unittest.TestCase):
def mock_mkstemp(self, suffix=None, prefix=None, dir=None, text=False):
self.fd = open('/tmp/pyt.cpp', "w+")
return [self.fd.fileno(), '/tmp/pyt.cpp']
#------------------------------------------------------------------------------
@staticmethod
def removeDbTestFile(cls):
if os.path.exists(cls.getDbNameMock()):
os.remove(cls.getDbNameMock())
#------------------------------------------------------------------------------
@staticmethod
def getDbNameMock():
return 'urls_test.db'
#------------------------------------------------------------------------------
@classmethod
def setUpClass(cls):
cls.removeDbTestFile(cls)
#------------------------------------------------------------------------------
def setUp(self):
self.app = app.test_client()
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace('subprocess.Popen', self.Popen)
self.r.replace('tempfile.mkstemp', self.mock_mkstemp)
self.r.replace('app.getDbName', self.getDbNameMock)
self.addCleanup(self.r.restore)
#------------------------------------------------------------------------------
@classmethod
def tearDownClass(cls):
cls.removeDbTestFile(cls)
#------------------------------------------------------------------------------
# def tearDown(self):
## if None != self.fd:
# self.fd.close()
# if hasattr(self, 'fd'):
# self.fd.close()
#------------------------------------------------------------------------------
def test_access_root(self):
rv = self.app.get('/')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_cpp_options_order_root(self):
rv = self.app.get('/')
data = rv.data.decode("utf-8").splitlines()
opts = [
'C++ Standard',
'cpp98',
'cpp11',
'cpp14',
'cpp17',
'cpp2a',
'Alternative Styles',
'alt-syntax-for',
'alt-syntax-subscription',
'More Transformations',
# 'stdinitlist',
'all-implicit-casts',
'use-libcpp',
]
regEx = re.compile(r'[value|label]="(.*?)"')
regExGroup = re.compile(r'label="(.*?)"') # optgroup label=
options = []
for line in data:
line = line.strip()
if not line.startswith('<option') and not line.startswith(
'<optgroup'):
continue
if -1 != line.find('class="fonts"'):
continue
m = regEx.search(line)
if None != m:
options.append(m.group(1))
assert opts == options
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_invalid_site(self):
rv = self.app.get('/aa')
assert b'Page Not Found' in rv.data
#------------------------------------------------------------------------------
def test_invalid_site_with_post(self):
rv = self.app.post('/test_function',
data=json.dumps(dict(foo='bar')),
content_type='application/json')
assert 405 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -- -std=c++98',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(
dict(insightsOptions=['cpp98'], code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid_with_result_1(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -- -std=c++98',
stdout=b'o',
stderr=b'',
returncode=1)
rv = self.app.post('/api/v1/transform',
data=json.dumps(
dict(insightsOptions=['cpp98'], code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 1)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 1')
self.assertTrue(data['stdout'] == 'Compilation failed!')
assert b'Compilation failed!' in data['stdout'].encode()
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid_with_result_and_insights_args_1(
self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -alt-syntax-for -- -std=c++98',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(
dict(
insightsOptions=['alt-syntax-for', 'cpp98'],
code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid_with_warnings(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -- -std=c++98',
stdout=b'o',
stderr=b'Warning: unused var',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(
dict(insightsOptions=['cpp98'], code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(data['stderr'] == 'Warning: unused var')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_invalid_std(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -- -std=c++17',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(
dict(insightsOptions=['cpp12'], code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_version(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none --rm -i insights-test --',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format \'{{.ID}} {{.CreatedAt}}\'',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format {{.ID}} {{.CreatedAt}}',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.get('/api/v1/version', content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(
data['stdout'] == 'o\nDocker image "insights-test" info: o\n')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_version_invalid(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none --rm -i insights-test --',
stdout=b'o',
stderr=b'',
returncode=1)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format \'{{.ID}} {{.CreatedAt}}\'',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format {{.ID}} {{.CreatedAt}}',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.get('/api/v1/version', content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 1)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 1')
assert b'Compilation failed!' in data['stdout'].encode()
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_version_none_sudo(self):
app.config['USE_SUDO'] = False
self.Popen.set_command(
'docker run --net=none --rm -i insights-test --',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format \'{{.ID}} {{.CreatedAt}}\'',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format {{.ID}} {{.CreatedAt}}',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.get('/api/v1/version', content_type='application/json')
app.config['USE_SUDO'] = True
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(
data['stdout'] == 'o\nDocker image "insights-test" info: o\n')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_version_none_docker(self):
app.config['USE_DOCKER'] = False
self.Popen.set_command('insights /tmp/pyt.cpp --',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format \'{{.ID}} {{.CreatedAt}}\'',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format {{.ID}} {{.CreatedAt}}',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.get('/api/v1/version', content_type='application/json')
app.config['USE_DOCKER'] = True
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(
data['stdout'] ==
'o\nDocker image "insights-test" info: Docker not used\n')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_version(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none --rm -i insights-test --',
stdout=b'fake version info from docker',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format \'{{.ID}} {{.CreatedAt}}\'',
stdout=b'o',
stderr=b'',
returncode=0)
self.Popen.set_command(
'docker images --filter=reference=insights-test --format {{.ID}} {{.CreatedAt}}',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.get('/version')
assert b'fake version info from docker' in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def selectedStandard(self, cppStd, text):
return (
'<option value="%s" class="single" selected="selected" >\n %s</option>'
% (cppStd, text)).encode()
#------------------------------------------------------------------------------
def test_link_rev_1_valid(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=1.0',
follow_redirects=True)
assert self.selectedStandard('cpp11', 'C++ 11') in rv.data
assert b'<meta property="og:title" content="C++ Insights" />' in rv.data
assert b'<meta property="og:description" content="#include <cstdio>\ntemplate<typename U>\nclass X\n{\npublic:\n X() = default;\n X(const X&" />' in rv.data
assert b'<title>C++ Insights</title>' in rv.data
#------------------------------------------------------------------------------
def test_link_rev_1_invalid_std(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp12&rev=1.0',
follow_redirects=True)
assert self.selectedStandard('cpp17', 'C++ 17') in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_missing_std(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&rev=1.0',
follow_redirects=True)
assert self.selectedStandard('cpp17', 'C++ 17') in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_missing_rev(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11',
follow_redirects=True)
assert self.selectedStandard('cpp17', 'C++ 17') in rv.data
assert b'The revision of the link is invalid.' in rv.data
assert 404 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_invalid_rev(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=22',
follow_redirects=True)
assert self.selectedStandard('cpp17', 'C++ 17') in rv.data
assert b'The revision of the link is invalid.' in rv.data
assert 404 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_invalid_base64(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQAAAAAAAAAAJiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=1.0',
follow_redirects=True)
assert self.selectedStandard('cpp11', 'C++ 11') in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def getShortLink(self,
code,
std='cpp98',
rev='1.0',
opts=['alt-syntax-for'],
description=''):
return self.app.post(
'/api/v1/getshortlink',
data=json.dumps(
dict(options=opts,
code=createBase64EncodedString(code),
desc=createBase64EncodedString(description),
rev=rev,
std=std)),
content_type='application/json')
#------------------------------------------------------------------------------
def test_create_short_link(self):
rv = self.getShortLink('hello')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_short_link_size(self):
rv = self.getShortLink('slzhello')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
shortLink = shortLink.replace('/s/', '')
assert len(shortLink) == 8
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_create_short_link_twice(self):
# Request a link the first time
rv = self.getShortLink('hellosame')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
# Request a link for the same parameters a second time
rv = self.getShortLink('hellosame')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 1)
shortLink2 = data['shortlink']
assert None != shortLink2
assert shortLink2.startswith('/s/')
assert 200 == rv.status_code
assert shortLink == shortLink2
#------------------------------------------------------------------------------
def test_create_short_link_none_base64(self):
rv = self.app.post('/api/v1/getshortlink',
data=json.dumps(
dict(options=['alt-syntax-for'],
code='not-base64-encoded',
desc='',
rev='1.0',
std='cpp98')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 2)
shortLink = data['shortlink']
assert None != shortLink
assert 'No source' == shortLink
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_create_short_link_null(self):
rv = self.app.post('/api/v1/getshortlink',
data=json.dumps(
dict(options=['alt-syntax-for'],
code=None,
rev='1.0',
desc='',
std='cpp98')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 2)
shortLink = data['shortlink']
assert None != shortLink
assert 'No source' == shortLink
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_short_link_code_differ(self):
# Request a link the first time
rv = self.getShortLink('hellosamed')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
# Request a link for 'nearly' the same parameters
rv = self.getShortLink('bellosamed')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink2 = data['shortlink']
assert None != shortLink2
assert shortLink2.startswith('/s/')
assert 200 == rv.status_code
assert shortLink != shortLink2
#------------------------------------------------------------------------------
def test_short_link_options_differ(self):
# Request a link the first time
rv = self.getShortLink('cellosamed')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
# Request a link for 'nearly' the same parameters
rv = self.getShortLink('cellosamed', opts=['alt-syntax-subscription'])
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink2 = data['shortlink']
assert None != shortLink2
assert shortLink2.startswith('/s/')
assert 200 == rv.status_code
assert shortLink != shortLink2
#------------------------------------------------------------------------------
def test_short_link_std_differ(self):
# Request a link the first time
rv = self.getShortLink('mellosamed', std='cpp11')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
# Request a link for 'nearly' the same parameters
rv = self.getShortLink('mellosamed', std='cpp14')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink2 = data['shortlink']
assert None != shortLink2
assert shortLink2.startswith('/s/')
assert 200 == rv.status_code
assert shortLink != shortLink2
#------------------------------------------------------------------------------
def test_short_link_multiple_options(self):
rv = self.getShortLink(createBase64EncodedString('multiple options'),
opts=['alt-syntax-subscription,alt-syntax-for'])
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
rv2 = self.app.get(shortLink, follow_redirects=False)
assert 200 == rv2.status_code
# XXX not working
# assert shortLink != shortLink2
#------------------------------------------------------------------------------
def test_invalid_short_link(self):
rv = self.app.get('/s/invalid', follow_redirects=True)
assert 404 == rv.status_code
assert b'// There is no such link.' in rv.data
#------------------------------------------------------------------------------
def test_invalid_short_link_root(self):
rv = self.app.get('/s', follow_redirects=True)
assert 404 == rv.status_code
assert b'Sorry, the content your are looking for is not there.' in rv.data
#------------------------------------------------------------------------------
def test_create_max_length_short_link(self):
s = 'a' * 1000000
rv = self.app.post('/api/v1/getshortlink',
data=json.dumps(
dict(options=['alt-syntax-for'],
code=createBase64EncodedString(s),
rev='1.0',
desc='',
std='cpp98')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_create_too_long_short_link(self):
s = 'a' * 1000001
rv = self.getShortLink(createBase64EncodedString(s))
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 1)
shortLink = data['shortlink']
assert None != shortLink
assert 'Source too long' == shortLink
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_favicon(self):
rv = self.app.get('/favicon.ico')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_twitter_description_for_root(self):
rv = self.app.get('/')
assert b'<meta property="og:description" content="C++ Insights - See your source code with the eyes of a compiler." />' in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_twitter_description_for_link(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=1.0',
follow_redirects=True)
assert b'<meta property="og:description" content="#include <cstdio>\ntemplate<typename U>\nclass X\n{\npublic:\n X() = default;\n X(const X&" />' in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_twitter_description_for_short_link(self):
rv = self.getShortLink(
'#include <cstdio> int main() { printf("hello\n"); }')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert 200 == rv.status_code
rv2 = self.app.get(shortLink, follow_redirects=False)
assert 200 == rv2.status_code
assert b'<meta property="og:description" content="#include <cstdio> int main() { printf("hello\n"); }" />' in rv2.data
#------------------------------------------------------------------------------
def test_create_short_link_with_description(self):
rv = self.getShortLink('hello with description',
description='A description')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
rv2 = self.app.get(shortLink, follow_redirects=False)
assert b'<meta property="og:title" content="C++ Insights - A description" />' in rv2.data
assert b'<meta name="description" content="C++ Insights - A description" />' in rv2.data
assert b'<title>C++ Insights - A description</title>' in rv2.data
assert 200 == rv2.status_code
#------------------------------------------------------------------------------
def test_root_description(self):
rv = self.app.get('/', follow_redirects=False)
assert b'<meta property="og:title" content="C++ Insights" />' in rv.data
assert b'<meta property="og:description" content="C++ Insights - See your source code with the eyes of a compiler." />' in rv.data
assert b'<title>C++ Insights</title>' in rv.data
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_short_link_toolid_0(self):
rv = self.getShortLink('test for tool id')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
shortLink = data['shortlink']
assert None != shortLink
assert shortLink.startswith('/s/')
assert 200 == rv.status_code
conn = sqlite3.connect(self.getDbNameMock())
c = conn.cursor()
cur = c.execute('SELECT toolid FROM shortened WHERE short = ?',
(shortLink.replace('/s/', ''), ))
rv = cur.fetchone()
conn.close()
assert 1 == rv[0]
#------------------------------------------------------------------------------
def test_get_app(self):
import app
rv = app.getApp()
assert None != rv
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command("svn ls -R foo", stdout=b"o", stderr=b"e")
# testing of results
compare(my_func(), b"o")
# testing calls were in the right order and with the correct parameters:
compare(
[call.Popen("svn ls -R foo", shell=True, stderr=PIPE, stdout=PIPE), call.Popen_instance.communicate()],
Popen.mock.method_calls,
)
def test_example_bad_returncode(self):
# set up
Popen.set_command("svn ls -R foo", stdout=b"o", stderr=b"e", returncode=1)
# testing of error
with ShouldRaise(RuntimeError("something bad happened")):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command("a command")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate("foo")
# test call list
compare(
[call.Popen("a command", shell=True, stderr=-1, stdout=-1), call.Popen_instance.communicate("foo")],
Popen.mock.method_calls,
)
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", stdout=b"foo", stderr=b"bar")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b"foo")
compare(process.stderr.read(), b"bar")
# test call list
compare([call.Popen("a command", shell=True, stderr=PIPE, stdout=PIPE)], Popen.mock.method_calls)
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", returncode=3)
# usage
process = Popen("a command")
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare([call.Popen("a command"), call.Popen_instance.wait()], Popen.mock.method_calls)
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command("a command")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare(
[call.Popen("a command", shell=True, stderr=-1, stdout=-1), call.Popen_instance.send_signal(0)],
Popen.mock.method_calls,
)
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", returncode=3, poll_count=2)
# example usage
process = Popen("a command")
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare(
[
call.Popen("a command"),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
],
Popen.mock.method_calls,
)
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b"o", stderr=b"e")
# testing of results
compare(my_func(), b"o")
# testing calls were in the right order and with the correct parameters:
compare(
[call.Popen("svn ls -R foo", shell=True, stderr=PIPE, stdout=PIPE), call.Popen_instance.communicate()],
Popen.mock.method_calls,
)
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo', shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_example_bad_returncode(self):
# set up
Popen.set_command('svn ls -R foo',
stdout=b'o',
stderr=b'e',
returncode=1)
# testing of error
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
# test call list
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.communicate('foo'),
], Popen.mock.method_calls)
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', stdout=b'foo', stderr=b'bar')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b'foo')
compare(process.stderr.read(), b'bar')
# test call list
compare([
call.Popen('a command', shell=True, stderr=PIPE, stdout=PIPE),
], Popen.mock.method_calls)
def test_write_to_stdin(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdin=PIPE, shell=True)
process.stdin.write('some text')
process.stdin.close()
# test call list
compare([
call.Popen('a command', shell=True, stdin=PIPE),
call.Popen_instance.stdin.write('some text'),
call.Popen_instance.stdin.close(),
], Popen.mock.method_calls)
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
# usage
process = Popen('a command')
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare([
call.Popen('a command'),
call.Popen_instance.wait(),
], Popen.mock.method_calls)
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.send_signal(0),
], Popen.mock.method_calls)
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
# example usage
process = Popen('a command')
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare([
call.Popen('a command'),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
], Popen.mock.method_calls)
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo', shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
class TestGetBase(TestCase):
def setUp(self):
self.r = Replacer()
def tearDown(self):
self.r.restore()
def test_first_call(self):
self.r.replace('mortar_rdb._bases',{})
b1 = declarative_base()
b2 = declarative_base()
self.assertTrue(isinstance(b1,DeclarativeMeta))
self.assertTrue(b1 is b2)
def test_existing_base(self):
base = object()
self.r.replace('mortar_rdb._bases',{():base})
self.assertTrue(base is declarative_base())
def test_arguments(self):
# the first parameter to declarative_base :-)
engine = object()
if PY2:
text = 'declarative_base() takes exactly 0 arguments (1 given)'
else:
text = 'declarative_base() takes 0 positional arguments but 1 was given'
with ShouldRaise(TypeError(text)):
declarative_base(engine)
def test_parameters_engine(self):
engine = create_engine('sqlite://')
b1 = declarative_base(bind=engine)
b2 = declarative_base(bind=engine)
self.assertTrue(b1 is b2)
self.assertTrue(b1.metadata.bind is engine)
self.assertTrue(b2.metadata.bind is engine)
def test_parameters_metadata(self):
metadata = MetaData()
b1 = declarative_base(metadata=metadata)
b2 = declarative_base(metadata=metadata)
self.assertTrue(b1 is b2)
self.assertTrue(b1.metadata is metadata)
self.assertTrue(b2.metadata is metadata)
def test_parameters_metaclass(self):
class MyMeta(DeclarativeMeta):
pass
b1 = declarative_base(metaclass=MyMeta)
b2 = declarative_base(metaclass=MyMeta)
self.assertTrue(b1 is b2)
self.assertTrue(isinstance(b1,MyMeta))
self.assertTrue(isinstance(b2,MyMeta))
def test_different_bases(self):
engine = create_engine('sqlite://')
metadata = MetaData()
class MyMeta(DeclarativeMeta):
pass
b1 = declarative_base(bind=engine)
b2 = declarative_base(metadata=metadata)
b3 = declarative_base(metaclass=MyMeta)
self.assertFalse(b1 is b2)
self.assertFalse(b1 is b3)
self.assertFalse(b2 is b3)
self.assertTrue(b1.metadata.bind is engine)
self.assertFalse(b2.metadata.bind is engine)
self.assertFalse(b3.metadata.bind is engine)
self.assertFalse(b1.metadata is metadata)
self.assertTrue(b2.metadata is metadata)
self.assertFalse(b3.metadata is metadata)
self.assertFalse(isinstance(b1,MyMeta))
self.assertFalse(isinstance(b2,MyMeta))
self.assertTrue(isinstance(b3,MyMeta))
class BackupManagerTestCase(unittest.TestCase):
def create_def_backup_obj(self):
self.args = {
'host':'localhost',
'src':os.path.join(os.getcwd(), 'test_src'),
'dest':os.path.join(os.getcwd(), 'test_dest'),
'num_backups':2,
'printer':backup_printer(),
# To debug tests, this will print all commands etc to stdout
#'printer':backup_printer(sys.stdout, sys.stdout, sys.stdout,
# sys.stdout, sys.stdout),
}
self.bm = backup_manager(**self.args)
# Create random/named files
def create_random_files(self, dest, num=5):
for i in range(num):
with open(os.path.join(dest, 'rand_{}'.format(i)), 'w+b') as f:
f.write(bytes([random.randrange(256) for j in range(4096)]))
def create_named_files(self, dest, files):
for i in files:
with open(os.path.join(dest, i), 'w+b') as f:
f.write(bytes([random.randrange(256) for j in range(4096)]))
# Create/cleanup a source directory with a few random files to test with
def create_test_src_dir(self, dest=None, rand_files=5):
if dest is None: dest = self.bm.src
os.mkdir(dest)
self.create_random_files(dest, num=rand_files)
def cleanup_test_src_dir(self):
if os.access(self.bm.src, os.F_OK):
shutil.rmtree(self.bm.src)
# Create/cleanup a destination directory, possibly with some junk in there
# to start with
def create_test_dest_dir(self, dest=None, named_files=[], rand_files=0):
if dest is None: dest = self.bm.dest
os.mkdir(dest)
self.create_random_files(dest, rand_files)
self.create_named_files(dest, named_files)
def cleanup_test_dest_dir(self):
if os.access(self.bm.dest, os.F_OK):
if not os.access(self.bm.dest, os.W_OK):
os.chmod(self.bm.dest, 777)
shutil.rmtree(self.bm.dest)
# Check a specific backup dir
def check_backup_dir(self, backup_dir):
backup_dir = os.path.join(self.bm.dest, backup_dir)
ret = os.listdir(backup_dir)
self.assertIn(os.path.basename(self.bm.src), ret)
ret = sorted(os.listdir(os.path.join(backup_dir, self.bm.src)))
self.assertEqual(ret,
['rand_0','rand_1','rand_2','rand_3','rand_4',]
)
# Mocks/restores the datetime object used by backup_manager
def replace_datetime(self, dl=1):
self.rp_datetime = Replacer()
self.rp_datetime.replace('backup.BackupManager.datetime',
test_datetime(2015, 1, 1, 12, 0, 0, delta=dl))
def restore_datetime(self):
self.rp_datetime.restore()
class SavedSearchResourceTests(TestCase):
def setUp(self):
super(SavedSearchResourceTests, self).setUp()
self.user = UserFactory()
self.client = TestClient()
self.data = {'email':'*****@*****.**', 'url':'www.my.jobs/jobs'}
create_api_key(User, instance=self.user, created=True)
self.credentials = (self.user.email, self.user.api_key.key)
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def tearDown(self):
self.r.restore()
def make_response(self, data):
"""
The tests in this section use the following block of code a lot. This
makes it somewhat easier to make modifications if something must change
Inputs:
:data: dict containing the data to be posted to the saved search api
endpoint
:credentials: api user's email and api key; used to authenticate the
transaction
"""
url = '/api/v1/savedsearch/'
response = self.client.get(url, data)
return response
def test_new_search_existing_user(self):
for data in [('*****@*****.**', 'www.my.jobs/search?q=django'),
('*****@*****.**', 'www.my.jobs/search?q=python')]:
self.data['email'] = data[0]
self.data['url'] = data[1]
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
search = SavedSearch.objects.all()[0]
self.assertEqual(search.user, self.user)
content = json.loads(response.content)
self.assertEqual(len(content), 3)
self.assertTrue(content['new_search'])
self.assertEqual(SavedSearch.objects.filter(user=self.user).count(), 2)
self.data['url'] = 'http://www.my.jobs/jobs'
response = self.make_response(self.data)
for search in SavedSearch.objects.all():
self.assertTrue('www.my.jobs' in search.notes)
def test_new_search_new_user(self):
self.data['email'] = '*****@*****.**'
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(SavedSearch.objects.count(), 0)
self.assertEqual(User.objects.count(), 1)
content = json.loads(response.content)
self.assertEqual(content['email'], 'No user with email %s exists' % \
self.data['email'])
self.assertEqual(len(content), 1)
def test_new_search_secondary_email(self):
SecondaryEmail.objects.create(user=self.user,
email='*****@*****.**')
self.data['email'] = '*****@*****.**'
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(SavedSearch.objects.count(), 1)
self.assertEqual(User.objects.count(), 1)
search = SavedSearch.objects.all()[0]
self.assertEqual(search.user, self.user)
self.assertEqual(search.email, '*****@*****.**')
content = json.loads(response.content)
self.assertEqual(len(content), 3)
def test_new_search_invalid_url(self):
self.data['url'] = 'google.com'
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
self.assertEqual(len(content), 1)
self.assertEqual(content['url'], 'This is not a valid .JOBS feed')
self.assertEqual(SavedSearch.objects.count(), 0)
def test_new_search_no_url(self):
del self.data['url']
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
self.assertEqual(len(content), 1)
self.assertEqual(content['url'], 'No .JOBS feed provided')
self.assertEqual(SavedSearch.objects.count(), 0)
def test_no_email(self):
del self.data['email']
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
self.assertEqual(len(content), 1)
self.assertEqual(content['email'], 'No email provided')
self.assertEqual(SavedSearch.objects.count(), 0)
def test_no_auth(self):
response = self.make_response(self.data)
self.assertEqual(response.status_code, 401)
self.assertEqual(response.content, '')
self.assertEqual(SavedSearch.objects.count(), 0)
def test_invalid_auth(self):
headers = [(self.user.email, 'invalid_key'),
('*****@*****.**', self.user.api_key.key),
('*****@*****.**', 'invalid_key')]
for header in headers:
self.data['username'] = header[0]
self.data['api_key'] = header[1]
response = self.make_response(self.data)
self.assertEqual(response.status_code, 401)
self.assertEqual(response.content, '')
self.assertEqual(SavedSearch.objects.count(), 0)
def test_existing_search(self):
self.data['username'] = self.user.email
self.data['api_key'] = self.user.api_key.key
response = self.make_response(self.data)
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
self.assertEqual(content['new_search'], True)
for email in [self.user.email, self.user.email.upper()]:
self.data['email'] = email
response = self.make_response(self.data)
content = json.loads(response.content)
self.assertEqual(len(content), 3)
self.assertFalse(content['new_search'])
self.assertEqual(SavedSearch.objects.count(), 1)
class EmailForwardTests(TestCase):
def setUp(self):
self.redirect_guid = JOB['guid']
self.redirect = RedirectFactory(buid=JOB['buid'],
guid='{%s}' %
uuid.UUID(self.redirect_guid))
self.password = '******'
self.user = User.objects.create(email='*****@*****.**')
self.user.set_password(self.password)
self.user.save()
self.contact = CompanyEmail.objects.create(
buid=self.redirect.buid,
email=self.user.email)
self.email = self.user.email.replace('@', '%40')
self.auth = {
'bad': [
'',
'Basic %s' % base64.b64encode('bad%40email:wrong_pass')],
'good':
'Basic %s' % base64.b64encode('%s:%s' % (self.user.email.\
replace('@', '%40'),
self.password))}
self.post_dict = {'to': '*****@*****.**',
'from': '*****@*****.**',
'text': 'This address does not contain a valid guid',
'html': '',
'subject': 'Bad Email',
'attachments': 0}
self.r = Replacer()
self.r.replace('pysolr.Solr.search', mock_search)
def tearDown(self):
self.r.restore()
def submit_email(self, use_data=True):
"""
Helper method for submitting parsed emails. Ensures that the request
returns a status of 200.
Inputs:
:use_data: Should we include post data; Default: True
Outputs:
:response: HttpResponse from email redirect view
"""
auth = self.auth.get('good')
kwargs = {'HTTP_AUTHORIZATION': auth}
if use_data:
kwargs['data'] = self.post_dict
response = self.client.post(reverse('email_redirect'),
**kwargs)
self.assertEqual(response.status_code, 200)
return response
def assert_guid_email_responses_are_correct(self,
redirect,
job=None):
"""
Helper method for validating parsed [email protected] emails.
Inputs:
:redirect: Redirect instance to use if a job is old
:job: Solr result for a new job
"""
email = mail.outbox.pop(0)
self.assertEqual(email.from_email,
settings.DEFAULT_FROM_EMAIL)
self.assertEqual(email.to, [self.post_dict['from']])
self.assertEqual(email.subject, self.post_dict['subject'])
# Emails turn lots of characters into HTML entities. Results from
# Solr and the database do not. Unescape the email body so we can
# compare the two.
parser = HTMLParser.HTMLParser()
body = parser.unescape(email.body)
if job is not None:
self.assertTrue(markdown.markdown(job['description']) in body)
else:
self.assertTrue(redirect.job_title in body)
def test_jira_login(self):
jira = JIRA(options=settings.JIRA_OPTIONS,
basic_auth=settings.JIRA_AUTH)
self.assertIsNotNone(jira)
def test_bad_authorization(self):
for auth in self.auth.get('bad'):
kwargs = {}
if auth:
# auth_value has a value, so we can pass an HTTP_AUTHORIZATION
# header
kwargs['HTTP_AUTHORIZATION'] = auth
response = self.client.post(reverse('email_redirect'),
**kwargs)
self.assertTrue(response.status_code, 403)
def test_good_authorization(self):
self.submit_email(use_data=False)
def test_bad_email(self):
self.submit_email()
self.assertEqual(len(mail.outbox), 0)
def test_bad_guid_email(self):
self.post_dict['to'] = '*****@*****.**' % ('1'*32)
self.post_dict['text'] = 'This address is not in the database'
self.submit_email()
email = mail.outbox.pop()
self.assertEqual(email.subject, 'Email forward failure')
self.assertTrue('There is no job associated with this address'
in email.body)
def test_good_guid_email_new_job(self):
self.post_dict['to'] = ['*****@*****.**' % self.redirect_guid]
self.post_dict['text'] = 'Questions about stuff and things'
self.post_dict['subject'] = 'Email forward success'
self.submit_email()
self.assert_guid_email_responses_are_correct(self.redirect, JOB)
def test_good_guid_email_new_job_no_user(self):
self.contact.delete()
self.post_dict['to'] = ['*****@*****.**' % self.redirect_guid]
self.post_dict['text'] = 'Questions about stuff and things'
self.post_dict['subject'] = 'Email forward success'
self.submit_email()
self.assert_guid_email_responses_are_correct(self.redirect, JOB)
def test_good_guid_email_old_job(self):
guid = '1'*32
redirect = RedirectFactory(guid='{%s}' % uuid.UUID(guid),
buid=self.redirect.buid,
uid=1)
self.post_dict['to'] = ['*****@*****.**' % guid]
self.post_dict['text'] = 'Questions about stuff and things'
self.post_dict['subject'] = 'Email forward success'
self.submit_email()
self.assert_guid_email_responses_are_correct(redirect)
def test_good_guid_email_old_job_no_user(self):
self.contact.delete()
guid = '1'*32
redirect = RedirectFactory(guid='{%s}' % uuid.UUID(guid),
buid=self.redirect.buid,
uid=1)
self.post_dict['to'] = ['*****@*****.**' % guid]
self.post_dict['text'] = 'Questions about stuff and things'
self.post_dict['subject'] = 'Email forward success'
self.submit_email()
self.assert_guid_email_responses_are_correct(redirect)
def test_email_with_name(self):
self.post_dict['to'] = 'User <*****@*****.**>' % self.redirect_guid
self.post_dict['text'] = 'Questions about stuff and things'
self.post_dict['subject'] = 'Email forward success'
self.submit_email()
email = mail.outbox.pop()
def test_no_emails(self):
self.post_dict.pop('to')
self.submit_email()
self.assertEqual(len(mail.outbox), 0)
def test_too_many_emails(self):
self.post_dict['to'] = '[email protected], [email protected]'
self.submit_email()
self.assertEqual(len(mail.outbox), 0)
def test_prm_email(self):
"""
If [email protected] is included as a recipient, we repost this email to
My.jobs. This is a straight post, which we don't want to do in a
testing environment. If we receive a 200 status code and no emails
were sent, this was reasonably likely to have completed successfully.
"""
prm_list = ['*****@*****.**', '*****@*****.**']
for email in prm_list:
# SendGrid adds [email protected] to the 'envelope' JSON string
# if it appears as a BCC
self.post_dict['envelope'] = '{"to":["%s"]}' % email
response = self.submit_email()
self.assertEqual(response.content, 'reposted')
self.assertEqual(len(mail.outbox), 0)
del self.post_dict['envelope']
for email in prm_list:
self.post_dict['to'] = email
response = self.submit_email()
self.assertEqual(response.content, 'reposted')
self.assertEqual(len(mail.outbox), 0)
class CppInsightsTestCase(unittest.TestCase):
def mock_mkstemp(self, suffix=None, prefix=None, dir=None, text=False):
self.fd = open('/tmp/pyt.cpp', "w+")
return [self.fd.fileno(), '/tmp/pyt.cpp']
#------------------------------------------------------------------------------
def setUp(self):
self.app = app.test_client()
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace('subprocess.Popen', self.Popen)
self.r.replace('tempfile.mkstemp', self.mock_mkstemp)
self.addCleanup(self.r.restore)
#------------------------------------------------------------------------------
# def tearDown(self):
#------------------------------------------------------------------------------
def test_access_root(self):
rv = self.app.get('/')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_invalid_site(self):
rv = self.app.get('/aa')
assert b'Page Not Found' in rv.data
#------------------------------------------------------------------------------
def test_invalid_site_with_post(self):
rv = self.app.post('/test_function',
data=json.dumps(dict(foo='bar')),
content_type='application/json')
assert 405 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -std=c++98',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(dict(cppStd='cpp98', code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid_with_result_1(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -std=c++98',
stdout=b'o',
stderr=b'',
returncode=1)
rv = self.app.post('/api/v1/transform',
data=json.dumps(dict(cppStd='cpp98', code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 1)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 1')
self.assertTrue(data['stdout'] == 'Compilation failed!')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_valid_with_warnings(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -std=c++98',
stdout=b'o',
stderr=b'Warning: unused var',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(dict(cppStd='cpp98', code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(data['stderr'] == 'Warning: unused var')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_request_api_v1_tranform_invalid_std(self):
self.Popen.set_command(
'sudo -u pfes docker run --net=none -v /tmp/pyt.cpp:/home/insights/insights.cpp --rm -i insights-test -std=c++17',
stdout=b'o',
stderr=b'',
returncode=0)
rv = self.app.post('/api/v1/transform',
data=json.dumps(dict(cppStd='cpp12', code='hello')),
content_type='application/json')
data = json.loads(rv.data.decode('utf-8'))
self.assertTrue(data['returncode'] == 0)
self.assertTrue(
data['stderr'] == 'Insights exited with result code: 0')
self.assertTrue(data['stdout'] == 'o')
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_valid(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=1.0',
follow_redirects=True)
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_missing_std(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp12&rev=1.0',
follow_redirects=True)
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_invalid_std(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&rev=1.0',
follow_redirects=True)
assert 200 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_missing_rev(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQ+JiB4IDogYXJyKSB7IH0KfQ==&std=cpp11',
follow_redirects=True)
assert 404 == rv.status_code
#------------------------------------------------------------------------------
def test_link_rev_1_invalid_base64(self):
rv = self.app.post(
'/lnk?code=I2luY2x1ZGUgPGNzdGRpbz4KdGVtcGxhdGU8dHlwZW5hbWUgVT4KY2xhc3MgWAp7CnB1YmxpYzoKICAgIFgoKSAgICAgICAgICAgPSBkZWZhdWx0OwogICAgWChjb25zdCBYJiB4KSA9IGRlZmF1bHQ7CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIFgoVCYmIHgpCiAgICA6IG1Ye30KICAgIHsgfQoKcHJpdmF0ZToKICAgIFUgbVg7Cn07CgppbnQgbWFpbigpCnsKICAgIFg8aW50PiBhcnJbMl17fTsKCiAgICBmb3IoY29uc3QgWDxjb25zdCBpbnQAAAAAAAAAAJiB4IDogYXJyKSB7IH0KfQ==&std=cpp11&rev=1.0',
follow_redirects=True)
assert 200 == rv.status_code
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
self.Popen.set_command('svn ls -R foo', stdout='o', stderr='e')
compare(my_func(), 'o')
compare([
call.Popen('svn ls -R foo', shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_example_bad_returncode(self):
Popen.set_command('svn ls -R foo',
stdout='o',
stderr='e',
returncode=1)
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
Popen = MockPopen()
Popen.set_command('a command')
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.communicate('foo')
], Popen.mock.method_calls)
def test_read_from_stdout_and_stderr(self):
Popen = MockPopen()
Popen.set_command('a command', stdout='foo', stderr='bar')
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), 'foo')
compare(process.stderr.read(), 'bar')
compare(
[call.Popen('a command', shell=True, stderr=PIPE, stdout=PIPE)],
Popen.mock.method_calls)
def test_wait_and_return_code(self):
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
process = Popen('a command')
compare(process.returncode, None)
compare(process.wait(), 3)
compare(process.returncode, 3)
compare([call.Popen('a command'),
call.Popen_instance.wait()], Popen.mock.method_calls)
def test_send_signal(self):
Popen = MockPopen()
Popen.set_command('a command')
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.send_signal(0)
], Popen.mock.method_calls)
def test_poll_until_result(self):
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
process = Popen('a command')
while process.poll() is None:
pass
compare(process.returncode, 3)
compare([
call.Popen('a command'),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll()
], Popen.mock.method_calls)
class SavedSearchHelperTests(TestCase):
def setUp(self):
super(SavedSearchHelperTests, self).setUp()
self.user = UserFactory()
self.valid_url = 'http://www.my.jobs/search?location=chicago&q=nurse'
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def tearDown(self):
self.r.restore()
def test_valid_dotjobs_url(self):
url, soup = validate_dotjobs_url(self.valid_url)
self.assertIsNotNone(url)
self.assertIsNotNone(soup)
no_netloc = 'www.my.jobs/search?location=chicago&q=nurse'
title, url = validate_dotjobs_url(no_netloc)
self.assertIsNotNone(title)
self.assertIsNotNone(url)
self.assertEquals(title, 'Jobs - nurse Jobs in Chicago')
valid_filter_url = 'www.my.jobs/chicago/illinois/usa/jobs/mcdonalds/careers/'
title, url = validate_dotjobs_url(valid_filter_url)
self.assertIsNotNone(title)
self.assertIsNotNone(url)
def test_invalid_dotjobs_url(self):
urls = [
'http://google.com', # url does not contain a feed
'', # url not provided
'http://'
] # invalid url provided
for url in urls:
title, url = validate_dotjobs_url(url)
self.assertIsNone(title)
self.assertIsNone(url)
def test_date_in_range(self):
start = datetime.date(month=1, day=1, year=2013)
end = datetime.date(month=12, day=1, year=2013)
x = datetime.date(month=6, day=1, year=2013)
is_in_range = date_in_range(start, end, x)
self.assertTrue(is_in_range)
start = datetime.date(month=1, day=1, year=2013)
end = datetime.date(month=12, day=1, year=2013)
x = datetime.date(month=6, day=1, year=2010)
is_in_range = date_in_range(start, end, x)
self.assertFalse(is_in_range)
def test_parse_rss(self):
feed_url = 'http://www.my.jobs/feed/rss'
items = parse_rss(feed_url)
self.assertEqual(len(items), 1)
item = items[0]
for element in ['pubdate', 'title', 'description', 'link']:
self.assertTrue(item[element])
def test_url_sort_options(self):
feed = 'http://www.my.jobs/jobs/feed/rss?date_sort=False'
# Test to make sure sort by "Relevance" has '&date_sort=False' added
# a single time
feed_url = url_sort_options(feed, "Relevance")
parsed = urlparse(feed_url)
query = parse_qs(parsed.query)
self.assertEquals(parsed.path, "/jobs/feed/rss")
self.assertEquals(query['date_sort'], [u'False'])
int(query['days_ago'][0])
# Test to make sure sort by "Date" doesn't have anything added
feed_url = url_sort_options(feed, "Date")
self.assertEquals(feed_url, "http://www.my.jobs/jobs/feed/rss")
def test_unicode_in_search(self):
search = SavedSearch(
url=u"http://www.my.jobs/search?q=%E2%80%93",
user=self.user,
feed=u"http://www.my.jobs/search/feed/rss?q=%E2%80%93",
sort_by=u'Relevance')
search.save()
feed_url = url_sort_options(search.feed, search.sort_by)
old = parse_qs(urlparse(search.feed).query)
new = parse_qs(urlparse(feed_url).query)
self.assertFalse(old.get('date_sort'))
self.assertFalse(old.get('days_ago'))
self.assertTrue(new['date_sort'][0])
self.assertTrue(new['days_ago'][0])
del new['date_sort']
del new['days_ago']
self.assertEqual(new, old)
