def test_change_axis(self):
view_x_label_mock = PropertyMock()
view_y_label_mock = PropertyMock()
model_x_label_mock = PropertyMock(return_value='x0')
model_y_label_mock = PropertyMock(return_value='y0')
type(self.view).x_label = view_x_label_mock
type(self.view).y_label = view_y_label_mock
type(self.model).x_label = model_x_label_mock
type(self.model).y_label = model_y_label_mock
# labels passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_x_label_mock.assert_called_once_with()
model_y_label_mock.assert_called_once_with()
view_x_label_mock.assert_called_once_with('x0')
view_y_label_mock.assert_called_once_with('y0')
# labels passed view -> model
model_x_label_mock.reset_mock()
model_y_label_mock.reset_mock()
view_x_label_mock.reset_mock()
view_y_label_mock.reset_mock()
view_x_label_mock.return_value = 'x1'
view_y_label_mock.return_value = 'y1'
self.presenter._value_modified('x_label')
self.presenter._value_modified('y_label')
self.presenter.get_new_config()
view_x_label_mock.assert_called_once_with()
view_y_label_mock.assert_called_once_with()
model_x_label_mock.assert_called_once_with('x1')
model_y_label_mock.assert_called_once_with('y1')
def test_change_xy_log(self):
view_x_log_mock = PropertyMock()
view_y_log_mock = PropertyMock()
model_x_log_mock = PropertyMock(return_value=True)
model_y_log_mock = PropertyMock(return_value=False)
model_x_range_mock = PropertyMock(return_value=(1, 2))
model_y_range_mock = PropertyMock(return_value=(3, 4))
type(self.view).x_log = view_x_log_mock
type(self.view).y_log = view_y_log_mock
type(self.model).x_log = model_x_log_mock
type(self.model).y_log = model_y_log_mock
type(self.model).x_range = model_x_range_mock
type(self.model).y_range = model_y_range_mock
# model -> view
self.presenter = CutPlotOptionsPresenter(self.view, self.model)
view_x_log_mock.assert_called_once_with(True)
view_y_log_mock.assert_called_once_with(False)
# view -> model
view_x_log_mock.return_value = False
view_y_log_mock.return_value = True
self.presenter._xy_config_modified('x_log')
self.presenter._xy_config_modified('y_log')
self.presenter.get_new_config()
self.model.change_axis_scale.assert_called_once_with({'x_range': (1, 2), 'y_range': (3, 4), 'modified': True,
'x_log': False, 'y_log': True})
def test_generate_plan_with_persist_no_lock_req(
self, mock_stack_action: PropertyMock,
mock_tags: PropertyMock) -> None:
"""Test generate plan with persist no lock req."""
mock_stack_action.return_value = MagicMock()
mock_tags.return_value = {}
context = mock_context(namespace="test",
extra_config_args=self.config_persist,
region=self.region)
persist_step = Step.from_stack_name("removed", context)
context._persistent_graph = Graph.from_steps([persist_step])
action = BaseAction(
context=context,
provider_builder=MockProviderBuilder(provider=self.provider,
region=self.region),
)
plan = action._generate_plan(include_persistent_graph=True,
require_unlocked=False)
self.assertIsInstance(plan, Plan)
mock_tags.assert_called_once()
# order is different between python2/3 so can't compare dicts
result_graph_dict = plan.graph.to_dict()
self.assertEqual(3, len(result_graph_dict))
self.assertEqual(set(), result_graph_dict["stack1"])
self.assertEqual(set(["stack1"]), result_graph_dict["stack2"])
self.assertEqual(set(), result_graph_dict["removed"])
self.assertEqual(BaseAction.DESCRIPTION, plan.description)
self.assertFalse(plan.require_unlocked)
def test_change_grid(self):
view_x_grid_mock = PropertyMock()
view_y_grid_mock = PropertyMock()
model_x_grid_mock = PropertyMock(return_value=False)
model_y_grid_mock = PropertyMock(return_value=False)
type(self.view).x_grid = view_x_grid_mock
type(self.view).y_grid = view_y_grid_mock
type(self.model).x_grid = model_x_grid_mock
type(self.model).y_grid = model_y_grid_mock
# labels passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_x_grid_mock.assert_called_once_with()
model_y_grid_mock.assert_called_once_with()
view_x_grid_mock.assert_called_once_with(False)
view_y_grid_mock.assert_called_once_with(False)
# labels passed view -> model
model_x_grid_mock.reset_mock()
model_y_grid_mock.reset_mock()
view_x_grid_mock.reset_mock()
view_y_grid_mock.reset_mock()
view_x_grid_mock.return_value = True
view_y_grid_mock.return_value = True
self.presenter._value_modified('x_grid')
self.presenter._value_modified('y_grid')
self.presenter.get_new_config()
view_x_grid_mock.assert_called_once_with()
view_y_grid_mock.assert_called_once_with()
model_x_grid_mock.assert_called_once_with(True)
model_y_grid_mock.assert_called_once_with(True)
def __MakeAppApiMock(self) -> MagicMock:
"""非公式pixivAPIの詳細操作機能のモックを作成する
Note:
以下のプロパティ、メソッドを模倣する
aapi_response
access_token
novel_detail(novel_id)
※self.__ReturnNovelDetail参照
novel_text(novel_id)
※self.__ReturnNovelText参照
Returns:
MagicMock: aapi_response
"""
aapi_response = MagicMock()
type(aapi_response).access_token = "ok"
p_novel_detail = PropertyMock()
p_novel_detail.return_value = self.__ReturnNovelDetail
type(aapi_response).novel_detail = p_novel_detail
p_novel_text = PropertyMock()
p_novel_text.return_value = self.__ReturnNovelText
type(aapi_response).novel_text = p_novel_text
return aapi_response
def test_PostTweet(self):
# ツイートポスト機能をチェックする
crawler = PictureGathering_fav.Crawler()
with ExitStack() as stack:
# with句にpatchを複数入れる
mockctapi = stack.enter_context(patch('PictureGathering_fav.Crawler.TwitterAPIRequest'))
mockoauth = stack.enter_context(patch('requests_oauthlib.OAuth1Session.post'))
mocksql = stack.enter_context(patch('DBControlar.DBControlar.DBDelInsert'))
# mock設定
mockctapi.return_value = {"id_str": "12345_id_str_sample"}
responce = MagicMock()
status_code = PropertyMock()
status_code.return_value = 200
type(responce).status_code = status_code
text = PropertyMock()
text.return_value = f'{{"text": "sample"}}'
type(responce).text = text
mockoauth.return_value = responce
mocksql.return_value = 0
self.assertEqual(0, crawler.PostTweet("test"))
mockctapi.assert_called_once()
mockoauth.assert_called_once()
mocksql.assert_called_once()
def __MakeAppApiMock(self) -> MagicMock:
"""非公式pixivAPIの詳細操作機能のモックを作成する
Note:
以下のプロパティ、メソッドを模倣する
aapi_response
access_token
download(url, path, name="")
illust_detail(illust_id)
※self.__ReturnIllustDetail参照
ugoira_metadata(illust_id)
ugoira_metadata
frames[]
Returns:
MagicMock: aapi_response
"""
aapi_response = MagicMock()
type(aapi_response).access_token = "ok"
def ReturnDownload(url, path, name=""):
if name == "":
name = Path(url).name
# ダミーファイルをダウンロードしたことにしてpathに生成する
with (Path(path) / name).open("wb") as fout:
fout.write(url.encode())
# DLには多少時間がかかる想定
sleep(0.01)
p_download = PropertyMock()
p_download.return_value = ReturnDownload
type(aapi_response).download = p_download
p_illust_detail = PropertyMock()
p_illust_detail.return_value = self.__ReturnIllustDetail
type(aapi_response).illust_detail = p_illust_detail
def ReturnUgoiraMetadata(illust_id):
s = {}
if 0 < illust_id and illust_id < 99999999:
s = self.__GetIllustData(illust_id)
frames_len = len(s["image_urls"])
DEFAULT_DELAY = 30
frames = [{"delay": DEFAULT_DELAY} for i in range(frames_len)]
r_frames = MagicMock()
type(r_frames).frames = frames
r_ugoira_metadata2 = MagicMock()
type(r_ugoira_metadata2).ugoira_metadata = r_frames
return r_ugoira_metadata2
p_ugoira_metadata = PropertyMock()
p_ugoira_metadata.return_value = ReturnUgoiraMetadata
type(aapi_response).ugoira_metadata = p_ugoira_metadata
return aapi_response
def test_change_colorbar_config(self):
view_colorbar_range_mock = PropertyMock()
view_colorbar_log_mock = PropertyMock()
type(self.view).colorbar_range = view_colorbar_range_mock
type(self.view).colorbar_log = view_colorbar_log_mock
model_colorbar_range_mock = PropertyMock(return_value=(1, 5))
model_colorbar_log_mock = PropertyMock(return_value=False)
type(self.model).colorbar_range = model_colorbar_range_mock
type(self.model).colorbar_log = model_colorbar_log_mock
# passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_colorbar_range_mock.assert_called_with()
model_colorbar_log_mock.assert_called_with()
view_colorbar_range_mock.assert_called_once_with((1, 5))
view_colorbar_log_mock.assert_called_once_with(False)
# passed view -> model
view_colorbar_range_mock.return_value = (2, 10)
view_colorbar_log_mock.return_value = True
self.presenter._set_c_range()
self.presenter._set_colorbar_log()
self.presenter.get_new_config()
self.model.change_axis_scale.assert_called_once_with((2, 10), True)
def test_generate_plan_no_persist_include(self,
mock_stack_action: PropertyMock,
mock_tags: PropertyMock) -> None:
"""Test generate plan no persist include."""
mock_stack_action.return_value = MagicMock()
mock_tags.return_value = {}
context = mock_context(
namespace="test",
extra_config_args=self.config_no_persist,
region=self.region,
)
action = BaseAction(
context=context,
provider_builder=MockProviderBuilder(provider=self.provider,
region=self.region),
)
plan = action._generate_plan(include_persistent_graph=True)
mock_tags.assert_not_called()
self.assertIsInstance(plan, Plan)
# order is different between python2/3 so can't compare dicts
result_graph_dict = plan.graph.to_dict()
self.assertEqual(2, len(result_graph_dict))
self.assertEqual(set(), result_graph_dict["stack1"])
self.assertEqual(set(["stack1"]), result_graph_dict["stack2"])
self.assertEqual(BaseAction.DESCRIPTION, plan.description)
self.assertTrue(plan.require_unlocked)
def test_change_xrange(self):
view_x_range_mock = PropertyMock()
type(self.view).x_range = view_x_range_mock
model_x_range_mock = PropertyMock(return_value=(1, 5))
type(self.model).x_range = model_x_range_mock
# passed model -> view
self.presenter1 = SlicePlotOptionsPresenter(self.view, self.model)
model_x_range_mock.assert_called_with()
view_x_range_mock.assert_called_once_with((1, 5))
# passed view -> model through slice presenter
model_x_range_mock.reset_mock()
view_x_range_mock.return_value = (2, 10)
self.presenter1._xy_config_modified('x_range')
self.presenter1.get_new_config()
model_x_range_mock.assert_called_once_with((2, 10))
# passed view -> model through cut presenter
self.presenter2 = CutPlotOptionsPresenter(self.view, self.model)
self.presenter2._xy_config_modified('x_range')
self.presenter2.get_new_config()
self.model.change_axis_scale.assert_called_once()
def test_generate_plan_persist_destroy(
self, mock_graph_tags: PropertyMock) -> None:
"""Test generate plan persist destroy."""
mock_graph_tags.return_value = {}
context = self._get_context(
extra_config_args={"persistent_graph_key": "test.json"})
context._persistent_graph = Graph.from_steps(
[Step.from_stack_name("removed", context)])
deploy_action = deploy.Action(context=context)
plan = cast(Plan,
deploy_action._Action__generate_plan()) # type: ignore
self.assertIsInstance(plan, Plan)
self.assertEqual(deploy.Action.DESCRIPTION, plan.description)
mock_graph_tags.assert_called_once()
# order is different between python2/3 so can't compare dicts
result_graph_dict = plan.graph.to_dict()
self.assertEqual(5, len(result_graph_dict))
self.assertEqual(set(), result_graph_dict["other"])
self.assertEqual(set(), result_graph_dict["removed"])
self.assertEqual(set(), result_graph_dict["vpc"])
self.assertEqual(set(["vpc"]), result_graph_dict["bastion"])
self.assertEqual(set(["bastion", "vpc"]), result_graph_dict["db"])
self.assertEqual(deploy_action._destroy_stack,
plan.graph.steps["removed"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["vpc"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["bastion"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["db"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["other"].fn)
def __ReturnNovelText(self, novel_id) -> MagicMock:
"""非公式pixivAPIの全体操作機能のモックを作成する
Note:
以下のプロパティ、メソッドを模倣する
novel_text
novel_text
error
Returns:
MagicMock: novel_text_response
"""
novel_text_response = MagicMock()
s = {}
if 0 < novel_id and novel_id < 99999999:
s = self.__GetNovelData(novel_id)
type(novel_text_response).error = None
else:
type(novel_text_response).error = "error"
type(novel_text_response).novel = None
return novel_text_response
p_response = PropertyMock()
p_response.return_value = s["text"]
type(novel_text_response).novel_text = p_response
return novel_text_response
def test_follow_redirects(self):
finder = URLFinder()
mock_response = MagicMock()
mock_response_url = PropertyMock()
type(mock_response).url = mock_response_url
with patch("requests.get", MagicMock(return_value=mock_response)) as mock_get:
# A request is sent to the URL. If there was a redirect return the
# final URL.
mock_response_url.return_value = "http://finalurl.com"
self.assertEquals(
finder.follow_redirects("http://redirects.to"),
"http://finalurl.com",
)
self.assertEquals(mock_get.call_count, 1)
self.assertEquals(mock_response_url.call_count, 1)
# If there was no redirect return the original URL.
self.assertEquals(
finder.follow_redirects("http://finalurl.com"),
"http://finalurl.com",
)
self.assertEquals(mock_get.call_count, 2)
self.assertEquals(mock_response_url.call_count, 2)
with patch("requests.get", MagicMock(side_effect=requests.RequestException)) as mock_get:
# If request failed return None
self.assertEquals(
finder.follow_redirects("http://redirects.to"),
None,
)
self.assertEquals(mock_get.call_count, 1)
def test_load_one_workspace(self, get_ws_handle_mock, load_mock, process_limits):
# Create a view that will return a path on call to get_workspace_to_load_path
tempdir = gettempdir() # To ensure sample paths are valid on platform of execution
path_to_nexus = join(tempdir, 'cde.nxs')
workspace_name = 'cde'
self.view.get_workspace_efixed = mock.Mock(return_value=(1.845, False))
ws_mock = mock.Mock(spec=Workspace)
get_ws_handle_mock.return_value = ws_mock
e_fixed = PropertyMock()
e_mode = PropertyMock(return_value="Indirect")
ef_defined = PropertyMock(return_value=False)
type(ws_mock).e_fixed = e_fixed
type(ws_mock).e_mode = e_mode
type(ws_mock).ef_defined = ef_defined
with patch('mslice.models.workspacemanager.workspace_algorithms.get_workspace_handle') as gwh:
gwh.return_value = ws_mock
limits = PropertyMock(side_effect=({} if i < 2 else {'DeltaE':[-1, 1]} for i in range(6)))
type(ws_mock).limits = limits
e_fixed.return_value = 1.845
self.presenter.load_workspace([path_to_nexus])
load_mock.assert_called_with(filename=path_to_nexus, output_workspace=workspace_name)
e_fixed.assert_has_calls([call(1.845), call()])
process_limits.assert_called_once_with(ws_mock)
self.main_presenter.show_workspace_manager_tab.assert_called_once()
self.main_presenter.show_tab_for_workspace.assert_called_once()
self.main_presenter.update_displayed_workspaces.assert_called_once()
def test_extract(self):
untiny = Untiny()
mock_response = MagicMock()
mock_response_text = PropertyMock()
type(mock_response).text = mock_response_text
untiny.is_tiny = MagicMock()
with patch("requests.get", MagicMock(return_value=mock_response)) as mock_get:
# If the URL is tiny send a request to untiny.me to extract
# full URL
untiny.is_tiny.return_value = True
mock_response_text.return_value = "http://foo.com"
self.assertEquals(
untiny.extract("http://2pl.us/234"),
"http://foo.com",
)
self.assertEquals(mock_get.call_count, 1)
self.assertEquals(mock_response_text.call_count, 1)
# Check with another URL
mock_response_text.return_value = "http://bar.com"
self.assertEquals(
untiny.extract("http://1u.ro/123"),
"http://bar.com",
)
self.assertEquals(mock_get.call_count, 2)
self.assertEquals(mock_response_text.call_count, 2)
# If the URL is not tiny return it unchanged.
untiny.is_tiny.return_value = False
self.assertEquals(
untiny.extract("http://example.com"),
"http://example.com",
)
self.assertEquals(mock_get.call_count, 2)
with patch("requests.get", MagicMock(side_effect=requests.RequestException)) as mock_get:
# If a request to untiny.me fails return the original URL.
untiny.is_tiny.return_value = True
self.assertEquals(
untiny.extract("http://1u.ro/123"),
"http://1u.ro/123",
)
self.assertEquals(mock_get.call_count, 1)
def test_no_events(self, mock_comms: PropertyMock) -> None:
mock_comms.return_value = MagicMock()
d = Document()
handle = binb.CommsHandle("comms", d)
binb.push_notebook(document=d, handle=handle)
assert mock_comms.call_count == 0
def response_factory(access_token, refresh_token):
response = MagicMock()
p_access_token = PropertyMock()
p_access_token.return_value = access_token
type(response).access_token = p_access_token
p_refresh_token = PropertyMock()
p_refresh_token.return_value = refresh_token
type(response).refresh_token = p_access_token
p_auth = MagicMock()
p_auth.side_effect = lambda refresh_token: refresh_token
type(response).auth = p_auth
p_login = MagicMock()
p_login.side_effect = lambda username, password: (username, password)
type(response).login = p_login
return response
def test_get_external_blocked_by(issue_mock):
links = issuelinks.get_external_blocked_by(issue_mock)
assert links == []
mock_issuelinks = PropertyMock()
mock_issuelinks.return_value = [fakes.IssueLink("outwardIssue", "EXT-2", "Blocks")]
type(issue_mock.fields).issuelinks = mock_issuelinks
links = issuelinks.get_external_blocked_by(issue_mock)
assert links == ["EXT-2"]
def interpolation_method(mocker, method):
# This uses the pytest-mock package in order to provide a fixture that will
# mock the global variable in the image module that determines if OpenCV
# should be used or not. Useful for running the unit tests with and without
# opencv
interp = PropertyMock()
interp.return_value = method
mocker.patch("menpo.image.base.cv2_perspective_interpolation",
new_callable=interp)
def ReturnList(q, fields=""):
def ReturnListExecute():
res = {}
records = []
rs = re.search("^mimeType='(.*)'$", q)
if rs and rs.groups():
mimeType = rs.groups()[0]
records = [
r for r in self.drive
if r["mimeType"] == mimeType
]
rs = re.search("^mimeType!='(.*)'$", q)
if rs and rs.groups():
mimeType = rs.groups()[0]
records = [
r for r in self.drive
if r["mimeType"] != mimeType
]
rs = re.search("^'(.*)' in parents$", q)
if rs and rs.groups():
parent = rs.groups()[0]
records = [
r for r in self.drive if parent in r["parents"]
]
rs = re.search(
"^mimeType='(.*)' and '(.*)' in parents$", q)
if rs and rs.groups():
mimeType = rs.groups()[0]
parent = rs.groups()[1]
records = [
r for r in self.drive
if r["mimeType"] == mimeType
and parent in r["parents"]
]
rs = re.search(
"^name='(.*)' and mimeType='(.*)' and '(.*)' in parents$",
q)
if rs and rs.groups():
name = rs.groups()[0]
mimeType = rs.groups()[1]
parent = rs.groups()[2]
records = [
r for r in self.drive
if r["name"] == name and r["mimeType"] ==
mimeType and parent in r["parents"]
]
res["files"] = records
return res
r3 = MagicMock()
p_execute = PropertyMock()
p_execute.return_value = ReturnListExecute
type(r3).execute = p_execute
return r3
def __ReturnNovelDetail(self, novel_id) -> MagicMock:
"""非公式pixivAPIの全体操作機能のモックを作成する
Note:
以下のプロパティ、メソッドを模倣する
novel
id
title
create_date
page_count
text_length
caption
user
name
id
error
Returns:
MagicMock: novel_response
"""
novel_response = MagicMock()
s = {}
if 0 < novel_id and novel_id < 99999999:
s = self.__GetNovelData(novel_id)
type(novel_response).error = None
else:
type(novel_response).error = "error"
type(novel_response).novel = None
return novel_response
def ReturnResponse():
r_response = MagicMock()
# ノベルデータ設定
type(r_response).id = s["id"]
type(r_response).title = s["title"]
type(r_response).create_date = s["create_date"]
type(r_response).page_count = int(s["page_count"])
type(r_response).text_length = int(s["text_length"])
type(r_response).caption = s["caption"]
r_name_id = MagicMock()
type(r_name_id).name = s["author_name"]
type(r_name_id).id = s["author_id"]
type(r_response).user = r_name_id
return r_response
p_response = PropertyMock()
p_response.return_value = ReturnResponse()
type(novel_response).novel = p_response
return novel_response
def test_compute_random_record_name(self):
someuuid = "someuuid"
domain = {"name": "domain"}
uuid1_m = self.create_patch("uuid.uuid1")
uuid_m = Mock()
hex_m = PropertyMock()
type(uuid_m).hex = hex_m
uuid1_m.return_value = uuid_m
hex_m.return_value = someuuid
self.assertEqual(compute_random_record_name(domain), someuuid)
def ReturnDelete(fileId):
def ReturnDeleteExecute():
records = [r for r in self.drive if r["id"] == fileId]
self.assertEqual(1, len(records))
r = records[0]
self.drive.remove(r)
return r["id"]
r3 = MagicMock()
p_execute = PropertyMock()
p_execute.return_value = ReturnDeleteExecute
type(r3).execute = p_execute
return r3
def ReturnOpen(path):
r_open = MagicMock()
p_copy = PropertyMock()
p_copy.return_value = lambda: ReturnOpen(path)
type(r_open).copy = p_copy
def ReturnSave(fp, save_all, append_images, optimize, duration, loop):
path_list = []
for image in append_images:
path_list.append(image.return_value)
# gifファイルを生成したことにしてダミーをfpに生成する
with Path(fp).open("wb") as fout:
fout.write(fp.encode())
fout.write(", ".join(path_list).encode())
fout.write(", ".join(map(str, duration)).encode())
p_save = PropertyMock()
p_save.return_value = ReturnSave
type(r_open).save = p_save
r_open.return_value = path
return r_open
def mockery(self, property_name, property_return_value=None):
"""
Return property of *property_name* on self.table with return value of
*property_return_value*.
"""
# mock <a:tbl> element of Table so we can mock its properties
tbl = MagicMock()
self.table._tbl_elm = tbl
# create a suitable mock for the property
property_ = PropertyMock()
if property_return_value:
property_.return_value = property_return_value
# and attach it the the <a:tbl> element object (class actually)
setattr(type(tbl), property_name, property_)
return property_
def mockery(self, property_name, property_return_value=None):
"""
Return property of *property_name* on self.table with return value of
*property_return_value*.
"""
# mock <a:tbl> element of Table so we can mock its properties
tbl = MagicMock()
self.table._tbl_elm = tbl
# create a suitable mock for the property
property_ = PropertyMock()
if property_return_value:
property_.return_value = property_return_value
# and attach it the the <a:tbl> element object (class actually)
setattr(type(tbl), property_name, property_)
return property_
def test_PostLineNotify(self):
# LINE通知ポスト機能をチェックする
crawler = PictureGathering_fav.Crawler()
with ExitStack() as stack:
# with句にpatchを複数入れる
mockreq = stack.enter_context(patch('PictureGathering_fav.requests.post'))
# mock設定
responce = MagicMock()
status_code = PropertyMock()
status_code.return_value = 200
type(responce).status_code = status_code
mockreq.return_value = responce
self.assertEqual(0, crawler.PostLineNotify("test"))
mockreq.assert_called_once()
def ReturnCreate(body, fields="", media_body=""):
def ReturnCreateExecute():
self.assertTrue("name" in body)
self.assertTrue("mimeType" in body)
self.assertTrue("parents" in body)
name = body.get("name")
mimeType = body.get("mimeType")
parents = body.get("parents")
r = self.__MakeFilesObject(name, mimeType, parents)
self.drive.append(r)
return {"id": r["id"]}
r3 = MagicMock()
p_execute = PropertyMock()
p_execute.return_value = ReturnCreateExecute
type(r3).execute = p_execute
return r3
def test_get_columns(self):
query = "SELECT * FROM some_table WHERE date_column >= '2018-01-01'"
Column = namedtuple('Column', ('name'))
description = PropertyMock()
description.return_value = [
Column(name='column1'),
Column(name='column2')
]
type(self.mock_cursor).description = description
actual = self.redshift.get_columns(query)
expected = ['"column1"', '"column2"']
self.assertListEqual(actual, expected)
self.mock_cursor.execute.assert_called_once()
def mocked_response(status_code=200):
"""
Return mocked response instance
>>> mocked_response(status_code=404).code == 404
True
>>> mocked_response(status_code=404).code == 200
False
>>> mocked_response(status_code=404).read() == 'mocked body'
True
"""
code = PropertyMock()
code.return_value = status_code
response = MagicMock()
response.read.return_value = 'mocked body'
type(response).code = code
return response
def __MakeImageMock(self, mock: MagicMock) -> MagicMock:
"""PIL.Imageクラスのモックを作成する
Note:
以下のプロパティ、メソッドを模倣する
mock
open(path)
copy()
save(fp, save_all, append_images, optimize, duration, loop)
Returns:
MagicMock: PIL.Imageクラスのモック
"""
def ReturnOpen(path):
r_open = MagicMock()
p_copy = PropertyMock()
p_copy.return_value = lambda: ReturnOpen(path)
type(r_open).copy = p_copy
def ReturnSave(fp, save_all, append_images, optimize, duration,
loop):
path_list = []
for image in append_images:
path_list.append(image.return_value)
# gifファイルを生成したことにしてダミーをfpに生成する
with Path(fp).open("wb") as fout:
fout.write(fp.encode())
fout.write(", ".join(path_list).encode())
fout.write(", ".join(map(str, duration)).encode())
p_save = PropertyMock()
p_save.return_value = ReturnSave
type(r_open).save = p_save
r_open.return_value = path
return r_open
p_open = PropertyMock()
p_open.return_value = ReturnOpen
type(mock).open = p_open
return mock
def test_cmd_praise(self, mock_dice_check, mock_get_week, mock_dom_get_week):
from web.character.models import PlayerAccount
from world.dominion.models import Organization, AssetOwner, RPEvent
self.roster_entry.current_account = PlayerAccount.objects.create(email="*****@*****.**")
self.roster_entry.save()
self.setup_cmd(social.CmdPraise, self.account)
mock_get_week.return_value = 1
mock_dom_get_week.return_value = 1
self.assertEqual(self.account.get_current_praises_and_condemns().count(), 0)
self.call_cmd("testaccount2", "You have already used all your praises for the week.")
# property mocks have to be reset at the end, or screws up other tests
old = type(self.char1).social_clout
prop_mock = PropertyMock(return_value=10)
type(self.char1).social_clout = prop_mock
mock_dice_check.return_value = 50
self.call_cmd("testaccount2,-2=hi", "The number of praises used must be a positive number, "
"and less than your max praises.")
self.call_cmd("testaccount2,99=hi", "The number of praises used must be a positive number, "
"and less than your max praises.")
self.account2.inform = Mock()
self.call_cmd("/all testaccount2=hi", 'You use 1 action points and have 99 remaining this week.|'
'You praise the actions of Testaccount2. You have 0 praises remaining.')
self.account2.inform.assert_called_with('Testaccount has praised you. Your prestige has been adjusted by 90.',
append=False, category='Praised', week=1)
self.assertEqual(self.assetowner2.fame, 90)
self.assertEqual(self.account.get_current_praises_and_condemns().count(), 1)
org = Organization.objects.create(name="test org")
org.inform = Mock()
org_assets = AssetOwner.objects.create(organization_owner=org)
self.call_cmd("/org foo", "No organization by that name.")
self.call_cmd("/org test org", 'There is no event going on that has test org as a sponsor.')
event = RPEvent.objects.create(name="test event", location=self.room)
self.room.db.current_event = event.id
event.org_event_participation.create(org=org, social=50)
prop_mock.return_value = 50
self.call_cmd("/org test org,40=hi2u", 'You use 1 action points and have 98 remaining this week.|'
'You praise the actions of Test org. You have 0 praises remaining.')
org.inform.assert_called_with('Testaccount has praised you. Your prestige has been adjusted by 10200.',
append=False, category='Praised', week=1)
self.assertEqual(org_assets.fame, 10200)
# cleanup property mock
type(self.char1).social_clout = old
def test_run_persist(
self,
mock_execute: MagicMock,
mock_unlock: MagicMock,
mock_lock: MagicMock,
mock_graph_tags: PropertyMock,
) -> None:
"""Test run persist."""
mock_graph_tags.return_value = {}
context = self._get_context(
extra_config_args={"persistent_graph_key": "test.json"})
context._persistent_graph = Graph.from_steps(
[Step.from_stack_name("removed", context)])
deploy_action = deploy.Action(context=context)
deploy_action.run()
mock_graph_tags.assert_called_once()
mock_lock.assert_called_once()
mock_execute.assert_called_once()
mock_unlock.assert_called_once()
def test_with_events(self, mock_comms: PropertyMock) -> None:
mock_comm = MagicMock()
mock_send = MagicMock(return_value="junk")
mock_comm.send = mock_send
mock_comms.return_value = mock_comm
d = Document()
handle = binb.CommsHandle("comms", d)
d.title = "foo"
binb.push_notebook(document=d, handle=handle)
assert mock_comms.call_count > 0
assert mock_send.call_count == 3 # sends header, metadata, then content
assert json.loads(mock_send.call_args[0][0]) == {
"events": [{
"kind": "TitleChanged",
"title": "foo"
}],
}
assert mock_send.call_args[1] == {}
def ReturnCopy(body, fileId):
def ReturnCopyExecute():
records = [r for r in self.drive if r["id"] == fileId]
self.assertEqual(1, len(records))
record = records[0]
self.assertTrue("name" in record)
self.assertTrue("mimeType" in record)
self.assertTrue("parents" in body)
parents = body.get("parents")
r = self.__MakeFilesObject(record["name"],
record["mimeType"], parents)
self.drive.append(r)
return r["id"]
r3 = MagicMock()
p_execute = PropertyMock()
p_execute.return_value = ReturnCopyExecute
type(r3).execute = p_execute
return r3
def test_drink(self):
#is carrying
#has 1 left
#Not carrying
potion = potions.StrengthPotion()
self.assertEqual(potion.count, 1)
player = Mock()
mock_is_carrying = PropertyMock(return_value=False)
player.is_carrying = mock_is_carrying
self.assertFalse(potion.drink(player))
mock_is_carrying.assert_called_once()
self.assertEqual(potion.count, 1)
#Carrying
mock_is_carrying.return_value = True
self.assertTrue(potion.drink(player))
self.assertEqual(potion.count, 0)
#None left
self.assertFalse(potion.drink(player))
def mock_connection():
mock_connection = PropertyMock()
class MockCursor(object):
def __init__(self, *args, **kwargs):
self.statements = []
self.return_rows = []
self.cursor_position = 0
def execute(self, statement, *args, **kwargs):
self.statements.append(statement)
def fetchone(self, *args, **kwargs):
if self.cursor_position > len(self.return_rows) - 1:
return None
else:
next_row = self.return_rows[self.cursor_position]
self.cursor_position += 1
return next_row
def __enter__(self, *args, **kwargs):
return self
def __exit__(self, *args, **kwargs):
return
def __iter__(self):
for row in self.return_rows:
yield row
mock_cursor = MockCursor()
mock_connection_enter = MagicMock()
mock_connection_enter.cursor.return_value = mock_cursor
mock_connection.return_value = mock_connection
mock_connection.cursor.return_value = mock_cursor
mock_connection.__enter__ = lambda x: mock_connection_enter
mock_connection.__exit__ = MagicMock()
return mock_connection
def test_change_title(self):
mock_view_title = PropertyMock()
type(self.view).title = mock_view_title
mock_model_title = PropertyMock(return_value='Title 0')
type(self.model).title = mock_model_title
# title passed model -> view
self.presenter = CutPlotOptionsPresenter(self.view, self.model)
mock_model_title.assert_called_once_with()
mock_view_title.assert_called_once_with('Title 0')
# title passed view -> model
mock_view_title.reset_mock()
mock_model_title.reset_mock()
mock_view_title.return_value = 'Title 1'
self.presenter._value_modified('title')
self.presenter.get_new_config()
mock_view_title.assert_called_once_with()
mock_model_title.assert_called_once_with('Title 1')
def mock_connection():
mock_connection = PropertyMock()
mock_connection.return_value = mock_connection
mock_connection.__enter__ = MagicMock()
mock_connection.__exit__ = MagicMock()
return mock_connection
