def test10(self):
import Image
image1 = Image.new("RGB", (400, 300), (255, 255, 255))
filename = "image_file.jpg"
image1.save(filename)
global response_str
fb = facebook.Facebook(my_api_key, my_secret_key)
fb.login = self.login
facebook.httplib.HTTP = Mock('httplib.HTTP')
http_connection = Mock('http_connection')
facebook.httplib.HTTP.mock_returns = http_connection
http_connection.send.mock_returns_func = self.send
def _http_passes():
return [200,]
http_connection.getreply.mock_returns_func = _http_passes
def read():
response = {"stuff":"stuff"}
response_str = simplejson.dumps(response)
return response_str
http_connection.file.read.mock_returns_func = read
response = {"session_key":"key","uid":"my_uid","secret":"my_secret","expires":"my_expires"}
response_str = simplejson.dumps(response)
res = fb.auth.getSession()
result = fb.photos.upload(image=filename,aid="aid",caption="a caption")
self.assertEquals(str(result["stuff"]),"stuff")
os.remove(filename)
def setUp(self):
urlopen_result = Mock('urlobject')
urlopen_result.read = Mock('urlobj.read',
returns='''
{"result":{"updated_at":"2010-10-02T02:06:00Z", "value":81,"target":"jpy",
"base":"eur"}, "code":0, "status":"ok"}
''')
xurrency.urllib2.urlopen = Mock('urlopen', returns=urlopen_result)
def __init__(self, config=None):
if config is None:
config = {}
bugzilla.BugzillaApi.__init__(self,
config=config,
jsonreq=Mock('jsonreq'),
getpass=Mock('getpass'))
self.request = Mock('bzapi.request')
def test_get_rate_InvalidCurrenciesError(self):
urlopen_result = Mock('urlobject')
urlopen_result.read = Mock('urlobj.read',
returns='''
{"code": 2, "message": "Currencies are not valid", "status": "fail"}
''')
xurrency.urllib2.urlopen = Mock('urlopen', returns=urlopen_result)
pyx = xurrency.Xurrency()
assert_equals(pyx.get_rate('eur', 'jpy', 37.2), 81 * 37.2)
def test_get_rate_XurrencyError(self):
urlopen_result = Mock('urlobject')
urlopen_result.read = Mock('urlobj.read',
returns='''
{"code": 1, "status": "fail",
"message": "Amount should be between 0 and 999999999"}
''')
xurrency.urllib2.urlopen = Mock('urlopen', returns=urlopen_result)
pyx = xurrency.Xurrency()
assert_equals(pyx.get_rate('eur', 'jpy', 37.2), 81 * 37.2)
def setUp(self):
self.tt = TraceTracker()
mock('helperlibs.bio.seqio.write', tracker=self.tt)
self.options = Mock('options',
tracker=self.tt,
outputfoldername='test',
input_type='nucl')
record1 = Mock('record1', tracker=self.tt, id='record1', features=[])
record2 = Mock('record2', tracker=self.tt, id='record2', features=[])
self.records = [record1, record2]
def test_encode_success(self):
"""encode test with succeeded"""
mock('encoder.subprocess.Popen', returns=Mock(
'proc',
communicate=Mock(
'proc.communicate',
returns=(b'', b'')),
returncode=0))
encoder.encode('aaa.m2ts', 'bbb.mp4', reso='1280x720', vb_mbps=2, ab_kbps=256, is_deint=False)
def setUp(self):
self.created_article = None
content_extractor = Mock('ContentExtractor')
article_repository = Mock('ArticleRepository')
self.article_id = ArticleID(uuid.uuid4())
article_repository.next_identity.mock_returns = self.article_id
article_repository.save = lambda a: setattr(self,
'created_article', a)
self.service = MemoriseArticleService(content_extractor,
article_repository)
def setUp(self):
self.config = Namespace()
self.config.cpus = 2
config.set_config(self.config)
self.tt = TraceTracker()
proc = Mock('proc', tracker=self.tt, returncode=0)
proc.communicate = Mock('proc.communicate',
returns=('output', 'error'),
tracker=self.tt)
mock('subprocess.Popen', tracker=self.tt, returns=proc)
def test_get_rate_APILimitReachedError(self):
urlopen_result = Mock('urlobject')
urlopen_result.read = Mock('urlobj.read',
returns='''
{"code": 3, "status": "fail",
"message":
"Limit Reached (10 requests per day). Please adquire a license key"}
''')
xurrency.urllib2.urlopen = Mock('urlopen', returns=urlopen_result)
pyx = xurrency.Xurrency()
assert_equals(pyx.get_rate('eur', 'jpy', 37.2), 81 * 37.2)
def setUp(self):
self.config = Namespace()
self.config.cpus = 2
config.set_config(self.config)
self.tt = TraceTracker()
proc = Mock('proc', tracker=self.tt, returncode=0)
proc.communicate = Mock('proc.communicate',
returns=('output', 'error'),
tracker=self.tt)
mock('subprocess.Popen', tracker=self.tt, returns=proc)
self.tmpdir = tempfile.mkdtemp(prefix="as_tests_util")
def test_email_report(self):
self.fill_db()
smtplib.SMTP = Mock('smtplib.SMTP')
conn = Mock('smtp_connection')
conn.send_message = Mock('send_message', returns_func=self.getmsg)
smtplib.SMTP.mock_returns = conn
self.controller.email_report()
msg = self.msg
self.assertIsInstance(msg, MIMEMultipart)
assert isinstance(msg, MIMEMultipart)
self.assertEqual(msg["Subject"], 'test subject 0')
def setUp(self):
self.stripe_controller = StripeController(StubbedStripeUser())
spudderstripe.api_utils.create_customer = Mock('Mocked_api_utils_create_customer')
spudderstripe.api_utils.create_customer.mock_returns = (None, None)
spudderstripe.api_utils.create_token = Mock('Mocked_api_utils_create_token')
spudderstripe.api_utils.create_token.mock_returns = (None, None)
spudderstripe.api_utils.make_charge = Mock('Mocked_api_utils_make_charge')
spudderstripe.api_utils.make_charge.mock_returns = ({'id': 999}, None)
def setup(self):
enrai.vim = None
mock("enrai.vim")
_eval_func = lambda var: self.eval_var[var]
enrai.vim.eval = Mock("eval", returns_func=_eval_func)
enrai.vim.current = Mock("current",
window=Mock("window"),
line=Mock(
"line",
split=Mock("split", returns=self.test_text.split(" ")),
),
)
def setUp(self):
""" Set up test fixtures """
self.mock_outfile = StringIO()
self.app_class_name = self.application_class.__name__
self.mock_app = Mock("test_app", outfile=self.mock_outfile)
self.mock_app_class = Mock(self.app_class_name,
outfile=self.mock_outfile)
self.mock_app_class.mock_returns = self.mock_app
mock(self.app_class_name,
mock_obj=self.mock_app_class,
nsdicts=[self.program_module.__dict__])
super(Test_ProgramMain, self).setUp()
def setUp(self):
""" Set up test fixtures. """
self.mock_tracker = MockTracker()
self.app_class_name = self.application_class.__name__
self.mock_app = Mock("test_app", tracker=self.mock_tracker)
self.mock_app_class = Mock(self.app_class_name,
tracker=self.mock_tracker)
self.mock_app_class.mock_returns = self.mock_app
mock(self.app_class_name,
mock_obj=self.mock_app_class,
nsdicts=[self.program_module.__dict__])
super(ProgramMain_TestCase, self).setUp()
def test_send_email_fucntion(self):
"""
test send email
:return:
"""
smtplib.SMTP = Mock('smtplib.SMTP')
smtplib.SMTP.mock_returns = Mock('smtp_connection')
send_local_mail(mail_to=["*****@*****.**"],
mail_from="*****@*****.**",
subject="subject_test",
text="body_text_test",
files=[],
username=None,
password=None,
server="localhost")
def test_get_rate_WithValue_InvalidCurrenciesError(self):
"""
Even if XurrencyAPIInvalidCurrenciesError is returned after execute,
the value has already been used if it has cached it.
"""
pyx = xurrency.Xurrency()
assert_equals(pyx.get_rate('eur', 'jpy', 37.2), 81 * 37.2)
urlopen_result = Mock('urlobject')
urlopen_result.read = Mock('urlobj.read',
returns='''
{"code": 4, "status": "fail",
"message": "The api key is not valid"}
''')
assert_equals(pyx.get_rate('eur', 'jpy', 37.2), 81 * 37.2)
def test_find_nr_cds(self):
"Test clusterfinder.find_nr_cds"
seq_record = Mock('seq_record', tracker=self.tt)
seq_record.features = []
seq_record.seq = Seq("X" * 2000, IUPAC.protein)
left = (0, 5)
newpos, num = clusterfinder.find_nr_cds(left, seq_record)
self.assertEqual(left, newpos)
self.assertEqual(0, num)
right = (150, 160)
newpos, num = clusterfinder.find_nr_cds(right, seq_record)
self.assertEqual(right, newpos)
self.assertEqual(0, num)
middle = (35, 115)
newpos, num = clusterfinder.find_nr_cds(middle, seq_record)
self.assertEqual([30, 120], newpos)
self.assertEqual(7, num)
small = (501, 504)
newpos, num = clusterfinder.find_nr_cds(small, seq_record)
self.assertEqual([500, 505], newpos)
self.assertEqual(1, num)
def setUp(self):
self.api = MediaMosaAPI('http://video.example.com')
self.tt = TraceTracker()
mock('self.api.session', tracker=self.tt)
self.response = Mock('requests.Response')
self.response.status_code = 200
self.api.session.get.mock_returns = self.response
def setUp(self):
self.tt = TraceTracker()
mock('helperlibs.bio.seqio.write', tracker=self.tt)
self.options = Mock('options',
tracker=self.tt,
outputfoldername='test',
input_type='nucl')
rec1_features = [
generate_cluster_feature(23, 42, 'lantipeptide', 1),
generate_cluster_feature(300, 500, 'nrps', 2)
]
rec2_features = [
generate_cluster_feature(50, 70, 'lassopeptide', 3),
generate_cluster_feature(500, 700, 't1pks', 4)
]
record1 = SeqRecord(UnknownSeq(1000),
'record1',
name='record1',
features=rec1_features)
record2 = SeqRecord(UnknownSeq(1000),
'record2',
name='record2',
features=rec2_features)
self.records = [record1, record2]
self.expected_template = """\
def test_annotate_geneclusters_overlaps(self):
"Test clusterfinder.annotate_geneclusters() with overlaps"
mock("antismash.utils.get_pfam_features",
tracker=self.tt,
returns=self.fake_features)
self.config.clusternr_offset = 1
seq_record = Mock('seq_record', tracker=self.tt)
seq_record.seq = Seq("X" * 2000, IUPAC.protein)
seq_record.features = [
_make_fake_feature(10, 40, type_='cluster'),
_make_fake_feature(1040, 1050, type_='cluster'),
_make_fake_feature(110, 400, type_='cluster'),
]
clusterfinder.annotate_geneclusters(seq_record, self.config)
self.assertEqual(3, len(seq_record.features))
self.assertEqual(10, int(seq_record.features[0].location.start))
self.assertEqual(120, int(seq_record.features[0].location.end))
self.assertAlmostEqual(
0.6429, float(seq_record.features[0].qualifiers['probability'][0]))
self.assertEqual(1030, int(seq_record.features[1].location.start))
self.assertEqual(1120, int(seq_record.features[1].location.end))
self.assertAlmostEqual(
0.6429, float(seq_record.features[1].qualifiers['probability'][0]))
self.assertEqual(30, int(seq_record.features[2].location.start))
self.assertEqual(400, int(seq_record.features[2].location.end))
self.assertAlmostEqual(
0.6429, float(seq_record.features[2].qualifiers['probability'][0]))
def setUp(self):
self.valid_url = 'http://python.org/'
self.valid_url_in_greek = '' # TODO: test Greek URLs
self.empty_url = ''
self.invalid_url_scheme_file = 'file://tmp/data/dddwikipedia.html'
self.content_extractor = Mock('ContentExtractService')
self.demo_content = 'demo'
self.content_extractor.extract_content.mock_returns = self.demo_content
def test_encode_failed_returncode_1(self):
"""encode test with failed"""
mock('encoder.subprocess.Popen', returns=Mock(
'proc',
communicate=Mock(
'proc.communicate',
returns=(b'', b'')),
returncode=1))
dummy_src_file = 'aaa.m2ts'
args = (dummy_src_file, 'bbb.mp4')
kwargs = {'reso': '1280x720', 'vb_mbps': 2, 'ab_kbps': 256, 'is_deint': False}
self.assertRaises(ConvertError, encoder.encode, *args, **kwargs)
self.assertTrue(os.path.isfile(os.path.splitext(dummy_src_file)[0] + '.log'))
os.remove(os.path.splitext(dummy_src_file)[0] + '.log')
def test_home_view(self):
request = testing.DummyRequest()
request.db = Mock('db')
request.db = {}
request.db['articles'] = []
home_view = HomePageView(request)
result = home_view.get()
self.assertFalse(result['contents'])
def setUp(self):
self.datajson = v.datajson
self.datadict = v.datadict
urllib.build_opener = Mock(
'build_opener',
returns=Mock('opener',
open=Mock('opener.open',
returns=Mock('opener.open',
read=Mock(
'opener.open.read',
returns=self.datajson)))))
self.uri = v.uri
self.token = v.token
self.data = ''
def setUp(self):
self.tracker = TraceTracker()
self.locate_exe = Mock('antismash.common.path.locate_executable',
tracker=self.tracker,
returns="/fake/path/to/binary")
mock('antismash.common.path.locate_executable',
mock_obj=self.locate_exe,
tracker=self.tracker)
def __getitem__(self, key):
if key not in self.mock_items:
new_name = "%s[%s]" % (self.mock_name, key) \
if self.mock_name else key
self.mock_items[key] = Mock(new_name,
show_attrs=self.mock_show_attrs,
tracker=self.mock_tracker)
return self.mock_items[key]
def setUp(self):
self.maxDiff = None
self.tt = TraceTracker()
self.locate_exe = Mock('antismash.utils.locate_executable',
tracker=self.tt,
returns="/fake/path/to/binary")
mock('antismash.utils.locate_executable',
mock_obj=self.locate_exe,
tracker=self.tt)
def setUp(self):
"""Mock out httplib.HTTPConnection and
httplib.HTTPSConnection"""
self.trace_tracker = TraceTracker()
self.conn = Mock('httplib.HTTPConnection', tracker=self.trace_tracker)
mock('httplib.HTTPConnection', mock_obj=self.conn)
mock('httplib.HTTPSConnection', mock_obj=self.conn)
self.conn.mock_returns = self.conn
