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 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 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_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 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_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_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 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_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 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_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 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_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 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
