def __init__(self, name, returns=None, returns_iter=None,
returns_func=None, raises=None, show_attrs=False,
tracker=DefaultTracker, items=None, **kw):
Mock.__init__(self, name, returns, returns_iter, returns_func, raises,
show_attrs, tracker, **kw)
object.__setattr__(self, 'mock_items', items or {})
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 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 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):
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 setResponse(self, status, headers, body):
mock_response = Mock('httplib.httpresponse')
mock_response.status = int(status.split()[0])
mock_response.reason = status.split(None, 1)[1]
mock_response.read.mock_returns = body
mock_response.getheader.mock_returns_func = headers.get
mock_response.msg.headers = [
'%s: %s' % (name, value) for name, value in headers.items()]
self.conn.getresponse.mock_returns = mock_response
def mock_vim(vim=None, vim_vars=None, vim_buffer=None, **kw):
""" Factory for MockVim. """
if vim is None:
vim = Mock('vim', **kw)
if vim_buffer is None:
vim_buffer = Mock_Buffer()
vim.current.buffer = vim_buffer
vim.vim_imitation = MockVim(vim, vim_vars)
return vim
def mock_vim(vim=None, vim_vars=None, vim_buffer=None, **kw):
""" Factory for MockVim. """
if vim is None:
vim = Mock('vim', **kw)
if vim_buffer is None:
vim_buffer = Mock_Buffer()
vim.current.buffer = vim_buffer
vim.vim_imitation = MockVim(vim, vim_vars)
return vim
def set_response(self, status, headers, body):
mock_response = Mock('httpresponse', tracker=self.trace_tracker)
mock_response.status = int(status.split()[0])
mock_response.reason = status.split(None, 1)[1]
mock_response.read.mock_returns = body
mock_response.getheader.mock_returns_func = headers.get
mock_response.msg.headers = [
'%s: %s' % (name, value) for name, value in headers.items()
]
self.conn.getresponse.mock_returns = mock_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')
record1 = Mock('record1', tracker=self.tt, id='record1', features=[])
record2 = Mock('record2', tracker=self.tt, id='record2', features=[])
self.records = [record1, record2]
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 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.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_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):
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 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 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 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 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):
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):
"""
Adds required temporary setting for the test.
"""
# Setup the mock
response = StringIO('issue:\n number: 123')
urllib = Mock('urllib', tracker=None)
urllib.urlopen = Mock('urllib.urlopen', returns=response, tracker=None)
settings.ERROR_CAPTURE_GITHUB_REPO = 'fake_repo'
settings.ERROR_CAPTURE_GITHUB_TOKEN = 'fake_token'
settings.ERROR_CAPTURE_GITHUB_LOGIN = '******'
super(GitHubHandlerTestCase, self).setUp()
self.instance.urllib = urllib
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_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 __init__(self,
name,
returns=None,
returns_iter=None,
returns_func=None,
raises=None,
show_attrs=False,
tracker=DefaultTracker,
items=None,
**kw):
Mock.__init__(self, name, returns, returns_iter, returns_func, raises,
show_attrs, tracker, **kw)
object.__setattr__(self, 'mock_items', items or {})
def testArchivingAfterDays(self):
self.assertEqual(len(self.feedManager.feeds), 0)
feed = Feed()
for i in range(0, 10):
entry = Mock("Entry")
entry.id = i
entry.updated = (datetime.today() - timedelta(days=i)).timetuple()
feed.entries.append(entry)
self.assertEquals(len(feed.entries), 10)
self.feedManager.feeds.append(feed)
tobedeleted = self.feedManager.checkForArchiveableEntries(True, 6, False, 0)
self.assertEqual(len(tobedeleted), 1)
self.assertEqual(len(tobedeleted[0]['entries']), 3)
for i in range(0, 3):
self.assertEqual(tobedeleted[0]['entries'][i].id, i + 7)
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_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')
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_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.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 test_get_builds(self):
mock('osc.core.http_GET', tracker=self.tt,
returns=StringIO('''<?xml version="1.0" encoding="UTF-8"?>
<project name="superkde" created="2005-01-01T00:00:02+01:00" updated="2007-01-19T10:44:45+01:00">
<title>SuperKDE</title>
<description>SuperKDE is a heavily tuned version of KDE.</description>
<link project="openSUSE:11.2:Update" />
<link project="openSUSE:11.2" />
<person role="maintainer" userid="ernie"/>
<group role="reviewer" groupid="release_team"/>
<build>
<disable />
</build>
<useforbuild>
<disable />
</useforbuild>
<repository name="kde4:factory" rebuild="transitive">
<path project="kde4" repository="factory"/>
<arch>i386</arch>
<arch>x86_64</arch>
</repository>
<repository name="suselinux-9.3">
<path project="suselinux-9.3" repository="standard"/>
<arch>i386</arch>
</repository>
<repository name="gnomespecial" rebuild="local">
<path project="gnome3" repository="suselinux-9.3"/>
<path project="suselinux-9.3" repository="standard"/>
<arch>i386</arch>
</repository>
</project>'''))
# source/superkde/_meta
# gets called by osc.core.get_repos_of_project
mock('obswatch.get_interested',
returns={'Geeko': '*****@*****.**'})
superkde = Mock('package')
superkde.name = 'superkde'
superkde.project = 'superkde'
superkde.created = '2007-01-19T10:44:45+01:00'
result = obswatch.get_builds(superkde)
assert_same_trace(self.tt, """Called osc.core.http_GET(
'%ssource/superkde/_meta')""" % obswatch.APIURL)
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 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 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.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 test_transport_called_on_get(self):
"""test transport is really called"""
configuration = Configuration(self.root_path + "/domaintools/conf/api.ini")
request = Request(configuration)
request.withType('json').domain('domaintools.com')
transport = Mock('RestService')
transport.get_status.mock_returns = 200
transport.get.mock_returns = open(self.root_path + '/tests/fixtures/domain-profile/domaintools.com/good.json').read()
request.set_transport(transport)
try:
request.execute()
except Exception as e:
pass
self.assertTrue(transport.get_status()==200)
def setUp(self):
self.tt = TraceTracker()
mock("smtplib.SMTP", returns=Mock('smtp_conn', tracker=self.tt),
tracker=self.tt)
self.config = ConfigParser.SafeConfigParser()
self.config.add_section('email')
self.config.set('email', 'host', 'localhost')
self.config.set('email', 'sender', '*****@*****.**')
self.config.set('email', 'recipients',
'[email protected], [email protected]')
mock("orig_ta.load_config", returns=self.config, tracker=self.tt)
mock_alert = Mock('TempAlert', tracker=self.tt)
mock_alert.get_status = Mock('get_status', returns='alarm',
tracker=self.tt)
mock_alert.find_problematic_sensors = Mock('find_problematic_sensors',
returns={'foo': 23.42, 'bar': 42.23}, tracker=self.tt)
mock("orig_ta.TempAlert", returns=mock_alert)
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 setUp(self):
"""
Adds required temporary setting for the test.
"""
# Setup the mock
BzImpl = Mock('bz.Bugzilla', tracker=None)
BzImpl.createbug = Mock('BzImpl.createbug',
returns=Jelly(bug_id=123, url='http'), tracker=None)
Bugzilla = Mock('bz.Bugzilla', returns=BzImpl, tracker=None)
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_SERVICE = 'http://example.com/'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_USERNAME = '******'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_PASSWORD = '******'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_PRODUCT = 'fake_product'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_COMPONENT = 'fake_component'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_VERSION = 'fake_version'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_PLATFORM = 'fake_platform'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_SEVERITY = 'fake_severity'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_OS = 'fake_os'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_LOC = 'fake_loc'
settings.ERROR_CAPTURE_GOOGLE_BUGZILLA_PRIORITY = 'fake_priority'
super(BugzillaHandlerTestCase, self).setUp()
self.instance.Bugzilla = Bugzilla
def setUp(self):
"""
Adds required temporary setting for the test.
"""
# Setup the mock
result_impl = Mock('result_impl', tracker=None)
result_impl.find_html_link = Mock('find_html_link',
returns='http://www.example.dom/123/?id=123', tracker=None)
client_impl = Mock('gdata.projecthosting.client', tracker=None)
client_impl.add_issue = Mock(
'add_issue', returns=result_impl, tracker=None)
client_impl.client_login = Mock(
'client_login', returns=True, tracker=None)
gdata_client = Mock(
'ProjectHostingClient', returns=client_impl, tracker=None)
settings.ERROR_CAPTURE_GOOGLE_CODE_PROJECT = 'fake_project'
settings.ERROR_CAPTURE_GOOGLE_CODE_LOGIN = '******'
settings.ERROR_CAPTURE_GOOGLE_CODE_PASSWORD = '******'
settings.ERROR_CAPTURE_GOOGLE_CODE_TYPE = 'fake_type'
super(GoogleCodeHandlerTestCase, self).setUp()
self.instance.gdata.projecthosting.client.ProjectHostingClient = (
gdata_client)
def make_mock_photo(self, photo_id):
r = random.Random(photo_id)
format = r.choice(('jpg', 'gif', 'png'))
h, w, s = map(r.randint, (1, 1, 512), (5000, 5000, sys.maxint))
url = "http://test_%s_o.%s" % (photo_id, format)
# The PhotoIndex refresh gives a photo ID.
self.photos.refresh.mock_returns.append(photo_id)
# The fake photo ID points at the PhotoIndex record.
self.photos[photo_id] = {
'id': photo_id,
'originalformat': format,
'o_height': str(h),
'o_width': str(w),
'size': str(s),
'url_o': url,
}
# The record's URL points at the request.
tail = 'tail data' + photo_id
request = Mock("Request(%s)" % url)
request.code = urllib2.httplib.PARTIAL_CONTENT
request.headers = {'content-range': "%u-%u/%u" % (s - 512, s, s)}
request.read.mock_returns = tail
self.urls[url] = request
# The tail data points at the fake shorthash.
shorthash = 'short hash' + photo_id
self.tails[tail] = shorthash
return shorthash
def testAddFeed(self):
model = self.feedModel
feed = Mock("Feed")
feed.title = "Title3"
feed.author = "Author3"
feed.updated = time.gmtime(time.time())
feed.unread = 2
feed.entries = [1, 4]
self.assertEqual(model.rowCount(), 2)
model.addFeed(feed)
self.assertEqual(model.rowCount(), 3)
def setUp(self):
repo = Mock('repo')
repo.name = 'standard'
repo.arch = 'x86_64'
package = Mock('package')
package.project = 'openSUSE:11.3'
package.name = 'osc'
self.build = obswatch.Build(package=package, repo=repo,
interested={'geeko':'*****@*****.**'})
self.package = package
self.tt = TraceTracker()
obswatch.SLEEP_TIME = 0
def create_mocked_vim_vars(blog_url, username, password, blog_name):
def vim_variable_mock(self, var_name, prefix=True):
if prefix:
var_name = "_".join((self.blog_name, var_name))
val = getattr(self, var_name)
return val if not isinstance(val, Mock) else None
vim_vars = Mock("VimVars")
vim_vars.vim_variable.mock_returns_func = partial(vim_variable_mock, vim_vars)
vim_vars.blog_url = blog_url
vim_vars.blog_username = username
vim_vars.blog_password = password
vim_vars.blog_name = blog_name
vim_vars.blog_postsource = False
return vim_vars
def __setattr__(self, attr, value):
if attr == 'mock_items':
object.__setattr__(self, attr, value)
return Mock.__setattr__(self, attr, value)
def setUp(self):
self.feedMgr = FeedManager()
feed = Mock("Feed")
feed.title = "Title1"
feed.author = "Author1"
feed.url = "Url1"
feed.updated = time.gmtime(time.time())
feed.unread = 1
feed.entries = [Entry(), Entry(), Entry()]
self.feedMgr.feeds.append(feed)
feed = Mock("Feed")
feed.title = "Title2"
feed.author = "Author2"
feed.url = "Url2"
feed.updated = time.gmtime(time.time())
feed.unread = 0
feed.entries = [Entry(), Entry()]
self.feedMgr.feeds.append(feed)
self.feedModel = FeedModel(self.feedMgr)
self.modeltest = ModelTest(self.feedModel, self.feedModel)
self.entryModel = MockEntryModel()
def setUp(self):
import time
self.feed = Feed()
entry = Mock("Entry")
entry.title = "Title1"
entry.author = "Author1"
entry.read = False
entry.important = False
entry.updated = time.gmtime(time.time())
self.feed.entries.append(entry)
entry = Mock("Entry")
entry.title = "Title2"
entry.author = "Author2"
entry.read = True
entry.important = True
entry.updated = time.gmtime(time.time())
self.feed.entries.append(entry)
self.entryModel = EntryModel(self.feed)
self.modeltest = ModelTest(self.entryModel, self.entryModel)
def setUp(self):
conn = Mock('httplib.HTTPConnection')
mock('httplib.HTTPConnection', mock_obj=conn)
conn.mock_returns = conn
self.conn = conn
self.piwik = PiwikAPI('http://exemple.org/', '123')
