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 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 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')