def mock_using_patch(mocker: MockerFixture) -> Tuple[MagicMock, MagicMock]:
return mocker.patch("os.remove"), mocker.patch("os.listdir")
def update_sql(self, mocker: MockerFixture) -> Mock:
return mocker.patch("dbupgrade.apply.update_sql")
async def test_publish(
mocker: MockerFixture,
fs: FakeFilesystem,
root: Path,
config: Config,
) -> None:
"""
Test ``publish``.
"""
mocker.patch.object(
CommandPublisher,
"find_modified_files",
return_value=iter(
[
root / "build/generic/one/index.html",
root / "build/generic/one/photo.jpg",
root / "build/generic/one/blob",
],
),
)
subprocess = mocker.patch("nefelibata.publishers.command.subprocess")
fs.create_file(root / "build/generic/one", contents="Hello, world!")
publisher = CommandPublisher(
root,
config,
"generic",
["touch $path", "cp $path dir/"],
["notify.py"],
)
with freeze_time("2021-01-01T00:00:00Z"):
publishing = await publisher.publish()
assert publishing.dict() == {
"timestamp": datetime(2021, 1, 1, 0, 0, tzinfo=timezone.utc),
}
print(subprocess.run.mock_calls)
subprocess.run.assert_has_calls(
[
mocker.call(
"touch $path",
shell=True,
check=True,
env={
"path": Path("one/index.html"),
},
),
mocker.call(
"cp $path dir/",
shell=True,
check=True,
env={
"path": Path("one/index.html"),
},
),
mocker.call(
"touch $path",
shell=True,
check=True,
env={
"path": Path("one/photo.jpg"),
},
),
mocker.call(
"cp $path dir/",
shell=True,
check=True,
env={
"path": Path("one/photo.jpg"),
},
),
mocker.call(
"touch $path",
shell=True,
check=True,
env={
"path": Path("one/blob"),
},
),
mocker.call(
"cp $path dir/",
shell=True,
check=True,
env={
"path": Path("one/blob"),
},
),
mocker.call(
"notify.py",
shell=True,
check=True,
),
],
)
def _establish_mocks(mocker: MockerFixture) -> None:
mocker.patch("terraform_manager.terraform.credentials.find_token",
return_value="test")
def open(self, mocker: MockerFixture) -> Mock:
return mocker.patch("dbupgrade.apply.open")
def test_get_df(mocker: MockerFixture):
"""It should call the sql extractor"""
snock = mocker.patch('pymysql.connect')
reasq = mocker.patch('pandas.read_sql')
mocker.patch(
'toucan_connectors.mysql.mysql_connector.MySQLConnector.get_foreign_key_info'
).return_value = []
mysql_connector = MySQLConnector(name='mycon',
host='localhost',
port=22,
user='******',
password='******')
# With table
data_source = MySQLDataSource(
**{
'domain': 'MySQL test',
'type': 'external_database',
'name': 'Some MySQL provider',
'database': 'mysql_db',
'table': 'City',
})
mysql_connector.get_df(data_source)
conv = pymysql.converters.conversions.copy()
conv[246] = float
snock.assert_called_once_with(
host='localhost',
user='******',
database='mysql_db',
password='******',
port=22,
charset='utf8mb4',
conv=conv,
cursorclass=pymysql.cursors.DictCursor,
)
reasq.assert_called_once_with('select * from City', con=snock(), params={})
# With query
reasq.reset_mock()
data_source = MySQLDataSource(
**{
'domain': 'MySQL test',
'type': 'external_database',
'name': 'Some MySQL provider',
'database': 'mysql_db',
'query': 'select * from Country',
})
mysql_connector.get_df(data_source)
reasq.assert_called_once_with('select * from Country',
con=snock(),
params={})
# With both: query should take precedence over table
reasq.reset_mock()
data_source = MySQLDataSource(
**{
'domain': 'MySQL test',
'type': 'external_database',
'name': 'Some MySQL provider',
'database': 'mysql_db',
'table': 'City',
'query': 'select * from Country',
})
mysql_connector.get_df(data_source)
reasq.assert_called_once_with('select * from Country',
con=snock(),
params={})
def test_batch_operation(mocker: MockerFixture) -> None:
for write_output in [True, False]:
_establish_mocks(mocker)
print_mock: MagicMock = mocker.patch("builtins.print")
error_json = {"data": {"id": _test_workspace2.workspace_id}}
responses.add(
responses.PATCH,
f"{TEST_API_URL}/workspaces/{_test_workspace1.workspace_id}",
status=200)
responses.add(
responses.PATCH,
f"{TEST_API_URL}/workspaces/{_test_workspace2.workspace_id}",
json=error_json,
status=500)
(field1, value1) = ("test-field1", _test_workspace1.terraform_version)
(field2, value2) = ("test-field2", "test2")
assert not batch_operation(
TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION, [_test_workspace1, _test_workspace2],
field_mappers=[lambda w: w.terraform_version, lambda w: w.name],
field_names=[field1, field2],
new_values=[value1, value2],
report_only_value_mappers=[
lambda x: "test-" + x, lambda x: "test-" + x
],
write_output=write_output)
if write_output:
# yapf: disable
print_mock.assert_has_calls([
call((
f'Terraform workspace {"/".join([field1, field2])} patch results for '
f'organization "{TEST_ORGANIZATION}" at "{TEST_TERRAFORM_DOMAIN}":'
)),
call(),
call(
tabulate(
[
[
_test_workspace2.name,
field1,
"test-" + _test_workspace2.terraform_version,
"test-" + _test_workspace2.terraform_version,
"error",
str(error_json)
],
[
_test_workspace2.name,
field2,
"test-" + _test_workspace2.name,
"test-" + _test_workspace2.name,
"error",
str(error_json)
],
[
_test_workspace1.name,
field1,
"test-" + _test_workspace1.terraform_version,
"test-" + value1,
"success",
"value unchanged"
],
[
_test_workspace1.name,
field2,
"test-" + _test_workspace1.name,
"test-" + value2,
"success",
"none"
]
],
headers=["Workspace", "Field", "Before", "After", "Status", "Message"]
)
),
call()
])
# yapf: enable
assert print_mock.call_count == 4
else:
print_mock.assert_not_called()
def xml_parse(mocker: MockerFixture) -> MockerFixture:
mocked_xmlparser = mocker.patch('xmltodict.parse')
return mocked_xmlparser
def rq_job(mocker: MockerFixture) -> MockerFixture:
mocked_get_current_job = mocker.patch(
'netpalm.backend.core.utilities.rediz_meta.get_current_job')
mocked_job = Mock()
mocked_job.meta = {"errors": []}
mocked_get_current_job.return_value = mocked_job
def db_upgrade(self, mocker: MockerFixture) -> Mock:
return mocker.patch("dbupgrade.main.db_upgrade",
return_value=UpgradeResult(vi, vi, []))
def mocked_logging_config_module(mocker: MockerFixture) -> MagicMock:
return mocker.patch("logging.config")
def parse_args(self, mocker: MockerFixture) -> Mock:
args = Arguments("myschema", "sqlite:///", "/tmp")
return mocker.patch("dbupgrade.main.parse_args", return_value=args)
def logging(self, mocker: MockerFixture) -> Mock:
logging = mocker.patch("dbupgrade.main.logging")
logging.INFO = logging.INFO
logging.WARNING = logging.WARNING
return logging
def test_TableauWorkbook(mocker: MockerFixture) -> None:
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponse)
mocker.patch("tableauscraper.api.select", return_value=vqlCmdResponse)
ts = TS()
ts.loads(fakeUri)
dataFrameGroup = ts.getWorkbook()
assert type(dataFrameGroup) is TableauWorkbook
assert "_originalData" in dataFrameGroup.__dict__
assert dataFrameGroup.__dict__["_scraper"] is ts
assert not dataFrameGroup.cmdResponse
assert len(dataFrameGroup.worksheets) == 2
# get worksheet names (initial response)
worksheetNames = dataFrameGroup.getWorksheetNames()
assert type(worksheetNames) is list
assert not dataFrameGroup.cmdResponse
assert worksheetNames == ["[WORKSHEET1]", "[WORKSHEET2]"]
# get worksheet names (vql response)
dataFrameGroup = dataFrameGroup.worksheets[0].select("[FIELD1]", "2")
assert dataFrameGroup.cmdResponse
assert len(dataFrameGroup.worksheets) == 1
worksheetNames = dataFrameGroup.getWorksheetNames()
assert type(worksheetNames) is list
assert worksheetNames == ["[WORKSHEET1]", "[WORKSHEET2]"]
# get worksheets (initial response)
dataFrameGroup = ts.getWorkbook()
dataFrameGroup = dataFrameGroup.getWorksheets()
assert type(dataFrameGroup) is TableauWorkbook
assert not dataFrameGroup.cmdResponse
assert len(dataFrameGroup.worksheets) == 2
# get worksheets (vql response)
dataFrameGroup = dataFrameGroup.worksheets[0].select("[FIELD1]", "2")
dataFrameGroup = dataFrameGroup.getWorksheets()
assert type(dataFrameGroup) is TableauWorkbook
assert dataFrameGroup.cmdResponse
assert len(dataFrameGroup.worksheets) == 1
# get single worksheet (initial response)
dataFrameGroup = ts.getWorkbook()
dataFrame = dataFrameGroup.getWorksheet("[WORKSHEET1]")
assert type(dataFrame) is TableauWorksheet
assert not dataFrameGroup.cmdResponse
assert len(dataFrameGroup.worksheets) == 2
# get single worksheet (vql response)
dataFrameGroup = ts.getWorkbook()
dataFrame = (dataFrameGroup.worksheets[0].select(
"[FIELD1]", "2").getWorksheet("[WORKSHEET1]"))
assert type(dataFrame) is TableauWorksheet
assert dataFrame.cmdResponse
assert dataFrame.name == "[WORKSHEET1]"
assert dataFrame.data.shape[0] == 4
assert dataFrame.data.shape[1] == 2
# get single worksheet (vql response) wrong sheet name
dataFrameGroup = ts.getWorkbook()
dataFrame = (dataFrameGroup.worksheets[0].select("[FIELD1]",
"2").getWorksheet("XXXX"))
assert type(dataFrame) is TableauWorksheet
assert dataFrame.cmdResponse
assert dataFrame.name == "XXXX"
assert dataFrame.data.shape[0] == 0
assert dataFrame.data.shape[1] == 0
# get single worksheet (vql response) no data
mocker.patch("tableauscraper.api.select",
return_value=vqlCmdResponseEmptyValues)
dataFrameGroup = ts.getWorkbook()
dataFrame = (dataFrameGroup.worksheets[0].select(
"[FIELD1]", "2").getWorksheet("[WORKSHEET1]"))
assert type(dataFrame) is TableauWorksheet
assert dataFrame.cmdResponse
assert dataFrame.name == "[WORKSHEET1]"
assert dataFrame.data.shape[0] == 0
assert dataFrame.data.shape[1] == 0
# get worksheet names (storypoints)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponseWithStoryPoints)
ts = TS()
ts.loads(fakeUri)
dataFrameGroup = ts.getWorkbook()
worksheetNames = dataFrameGroup.getWorksheetNames()
assert type(worksheetNames) is list
assert not dataFrameGroup.cmdResponse
assert worksheetNames == ["[WORKSHEET1]"]
# get parameters with storypoints
parameters = dataFrameGroup.getParameters()
assert type(parameters) is list
assert parameters == [{
"column": "[INPUT_NAME1]",
"values": [
"select1",
"select2",
"select3",
],
"parameterName": "[Parameters].[Parameter 1]"
}, {
"column": "[INPUT_NAME2]",
"values": [
"select4",
"select5",
"select6",
],
"parameterName": "[Parameters].[Parameter 1]",
}]
# set parameter with story points on vql cmd response
mocker.patch("tableauscraper.api.setParameterValue",
return_value=storyPointsCmdResponse)
wb = dataFrameGroup.setParameter("[INPUT_NAME1]", "select1")
parameters = wb.getParameters()
assert type(parameters) is list
assert parameters == [{
"column": "[INPUT_NAME1]",
"values": [
"select1",
"select2",
"select3",
],
"parameterName": "[Parameters].[Parameter 1]"
}, {
"column": "[INPUT_NAME2]",
"values": [
"select4",
"select5",
"select6",
],
"parameterName": "[Parameters].[Parameter 1]",
}]
def deactivate_certificate_validation(mocker: MockerFixture) -> None:
mocker.patch(
"agent_receiver.certificates._invalid_certificate_response",
lambda _h: None,
)
async def test_archive_urls(mocker: MockerFixture) -> None:
"""
Test ``archive_urls``.
"""
links = {
"original": {
"rel": "original",
"url": URL("https://nefelibata.readthedocs.io/"),
},
"timemap": {
"rel":
"timemap",
"type":
"application/link-format",
"url":
URL(
"https://web.archive.org/web/timemap/link/https://nefelibata.readthedocs.io/",
),
},
"timegate": {
"rel":
"timegate",
"url":
URL(
"https://web.archive.org/web/https://nefelibata.readthedocs.io/",
),
},
"first memento": {
"rel":
"first memento",
"datetime":
"Sun, 05 Aug 2018 06:22:28 GMT",
"url":
URL(
"https://web.archive.org/web/20180805062228/http://nefelibata.readthedocs.io/",
),
},
"prev memento": {
"rel":
"prev memento",
"datetime":
"Tue, 29 Jun 2021 01:15:06 GMT",
"url":
URL(
"https://web.archive.org/web/20210629011506/https://nefelibata.readthedocs.io/",
),
},
"memento": {
"rel":
"memento",
"datetime":
"Sun, 03 Oct 2021 15:46:02 GMT",
"url":
URL(
"https://web.archive.org/web/20211003154602/https://nefelibata.readthedocs.io/",
),
},
"last memento": {
"rel":
"last memento",
"datetime":
"Sun, 03 Oct 2021 15:46:02 GMT",
"url":
URL(
"https://web.archive.org/web/20211003154602/https://nefelibata.readthedocs.io/",
),
},
}
get = mocker.patch("nefelibata.utils.ClientSession.get")
get.return_value.__aenter__.return_value.links = links
saved_urls = await archive_urls([
URL("https://nefelibata.readthedocs.io/"),
URL("gemini://taoetc.org/"),
], )
assert saved_urls == {
URL("https://nefelibata.readthedocs.io/"):
URL(
"https://web.archive.org/web/20211003154602/https://nefelibata.readthedocs.io/",
),
}
def mock_github3_enterprise_login(mocker: MockerFixture) -> MockerFixture:
"""Fixture for mocking github3.enterprise_login."""
return mocker.patch("github3.enterprise_login", autospec=True)
def test_upload(mocker: MockerFixture):
mock = mocker.patch('requests.post')
main(['upload', '--dry-run', _test_sample])
assert mock.call_count == 0
main(['upload', _test_sample])
assert mock.call_count == 1
def test_TableauWorksheet(mocker: MockerFixture) -> None:
ts = TS()
tableauDataFrame = dashboard.getWorksheet(ts, data, info, "[WORKSHEET1]")
assert tableauDataFrame.name == "[WORKSHEET1]"
assert tableauDataFrame.data.shape[0] == 4
assert tableauDataFrame.data.shape[1] == 2
assert type(tableauDataFrame) is TableauWorksheet
columns = tableauDataFrame.getColumns()
assert type(columns) is list
assert columns == ["[FIELD1]", "[FIELD2]"]
selectableColumns = tableauDataFrame.getSelectableItems()
assert type(selectableColumns) is list
assert selectableColumns == [{
"column": "[FIELD1]",
"values": ["2", "3", "4", "5"]
}, {
"column": "[FIELD2]",
"values": ["6", "7", "8", "9"]
}]
values = tableauDataFrame.getSelectableValues("[FIELD1]")
assert type(values) is list
assert values == ["2", "3", "4", "5"]
# column name doesn't exist
values = tableauDataFrame.getSelectableValues("XXX")
assert type(values) is list
assert values == []
# no values
tableauDataFrame = dashboard.getWorksheet(ts, emptyValues, info,
"[WORKSHEET1]")
values = tableauDataFrame.getSelectableValues("[FIELD1]")
assert type(values) is list
assert values == []
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponse)
mocker.patch("tableauscraper.api.select", return_value=vqlCmdResponse)
ts.loads(fakeUri)
tableauDataFrame = dashboard.getWorksheet(ts, data, info, "[WORKSHEET1]")
tableauDataFrameGroup = tableauDataFrame.select("[FIELD1]", "2")
assert type(tableauDataFrameGroup) is TableauWorkbook
assert len(tableauDataFrameGroup.worksheets) == 1
assert tableauDataFrameGroup.worksheets[0].name == "[WORKSHEET1]"
assert tableauDataFrameGroup.worksheets[0].data.shape[0] == 4
assert tableauDataFrameGroup.worksheets[0].data.shape[1] == 2
assert list(tableauDataFrameGroup.worksheets[0].data.columns.values) == [
"[FIELD1]-value",
"[FIELD2]-alias",
]
# column name doesn't exist
tableauDataFrameGroup = tableauDataFrame.select("XXXX", "2")
assert type(tableauDataFrameGroup) is TableauWorkbook
assert len(tableauDataFrameGroup.worksheets) == 0
#### VQL CMD RESPONSE ####
tableauDataFrame = dashboard.getWorksheet(ts, data, info, "[WORKSHEET1]")
tableauDataFrame = tableauDataFrame.select(
"[FIELD1]", "2").getWorksheet("[WORKSHEET1]")
assert type(tableauDataFrame) is TableauWorksheet
assert tableauDataFrame.cmdResponse
columns = tableauDataFrame.getColumns()
assert type(columns) is list
assert columns == ["[FIELD1]", "[FIELD2]"]
selectableColumns = tableauDataFrame.getSelectableItems()
assert type(selectableColumns) is list
assert selectableColumns == [{
"column": "[FIELD1]",
"values": ["2", "3", "4", "5"]
}, {
"column": "[FIELD2]",
"values": ["6", "7", "8", "9"]
}]
values = tableauDataFrame.getSelectableValues("[FIELD1]")
assert type(values) is list
assert values == ["2", "3", "4", "5"]
# column name doesn't exist
values = tableauDataFrame.getSelectableValues("XXX")
assert type(values) is list
assert values == []
# no values
mocker.patch("tableauscraper.api.select",
return_value=vqlCmdResponseDictionaryEmpty)
tableauDataFrame = dashboard.getWorksheet(ts, data, info, "[WORKSHEET1]")
tableauDataFrame = tableauDataFrame.select(
"[FIELD1]", "2").getWorksheet("[WORKSHEET1]")
values = tableauDataFrame.getSelectableValues("[FIELD1]")
assert type(values) is list
assert values == []
####
# story point
ts = TS()
tableauDataFrameGroup = dashboard.getWorksheets(
ts, dataWithoutPresModelWithDictionary, storyPointsInfo)
assert type(tableauDataFrameGroup) is TableauWorkbook
assert not tableauDataFrameGroup.cmdResponse
ws = tableauDataFrameGroup.getWorksheet("[WORKSHEET1]")
values = ws.getSelectableValues("[FIELD1]")
assert type(values) is list
assert values == ["2", "3", "4", "5"]
def test_execute_executes_a_batch_of_operations(
mocker: MockerFixture,
config: Config,
pool: Pool,
io: BufferedIO,
tmp_dir: str,
mock_file_downloads: None,
env: MockEnv,
):
pip_install = mocker.patch("poetry.installation.executor.pip_install")
config.merge({"cache-dir": tmp_dir})
executor = Executor(env, pool, config, io)
file_package = Package(
"demo",
"0.1.0",
source_type="file",
source_url=Path(__file__).parent.parent.joinpath(
"fixtures/distributions/demo-0.1.0-py2.py3-none-any.whl").resolve(
).as_posix(),
)
directory_package = Package(
"simple-project",
"1.2.3",
source_type="directory",
source_url=Path(__file__).parent.parent.joinpath(
"fixtures/simple_project").resolve().as_posix(),
)
git_package = Package(
"demo",
"0.1.0",
source_type="git",
source_reference="master",
source_url="https://github.com/demo/demo.git",
develop=True,
)
return_code = executor.execute([
Install(Package("pytest", "3.5.2")),
Uninstall(Package("attrs", "17.4.0")),
Update(Package("requests", "2.18.3"), Package("requests", "2.18.4")),
Uninstall(Package("clikit", "0.2.3")).skip("Not currently installed"),
Install(file_package),
Install(directory_package),
Install(git_package),
])
expected = f"""
Package operations: 4 installs, 1 update, 1 removal
• Installing pytest (3.5.2)
• Removing attrs (17.4.0)
• Updating requests (2.18.3 -> 2.18.4)
• Installing demo (0.1.0 {file_package.source_url})
• Installing simple-project (1.2.3 {directory_package.source_url})
• Installing demo (0.1.0 master)
"""
expected = set(expected.splitlines())
output = set(io.fetch_output().splitlines())
assert output == expected
assert len(env.executed) == 1
assert return_code == 0
assert pip_install.call_count == 5
assert pip_install.call_args.kwargs.get("upgrade", False)
assert pip_install.call_args.kwargs.get("editable", False)
def test_batch_operation_bad_arguments(mocker: MockerFixture) -> None:
def name(workspace: Workspace) -> str:
return workspace.name
def test1() -> None:
assert not batch_operation(TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION,
[_test_workspace1, _test_workspace2],
field_mappers=[name],
field_names=["test", "test"],
new_values=["test", "test"],
write_output=write_output)
def test2() -> None:
assert not batch_operation(TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION,
[_test_workspace1, _test_workspace2],
field_mappers=[name, name],
field_names=["test"],
new_values=["test", "test"],
write_output=write_output)
def test3() -> None:
assert not batch_operation(TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION,
[_test_workspace1, _test_workspace2],
field_mappers=[name, name],
field_names=["test", "test"],
new_values=["test"],
write_output=write_output)
def test4() -> None:
assert not batch_operation(TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION,
[_test_workspace1, _test_workspace2],
field_mappers=[name, name],
field_names=["test", "test"],
new_values=["test", "test"],
report_only_value_mappers=[str],
write_output=write_output)
def test5() -> None:
assert not batch_operation(TEST_TERRAFORM_DOMAIN,
TEST_ORGANIZATION,
[_test_workspace1, _test_workspace2],
field_mappers=[],
field_names=["test"],
new_values=["test"],
write_output=write_output)
for write_output in [True, False]:
for test in [test1, test2, test3, test4, test5]:
print_mock: MagicMock = mocker.patch("builtins.print")
test()
if write_output:
# yapf: disable
print_mock.assert_called_once_with((
"Error: invalid arguments passed to batch_operation. Ensure the number of "
"elements specified for field_mappers, field_names, new_values, and "
"report_only_value_mappers (if specified) match up."
), file=sys.stderr)
# yapf: enable
else:
print_mock.assert_not_called()
def test_sls_deploy(self, mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test sls_deploy."""
# pylint: disable=no-member
mock_deploy = mocker.patch("runway.module.serverless.deploy_package")
mock_run = mocker.patch("runway.module.serverless.run_module_command")
mocker.patch.object(runway_context, "no_color", False)
mocker.patch.object(Serverless, "gen_cmd",
MagicMock(return_value=["deploy"]))
mocker.patch.object(Serverless, "npm_install", MagicMock())
obj = Serverless(
runway_context,
module_root=tmp_path,
options={"args": ["--config", "test.yml"]},
)
assert not obj.sls_deploy()
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with("deploy")
mock_run.assert_called_once_with(cmd_list=["deploy"],
env_vars=runway_context.env.vars,
logger=obj.logger)
obj.options.promotezip["bucketname"] = "test-bucket"
assert not obj.sls_deploy(skip_install=True)
obj.npm_install.assert_called_once()
mock_deploy.assert_called_once_with(
[
"deploy",
"--region",
runway_context.env.aws_region,
"--stage",
runway_context.env.name,
"--config",
"test.yml",
],
"test-bucket",
runway_context,
tmp_path,
obj.logger,
)
mock_run.assert_called_once()
mocker.patch.object(runway_context, "no_color", True)
assert not obj.sls_deploy(skip_install=True)
mock_deploy.assert_called_with(
[
"deploy",
"--region",
runway_context.env.aws_region,
"--stage",
runway_context.env.name,
"--config",
"test.yml",
"--no-color",
],
"test-bucket",
runway_context,
tmp_path,
obj.logger,
)
def apply(self, mocker: MockerFixture) -> Mock:
return mocker.patch("dbupgrade.apply.apply_file")
def test_eol_date_recent(mocker: MockerFixture, pyvinfo: CPythonVersionInfo) -> None:
mocker.patch("time.time", return_value=1635992101)
assert pyvinfo.eol_date("2") == date(2020, 1, 1)
def logging(self, mocker: MockerFixture) -> Mock:
return mocker.patch("dbupgrade.apply.logging")
def test_is_eol_recent(mocker: MockerFixture, pyvinfo: CPythonVersionInfo) -> None:
mocker.patch("time.time", return_value=1635992101)
assert pyvinfo.is_eol("2") is True
def no_asynch(mocker: MockerFixture) -> None:
"""
Make all function calls synchronous.
"""
mocker.patch("zulipterminal.helper.asynch")
def mock_create_review(mocker: MockerFixture) -> MagicMock:
return mocker.patch("booklog.cli.add_review.booklog_api.create_review")
def test_repositories_by_user_success(mocker: MockerFixture, client: TestClient):
user_out = UserOut(id=1, username="******")
mocker.patch('app.api.router.GetReposByUserUseCase.execute', return_value=user_out)
response = client.get("/repositories/?username=test&from_local=true")
assert response.status_code == 200
assert response.json() == user_out.dict()
def test_wait_field_detected(mocker: MockerFixture, under_test: x3270):
mocker.patch("Mainframe3270.py3270.Emulator.wait_for_field")
under_test.wait_field_detected()
Emulator.wait_for_field.assert_called_once()
