def test_story_runner_returns_a_result_with_the_original_Fixture(): mocker = Mocker() settings = Settings() fixture = Fixture() action = some_action() fixture.append_story(action.scenario.story) runner = StoryRunner() context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_successful mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') context.language.get('when') mocker.result('When') context.language.get('then') mocker.result('Then') with mocker: result = runner.run_stories(settings, fixture, context=context) assert result.fixture == fixture
def test_should_execute_scenarios_successfully(): mocker = Mocker() settings = Settings() runner = StoryRunner() fixture = Fixture() fixture.append_story(some_action().scenario.story) context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_successful mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') context.language.get('when') mocker.result('When') context.language.get('then') mocker.result('Then') with mocker: result = runner.run_stories(settings=settings, fixture=fixture, context=context) assert fixture.get_status() == Status.Successful
def test_offset(self): """ Test that, if the server's BEGIN_CONTENT message specifies an offset, the file to be uploaded is seek'ed to the right position. """ offset = 23 mocker = Mocker() transport = mocker.mock() transport.registerProducer(ANY, streaming=True) transport.write(ANY) mocker.count(1, None) # I don't really care how many times fd = mocker.mock() fd.seek(offset) # this is really all I care about fd.read(ANY) mocker.result('') mocker.replay() protocol = StorageClient() protocol.transport = transport pc = PutContent(protocol, 'share', 'node', '', '', 0, 0, 0, fd) message = protocol_pb2.Message() message.type = protocol_pb2.Message.BEGIN_CONTENT message.begin_content.offset = offset pc.start() pc.processMessage(message)
def test_server_start_stop_metrics(self): """Test start/stop metrics.""" mocker = Mocker() service_meter = mocker.mock(name='meter') self.service.metrics = service_meter revno = mocker.mock(name='revno') self.patch(metrics.services, 'revno', revno) service_meter.meter('server_stop') service_meter.decrement('services_active') service_meter.meter('server_start') service_meter.increment('services_active') service_meter.timing("busy.ping", ANY) mocker.count(0, None) revno() mocker.count(0, None) service_meter.connection mocker.result(None) with mocker: yield self.service.stopService() yield self.service.startService()
def test_action_registry_can_resolve_same_name_classes(): mocker = Mocker() class MyActionSameName(ActionBase): regex = r'I do (\w+) very well' def execute(self, context, *args, **kw): pass Temp1 = MyActionSameName class MyActionSameName(ActionBase): regex = r'I do (\w+) very bad' def execute(self, context, *args, **kw): pass Temp2 = MyActionSameName language_getter_mock = mocker.mock() language_getter_mock.get(ANY) mocker.count(min=1, max=None) mocker.result('^$') with mocker: Action1, args1, kwargs1 = ActionRegistry.suitable_for( 'I do test very well', 'en-us', getter=language_getter_mock) Action2, args2, kwargs2 = ActionRegistry.suitable_for( 'I do test very bad', 'en-us', getter=language_getter_mock) assert Action1 is not MyActionSameName assert Action1 is not Temp2 assert Action1 is Temp1 assert Action2 is Temp2 assert Action2 is MyActionSameName
def test_wait_for_disappear(self): mocker = Mocker() context = Context(Settings()) browser_mock = mocker.mock() browser_mock.find_by_xpath('some element') mocker.count(min=1, max=None) element_mock = mocker.mock() mocker.result(element_mock) element_mock.visible mocker.result(True) mocker.count(min=1, max=None) mocker.result(True) element_mock.visible mocker.result(False) mocker.count(min=2, max=None) mocker.result(True) with mocker: driver = SplinterDriver(context, browser=browser_mock) driver.wait_for_element_to_disappear("some element", 1)
def test_see_summary_for_fixture_returns_proper_string_for_no_tests(): mocker = Mocker() expected = """================ Test Run Summary ================ Status: UNKNOWN Test Data Stats --------------- Successful Stories......0/0 (0.00%) Failed Stories..........0/0 (0.00%) Successful Scenarios....0/0 (0.00%) Failed Scenarios........0/0 (0.00%)""" template_loader_mock = mocker.mock() template_loader_mock.load("summary") mocker.result(summary_template) with mocker: settings = Settings() fixture = Fixture() result = Result(fixture=fixture, template_loader=template_loader_mock) summary = result.summary_for(settings.default_culture) assert summary == expected
def test_read_tags(self): mocker = Mocker() csv_reader = mocker.mock() headers = [ 'title', 'isbn', 'publisher', 'list_price', 'publish_date', 'class_', 'sheet_numbers', 'folio', 'print_type', 'author', 'barcode', 'comments', 'audience', 'awards'] first_line = [ 'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a', 'blahblahblah', 'ms', 'annual'] field_map = {'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3, 'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7, 'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 } csv_reader.next() # read headers mocker.result(headers) csv_reader.next() # read first line mocker.result(first_line) mocker.replay() reader = CatalogReader(csv_reader, field_map) item = reader.read() self.assertIsInstance(item, CatalogItem) self.assertEquals(2, len(item.tags)) self.assertEquals('ms', item.tags['audience']) self.assertEquals('annual', item.tags['awards']) mocker.restore() mocker.verify()
def test_parsing_files_with_proper_header_returns_parsed_scenario(): mocker = Mocker() settings = Settings() files = ["some path"] story_text = """As a someone I want to do something So that I'm happy""" filemock = mocker.mock() filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern) mocker.result(files) filemock.read_file(files[0]) mocker.result(story_text) language_mock = mocker.mock() language_mock.get("as_a") mocker.result("As a") language_mock.get("i_want_to") mocker.result("I want to") language_mock.get("so_that") mocker.result("So that") with mocker: parser = FileParser(language=language_mock, file_object=filemock) fixture = parser.get_stories(settings=settings) assert len(fixture.stories) == 1 assert fixture.stories[0].as_a == "someone" assert fixture.stories[0].i_want_to == "do something" assert fixture.stories[0].so_that == "I'm happy"
def auth_headers_for_method_call_on(self, url, auth_backend): parsed = urlparse.urlparse(url) mocker = Mocker() transport = mocker.mock() auth_data = [] def intercept_request(host, handler, request_body, verbose=0): actual_transport = XMLRPCTransport(parsed.scheme, auth_backend) request = actual_transport.build_http_request( host, handler, request_body) if (request.has_header('Authorization')): auth_data.append(request.get_header('Authorization')) response_body = xmlrpclib.dumps((1, ), methodresponse=True) response = StringIO.StringIO(response_body) response.status = 200 response.__len__ = lambda: len(response_body) transport.request(ARGS, KWARGS) mocker.call(intercept_request) mocker.result(response) with mocker: server_proxy = AuthenticatingServerProxy(url, auth_backend=auth_backend, transport=transport) server_proxy.method() return auth_data
def setUpZope(self, app, configurationContext): # Mock postmonkey mocker = Mocker() postmonkey = mocker.replace("postmonkey") mailchimp = postmonkey.PostMonkey(ANY) mocker.count(0, 1000) # Lists mailchimp.lists() mocker.count(0, 1000) mocker.result({ u'total': 2, u'data': [ { u'id': 625, u'web_id': 625, u'name': u'ACME Newsletter', u'default_from_name': u'*****@*****.**', }, { u'id': 626, u'web_id': 626, u'name': u'ACME Newsletter 2', u'default_from_name': u'*****@*****.**', }, ] }) mocker.replay() # Load ZCML import example.tdd xmlconfig.file('configure.zcml', example.tdd, context=configurationContext)
def test_parse_scenario_line(): mocker = Mocker() story = Story(as_a="Someone", i_want_to="Do Something", so_that="I'm Happy", identity="some file") settings_mock = mocker.mock() settings_mock.scenarios_to_run mocker.result([]) language_mock = mocker.mock() language_mock.get("scenario") mocker.result("Scenario") with mocker: parser = FileParser(language=language_mock, file_object=None) scenario = parser.parse_scenario_line(story, "Scenario 1 - Doing something", settings_mock) assert scenario is not None assert scenario.index == "1", "Expected 1 actual %s" % scenario.index assert scenario.title == "Doing something"
def test_execute_action_will_not_execute_itself(): mocker = Mocker() class DoSomethingRecursiveAction(ActionBase): regex = r'^(And )?I do "(?P<what>\w+)" stuff$' def execute(self, context, getter_mock, *args, **kwargs): self.execute_action('And I do "recursive" stuff', context, getter=getter_mock) language_getter_mock = mocker.mock() language_getter_mock.get(ANY) mocker.count(min=1, max=None) mocker.result("^$") context_mock = Object(settings=mocker.mock()) context_mock.settings.default_culture mocker.result("en-us") with mocker: dosaction = DoSomethingRecursiveAction() args = [] kwargs = dict(what="nothing") dosaction.execute(context_mock, getter_mock=language_getter_mock, *args, **kwargs)
def test(serial): m = Mocker() proj = Project.create() log = m.replace("editxt.project.log", passthrough=False) nsdat = m.replace(NSData, passthrough=False) nspls = m.replace(NSPropertyListSerialization, passthrough=False) create_document_view_with_state = m.method(Project.create_document_view_with_state) create_document_view = m.method(Project.create_document_view) proj._documents = docs = m.mock(KVOList) if "path" in serial: data = nsdat.dataWithContentsOfFile_(serial["path"]) >> m.mock() serial_, format, error = nspls. \ propertyListFromData_mutabilityOption_format_errorDescription_( \ data, NSPropertyListImmutable, None, None) >> ({}, m.mock(), None) else: serial_ = serial docs_ = serial_.get("documents", []) for item in docs_: create_document_view_with_state(item) if item == "doc_not_found": m.throw(Exception("document not found")) log.warn("cannot open document: %r" % item) #proj._is_dirty = True bool(docs); m.result(bool(docs_)) if not docs_: create_document_view() #proj._is_dirty = True with m: proj.deserialize(serial) if "path" in serial: eq_(proj.path, serial["path"]) assert "name" not in serial else: eq_(proj.name, serial.get("name", const.UNTITLED_PROJECT_NAME)) eq_(proj.expanded, serial.get("expanded", True))
def test_read_basic_fields(self): mocker = Mocker() csv_reader = mocker.mock() csv_reader.next() header_line = [ 'title', 'isbn', 'publisher', 'list_price', 'publish_date', 'class_', 'sheet_numbers', 'folio', 'print_type', 'author', 'barcode', 'comments'] mocker.result(header_line) csv_reader.next() first_line = [ 'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a', 'blahblahblah' ] mocker.result(first_line) mocker.replay() field_map = {'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3, 'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7, 'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 } reader = CatalogReader(csv_reader, field_map) item = reader.read() self.assertIsInstance(item, CatalogItem) mocker.restore() mocker.verify()
def test_without_when(self): mocker = Mocker() mock_time = mocker.replace('time.time') mock_time() mocker.result(1.0) mock_time() mocker.result(2.0) mock_time() mocker.result(3.0) mock_time() mocker.result(4.0) mock_time() mocker.result(5.0) mocker.replay() controller = pid.PID(P = 0.5, I = 0.5, D = 0.5, setpoint = 0, initial = 12) self.assertEqual(controller.calculate_response(6), -3) self.assertEqual(controller.calculate_response(3), -4.5) self.assertEqual(controller.calculate_response(-1.5), -0.75) self.assertEqual(controller.calculate_response(-2.25), -1.125) mocker.restore() mocker.verify()
def test_execute_action_will_not_execute_itself(): mocker = Mocker() class DoSomethingRecursiveAction(ActionBase): regex = r'^(And )?I do "(?P<what>\w+)" stuff$' def execute(self, context, getter_mock, *args, **kwargs): self.execute_action('And I do "recursive" stuff', context, getter=getter_mock) language_getter_mock = mocker.mock() language_getter_mock.get(ANY) mocker.count(min=1, max=None) mocker.result('^$') context_mock = Object(settings=mocker.mock()) context_mock.settings.default_culture mocker.result("en-us") with mocker: dosaction = DoSomethingRecursiveAction() args = [] kwargs = dict(what='nothing') dosaction.execute(context_mock, getter_mock=language_getter_mock, *args, **kwargs)
def test_log_changes_with_valid_params(self): mocker = Mocker() databroker = mocker.mock() document_types = ['article', 'journal'] events = ['add', 'update', 'delete'] # db "insert" must be called len(document_types) * len(events) times for document_type in document_types: for event in events: databroker['historychanges_%s' % document_type].insert(ANY) mocker.result(123457890) mocker.replay() db = DataBroker(databroker) for document_type in document_types: for event in events: log_data = { 'document_type': document_type, 'code': '123', 'collection': 'test_collection', 'event': event, 'date': datetime.now().isoformat(), } log_id = db._log_changes(**log_data) self.assertEqual(log_id, 123457890)
def test_historylogs_without_filters(self): for document_type in ['article', 'journal']: historylogs = json.loads( open( os.path.dirname(__file__) + '/fixtures/historylogs_%s.json' % document_type).read()) mocker = Mocker() databroker = mocker.mock() databroker['historychanges_%s' % document_type].find(ANY).count() mocker.result(historylogs['meta']['total']) databroker['historychanges_%s' % document_type].find(ANY).skip( ANY).limit(ANY).sort("date") mocker.result(historylogs['objects']) mocker.replay() db = DataBroker(databroker) result = db.historychanges(document_type) # assert date filters are correct in meta self.assertIn('meta', result.keys()) self.assertIn('filter', result['meta'].keys()) self.assertIn('date', result['meta']['filter'].keys()) self.assertEqual(['$lte', '$gt'], result['meta']['filter']['date'].keys()) self.assertEqual(historylogs['meta']['total'], result['meta']['total']) self.assertIn('objects', result.keys()) self.assertEqual(historylogs['objects'], result['objects']) self.assertEqual(result['objects'][0].keys(), ['date', 'code', 'event', 'collection'])
def test_see_summary_for_fixture_returns_proper_string_for_failed_tests(): mocker = Mocker() expected = """================ Test Run Summary ================ Status: FAILED Test Data Stats --------------- Successful Stories......0/1 (0.00%) Failed Stories..........1/1 (100.00%) Successful Scenarios....0/1 (0.00%) Failed Scenarios........1/1 (100.00%)""" template_loader_mock = mocker.mock() template_loader_mock.load("summary") mocker.result(summary_template) with mocker: settings = Settings() fixture = Fixture() action = some_action() fixture.append_story(action.scenario.story) action.mark_as_failed() result = Result(fixture=fixture, template_loader=template_loader_mock) summary = result.summary_for(settings.default_culture) assert summary == expected
def setUpZope(self, app, configurationContext): # Mock postmonkey mocker = Mocker() postmonkey = mocker.replace("postmonkey") mailchimp = postmonkey.PostMonkey(ANY) mocker.count(0, 1000) # Lists mailchimp.lists() mocker.count(0, 1000) mocker.result({ u'total': 2, u'data': [{ u'id': 625, u'web_id': 625, u'name': u'ACME Newsletter', u'default_from_name': u'*****@*****.**', }, { u'id': 626, u'web_id': 626, u'name': u'ACME Newsletter 2', u'default_from_name': u'*****@*****.**', }, ]}) mocker.replay() # Load ZCML import example.tdd xmlconfig.file( 'configure.zcml', example.tdd, context=configurationContext )
def test_call_invalid_request(self): reg = getUtility(IRegistry).forInterface(ICollectiveFlattr) reg.access_token = u'' mocker = Mocker() func = mocker.replace('collective.flattr.browser.flattr.Flattr.getAccessToken') func(u'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz') mocker.result({'error': u'invalid_request', 'error_description': u'error desc'}) with as_manager(self.portal) as view: ## need the real class here, not the wrapped one, to get mocker ## working from collective.flattr.browser.flattr import Flattr with mocker: view = Flattr(self.portal, self.layer['request']) self.layer['request']['code'] = u'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz' ret = view() self.assertEquals(self.layer['request'].response\ .headers['location'], 'http://nohost/plone') ret = IStatusMessage(self.layer['request'])\ .showStatusMessages()[0] self.assertEquals(ret.message, u'invalid_request: error desc') self.assertEquals(ret.type, u'error')
def test_historylogs_without_filters(self): for document_type in ['article', 'journal']: historylogs = json.loads( open(os.path.dirname(__file__) + '/fixtures/historylogs_%s.json' % document_type).read() ) mocker = Mocker() databroker = mocker.mock() databroker['historychanges_%s' % document_type].find(ANY).count() mocker.result(historylogs['meta']['total']) databroker['historychanges_%s' % document_type].find(ANY).skip(ANY).limit(ANY).sort("date") mocker.result(historylogs['objects']) mocker.replay() db = DataBroker(databroker) result = db.historychanges(document_type) # assert date filters are correct in meta self.assertIn('meta', result.keys()) self.assertIn('filter', result['meta'].keys()) self.assertIn('date', result['meta']['filter'].keys()) self.assertEqual(['$lte', '$gt'], result['meta']['filter']['date'].keys()) self.assertEqual( historylogs['meta']['total'], result['meta']['total'] ) self.assertIn('objects', result.keys()) self.assertEqual(historylogs['objects'], result['objects']) self.assertEqual( result['objects'][0].keys(), ['date', 'code', 'event', 'collection'] )
def test_call_valid(self): reg = getUtility(IRegistry).forInterface(ICollectiveFlattr) reg.access_token = u'' mocker = Mocker() func = mocker.replace('collective.flattr.browser.flattr.Flattr.getAccessToken') func(u'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz') mocker.result({'access_token': u'NEW_ACCESS_TOKEN', 'token_type': u'bearer'}) with as_manager(self.portal) as view: ## need the real class here, not the wrapped one, to get mocker ## working from collective.flattr.browser.flattr import Flattr with mocker: self.layer['request']['code'] = u'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz' view = Flattr(self.portal, self.layer['request']) ret = view() self.assertEquals(reg.access_token, u'NEW_ACCESS_TOKEN') self.assertEquals(self.layer['request'].response\ .headers['location'], 'http://nohost/plone') ret = IStatusMessage(self.layer['request'])\ .showStatusMessages()[0] self.assertEquals(ret.message, u'collective.flattr successfully configured') self.assertEquals(ret.type, u'info')
def test_call_no_unicode_and_no_error_desc(self): reg = getUtility(IRegistry).forInterface(ICollectiveFlattr) reg.access_token = u'' mocker = Mocker() func = mocker.replace('collective.flattr.browser.flattr.Flattr.getAccessToken') func(u'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz') mocker.result({'access_token': u'NEW_ACCESS_TOKEN', 'token_type': u'bearer', 'error': u'blubber'}) with as_manager(self.portal) as view: from collective.flattr.browser.flattr import Flattr with mocker: self.layer['request']['code'] = 'un8Vzv7pNMXNuAQY3uRgjYfM4V3Feirz' view = Flattr(self.portal, self.layer['request']) ret = view() self.assertEquals(reg.access_token, u'') self.assertEquals(self.layer['request'].response\ .headers['location'], 'http://nohost/plone') ret = IStatusMessage(self.layer['request'])\ .showStatusMessages() self.assertEquals(ret[0].message, u'undefined: Undefined error while getting access token') self.assertEquals(ret[0].type, u'error')
def test_required_field_missing(self): mocker = Mocker() csv_reader = mocker.mock() headers = [ 'title', 'isbn', 'publisher', 'list_price', 'publish_date', 'class_', 'sheet_numbers', 'folio', 'print_type', 'author', 'barcode'] first_line = [ 'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a'] field_map = { 'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3, 'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7, 'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 } csv_reader.next() # read headers mocker.result(headers) csv_reader.next() # read first line mocker.result(first_line) mocker.replay() reader = CatalogReader(csv_reader, field_map) item = reader.read() self.assertIsNone(item.comments) mocker.restore() mocker.verify()
class MockRequestMixin(object): def setUp(self): self.mocker = Mocker() def create_mock_request(self, username='******', realm=None, method='GET', uri='/dummy/uri', nonce=None, request_digest=None, algorithm=None, opaque='dummy-opaque', qop='auth', nonce_count=1, client_nonce=None, password='******', request_path=None): if not realm: realm = get_setting('DIGEST_REALM', DEFAULT_REALM) if not nonce: nonce = python_digest.calculate_nonce(time.time(), secret=settings.SECRET_KEY) if not request_path: request_path = uri header = python_digest.build_authorization_request( username=username, realm=realm, method=method, uri=uri, nonce=nonce, opaque=opaque, nonce_count=nonce_count, password=password, request_digest=request_digest, client_nonce=client_nonce) request = self.create_mock_request_for_header(header) expect(request.method).result(method) expect(request.path).result(request_path) return request def create_mock_request_for_header(self, header): request = self.mocker.mock(HttpRequest, count=False) # bug in mocker: https://bugs.launchpad.net/mocker/+bug/179072 try: 'HTTP_AUTHORIZATION' in request.META except: pass self.mocker.result(not header == None) if header: expect(request.META['HTTP_AUTHORIZATION']).count( 0, None).result(header) return request
def test_str(self): mocker = Mocker() junc = mocker.mock() junc.getCoord() mocker.result("chr1:154000-230000") junc.name mocker.result("JUNC00001") mocker.replay() self.assertEqual(jc.Junction.__str__.im_func(junc), "chr1:154000-230000, JUNC00001")
def test_is_up_should_return_false_when_instance_is_not_running(self): mocker = Mocker() obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up") obj() mocker.result(False) mocker.replay() instance = Instance(name="foo", state="running") manager = DatabaseManager("foo", "127.0.0.1") self.assertFalse(instance.is_up(manager))
def test_default_variant_label_empty(self): mocker = Mocker() data = mocker.mock() data.context.objectValues() mocker.result(()) mocker.replay() self.assertEquals(shopitem.default_variant_label(data), '')
def test_is_up_shold_return_true_when_instance_is_running_and_db_is_up(self): mocker = Mocker() obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up") obj() mocker.result(True) mocker.replay() instance = Instance(name="foo", state="running") manager = DatabaseManager("foo", "127.0.0.1") self.assertTrue(instance.is_up(manager))
def test_default_opener(self): mocker = Mocker() DeliciousAPI = mocker.replace("deliciousapi.DeliciousAPI") dapi = DeliciousAPI() dapi.get_user("test_user", "test_pass") mocker.result(OPENER_RESULT) mocker.replay() default_opener("test_user", "test_pass") mocker.verify()
def test_str(self): mocker = Mocker() junc = mocker.mock() junc.getCoord() mocker.result('chr1:154000-230000') junc.name mocker.result('JUNC00001') mocker.replay() self.assertEqual(jc.Junction.__str__.im_func(junc), 'chr1:154000-230000, JUNC00001')
def test_get_article_unavailable_code(self): mocker = Mocker() databroker = mocker.mock() databroker['articles'].find_one(ANY) mocker.result(None) mocker.replay() db = DataBroker(databroker) self.assertEqual(db.get_article('xx'), None)
def test_exists_article_False(self): mocker = Mocker() databroker = mocker.mock() databroker['articles'].find(ANY).count() mocker.result(None) mocker.replay() db = DataBroker(databroker) self.assertEqual(db.exists_article('xx'), False)
def unpickle_mocked_task(begins): mocker = Mocker() ret = mocker.mock() ret.overlaps(ANY) mocker.result(False) mocker.count(0, None) ret.begins mocker.result(begins) mocker.count(0, None) mocker.replay() return ret
def test_get_article_available_code(self): mocker = Mocker() databroker = mocker.mock() databroker['articles'].find_one(ANY) mocker.result(self._raw_json) mocker.replay() db = DataBroker(databroker) self.assertEqual(db.get_article('xx')['code'], 'S0034-89102010000400007')
def test_converte2opl(self): linhas_arquivo_entrada = [['4','3'],['0','1','2','4'],['0','2','4','8'],['1','3','6','12'],['0','3']] linhas_arquivo_saida_esperada = ['s = "0";','d = "3";', 'A = {<"0","1",[2,4]>,\n<"0","2",[4,8]>,\n<"1","3",[6,12]>};'] converte2opl = Converte2OPL('arquivo.txt','arquivo_saida.txt') mocker = Mocker() obj = mocker.patch(converte2opl) obj.le_arquivo_entrada() mocker.result(linhas_arquivo_entrada) mocker.replay() obj.converte() self.assertListEqual(linhas_arquivo_saida_esperada,obj.linhas_arquivo_saida)
def test_page_go_to_action_raises_with_invalid_page(): mocker = Mocker() context = FakeContext(mocker) context.language.format("page_go_to_failure", "http://www.google.com") mocker.result("Error Message") with mocker: action = PageGoToAction() assert_raises(ActionFailedError, action.execute, context=context, url="http://www.google.com", exc_pattern=re_compile(r'^Error Message$'))
def test_is_not_keyword(): mocker = Mocker() language_mock = mocker.mock() language_mock.get("keyword") mocker.result("kw") with mocker: parser = FileParser(language=language_mock, file_object=None) is_keyword = parser.is_keyword("other", "keyword") assert not is_keyword
def test_selenium_driver_calls_proper_selenese_on_get_title(): mocker = Mocker() context = Context(Settings()) selenium_mock = mocker.mock() selenium_mock.get_title() mocker.result("Some title") with mocker: driver = SeleniumDriver(context, selenium=selenium_mock) title = driver.get_title() assert title == "Some title"
def test_page_see_title_action_calls_the_right_browser_driver_methods(): mocker = Mocker() context = FakeContext(mocker) context.browser_driver.get_title() mocker.result("some title") with mocker: action = PageSeeTitleAction() action.execute(context, title="some title")
def test_is_not_scenario_starter_line(): mocker = Mocker() language_mock = mocker.mock() language_mock.get("scenario") mocker.result("Scenario") with mocker: parser = FileParser(language=language_mock, file_object=None) is_scenario_starter_line = parser.is_scenario_starter_line( "Cenario bla") assert not is_scenario_starter_line
def test_element_click_action_calls_the_right_browser_driver_methods(): mocker = Mocker() context = FakeContext(mocker) context.browser_driver.resolve_element_key(context, "button", "some") mocker.result("btnSome") context.browser_driver.is_element_visible("btnSome") mocker.result(True) context.browser_driver.click_element("btnSome") context.language.format("element_is_visible_failure", "button", "some") mocker.result("button") context.language.get("button_category") mocker.count(min=0, max=None) mocker.result("button") with mocker: action = ElementClickAction() action.execute(context, element_name="some", element_type="button", should_wait=None)
def test_page_go_to_with_parameters_action_raises_error_when_parameters_are_invalid(): mocker = Mocker() action = PageGoToWithParametersAction() context = FakeContext(mocker) context.language.format('page_go_to_with_parameters_failure', 'Blah blahabla blah') mocker.result('Error Message') with mocker: assert_raises(ActionFailedError, action.parse_parameters, context, 'Blah blahabla blah')
def test_selenium_driver_calls_get_eval(): mocker = Mocker() javascript = "some javascript" context = Context(Settings()) selenium_mock = mocker.mock() selenium_mock.get_eval(javascript) mocker.result("ok") with mocker: driver = SeleniumDriver(context, selenium=selenium_mock) assert driver.exec_js(javascript) == "ok"
def test_wait_for_presence(): mocker = Mocker() context = Context(Settings()) selenium_mock = mocker.mock() selenium_mock.is_element_present('some element') mocker.result(True) selenium_mock.is_visible('some element') mocker.result(True) with mocker: driver = SeleniumDriver(context, selenium=selenium_mock) driver.wait_for_element_present("some element", 1)
def test_parsing_stories_returns_list(): mocker = Mocker() settings = Settings() filemock = mocker.mock() filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern) mocker.result([]) with mocker: parser = FileParser(file_object=filemock) fixture = parser.get_stories(settings=settings) assert isinstance(fixture, Fixture)
def test_wait_for_disappear_works_even_when_is_visible_raises(): mocker = Mocker() context = Context(Settings()) selenium_mock = mocker.mock() selenium_mock.is_element_present('some element') mocker.count(min=1, max=None) mocker.result(True) selenium_mock.is_visible('some element') mocker.throw(Exception("ERROR: Element some element not found")) with mocker: driver = SeleniumDriver(context, selenium=selenium_mock) driver.wait_for_element_to_disappear("some element", 1)
def test_parsing_folder_with_no_stories_returns_empty_list(): mocker = Mocker() settings = Settings() files = [] filemock = mocker.mock() filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern) mocker.result(files) with mocker: parser = FileParser(file_object=filemock) fixture = parser.get_stories(settings=settings) assert len(fixture.stories) == 0