def test_spec_inheritance_for_classes(self):
class Foo(object):
def a(self):
pass
class Bar(object):
def f(self):
pass
class_mock = create_autospec(Foo)
self.assertIsNot(class_mock, class_mock())
for this_mock in class_mock, class_mock():
this_mock.a()
this_mock.a.assert_called_with()
self.assertRaises(TypeError, this_mock.a, 'foo')
self.assertRaises(AttributeError, getattr, this_mock, 'b')
instance_mock = create_autospec(Foo())
instance_mock.a()
instance_mock.a.assert_called_with()
self.assertRaises(TypeError, instance_mock.a, 'foo')
self.assertRaises(AttributeError, getattr, instance_mock, 'b')
# The return value isn't isn't callable
self.assertRaises(TypeError, instance_mock)
instance_mock.Bar.f()
instance_mock.Bar.f.assert_called_with()
self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
instance_mock.Bar().f()
instance_mock.Bar().f.assert_called_with()
self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
def setUp(self):
view = mock.create_autospec(PlotView)
view.subplotRemovedSignal = mock.Mock()
self.presenter = PlotPresenter(view)
self.presenter.view.canvas = mock.Mock()
self.presenter.view.canvas.draw = mock.Mock()
self.view = self.presenter.view
self.view.close = mock.Mock()
self.view.get_subplots = mock.Mock(return_value={})
self.view.removeLine = mock.Mock()
# explicitly mock pop up
self.mock_selector = mock.create_autospec(dummy_popup)
self.mock_selector.subplotSelectorSignal = mock.Mock()
self.mock_selector.closeEventSignal = mock.Mock()
self.mock_rmWindow = mock.create_autospec(dummy_popup)
self.mock_rmWindow.applyRemoveSignal = mock.Mock()
self.mock_rmWindow.closeEventSignal = mock.Mock()
self.mock_rmWindow.subplot = mock.Mock(return_value="plot")
self.mock_rmWindow.getState = mock.Mock(side_effect=[True, True])
self.mock_rmWindow.getLine = mock.Mock()
# mock presenter to create mock pop ups
self.presenter.createRmWindow = mock.Mock(
return_value=self.mock_rmWindow)
self.presenter.createSelectWindow = mock.Mock(
return_value=self.mock_selector)
self.mock_name = mock.Mock()
self.mock_workspace = mock.Mock()
self.mock_func = mock.Mock()
self.mock_arbitrary_args = [mock.Mock() for i in range(3)]
def test_copy_target():
src = create_autospec(Path, spec_set=True)
dest = create_autospec(Path, spec_set=True)
ct = CopyTarget(src, dest)
assert ct.dest == dest
ct.dest.exists.return_value = False
with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp:
cmp.return_value = False
cres1 = ct.create()
cres1.is_success
assert copy2.call_count == 1
assert cmp.call_count == 0
ct.dest.exists.return_value = True
with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp:
cmp.return_value = False
cres2 = ct.create()
cres2.is_success
assert copy2.call_count == 1
assert cmp.call_count == 1
ct.dest.exists.return_value = True
with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp:
cmp.return_value = True
cres3 = ct.create()
cres3.is_success
assert copy2.call_count == 0
assert cmp.call_count == 1
def test_credentials_get_token(self):
creds = mock.create_autospec(InteractiveCredentials)
session = mock.create_autospec(OAuth2Session)
creds._setup_session.return_value = session
session.fetch_token.return_value = {
'expires_at':'1',
'expires_in':'2',
'refresh_token':"test"}
creds.redirect = "//my_service.com"
creds.token_uri = "token_uri"
creds._check_state.return_value = True
creds.verify = True
InteractiveCredentials.set_token(creds, "response")
self.assertEqual(creds.token, session.fetch_token.return_value)
session.fetch_token.assert_called_with(
"token_uri",
authorization_response="https://my_service.com/response",
verify=True)
creds._check_state.side_effect = ValueError("failed")
with self.assertRaises(ValueError):
InteractiveCredentials.set_token(creds, "response")
creds._check_state.side_effect = None
session.fetch_token.side_effect = oauthlib.oauth2.OAuth2Error
with self.assertRaises(AuthenticationError):
InteractiveCredentials.set_token(creds, "response")
def test_run_implementations_parallel_output_enabled_slow_implementations(self, mock_loadImplementation):
"""Coverage case for the display_progress option where the future is still not done after the timer expires."""
test_implementation_mapping = {"foo": "bar", "baz": "bog"}
test_command = CommandUnderTest()
# create dummy imps where the side_effect of calling run is to sleep.
mock_imp1 = create_autospec(spec = Implementation, spec_set = True, instance = True)
mock_imp1.run.side_effect = lambda args: time.sleep(4)
mock_imp2 = create_autospec(spec = Implementation, spec_set = True, instance = True)
mock_imp2.run.side_effect = lambda args: time.sleep(5)
gen = (impl for impl in (mock_imp1, mock_imp2))
test_command.impl_list = {
key: next(gen) for key in test_implementation_mapping
}
result = test_command.run_implementations_parallel(
implementation_mapping = test_implementation_mapping,
display_progress = True
)
assert result == {
key: namedtuple("_", ("result", "exception"))(
result = None,
exception = None,
)
for key in test_implementation_mapping
}
def setUp(self):
self.load=mock.create_autospec(load_utils.LoadUtils,spec_set=True)
self.load.getCurrentWS=mock.Mock(return_value=["TEST00000001",["fwd","bkwd"]])
self.load.hasDataChanged = mock.MagicMock(return_value=False)
self.model=mock.create_autospec(maxent_model.MaxEntModel,spec_set=True)
self.view=mock.create_autospec(maxent_view.MaxEntView,spec_set=True)
#signals
#needed for connect in presenter
self.view.maxEntButtonSignal=mock.Mock()
self.view.cancelSignal=mock.Mock()
self.view.phaseSignal=mock.Mock()
# functions
self.view.addItems=mock.MagicMock()
self.view.initMaxEntInput=mock.Mock(return_value={"InputWorkspace":"testWS","EvolChi":"out",
"ReconstructedData":"out2","ReconstructedImage":"out3","EvolAngle":"out4"})
self.view.deactivateCalculateButton=mock.Mock()
self.view.activateCalculateButton=mock.Mock()
self.view.usePhases = mock.Mock(return_value=False)
#set presenter
self.presenter=maxent_presenter.MaxEntPresenter(self.view,self.model,self.load)
# make thread
self.thread=mock.create_autospec(thread_model.ThreadModel)
self.thread.start=mock.Mock()
self.thread.started=mock.Mock()
self.thread.finished=mock.Mock()
self.thread.setInputs=mock.Mock()
self.thread.loadData=mock.Mock()
self.thread.threadWrapperSetup = mock.Mock()
self.thread.threadWrapperTearDown = mock.Mock()
def test_userfile_is_uploaded(self, mock_mod, mock_query, mock_ufile):
"""Test is_uploaded"""
mock_mod.return_value = True
result = mock.create_autospec(UserFile)
result.name = "1"
mock_ufile.return_value = result
api = mock.create_autospec(batchapps.api.BatchAppsApi)
ufile = UserFile(api, {'name':'1'})
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "Boom", None)
api.query_files.return_value = resp
with self.assertRaises(RestCallException):
ufile.is_uploaded()
resp.success = True
resp.result = ['1', '2', '3']
self.assertIsInstance(ufile.is_uploaded(), UserFile)
self.assertTrue(api.query_files.called)
self.assertTrue(mock_query.called)
self.assertEqual(mock_ufile.call_count, 3)
mock_ufile.assert_called_with(mock.ANY, '3')
result.name = "4"
self.assertIsNone(ufile.is_uploaded())
def test_engine_logger(self, mocked_application, mocked_adapter):
logger = ema_logging.get_logger()
mocked_logger = mock.Mock(spec=logger)
mocked_logger.handlers = []
mocked_logger.manager = mock.Mock(spec=logging.Manager)
mocked_logger.manager.disable = 0
ema_logging._logger = mocked_logger
mocked_application.instance.return_value = mocked_application
mocked_application.log = mocked_logger
# no handlers
ema.set_engine_logger()
logger = ema_logging._logger
# self.assertTrue(type(logger) == type(mocked_adapter))
mocked_logger.setLevel.assert_called_once_with(ema_logging.DEBUG)
mocked_adapter.assert_called_with(mocked_logger, ema.SUBTOPIC)
# with handlers
mocked_logger = mock.create_autospec(logging.Logger)
mock_engine_handler = mock.create_autospec(ipykernel.log.EnginePUBHandler)
mocked_logger.handlers = [mock_engine_handler]
mocked_application.instance.return_value = mocked_application
mocked_application.log = mocked_logger
ema.set_engine_logger()
logger = ema_logging._logger
# self.assertTrue(type(logger) == ema.EngingeLoggerAdapter)
mocked_logger.setLevel.assert_called_once_with(ema_logging.DEBUG)
mocked_adapter.assert_called_with(mocked_logger, ema.SUBTOPIC)
mock_engine_handler.setLevel.assert_called_once_with(ema_logging.DEBUG)
def test_create_autopsec(self):
mock = create_autospec(X)
instance = mock()
self.assertRaises(TypeError, instance)
mock = create_autospec(X())
self.assertRaises(TypeError, mock)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.randomizer_mock = create_autospec(Randomizer)
self.configuration = EvolutionConfiguration()
self.configuration.operators = EvolutionOperatorsConfiguration()
self.configuration.operators.inversion = EvolutionOperatorConfiguration()
self.configuration.operators.inversion.chance = 0.5
self.configuration.operators.mutation = EvolutionOperatorConfiguration()
self.configuration.operators.mutation.chance = 0.2
self.configuration.operators.crossover = EvolutionOperatorConfiguration()
self.configuration.operators.crossover.chance = 0.3
self.rule_population_mock = create_autospec(RulePopulation)
self.service_mock = create_autospec(EvolutionService)
self.service_mock.configure_mock(randomizer=self.randomizer_mock,
configuration=self.configuration)
self.rule_1 = Rule(Symbol('A'), Symbol('B'), Symbol('C'))
self.rule_2 = Rule(Symbol('D'), Symbol('E'), Symbol('F'))
self.sut = None
def test_spec_inheritance_for_classes(self):
class Foo(object):
__qualname__ = 'SpecSignatureTest.test_spec_inheritance_for_classes.<locals>.Foo'
def a(self):
pass
class Bar(object):
__qualname__ = 'SpecSignatureTest.test_spec_inheritance_for_classes.<locals>.Foo.Bar'
def f(self):
pass
class_mock = create_autospec(Foo)
self.assertIsNot(class_mock, class_mock())
for this_mock in (class_mock, class_mock()):
this_mock.a()
this_mock.a.assert_called_with()
self.assertRaises(TypeError, this_mock.a, 'foo')
self.assertRaises(AttributeError, getattr, this_mock, 'b')
instance_mock = create_autospec(Foo())
instance_mock.a()
instance_mock.a.assert_called_with()
self.assertRaises(TypeError, instance_mock.a, 'foo')
self.assertRaises(AttributeError, getattr, instance_mock, 'b')
self.assertRaises(TypeError, instance_mock)
instance_mock.Bar.f()
instance_mock.Bar.f.assert_called_with()
self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
instance_mock.Bar().f()
instance_mock.Bar().f.assert_called_with()
self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
def build_mock_player(position, pid):
player = create_autospec(Player)
pose = create_autospec(Pose)
pose.position = position
player.pose = pose
player.id = pid
return player
def test_synchronization_flow(self):
session = {
'id': self.session_id
}
queue_items = [{
'data': {
'id': 1,
},
'meta': {
'type': 'user',
'sync': {
'event_type': 'created',
'ack_key': 'User-1234-1',
'revision': 1
}
}
}]
client = mock.create_autospec(basecrm.Client)
sync_service = mock.create_autospec(basecrm.SyncService)
sync_service.start.return_value = session
sync_service.fetch.side_effect = [queue_items, []]
sync_service.ack.return_value = True
client.sync = sync_service
sync = basecrm.Sync(client, self.device_uuid)
sync.fetch(lambda meta, data: basecrm.Sync.ACK)
sync_service.start.assert_called_once_with(self.device_uuid)
sync_service.fetch.assert_has_calls([mock.call(self.device_uuid, self.session_id),
mock.call(self.device_uuid, self.session_id)])
sync_service.ack.assert_called_once_with(self.device_uuid, ['User-1234-1'])
def test_submittedjob_get_thumbnail(self, mock_prev):
"""Test get_thumbnail"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mock_prev.return_value = resp
api = mock.create_autospec(BatchAppsApi)
job = SubmittedJob(api, "abc", None, None)
with self.assertRaises(FileDownloadException):
job.get_thumbnail()
self.assertFalse(mock_prev.called)
job = SubmittedJob(api,
"abc",
None,
None,
previewLink={'href':'http://'})
with self.assertRaises(RestCallException):
job.get_thumbnail()
self.assertTrue(mock_prev.called)
resp.success = True
thumb = job.get_thumbnail(filename="thumb.png")
mock_prev.assert_called_with(tempfile.gettempdir(), "thumb.png", True)
thumb = job.get_thumbnail(download_dir="dir",
filename="thumb.png",
overwrite=False)
mock_prev.assert_called_with("dir", "thumb.png", False)
self.assertEqual(thumb, "dir\\thumb.png")
def mock_update(url, headers=None):
response = mock.create_autospec(Response)
response.request = mock.create_autospec(Request)
response.request.method = 'GET'
if url == ASYNC_URL:
response.request.url = url
response.status_code = POLLING_STATUS
response.content = ASYNC_BODY
response.randomFieldFromPollAsyncOpHeader = None
elif url == LOCATION_URL:
response.request.url = url
response.status_code = POLLING_STATUS
response.content = LOCATION_BODY
response.randomFieldFromPollLocationHeader = None
elif url == ERROR:
raise BadEndpointError("boom")
elif url == RESOURCE_URL:
response.request.url = url
response.status_code = POLLING_STATUS
response.content = RESOURCE_BODY
else:
raise Exception('URL does not match')
response.json = lambda: json.loads(response.content)
return response
def test_submittedjob_get_output(self, mock_final, mock_int):
"""Test get_output"""
_callback = mock.Mock()
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
mock_final.return_value = resp
mock_int.return_value = resp
job = SubmittedJob(api, "abc", None, None)
with self.assertRaises(FileDownloadException):
job.get_output("dir")
job = SubmittedJob(api, "abc", None, None,
outputLink={'href':'http://'},
outputFileName="filename")
with self.assertRaises(RestCallException):
output = job.get_output("dir")
mock_final.assert_called_with("dir", False, callback=None, block=4096)
self.assertFalse(mock_int.called)
resp.success = True
output = job.get_output("dir")
self.assertEqual(output, "dir\\filename")
mock_final.called = False
output = job.get_output("dir", output={'name':'test'}, overwrite=True, callback=_callback, block=1)
self.assertFalse(mock_final.called)
mock_int.assert_called_with({'name':'test'}, "dir", True, callback=_callback, block=1)
self.assertEqual(output, "dir\\test")
def test_submittedjob_get_final_preview(self):
"""Test _get_final_preview"""
_callback = mock.Mock()
resp = mock.create_autospec(Response)
api = mock.create_autospec(BatchAppsApi)
api.get_output.return_value = resp
job = SubmittedJob(api, None, None, None)
output = job._get_final_preview("dir", "name", True)
api.get_output.assert_called_with("dir", 0, "name", True, url=None, callback=None, block=4096)
self.assertEqual(output, resp)
job = SubmittedJob(api,
None,
None,
None,
previewLink={'href':'http://thumb'})
output = job._get_final_preview("dir", "name", False, callback=_callback, block=111)
api.get_output.assert_called_with("dir",
0,
"name",
False,
url='http://thumb',
callback=_callback,
block=111)
self.assertEqual(output, resp)
def test_jobsubmission_job_file(self):
"""Test set_job_file"""
jfile = mock.create_autospec(UserFile)
coll = mock.create_autospec(FileCollection)
api = mock.create_autospec(BatchAppsApi)
jfile.name = "test"
job = JobSubmission(api, "test_job")
with self.assertRaises(ValueError):
job.set_job_file(2)
with self.assertRaises(ValueError):
job.set_job_file(None)
with self.assertRaises(ValueError):
job.set_job_file("Something")
with self.assertRaises(ValueError):
job.set_job_file(jfile)
job.required_files = coll
job.set_job_file(jfile)
self.assertEqual(job.source, "test")
coll.add.assert_called_with(jfile)
coll.__len__.return_value = 1
job = JobSubmission(api, "test_job")
job.required_files = coll
job.set_job_file(0)
def test_filecoll_remove(self, mock_api):
"""Test remove"""
col = FileCollection(mock_api)
test_file = mock.create_autospec(UserFile)
test_file.name = "test"
col._collection = [test_file, 1, "2", None, []]
with self.assertRaises(TypeError):
col.remove(None)
with self.assertRaises(TypeError):
col.remove(10)
col.remove(1)
col.remove(-1)
col.remove(slice(1))
self.assertEqual(col._collection, ["2", None])
test_file2 = mock.create_autospec(UserFile)
test_file2.name = "test2"
test_file3 = mock.create_autospec(UserFile)
test_file3.name = "test3"
col._collection = [test_file, test_file2, test_file3]
col.remove("test")
self.assertEqual(col._collection, [test_file2, test_file3])
col.remove(["test2", "test3"])
self.assertEqual(col._collection, [])
def test_signature_callable(self):
class Callable(object):
def __init__(self):
pass
def __call__(self, a):
pass
mock = create_autospec(Callable)
mock()
mock.assert_called_once_with()
self.assertRaises(TypeError, mock, 'a')
instance = mock()
self.assertRaises(TypeError, instance)
instance(a='a')
instance.assert_called_once_with(a='a')
instance('a')
instance.assert_called_with('a')
mock = create_autospec(Callable())
mock(a='a')
mock.assert_called_once_with(a='a')
self.assertRaises(TypeError, mock)
mock('a')
mock.assert_called_with('a')
def test_filecoll_extend(self, mock_api):
"""Test extend"""
col = FileCollection(mock_api)
col2 = FileCollection(mock_api)
test_file = mock.create_autospec(UserFile)
test_file2 = mock.create_autospec(UserFile)
col._collection = [test_file]
col2._collection = [test_file2, test_file]
with self.assertRaises(AttributeError):
col.extend(None)
with self.assertRaises(AttributeError):
col.extend("test")
with self.assertRaises(AttributeError):
col.extend([])
col.extend(col2)
self.assertEqual(len(col._collection), 2)
self.assertTrue(all(i in [test_file, test_file2]
for i in col._collection))
col2.extend(col)
self.assertEqual(len(col._collection), 2)
self.assertTrue(all(i in [test_file, test_file2]
for i in col._collection))
def test_pool_update(self):
"""Test delete"""
api = mock.create_autospec(BatchAppsApi)
pool = Pool(api)
api.get_pool.return_value = mock.create_autospec(Response)
api.get_pool.return_value.success = True
api.get_pool.return_value.result = {
'targetDedicated':'5',
'currentDedicated':'4',
'state':'active',
'allocationState':'test',
}
self.assertEqual(pool.target_size, 0)
self.assertEqual(pool.current_size, 0)
self.assertEqual(pool.state, None)
self.assertEqual(pool.allocation_state, None)
self.assertEqual(pool.resize_error, '')
pool.update()
api.get_pool.assert_called_with(pool_id=None)
self.assertEqual(pool.target_size, 5)
self.assertEqual(pool.current_size, 4)
self.assertEqual(pool.state, 'active')
self.assertEqual(pool.allocation_state, 'test')
self.assertEqual(pool.resize_error, '')
api.get_pool.return_value.success = False
api.get_pool.return_value.result = RestCallException(None, "Test", None)
with self.assertRaises(RestCallException):
pool.update()
def test_step_and_run(self):
"""Test command execution."""
def do_nothing():
"""Empty function."""
self.control_unit.fetch_and_decode = create_autospec(do_nothing)
self.control_unit.load = create_autospec(do_nothing)
self.control_unit.execute = create_autospec(do_nothing)
self.control_unit.write_back = create_autospec(do_nothing)
self.control_unit.step()
self.control_unit.fetch_and_decode.assert_called_once_with()
self.control_unit.load.assert_called_once_with()
self.control_unit.execute.assert_called_once_with()
self.control_unit.write_back.assert_called_once_with()
self.control_unit.get_status = create_autospec(do_nothing)
self.control_unit.get_status.return_value = HALTED
self.control_unit.run()
self.control_unit.get_status.assert_called_with()
self.control_unit.fetch_and_decode.assert_called_once_with()
self.control_unit.load.assert_called_once_with()
self.control_unit.execute.assert_called_once_with()
self.control_unit.write_back.assert_called_once_with()
def test_count(self):
node1 = mock.create_autospec(PeerNode)
node2 = mock.create_autospec(PeerNode)
peer_list = PeerNodeList()
peer_list.add(node1)
peer_list.add(node2)
self.assertEqual(2, peer_list.count())
def test_init_no_services(self):
test_name = "test name"
mock_address = mock.create_autospec(Address)
mock_timestamp = mock.create_autospec(Timestamp)
node = PeerNode(test_name, mock_address, mock_timestamp)
self.assertEqual(test_name, node.name)
self.assertEqual(mock_address, node.address)
self.assertEqual(mock_timestamp, node.timestamp)
def timer():
histogram = mock.create_autospec(Histogram)
meter = mock.create_autospec(Meter)
timer = Timer('seconds')
timer.meter = meter
timer.histogram = histogram
return timer
def test_rest_client_put(self, mock_open, mock_call):
"""Test put"""
auth = mock.create_autospec(Credentials)
u_file = mock.create_autospec(UserFile)
u_file.name = "test.jpg"
u_file.path = "testfile"
def _callback(progress, data, total):
self.assertEqual(progress, 0.0)
self.assertIsInstance(progress, float)
self.assertIsInstance(data, int)
self.assertIsInstance(total, int)
with self.assertRaises(RestCallException):
rest_client.put(auth,
"http://test//{0}",
{"Content-Type": "application/json"},
u_file,
{})
with self.assertRaises(RestCallException):
rest_client.put(auth,
"http://test//{0}",
{"Content-Type": "application/json"},
u_file,
{'timestamp':'a', 'originalFilePath':'b'})
val = rest_client.put(auth,
"http://test//{name}",
{"Content-Type": "application/json"},
u_file,
{'timestamp':'a', 'originalFilePath':'b'},
callback=_callback,
block_size=1111)
mock_open.assert_called_with("testfile", 'rb')
mock_call.assert_called_with(auth, 'PUT', "http://test//test.jpg",
data=mock.ANY,
params={'timestamp':'a', 'originalFilePath':'b'},
headers={'Content-Type': 'application/octet-stream'})
self.assertIsNotNone(val)
mock_open.side_effect = OSError("test")
with self.assertRaises(RestCallException):
rest_client.put(auth,
"http://test//{name}",
{"Content-Type": "application/json"},
u_file,
{'timestamp':'a', 'originalFilePath':'b'})
mock_open.side_effect = None
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.put(auth,
"http://test//{name}",
{"Content-Type": "application/json"},
u_file,
{})
def test_get(self):
test_name = "hello"
mock_address = mock.create_autospec(Address)
mock_timestamp = mock.create_autospec(Timestamp)
node = PeerNode(test_name, mock_address, mock_timestamp)
peer_list = PeerNodeList()
peer_list.add(node)
self.assertEqual(node, peer_list.get(test_name))
self.assertRaises(PeerNodeNotFoundException, peer_list.get, "no name")
def setUp(self):
self._qapp = mock_widget.mockQapp()
self._view = mock.create_autospec(LoadView)
self._load_model = mock.create_autospec(LoadModel)
self._co_model = mock.create_autospec(CoLoadModel)
self.presenter = LoadPresenter(
self._view, self._load_model, self._co_model)
self.view = self.presenter.view
def create_mock_teams(allies, opponents):
team1 = create_autospec(Team)
team1.available_players = allies
GameState()._our_team = team1
print(GameState().our_team.available_players.values())
team2 = create_autospec(Team)
team2.available_players = opponents
GameState()._enemy_team = team2
class BehaviorsTest(behaviors.Behaviors):
"""Class to add dynamic values for tests"""
survive_egg = mk.create_autospec(survival.Egg, spec_set=True)
develop_egg = mk.create_autospec(development.Egg, spec_set=True)
def mock_games(mock_players, game_stats_service):
return mock.create_autospec(GameService(mock_players, game_stats_service))
def mock_context(loop):
return mock.create_autospec(ServerContext(lambda: None, loop))
def create_mock_beam_centre_tab():
view = mock.create_autospec(BeamCentre, spec_set=False)
return view
def create_mock_settings_diagnostic_tab():
view = mock.create_autospec(SettingsDiagnosticTab, spec_set=False)
view.get_current_row = mock.MagicMock(return_value=3)
return view
def setUp(self):
self.filter = JivagoBannerFilter()
self.filter_chain_mock: FilterChain = mock.create_autospec(FilterChain)
def create_mock_view(user_file_path,
batch_file_path=None,
row_user_file_path=""):
get_cell_mock_with_path = partial(get_cell_mock,
user_file_path=row_user_file_path)
view = mock.create_autospec(SANSDataProcessorGui, spec_set=False)
view.get_user_file_path = mock.Mock(return_value=user_file_path)
view.get_cell = mock.MagicMock(side_effect=get_cell_mock_with_path)
view.get_batch_file_path = mock.MagicMock(return_value=batch_file_path)
view.get_number_of_rows = mock.MagicMock(return_value=2)
# Add the settings diagnostic mock
settings_diagnostic_tab = create_mock_settings_diagnostic_tab()
view.settings_diagnostic_tab = settings_diagnostic_tab
# Add the masking table view
masking_table = create_mock_masking_table()
view.masking_table = masking_table
# Add the beam centre view
beam_centre = create_mock_beam_centre_tab()
view.beam_centre = beam_centre
# Add the data diagnostic tab
diagnostic_page = create_mock_diagnostics_tab()
view.diagnostic_page = diagnostic_page
view.halt_process_flag = mock.MagicMock()
# ---------------------
# Mocking properties
# ---------------------
_event_slices = mock.PropertyMock(return_value="")
type(view).event_slices = _event_slices
_merge_scale = mock.PropertyMock(return_value=1.)
type(view).merge_scale = _merge_scale
_merge_shift = mock.PropertyMock(return_value=0.)
type(view).merge_shift = _merge_shift
_merge_q_range_start = mock.PropertyMock(return_value=None)
type(view).merge_q_range_start = _merge_q_range_start
_merge_q_range_stop = mock.PropertyMock(return_value=None)
type(view).merge_q_range_stop = _merge_q_range_stop
_merge_q_range_stop = mock.PropertyMock(return_value=None)
type(view).merge_q_range_stop = _merge_q_range_stop
_merge_min = mock.PropertyMock(return_value=None)
type(view).merge_min = _merge_min
_merge_max = mock.PropertyMock(return_value=None)
type(view).merge_max = _merge_max
_sample_height = mock.PropertyMock(return_value=None)
type(view).sample_height = _sample_height
_sample_width = mock.PropertyMock(return_value=None)
type(view).sample_width = _sample_width
_sample_thickness = mock.PropertyMock(return_value=None)
type(view).sample_thickness = _sample_thickness
_sample_shape = mock.PropertyMock(return_value=None)
type(view).sample_shape = _sample_shape
_pixel_adjustment_det_1 = mock.PropertyMock(return_value="")
type(view).pixel_adjustment_det_1 = _pixel_adjustment_det_1
_pixel_adjustment_det_2 = mock.PropertyMock(return_value="")
type(view).pixel_adjustment_det_2 = _pixel_adjustment_det_2
_wavelength_adjustment_det_1 = mock.PropertyMock(return_value="")
type(view).wavelength_adjustment_det_1 = _wavelength_adjustment_det_1
_wavelength_adjustment_det_2 = mock.PropertyMock(return_value="")
type(view).wavelength_adjustment_det_2 = _wavelength_adjustment_det_2
_gravity_extra_length = mock.PropertyMock(return_value=None)
type(view).gravity_extra_length = _gravity_extra_length
_q_resolution_source_h = mock.PropertyMock(return_value=None)
type(view).q_resolution_source_h = _q_resolution_source_h
_q_resolution_sample_h = mock.PropertyMock(return_value=None)
type(view).q_resolution_sample_h = _q_resolution_sample_h
_q_resolution_source_w = mock.PropertyMock(return_value=None)
type(view).q_resolution_source_w = _q_resolution_source_w
_q_resolution_sample_w = mock.PropertyMock(return_value=None)
type(view).q_resolution_sample_w = _q_resolution_sample_w
_phi_limit_min = mock.PropertyMock(return_value=None)
type(view).phi_limit_min = _phi_limit_min
_phi_limit_max = mock.PropertyMock(return_value=None)
type(view).phi_limit_max = _phi_limit_max
_phi_limit_max = mock.PropertyMock(return_value=None)
type(view).phi_limit_max = _phi_limit_max
_q_1d_step = mock.PropertyMock(return_value=.001)
type(view).q_1d_step = _q_1d_step
_q_1d_step_type = mock.PropertyMock(return_value=RangeStepType.Lin)
type(view)._q_1d_step_type = _q_1d_step_type
_output_mode = mock.PropertyMock(return_value=OutputMode.PublishToADS)
type(view).output_mode = _output_mode
_wavelength_range = mock.PropertyMock(return_value='')
type(view).wavelength_range = _wavelength_range
_instrument = mock.PropertyMock(return_value=SANSInstrument.SANS2D)
type(view).instrument = _instrument
return view, settings_diagnostic_tab, masking_table
def mock_logger():
return mock.create_autospec(logger)
def test_no_default_attributes_in_init(self):
sm = create_autospec(SimConnect.SimConnect)
pl = SimConnect.Plane(sm=sm, add_default=False)
with self.assertRaises(AttributeError):
pl.altitude
def mock_gcs():
m = mock.create_autospec(WebDelegatingSubject)
m.check_permission.side_effect = ValueError
def test_setup(self):
"""test setup an initial adult"""
self.simulation.behaviors = mk.create_autospec(BehaviorsTest,
spec_set=True)
self.simulation.behaviors.survive_adult = self.survival
self.simulation.behaviors.move_adult = self.movement
self.simulation.behaviors.lay = self.lay
self.simulation.behaviors.mate = self.mating
self.simulation.space = mk.create_autospec(space.Space, spec_set=True)
self.simulation.models = mk.create_autospec(models.Models,
spec_set=True)
unique_id_num = mk.MagicMock(spec=int)
initial_key = mk.MagicMock(spec=str)
with mk.patch.object(adult.Adult, '_set_sex', autospec=True) as mkSex:
# Test regular
self.Adult = adult.Adult.setup(unique_id_num, initial_key,
self.simulation, self.genotype,
self.mate)
self.assertIsInstance(self.Adult, agent.Agent)
self.assertIsInstance(self.Adult, insect.Insect)
self.assertIsInstance(self.Adult, adult.Adult)
self.assertEqual(
self.Adult.unique_id,
str(initial_key) + str(unique_id_num) + keyword.adult)
self.assertEqual(self.Adult.location,
self.simulation.space.new_location.return_value)
self.assertEqual(self.simulation.space.new_location.call_args_list,
[mk.call(keyword.adult_depth)])
self.assertEqual(
self.Adult.mass,
self.simulation.models.__getitem__.return_value.return_value)
self.assertEqual(
self.simulation.models.__getitem__.return_value.call_args_list,
[mk.call(self.genotype)])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[mk.call(keyword.init_mature)])
self.assertEqual(self.Adult.agent_key, '')
self.assertEqual(self.Adult.alive, True)
self.assertEqual(self.Adult.age, 0)
self.assertEqual(self.Adult.death, keyword.alive)
self.assertEqual(self.Adult.num_eggs, 0)
self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)])
self.assertEqual(self.Adult.simulation, self.simulation)
self.assertEqual(self.Adult.genotype, self.genotype)
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.survival, self.survival)
self.assertEqual(self.Adult.movement, self.movement)
self.assertEqual(self.Adult.lay, self.lay)
self.assertEqual(self.Adult.mating, self.mating)
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._age_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._age_count),
next(i_tools.count(1)))
self.assertTrue(dclass.is_dataclass(self.Adult))
mkSex.reset_mock()
self.simulation.space.reset_mock()
self.simulation.models.reset_mock()
# Test no mate
self.Adult = adult.Adult.setup(unique_id_num, initial_key,
self.simulation, self.genotype,
self.mate)
self.assertIsInstance(self.Adult, agent.Agent)
self.assertIsInstance(self.Adult, insect.Insect)
self.assertIsInstance(self.Adult, adult.Adult)
self.assertEqual(
self.Adult.unique_id,
str(initial_key) + str(unique_id_num) + keyword.adult)
self.assertEqual(self.Adult.location,
self.simulation.space.new_location.return_value)
self.assertEqual(self.simulation.space.new_location.call_args_list,
[mk.call(keyword.adult_depth)])
self.assertEqual(
self.Adult.mass,
self.simulation.models.__getitem__.return_value.return_value)
self.assertEqual(
self.simulation.models.__getitem__.return_value.call_args_list,
[mk.call(self.genotype)])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[mk.call(keyword.init_mature)])
self.assertEqual(self.Adult.agent_key, '')
self.assertEqual(self.Adult.alive, True)
self.assertEqual(self.Adult.age, 0)
self.assertEqual(self.Adult.death, keyword.alive)
self.assertEqual(self.Adult.num_eggs, 0)
self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)])
self.assertEqual(self.Adult.simulation, self.simulation)
self.assertEqual(self.Adult.genotype, self.genotype)
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.survival, self.survival)
self.assertEqual(self.Adult.movement, self.movement)
self.assertEqual(self.Adult.lay, self.lay)
self.assertEqual(self.Adult.mating, self.mating)
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._age_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._age_count),
next(i_tools.count(1)))
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._id_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._id_count), next(i_tools.count()))
self.assertTrue(dclass.is_dataclass(self.Adult))
def test_initialize(self):
"""test initialize the agent"""
self.simulation.behaviors = mk.create_autospec(BehaviorsTest,
spec_set=True)
self.simulation.behaviors.survive_adult = self.survival
self.simulation.behaviors.move_adult = self.movement
self.simulation.behaviors.lay = self.lay
self.simulation.behaviors.mate = self.mating
with mk.patch.object(adult.Adult, '_set_sex', autospec=True) as mkSex:
# Test regular
self.Adult = adult.Adult.initialize(self.unique_id,
self.simulation, self.location,
self.mass, self.genotype,
self.mate)
self.assertIsInstance(self.Adult, agent.Agent)
self.assertIsInstance(self.Adult, insect.Insect)
self.assertIsInstance(self.Adult, adult.Adult)
self.assertEqual(self.Adult.agent_key, '')
self.assertEqual(self.Adult.alive, True)
self.assertEqual(self.Adult.age, 0)
self.assertEqual(self.Adult.death, keyword.alive)
self.assertEqual(self.Adult.num_eggs, 0)
self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)])
self.assertEqual(self.Adult.unique_id, self.unique_id)
self.assertEqual(self.Adult.simulation, self.simulation)
self.assertEqual(self.Adult.location, self.location)
self.assertEqual(self.Adult.mass, self.mass)
self.assertEqual(self.Adult.genotype, self.genotype)
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.survival, self.survival)
self.assertEqual(self.Adult.movement, self.movement)
self.assertEqual(self.Adult.lay, self.lay)
self.assertEqual(self.Adult.mating, self.mating)
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._age_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._age_count),
next(i_tools.count(1)))
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._id_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._id_count), next(i_tools.count()))
self.assertTrue(dclass.is_dataclass(self.Adult))
mkSex.reset_mock()
# Test no mate
self.Adult = adult.Adult.initialize(self.unique_id,
self.simulation, self.location,
self.mass, self.genotype)
self.assertIsInstance(self.Adult, agent.Agent)
self.assertIsInstance(self.Adult, insect.Insect)
self.assertIsInstance(self.Adult, adult.Adult)
self.assertEqual(self.Adult.agent_key, '')
self.assertEqual(self.Adult.alive, True)
self.assertEqual(self.Adult.age, 0)
self.assertEqual(self.Adult.death, keyword.alive)
self.assertEqual(self.Adult.num_eggs, 0)
self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)])
self.assertEqual(self.Adult.unique_id, self.unique_id)
self.assertEqual(self.Adult.simulation, self.simulation)
self.assertEqual(self.Adult.location, self.location)
self.assertEqual(self.Adult.mass, self.mass)
self.assertEqual(self.Adult.genotype, self.genotype)
self.assertEqual(self.Adult.mate, None)
self.assertEqual(self.Adult.survival, self.survival)
self.assertEqual(self.Adult.movement, self.movement)
self.assertEqual(self.Adult.lay, self.lay)
self.assertEqual(self.Adult.mating, self.mating)
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._age_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._age_count),
next(i_tools.count(1)))
# noinspection PyTypeChecker
self.assertIsInstance(self.Adult._id_count, i_tools.count)
# noinspection PyTypeChecker
self.assertEqual(next(self.Adult._id_count), next(i_tools.count()))
self.assertTrue(dclass.is_dataclass(self.Adult))
def make_view(self):
controller = mock.create_autospec(spec=FilesystemController)
return GuidedFilesystemView(controller)
def test_rest_client_download(self, mock_open, mock_call, mock_path):
"""Test download"""
def _callback(progress, data, total):
self.assertEqual(progress, 0.0)
self.assertIsInstance(progress, float)
self.assertIsInstance(data, int)
self.assertIsInstance(total, int)
auth = mock.create_autospec(Credentials)
mock_path.return_value = True
val = rest_client.download(auth,
"http://host//something//test?a=b", {},
"c:\\test",
10,
False,
block_size=12345,
callback=_callback)
self.assertFalse(mock_call.called)
self.assertTrue(val)
val = rest_client.download(auth,
"http://host//something//test?a=b", {},
"c:\\test",
0,
True,
callback=_callback)
mock_call.assert_called_with(auth,
'GET',
"http://host//something//test?a=b",
headers={},
stream=True)
mock_path.return_value = False
val = rest_client.download(auth,
"http://host//something//test?a=b", {},
"c:\\test",
500,
False,
ext=".jpg",
callback=_callback)
mock_call.assert_called_with(auth,
'GET',
"http://host//something//test?a=b",
headers={},
stream=True)
mock_open.assert_called_with("c:\\test\\test.jpg", "wb")
val = rest_client.download(auth,
"http://host//something//test?a=b", {},
"c:\\test",
500,
False,
ext=".jpg",
f_name="another.png")
mock_call.assert_called_with(auth,
'GET',
"http://host//something//test?a=b",
headers={},
stream=True)
mock_open.assert_called_with("c:\\test\\another.png", "wb")
mock_open.side_effect = IOError('oops!')
with self.assertRaises(RestCallException):
rest_client.download(auth, "http://host//something//test?a=b", {},
"c:\\test", 0, True)
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.download(auth, "http://host//something//test?a=b", {},
"c:\\test", 0, True)
def socket_spec():
spec = create_autospec(zmq.Socket, instance=True)
spec.FD = 2
return spec
def setUp(self):
super().setUp()
self.naming = mock.create_autospec(naming.Naming)
def create_mock_diagnostics_tab():
view = mock.create_autospec(DiagnosticsPage, spec_set=False)
return view
def model():
return create_autospec(Model)
def create_mock_masking_table():
view = mock.create_autospec(MaskingTable, spec_set=False)
view.get_current_row = mock.MagicMock(return_value=3)
return view
def setUp(self):
self.mock_stdin = create_autospec(sys.stdin)
self.mock_stdout = create_autospec(sys.stdout)
def mock_protocol():
return mock.create_autospec(QDataStreamProtocol(mock.Mock(), mock.Mock()))
def setup(self):
self.mock_client = mock.create_autospec(api.Client)
self.lcp_crud = crud.LCPCrud(self.mock_client)
def mock_players(mock_db_pool):
return mock.create_autospec(PlayerService(mock_db_pool))
def setUp(self):
self.message_dispatcher: MessageDispatcher = mock.create_autospec(
MessageDispatcher)
self.message_bus = SynchronousEventBus([self.message_dispatcher])
self.message_dispatcher.can_handle.return_value = True
def mock_player():
return mock.create_autospec(Player(login='******', id=42))
def setUp(self):
self.view = mock.create_autospec(view.FocusView)
self.model = mock.create_autospec(model.FocusModel)
self.presenter = presenter.FocusPresenter(self.model, self.view)
self.presenter.current_calibration.set_roi_info(None, None, None)
def setUp(self):
self.site_adapter = create_autospec(SiteAdapter)
self.site_agent = SiteAgent(self.site_adapter)
# Switch data to mock MAC address table
SWITCH_DATA = """
Flow Link Back Mdix
Port Type Duplex Speed Neg ctrl State Pressure Mode
-------- ------------ ------ ----- -------- ---- ----------- -------- -------
gi1/0/1 1G-Copper -- -- -- -- Down -- --
gi1/0/2 1G-Copper Full 1000 Enabled Off Up Disabled Off
gi1/0/3 1G-Copper Full 1000 Enabled Off Up Disabled On
te1/0/1 10G-Fiber -- -- -- -- Down -- --
console#:
"""
# Intercept expectmore calls
mock_expectmore = patch(target="stack.switch.x1052.ExpectMore",
autospec=True).start()
# Need to set the instance mock returned from calling ExpectMore()
mock_expectmore.return_value = create_autospec(
spec=ExpectMore,
spec_set=True,
instance=True,
)
# Need to set the match_index to the base console prompt so that the switch thinks it is at the
# correct prompt, and wont try to page through output.
type(mock_expectmore.return_value).match_index = PropertyMock(
return_value=SwitchDellX1052.CONSOLE_PROMPTS.index(
SwitchDellX1052.CONSOLE_PROMPT))
# Return our SWITCH_DATA from ExpectMore().ask()
mock_expectmore.return_value.ask.return_value = SWITCH_DATA.splitlines()
def test_reset(self):
"""test reset the mock"""
self.simulation.models = \
mk.create_autospec(models.Models, spec_set=True)
self.simulation.models.__getitem__.side_effect = [True, False]
with mk.patch.object(adult.Adult, 'transition',
autospec=True) as mkTransition:
# Not female or mated
self.assertEqual(self.Adult.reset(), [])
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.num_eggs, self.num_eggs)
self.assertEqual(self.lay.reset.call_args_list, [])
self.assertEqual(mkTransition.call_args_list, [])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[])
# Is female
self.Adult.agent_key = keyword.female
# Female lifetime mate
self.assertEqual(self.Adult.reset(), [])
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.num_eggs, self.lay.reset.return_value)
self.assertEqual(self.lay.reset.call_args_list,
[mk.call(self.Adult)])
self.assertEqual(mkTransition.call_args_list, [])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[mk.call(keyword.lifetime_female)])
# Not female lifetime mate
self.Adult.num_eggs = self.num_eggs
self.simulation.models.reset_mock()
self.lay.reset_mock()
self.assertEqual(self.Adult.reset(), [])
self.assertEqual(self.Adult.mate, None)
self.assertEqual(self.Adult.num_eggs, self.lay.reset.return_value)
self.assertEqual(self.lay.reset.call_args_list,
[mk.call(self.Adult)])
self.assertEqual(mkTransition.call_args_list, [])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[mk.call(keyword.lifetime_female)])
self.Adult.num_eggs = self.num_eggs
self.Adult.mate = self.mate
self.simulation.models.reset_mock()
self.lay.reset_mock()
# Is mated and not alive
self.Adult.alive = False
self.Adult.agent_key = keyword.mated
self.assertEqual(self.Adult.reset(), [])
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.num_eggs, self.num_eggs)
self.assertEqual(self.lay.reset.call_args_list, [])
self.assertEqual(mkTransition.call_args_list, [])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[])
# Is mated and alive
self.Adult.alive = True
self.Adult.agent_key = keyword.mated
self.assertEqual(self.Adult.reset(), [])
self.assertEqual(self.Adult.mate, self.mate)
self.assertEqual(self.Adult.num_eggs, self.num_eggs)
self.assertEqual(self.lay.reset.call_args_list, [])
self.assertEqual(mkTransition.call_args_list,
[mk.call(self.Adult, keyword.male)])
self.assertEqual(self.simulation.models.__getitem__.call_args_list,
[])
def annotation_delete_service(pyramid_config):
service = mock.create_autospec(AnnotationDeleteService,
spec_set=True,
instance=True)
pyramid_config.register_service(service, name="annotation_delete")
return service
