def test_update_job(mocker, SETTINGS):
aget_job = mocker.patch(
'jenkins_epo.jenkins.JENKINS.aget_job',
CoroutineMock(),
)
rest = mocker.patch('jenkins_epo.jenkins.JENKINS.rest')
url = rest.job()
url.api.python.aget = CoroutineMock()
url().aget = CoroutineMock()
url().apost = CoroutineMock()
from jenkins_epo.jenkins import Job
SETTINGS.DRY_RUN = 1
spec = Mock(config=dict())
spec.name = 'job'
job = Job(Mock(_data=dict()))
new_job = yield from job.update(spec)
assert new_job is job
SETTINGS.DRY_RUN = 0
new_job = yield from job.update(spec)
assert new_job is not job
assert aget_job.mock_calls
def test_matrix_build(mocker, SETTINGS):
JENKINS = mocker.patch('jenkins_epo.jenkins.JENKINS')
from jenkins_epo.jenkins import MatrixJob, JobSpec
SETTINGS.DRY_RUN = 0
api_instance = Mock()
api_instance.name = 'matrix'
api_instance._data = {'url': 'https://jenkins/job'}
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
spec = JobSpec(api_instance.name)
spec.config['parameters'] = {'PARAM': 1}
job = MatrixJob(api_instance)
job._node_axis = job._revision_param = None
job._combination_param = 'C'
job._revision_param = 'R'
yield from job.build(
Mock(url='url://', fullref='refs/heads/master'), spec, 'matrix',
)
assert JENKINS.rest.job().buildWithParameters.mock_calls
async def test_app_middleware_with_handlers(self):
mock = Mock()
class Middleware(BaseMiddleware):
async def do(self, r, h, a):
mock(r, h, a)
return await h(r)
@Middleware(self.resolver)
class App(jj.App):
resolver = self.resolver
@MethodMatcher(resolver, "*")
async def handler(request):
return Response(status=200)
app = App()
async with run(app) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_called_once()
request_arg, handler_arg, app_arg = mock.call_args[0]
self.assertIsInstance(request_arg, Request)
self.assertEqual(handler_arg, App.handler)
self.assertEqual(app_arg, app)
def test_run_extension(mocker):
pkg_resources = mocker.patch('jenkins_epo.bot.pkg_resources')
from jenkins_epo.bot import Bot
ep = Mock()
ep.name = 'ext'
pkg_resources.iter_entry_points.return_value = [ep]
ext = ep.resolve.return_value.return_value
ext.DEFAULTS = {}
ext.SETTINGS = {}
ext.run.return_value = []
bot = Bot()
assert 'ext' in bot.extensions_map
pr = Mock(name='pr', payload=dict())
pr.fetch_commits = CoroutineMock()
commits = [Mock()]
pr.repository.process_commits.return_value = commits
pr.fetch_comments = CoroutineMock(return_value=[])
commits[0].fetch_statuses = CoroutineMock()
yield from bot.run(pr)
assert pr.fetch_commits.mock_calls
assert pr.fetch_comments.mock_calls
assert ext.begin.mock_calls
assert ext.run.mock_calls
def test_send_membership(self):
account = Account("test_salt", "H8uYXvyF6GWeCr8cwFJ6V5B8tNprwRdjepFNJBqivrzr",
"test_account", [], [], [],
self.identities_registry)
account_identity = MagicMock(autospec='sakia.core.registry.Identity')
account_identity.selfcert = CoroutineMock(return_value=SelfCertification(2, "meta_brouzouf",
"H8uYXvyF6GWeCr8cwFJ6V5B8tNprwRdjepFNJBqivrzr", "test_account", 1000000000, ""))
community = MagicMock(autospec='sakia.core.Community')
community.blockUID = CoroutineMock(return_value=BlockUID(3102, "0000C5336F0B64BFB87FF4BC858AE25726B88175"))
self.identities_registry.future_find = CoroutineMock(return_value=account_identity)
community.bma_access = MagicMock(autospec='sakia.core.net.api.bma.access.BmaAccess')
response = Mock()
response.json = CoroutineMock(return_value={
"signature": "H41/8OGV2W4CLKbE35kk5t1HJQsb3jEM0/QGLUf80CwJvGZf3HvVCcNtHPUFoUBKEDQO9mPK3KJkqOoxHpqHCw==",
"membership": {
"version": 2,
"currency": "beta_brouzouf",
"issuer": "HsLShAtzXTVxeUtQd7yi5Z5Zh4zNvbu8sTEZ53nfKcqY",
"membership": "IN",
"sigDate": 1390739944,
"uid": "superman63"
}
})
response.status = 200
community.bma_access.broadcast = CoroutineMock(return_value=[response])
async def exec_test():
result = await account.send_membership("test_password", community, "IN")
self.assertTrue(result)
self.lp.run_until_complete(exec_test())
def test_create_job(mocker, SETTINGS):
from jenkins_epo.jenkins import LazyJenkins
JENKINS = LazyJenkins(Mock())
JENKINS.rest = Mock()
JENKINS.rest.createItem.apost = CoroutineMock()
JENKINS.rest.job().api.python.aget = CoroutineMock(return_value=dict(
url='url://', name='job',
))
JENKINS.rest.job()('config.xml').aget = CoroutineMock(
return_value=Mock(data='<project/>')
)
spec = Mock(config=dict())
spec.name = 'job'
SETTINGS.DRY_RUN = 1
job = yield from JENKINS.create_job(spec)
assert job is None
assert 'updated_at' in spec.config['description']
assert not JENKINS.rest.createItem.apost.mock_calls
SETTINGS.DRY_RUN = 0
job = yield from JENKINS.create_job(spec)
assert job
assert JENKINS.rest.createItem.apost.mock_calls
assert JENKINS.rest.job().api.python.aget.mock_calls
assert JENKINS.rest.job()().aget.mock_calls
def test_matrix_list_context_node():
from jenkins_yml import Job
from jenkins_epo.jenkins import MatrixJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance.name = 'matrix'
api_instance._data = dict(activeConfigurations=[
{'name': 'NODE=slave-legacy,P=a'},
{'name': 'NODE=slave-ng,P=a'},
{'name': 'NODE=slave-legacy,P=b'},
{'name': 'NODE=slave-ng,P=b'},
])
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = MatrixJob(api_instance)
job._node_axis = 'NODE'
spec = Job('matrix', dict(
node='slave-ng',
axis={'P': ['a', 'b', 4.3]},
))
contexts = [c for c in job.list_contexts(spec)]
assert 2 == len(contexts)
assert 'NODE=slave-legacy' not in ''.join(contexts)
assert 'NODE=slave-ng' in ''.join(contexts)
async def test_handler_logger(self):
mock = Mock()
record = {"request": None, "response": None}
class App(jj.App):
resolver = self.resolver
@LoggerMiddleware(self.resolver, mock)
@MethodMatcher(resolver, "*")
async def handler(request):
record["request"] = request
response = Response(status=200)
record["response"] = response
return response
async with run(App()) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_has_calls([
call.info(record["request"], extra={
"jj_request": record["request"],
}),
call.info(record["response"], extra={
"jj_request": record["request"],
"jj_response": record["response"],
}),
])
self.assertEqual(mock.info.call_count, 2)
def test_matrix_list_context_superset(JobSpec):
from jenkins_yml import Job
from jenkins_epo.jenkins import MatrixJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance.name = 'matrix'
api_instance._data = dict(activeConfigurations=[
{'name': 'A=0,B=a'},
{'name': 'A=1,B=a'},
{'name': 'A=0,B=b'},
{'name': 'A=1,B=b'},
{'name': 'A=0,B=c'},
{'name': 'A=1,B=c'},
])
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
jenkins_spec = JobSpec.from_xml.return_value
jenkins_spec.config = dict(axis={'A': [0, 1], 'B': 'abc'})
job = MatrixJob(api_instance)
spec = Job('matrix', dict(axis={'B': 'acd'}))
contexts = [c for c in job.list_contexts(spec)]
haystack = '\n'.join(contexts)
assert 'A=0' in haystack
assert 'A=1' not in haystack
assert 'B=b' not in haystack
assert 2 == len(contexts)
def test_run_skip_closed(mocker):
pkg_resources = mocker.patch('jenkins_epo.bot.pkg_resources')
from jenkins_epo.bot import Bot
pkg_resources.iter_entry_points.return_value = []
pr = Mock(name='pr')
pr.payload = dict(state='closed')
yield from Bot().run(pr)
def test_fetch_builds(mocker):
Client = mocker.patch('jenkins_epo.jenkins.rest.Client')
Client().api.python.aget = aget = CoroutineMock(
return_value=dict(builds=[])
)
from jenkins_epo.jenkins import Job
api_instance = Mock(_data=dict())
api_instance.name = 'freestyle'
job = Job(api_instance)
yield from job.fetch_builds()
assert aget.mock_calls
async def test_004_patch_rest_configuration(self, bus_stop_mock):
req = Mock()
async def json():
return {
'bus': {'jid': 'updated@localhost'},
'new': True
}
req.headers = {'Content-Type': 'application/json'}
req.json = json
await self.apiconf.patch(req)
eq_(self.nyuki._config['new'], True)
eq_(self.nyuki._config['bus']['jid'], 'updated@localhost')
# finish coroutines
await exhaust_callbacks(self.loop)
bus_stop_mock.assert_called_once_with()
def test_main_sync(mocker):
COMMANDS = []
mocker.patch('jenkins_epo.main.COMMANDS', COMMANDS)
command = Mock()
command.__name__ = 'bot'
command.__code__ = Mock(co_varnames=(), co_argcount=0)
command._is_coroutine = None
COMMANDS.append(command)
from jenkins_epo.main import main
assert not asyncio.iscoroutinefunction(command)
main(argv=['bot'])
assert command.mock_calls
def request(method, url, data, headers):
eq_(method, 'get')
eq_(url, 'url')
eq_(data, '{"message": "text"}')
eq_(headers, {
'Content-Type': 'application/json',
'Accept': 'application/json'
})
m = Mock()
m.status = 200
@future_func
def to_json():
return {'response': 'text'}
m.json = to_json
return m
def test_process_builds():
from jenkins_epo.jenkins import Job
api_instance = Mock(_data=dict())
api_instance.name = 'freestyle'
job = Job(api_instance)
builds = list(job.process_builds([
{'number': 1, 'url': 'url://'},
{'number': 2, 'url': 'url://'},
]))
assert 2 == len(builds)
assert 2 == builds[0].number
assert 1 == builds[1].number
def test_apost(mocker):
from jenkins_epo.github import CustomGitHub, ApiError
aiohttp = mocker.patch('jenkins_epo.github.aiohttp')
session = aiohttp.ClientSession.return_value
response = Mock(spec=['headers', 'json', 'status'])
session.post = CoroutineMock(return_value=response)
response.status = 304
response.content_type = 'application/json'
response.headers = {'ETag': 'cafed0d0'}
response.json = CoroutineMock(return_value={'message': 'Not found'})
GITHUB = CustomGitHub(access_token='cafed0d0')
with pytest.raises(ApiError):
yield from GITHUB.user.apost(pouet=True)
def test_aget_dict(mocker):
from jenkins_epo.github import CustomGitHub
aiohttp = mocker.patch('jenkins_epo.github.aiohttp')
session = aiohttp.ClientSession.return_value
response = Mock(spec=['headers', 'json', 'status'])
session.get = CoroutineMock(return_value=response)
response.status = 200
response.content_type = 'application/json'
response.headers = {'ETag': 'cafed0d0'}
response.json = CoroutineMock(return_value={'data': 1})
GITHUB = CustomGitHub(access_token='cafed0d0')
res = yield from GITHUB.user.aget(per_page='100')
assert res._headers
assert 'data' in res
def test_compat():
from jenkins_epo.extensions.core import ReportExtension
ext = ReportExtension('merger', Mock())
ext.current = Mock()
ext.current.issue_url = None
instruction = Mock(name='instruction', args='https://...')
instruction.name = 'report-done'
ext.process_instruction(instruction)
assert ext.current.issue_url
yield from ext.run()
assert not ext.current.head.comment.mock_calls
assert not ext.current.repository.report_issue.mock_calls
def test_freestyle_node_param():
from jenkins_epo.jenkins import FreestyleJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance._data = dict()
api_instance.name = 'freestyle'
api_instance.get_params.return_value = [
{'name': 'P', 'type': 'StringParameter'},
{'name': 'N', 'type': 'LabelParameterDefinition'},
]
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = FreestyleJob(api_instance)
assert 'N' == job.node_param
def test_aget_html(mocker):
from jenkins_epo.github import CustomGitHub
aiohttp = mocker.patch('jenkins_epo.github.aiohttp')
session = aiohttp.ClientSession.return_value
response = Mock(spec=['headers', 'read', 'status'])
session.get = CoroutineMock(return_value=response)
response.status = 200
response.content_type = 'text/html'
response.headers = {'ETag': 'cafed0d0'}
response.read = CoroutineMock(return_value='<!DOCTYPE')
GITHUB = CustomGitHub(access_token='cafed0d0')
with pytest.raises(Exception):
yield from GITHUB.user.aget()
assert response.read.mock_calls
def test_matrix_combination_param():
from jenkins_epo.jenkins import MatrixJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance.name = 'matrix'
api_instance._data = dict()
api_instance.get_params.return_value = [
{'name': 'P', 'type': 'StringParameter'},
{'name': 'C', 'type': 'MatrixCombinationsParameterDefinition'},
]
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = MatrixJob(api_instance)
assert 'C' == job.combination_param
async def test_root_and_app_and_handler_middlewares_priority(self):
mock = Mock()
class Do:
async def do(self, request, handler, app):
mock(self.__class__.__name__, sentinel.BEFORE)
response = await handler(request)
mock(self.__class__.__name__, sentinel.AFTER)
return response
class Middleware(Do, RootMiddleware):
resolver = self.resolver
class AppMiddleware(Do, BaseMiddleware):
resolver = self.resolver
class HandlerMiddleware(Do, BaseMiddleware):
resolver = self.resolver
@AppMiddleware()
class App(jj.App):
resolver = self.resolver
@MethodMatcher(resolver, "*")
@HandlerMiddleware()
async def handler(request):
mock(App.__name__, sentinel.BEFORE)
response = Response(status=200)
mock(App.__name__, sentinel.AFTER)
return response
async with run(App(), middlewares=[Middleware()]) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_has_calls([
call(AppMiddleware.__name__, sentinel.BEFORE),
call(HandlerMiddleware.__name__, sentinel.BEFORE),
call(Middleware.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.AFTER),
call(Middleware.__name__, sentinel.AFTER),
call(HandlerMiddleware.__name__, sentinel.AFTER),
call(AppMiddleware.__name__, sentinel.AFTER),
])
self.assertEqual(mock.call_count, 8)
def test_post(mocker):
ClientSession = mocker.patch('jenkins_epo.rest.aiohttp.ClientSession')
from jenkins_epo.rest import Client
client = Client()
client = client('http://jenkins/path').subpath
session = ClientSession.return_value
response = Mock(name='response')
session.post = CoroutineMock(return_value=response)
response.read = CoroutineMock(
return_value=repr(dict(unittest=True)).encode('utf-8')
)
payload = yield from client.apost(param=1)
assert ': True' in payload
def test_github_webhook_ping(mocker, SETTINGS, WORKERS):
SETTINGS.GITHUB_SECRET = 'notasecret'
validate = mocker.patch('jenkins_epo.web.validate_signature')
infer = mocker.patch('jenkins_epo.web.infer_url_from_event')
mocker.patch('jenkins_epo.web.WORKERS', WORKERS)
from jenkins_epo.web import github_webhook
req = Mock()
req.read = CoroutineMock(return_value=b'''{"hook_id": null}''')
req.release = CoroutineMock()
res = yield from github_webhook(req)
assert validate.mock_calls
assert not infer.mock_calls
assert not WORKERS.enqueue.mock_calls
assert 200 == res.status
async def test_middleware_with_handler(self):
mock = Mock()
class App(jj.App):
resolver = self.resolver
@MethodMatcher(resolver, "*")
async def handler(request):
mock(request)
return Response(status=200)
middleware = SelfMiddleware(self.resolver)
async with run(App(), middlewares=[middleware]) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_called_once()
request_arg, = mock.call_args[0]
self.assertIsInstance(request_arg, Request)
def test_matrix_node_axis():
from jenkins_epo.jenkins import MatrixJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance.name = 'matrix'
api_instance._data = dict()
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = MatrixJob(api_instance)
name_element = Mock()
name_element.text = 'NODE'
xml.findall.return_value = [name_element]
assert 'NODE' == job.node_axis
def test_filter_extension(iter_entry_points):
loaded = Mock()
loaded.name = 'loaded'
ext = loaded.resolve.return_value.return_value
ext.SETTINGS = {}
skipped = Mock()
skipped.name = 'skipped'
iter_entry_points.return_value = [loaded, skipped]
from jenkins_epo.bot import Bot
Bot.ext_patterns.extend(['*', '-skip*'])
bot = Bot()
assert 'loaded' in bot.extensions_map
assert 'skipped' not in bot.extensions_map
async def test_app_middleware_hook(self):
mock = Mock()
class Middleware(BaseMiddleware):
def on_app(self, app):
mock(app)
def on_handler(self, handler):
mock(handler)
@Middleware(self.resolver)
class App(jj.App):
resolver = self.resolver
async with run(App()) as client:
response = await client.get("/")
self.assertEqual(response.status, 404)
mock.assert_called_once_with(App)
def test_aget_422(mocker):
from jenkins_epo.github import CustomGitHub, ApiError
aiohttp = mocker.patch('jenkins_epo.github.aiohttp')
session = aiohttp.ClientSession.return_value
response = Mock(spec=['headers', 'json', 'status'])
session.get = CoroutineMock(return_value=response)
response.status = 422
response.headers = {}
response.content_type = 'application/json'
response.json = CoroutineMock(
return_value={'errors': [{'message': 'Pouet'}]},
)
GITHUB = CustomGitHub(access_token='cafed0d0')
with pytest.raises(ApiError):
yield from GITHUB.user.aget()
def request(method, url, data, headers):
eq_(method, 'get')
eq_(url, 'url')
eq_(data, '{"message": "text"}')
eq_(headers, {
'Content-Type': 'application/json',
'Accept': 'application/json'
})
m = Mock()
m.status = 200
@future_func
def to_json():
raise ValueError
m.json = to_json
@future_func
def to_text():
return 'something'
m.text = to_text
return m
async def test_can_unsubscribe(self):
handler = Mock()
subscription = Subscription('/queue/123', 1, 'client',
{'my-header': 'my-value'}, handler)
await self.protocol.connect()
self.protocol.unsubscribe(subscription)
self._protocol.send_frame.assert_called_with(
'UNSUBSCRIBE', {
'id': 1,
'destination': '/queue/123',
})
def setUp(self):
self.agent = Mock()
self.agent.name = "my agent"
self.agent.predictor.predict = CoroutineMock()
self.behaviour = StoreNewData()
self.behaviour.receive = CoroutineMock()
self.behaviour.set_agent(self.agent)
self.body = dict(data=dict(test="any data"),
metadata=dict(timestamp=datetime.utcnow().timestamp(),
identifier="my data"))
self.template = Template(body=str(orjson.dumps(self.body), "utf-8"))
self.behaviour.set_template(self.template)
self.agent.connection.lazy_insert = CoroutineMock()
async def test_can_handle_error_frame(self, logger_mock):
frame = Frame(
'ERROR',
{'message': 'Invalid error, blah, blah, blah'},
'Detail Error: blah, blahh-line-a',
)
frame_handler = Mock()
frame_handler._on_error = CoroutineMock()
stomp = StompReader(frame_handler, self.loop)
await stomp._handle_error(frame)
frame_handler._on_error.assert_called_once()
self.assertTrue(
isinstance(frame_handler._on_error.call_args[0][0], StompError))
logger_mock.error.assert_called_with(
'Received error: Invalid error, blah, blah, blah')
logger_mock.debug.assert_called_with(
'Error details: Detail Error: blah, blahh-line-a')
def test_freestyle_node_param():
from jenkins_epo.jenkins import FreestyleJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance._data = dict()
api_instance.name = 'freestyle'
api_instance.get_params.return_value = [
{
'name': 'P',
'type': 'StringParameter'
},
{
'name': 'N',
'type': 'LabelParameterDefinition'
},
]
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = FreestyleJob(api_instance)
assert 'N' == job.node_param
async def test_smartapp_webhook(hass):
"""Test the smartapp webhook calls the manager."""
manager = Mock()
manager.handle_request = CoroutineMock(return_value={})
hass.data[DOMAIN][DATA_MANAGER] = manager
request = Mock()
request.headers = []
request.json = CoroutineMock(return_value={})
result = await smartapp.smartapp_webhook(hass, "", request)
assert result.body == b"{}"
async def test_can_connect(self):
stomp = StompReader(None,
self.loop,
heartbeat={
'enabled': True,
'cx': 1000,
'cy': 1000
})
stomp._transport = Mock()
stomp.connect()
stomp._transport.write.assert_called_with(
b'CONNECT\naccept-version:1.1\nheart-beat:1000,1000\n\n\x00')
async def test_it_calls_multiple_handlers_if_multiple_handle_matches_are_found_for_record(
self):
level10_handler = Mock(level=10, handle=CoroutineMock())
level20_handler = Mock(level=20, handle=CoroutineMock())
logger = Logger.with_default_handlers()
logger.handlers = [level10_handler, level20_handler]
record = LogRecord(
level=30,
name="aiologger",
pathname="/aiologger/tests/test_logger.py",
lineno=17,
msg="Xablau!",
exc_info=None,
args=None,
)
await logger.callHandlers(record)
level10_handler.handle.assert_awaited_once_with(record)
level20_handler.handle.assert_awaited_once_with(record)
def test_branch_fetch_commits(mocker):
cached_arequest = mocker.patch('jenkins_epo.repository.cached_arequest',
CoroutineMock())
cached_arequest.side_effect = [
dict(parents=[dict(sha='d0d0cafe')]),
dict()
]
from jenkins_epo.repository import Branch
head = Branch(Mock(), dict(name='branch', commit=dict(sha='d0d0cafe')))
payload = yield from head.fetch_commits()
assert payload
assert cached_arequest.mock_calls
async def test_init():
datastream = Mock()
return_sub_responses = False
with patch(
'aioidex.datastream.sub_manager.SubscriptionManager._init_subscriptions'
) as mock:
sm = SubscriptionManager(datastream, return_sub_responses)
mock.assert_called_once()
assert sm._ds is datastream
assert sm._return_responses == return_sub_responses
assert isinstance(sm._logger, Logger)
assert sm._CATEGORY_VALUES == set(_.value for _ in Category)
async def test_unsubscribe_rid(sm: SubscriptionManager):
sm._ds.send_message = CoroutineMock(return_value='some return value')
sm._sub_payload = Mock(return_value='some value')
category = Category.MARKET
result = await sm.unsubscribe(category, ['ETH_AURA'], 'some_rid')
sm._sub_payload.assert_called_once_with(Action.UNSUBSCRIBE, ['ETH_AURA'])
sm._ds.send_message.assert_awaited_once_with(category.value, 'some value',
'some_rid')
assert result == 'some return value'
def test_commit_date():
from jenkins_epo.repository import Commit
commit = Commit(Mock(), 'd0d0')
assert repr(commit)
commit.payload = {'author': {'date': '2016-10-11T14:45:00Z'}}
assert 2016 == commit.date.year
commit.payload = dict(commit=commit.payload)
assert 2016 == commit.date.year
async def test_subscribe_after_connection(self):
self.stomp._protocol.connect = CoroutineMock()
self.stomp._protocol.subscribe = Mock()
self.stomp.subscribe('/queue/test')
self.assertEqual(len(self.stomp._subscriptions), 1)
self.stomp._protocol.subscribe.assert_not_called()
await self.stomp.connect()
self.assertTrue(self.stomp._connected)
self.stomp._protocol.subscribe.assert_called_once()
def inner(return_value=None, side_effect=None):
stub = stub_connection(return_value=return_value, side_effect=side_effect)
context_manager = MagicMock()
context_manager.__aenter__ = CoroutineMock(
return_value=stub
)
context_manager.__aexit__ = CoroutineMock()
manager = MagicMock()
manager.new_connection = Mock(return_value=context_manager)
manager.connection_stub = stub
return manager
async def test__interfaces_service__create_vlan_invalid_name():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create({
'type': 'VLAN',
'name': 'myvlan1',
'vlan_tag': 5,
'vlan_parent_interface': 'em0',
})
assert 'interface_create.name' in ve.value
def test_pr_fetch_commits(mocker):
cached_arequest = mocker.patch('jenkins_epo.repository.cached_arequest',
CoroutineMock())
cached_arequest.return_value = dict(commits=['previous', 'last'])
from jenkins_epo.repository import PullRequest
head = PullRequest(
Mock(),
dict(
head=dict(ref='pr', sha='d0d0cafe', label='owner:pr'),
base=dict(label='owner:base'),
))
commits = yield from head.fetch_commits()
assert ['last', 'previous'] == list(commits)
async def test__interfaces_service__create_lagg_invalid_name():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create({
'type': 'LINK_AGGREGATION',
'name': 'mylag11',
'lag_protocol': 'LACP',
'lag_ports': ['em0'],
})
assert 'interface_create.name' in ve.value
def test_find_caller_without_current_frame_code(self):
logger = Logger()
with patch(
"aiologger.logger.get_current_frame",
return_value=Mock(f_back=object()),
):
caller = logger.find_caller()
self.assertEqual(caller.filename, "(unknown file)")
self.assertEqual(caller.line_number, 0)
self.assertEqual(caller.function_name, "(unknown function)")
self.assertIsNone(caller.stack)
async def test_get_result():
con_mock = AMock()
con_mock.post_json = CoroutineMock(return_value=Mock(
status_code=202,
json=Mock(return_value=dict(msg="DUMMY_ERROR"), ),
headers=dict(Location="DUMMY"),
), )
con_mock.get_url = CoroutineMock(side_effect=[
Mock(
status_code=303,
headers=dict(Location="DUMMY"),
),
Mock(
status_code=200,
headers=dict(Location="DUMMY"),
json=Mock(return_value=dict(query_result=[{
"0": 1
}])),
),
])
assert (await get_result(connection=con_mock,
query_spec="foo")).values.tolist() == [[1]]
async def test_broker_regenerates_token(hass, config_entry):
"""Test the device broker regenerates the refresh token."""
token = Mock(OAuthToken)
token.refresh_token = str(uuid4())
stored_action = None
def async_track_time_interval(hass, action, interval):
nonlocal stored_action
stored_action = action
with patch(
"homeassistant.components.smartthings.async_track_time_interval",
new=async_track_time_interval,
):
broker = smartthings.DeviceBroker(hass, config_entry, token, Mock(),
[], [])
broker.connect()
assert stored_action
await stored_action(None) # pylint:disable=not-callable
assert token.refresh.call_count == 1
assert config_entry.data[CONF_REFRESH_TOKEN] == token.refresh_token
async def test_clear_rid(sm: SubscriptionManager):
sm._ds.send_message = CoroutineMock(return_value='some return value')
sm._sub_payload = Mock(return_value='some value')
category = Category.MARKET
result = await sm.clear(category, 'some_rid')
sm._sub_payload.assert_called_once_with(Action.CLEAR)
sm._ds.send_message.assert_awaited_once_with(category.value, 'some value',
'some_rid')
assert result == 'some return value'
async def test_handle_connection_loops():
class StopAfterThree:
prompt = "> "
MAX_INPUTS = 3
def __init__(self):
self.inputs_handled = 0
async def handle_input(self, conn, line):
self.inputs_handled += 1
if self.inputs_handled >= self.MAX_INPUTS:
await conn.stop()
prompt = StopAfterThree()
async def boot(conn):
await conn.push(prompt=prompt)
conn_server = ConnectionServer()
await conn_server.handle_connection(boot, Mock(), Mock())
assert prompt.inputs_handled == 3
async def test_resubscribe(sm: SubscriptionManager):
sub = Subscription(category=Category.MARKET,
events=[MarketEvents.CANCELS, MarketEvents.ORDERS],
topics=['ETH_AURA', 'ETH_ZRX'])
sm.subscriptions = {Category.MARKET: sub}
sm._init_subscriptions = Mock()
sm.subscribe = CoroutineMock()
await sm.resubscribe()
sm._init_subscriptions.assert_called_once()
sm.subscribe.assert_awaited_once_with(sub)
def test_process_sub_response_error(sm: SubscriptionManager):
message = dict(
result='error',
request='subscribeToMarkets',
payload=dict(action='get'),
)
sm._logger.error = Mock()
result = sm.process_sub_response(message)
sm._logger.error.assert_called_once_with('Subscription error: %s', message)
assert result is None
async def test_remove_entry_app_api_error(hass, config_entry,
smartthings_mock):
"""Test raises exceptions removing the app."""
# Arrange
request_info = Mock(real_url="http://example.com")
smartthings_mock.delete_app.side_effect = ClientResponseError(
request_info=request_info, history=None, status=500)
# Act
with pytest.raises(ClientResponseError):
await smartthings.async_remove_entry(hass, config_entry)
# Assert
assert smartthings_mock.delete_installed_app.call_count == 1
assert smartthings_mock.delete_app.call_count == 1
async def test_auth_auth_check_and_register_with_exception(hass):
"""Test auth client registration."""
config = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"}
hmip_auth = HomematicipAuth(hass, config)
hmip_auth.auth = Mock(spec=AsyncAuth)
with patch.object(hmip_auth.auth,
"isRequestAcknowledged",
side_effect=HmipConnectionError), patch.object(
hmip_auth.auth,
"requestAuthToken",
side_effect=HmipConnectionError):
assert not await hmip_auth.async_checkbutton()
assert await hmip_auth.async_register() is False
async def test_get(sm: SubscriptionManager):
sm._ds.send_message = CoroutineMock(return_value='some return value')
sm._sub_payload = Mock(return_value='some value')
category = Category.MARKET
result = await sm.get(category)
sm._sub_payload.assert_called_once_with(Action.GET)
sm._ds.send_message.assert_awaited_once_with(category.value, 'some value',
None)
assert result == 'some return value'
def test_load_settings_collaborators_denied(mocker):
GITHUB = mocker.patch('jenkins_epo.repository.GITHUB')
unpaginate = mocker.patch(
'jenkins_epo.repository.unpaginate',
CoroutineMock(),
)
from jenkins_epo.repository import (
Repository,
ApiNotFoundError,
UnauthorizedRepository,
)
GITHUB.fetch_file_contents = CoroutineMock(
return_value=repr(dict(settings=dict(branches=['master']))))
unpaginate.side_effect = ApiNotFoundError('u', Mock(), Mock())
repo = Repository('owner', 'repo1')
with pytest.raises(UnauthorizedRepository):
yield from repo.load_settings()
assert GITHUB.fetch_file_contents.mock_calls
assert unpaginate.mock_calls
def create_mock_device(platform, spec):
"""Create a dynalite mock device for a platform according to a spec."""
device = Mock(spec=spec)
device.category = platform
device.unique_id = "UNIQUE"
device.name = "NAME"
device.device_class = "Device Class"
return device
async def test_should_increment_on_connection_fail_counter(self, metrics):
counter = Mock()
labels = Mock(labels=Mock(return_value=counter))
metrics.__getitem__ = Mock(return_value=labels)
await self.prometheus.on_connection_fail(Mock(), Mock())
self.assertEqual(labels.labels.call_count, 1)
labels.labels.assert_called_with(test='my_test')
counter.inc.assert_called_once()
def create_mock_client():
"""Create a mock Hyperion client."""
mock_client = Mock()
mock_client.async_client_connect = CoroutineMock(return_value=True)
mock_client.adjustment = None
mock_client.effects = None
mock_client.id = "%s:%i" % (TEST_HOST, TEST_PORT)
return mock_client
