def test_memoized_func(mocker: MockerFixture) -> None:
"""
Test the ``memoized_func`` decorator.
"""
from superset.utils.cache import memoized_func
cache = mocker.MagicMock()
decorator = memoized_func("db:{self.id}:schema:{schema}:view_list", cache)
decorated = decorator(lambda self, schema, cache=False: 42)
self = mocker.MagicMock()
self.id = 1
# skip cache
result = decorated(self, "public", cache=False)
assert result == 42
cache.get.assert_not_called()
# check cache, no cached value
cache.get.return_value = None
result = decorated(self, "public", cache=True)
assert result == 42
cache.get.assert_called_with("db:1:schema:public:view_list")
# check cache, cached value
cache.get.return_value = 43
result = decorated(self, "public", cache=True)
assert result == 43
def test_dunder(mocker: MockerFixture):
assert repr(Column.from_definition("name dtype")) == "name"
assert (repr(
Column.from_definition("name dtype", table=Table(None, "table",
[]))) == "table.name")
assert repr(Column.from_definition("name dtype", table=None)) == "name"
db = mocker.Mock()
db.add = mocker.MagicMock()
db.div = mocker.MagicMock()
db.mul = mocker.MagicMock()
db.sub = mocker.MagicMock()
tbl = Table(db, "table", [])
col1 = Column(tbl, "name1", "dtype")
col2 = Column(tbl, "name2", "dtype")
col1 + col2
assert db.add.called_once()
col1 / col2
assert db.div.called_once()
col1 * col2
assert db.mul.called_once()
col1 - col2
assert db.sub.called_once()
def test_kafka_transport_sync(mocker: MockerFixture):
mocker.patch('transport.kafka_transport.KafkaConsumer', autospec=True)
logger_patch = mocker.patch('transport.kafka_transport.logger',
autospec=True)
consumer = KafkaTransportSync({})
consumer.set_topic("topic")
assert consumer._topic == "topic"
callback_fn = mocker.MagicMock()
end_of_partition_msg = mocker.MagicMock()
end_of_partition_msg.error.return_value.code.return_value = KafkaError._PARTITION_EOF
valid_msg = mocker.MagicMock()
valid_msg.error.return_value = False
error_msg = mocker.MagicMock()
error_msg.error.return_value.code.return_value = False
consumer.kafka_consumer.poll.side_effect = [
valid_msg, None, end_of_partition_msg, error_msg
]
with raises(KafkaException):
consumer.consume_message(callback_fn)
callback_fn.assert_called_once()
logger_patch.info.assert_called_once_with("No Message found\n")
logger_patch.error.assert_called_once()
async def test_nuannuan(
app: App,
mocker: MockerFixture,
):
"""测试时尚品鉴"""
from nonebot import get_driver
from nonebot.adapters.onebot.v11 import Adapter, Bot, Message
from nonebug.mixin.call_api.fake import make_fake_adapter, make_fake_bot
from src.plugins.ff14 import nuannuan_cmd
with open(Path(__file__).parent / "nuannuan.json", "r", encoding="utf-8") as f:
data = json.load(f)
async_client = mocker.patch("httpx.AsyncClient.get")
r = mocker.MagicMock()
r.json = mocker.MagicMock(return_value=data)
async_client.return_value = r
async with app.test_matcher(nuannuan_cmd) as ctx:
adapter = make_fake_adapter(Adapter)(get_driver(), ctx)
bot = make_fake_bot(Bot)(adapter, "1")
event = fake_group_message_event(message=Message("/时尚品鉴"))
ctx.receive_event(bot, event)
ctx.should_call_send(
event,
"【FF14/时尚品鉴】第204期 满分攻略 12月24日 最终幻想14\n游玩C哩酱攻略站：www.youwanc.com\n-\n【12月24日 第204周时尚品鉴预告预测】\n主题：高贵的魔法师\n\n【身体防具】*提示内容：决斗者\n——*往期：116 92 57\n狂妄长衣 莽撞长衣 匿盗外套 鬼盗外套 红盗外套 瘟疫使者长衣 瘟疫医生长衣 \n60级副本地脉灵灯天狼星灯塔/草木庭园圣茉夏娜植物园\n\n【腿部防具】*提示内容：暗魔\n——*往期：169 139\n暗魔xx打底裤\n24人副本影之国获得\n\n【脚部防具】*提示内容：祭祀仪式\n——*往期：132 115\n真狮鹫革XX凉鞋/XX战靴\n70\nhttps://www.bilibili.com/video/BV1Pq4y1m7wK",
"result",
)
ctx.should_finished()
def test_consumer_runner_call_consume_message(mocker: MockerFixture):
transport = mocker.MagicMock()
transport.consume_message = mocker.MagicMock()
db = mocker.MagicMock()
runner = ConsumerRunner(transport, db)
runner.run()
transport.consume_message.assert_called_once()
async def test_deployment_progress(mocker: MockerFixture, gstate: GlobalState):
from gravel.controllers.nodes.conn import ConnMgr
from gravel.controllers.nodes.deployment import (
DeploymentErrorEnum,
NodeDeployment,
ProgressEnum,
)
fake_connmgr: ConnMgr = cast(ConnMgr, mocker.MagicMock())
deployment = NodeDeployment(gstate, fake_connmgr)
# no bootstrapper, nostage
assert deployment.progress == 0
# test actual progress
deployment.state.mark_bootstrap()
assert deployment.progress == 0 # no bootstrapper set
deployment._bootstrapper = mocker.MagicMock()
assert deployment._bootstrapper is not None
# we need to do creative mocking for a property that happens to be an
# attribute on a mock object itself.
# https://docs.python.org/3/library/unittest.mock.html#unittest.mock.PropertyMock
fake_progress = mocker.PropertyMock()
type(deployment._bootstrapper).progress = fake_progress # type: ignore
fake_progress.return_value = 0
# progress is set at NONE
assert deployment.progress == 0
deployment._progress = ProgressEnum.PREPARING
assert deployment.progress == 25
deployment._progress = ProgressEnum.PERFORMING
assert deployment._bootstrapper.progress == 0
assert deployment.progress == 25
fake_progress.return_value = 100
assert deployment._bootstrapper.progress == 100
assert deployment.progress == 80
deployment._progress = ProgressEnum.ASSIMILATING
assert deployment.progress == 90
deployment._progress = ProgressEnum.DONE
assert deployment.progress == 100
# deployed stage
deployment.state.mark_deployed()
assert deployment.progress == 100
# error state
deployment.state.mark_error(DeploymentErrorEnum.UNKNOWN_ERROR, "foobar")
assert deployment.progress == 0
def test_execute_sql_statement_with_rls(
mocker: MockerFixture,
app_context: None,
) -> None:
"""
Test for `execute_sql_statement` when an RLS rule is in place.
"""
from superset.sql_lab import execute_sql_statement
sql_statement = "SELECT * FROM sales"
query = mocker.MagicMock()
query.limit = 100
query.select_as_cta_used = False
database = query.database
database.allow_dml = False
database.apply_limit_to_sql.return_value = (
"SELECT * FROM sales WHERE organization_id=42 LIMIT 101")
db_engine_spec = database.db_engine_spec
db_engine_spec.is_select_query.return_value = True
db_engine_spec.fetch_data.return_value = [(42, )]
session = mocker.MagicMock()
cursor = mocker.MagicMock()
SupersetResultSet = mocker.patch("superset.sql_lab.SupersetResultSet")
mocker.patch(
"superset.sql_lab.insert_rls",
return_value=sqlparse.parse(
"SELECT * FROM sales WHERE organization_id=42")[0],
)
mocker.patch("superset.sql_lab.is_feature_enabled", return_value=True)
execute_sql_statement(
sql_statement,
query,
session=session,
cursor=cursor,
log_params={},
apply_ctas=False,
)
database.apply_limit_to_sql.assert_called_with(
"SELECT * FROM sales WHERE organization_id=42",
101,
force=True,
)
db_engine_spec.execute.assert_called_with(
cursor,
"SELECT * FROM sales WHERE organization_id=42 LIMIT 101",
async_=True,
)
SupersetResultSet.assert_called_with([(42, )], cursor.description,
db_engine_spec)
def test_producer_runner_call_consume_message(mocker: MockerFixture):
metric_collector = mocker.MagicMock()
metric_collector.collect_metrics = AsyncMock()
data = {"data": "blah"}
metric_collector.collect_metrics.return_value = data
transport = mocker.MagicMock()
transport.publish = mocker.MagicMock()
runner = ProducerRunner(metric_collector, transport)
asyncio.get_event_loop().run_until_complete(runner.run())
metric_collector.collect_metrics.assert_called_once()
transport.publish.assert_called_once_with(data)
def test_update_calendar(mocker: MockerFixture) -> None:
"""
Test ``update_calendar``.
"""
client = mocker.MagicMock()
calendar = client.principal.return_value.calendar.return_value
event = Event()
event.add("summary", "A summary")
event.add("dtstart", datetime(2021, 1, 1, 12, tzinfo=timezone.utc))
event.add("dtend", datetime(2021, 1, 1, 14, tzinfo=timezone.utc))
update_calendar(client, "Personal", event)
calendar.save_event.assert_called_with(
b"""BEGIN:VCALENDAR\r
VERSION:2.0\r
PRODID:-//Nefelibata Corp.//CalDAV Client//EN\r
X-WR-CALNAME:Personal\r
BEGIN:VEVENT\r
SUMMARY:A summary\r
DTSTART;TZID=UTC;VALUE=DATE-TIME:20210101T120000Z\r
DTEND;TZID=UTC;VALUE=DATE-TIME:20210101T140000Z\r
END:VEVENT\r
END:VCALENDAR\r
""", )
def test_invalid_data(self, client, mocker: MockerFixture) -> None:
session_get_mock = mocker.patch("requests.Session.get",
return_value=mocker.MagicMock())
session_get_mock.ok.return_value = False
with pytest.raises(RequestError):
client.auth()
def test_schedule_absolute(mocker: MockerFixture, mode: TimeMode, interval: int):
timer = mocker.patch(f"bge.logic.get{mode.name}Time")
timer.return_value = 0
start = datetime.now()
due = start + timedelta(seconds=interval)
scheduler = EventLoopScheduler(start, mode)
action = mocker.MagicMock()
scheduler.schedule_absolute(due, action, "State")
scheduler.process()
action.assert_not_called()
timer.return_value = interval * 0.8
scheduler.process()
action.assert_not_called()
timer.return_value = interval + 1
scheduler.process()
action.assert_called_with(scheduler, "State")
timer.return_value = interval * 1.1
scheduler.process()
action.assert_called_once()
def test_database_connect(mocker: MockerFixture):
db = MysqldbDatabase("loc", "user", "password", "database")
mocker.patch.object(MySQLdb, "connect")
query = mocker.MagicMock()
query.return_value = []
mocker.patch.object(db, "query", query)
db.connect()
MySQLdb.connect.assert_has_calls([
mocker.call(
"loc",
"user",
"password",
"database",
use_unicode=True,
charset="utf8mb4",
)
])
query.assert_has_calls([mocker.call("show", "tables")])
db.close()
db.query = lambda a, b: [{"": "foo"}] if a == "show" else []
query_spy = mocker.spy(db, "query")
mocker.patch.object(db, "query", query_spy)
db.connect()
query_spy.assert_has_calls(
[mocker.call("show", "tables"),
mocker.call("describe", "foo")])
assert "foo" in db.table_names
async def test_update_webmention(mocker: MockerFixture) -> None:
"""
Test ``update_webmention``.
"""
session = mocker.MagicMock()
get_response = session.get.return_value.__aenter__.return_value
source = URL("https://alice.example.com/posts/one")
target = URL("https://bob.example.com/posts/two")
location = URL("https://bob.example.com/webmention.php?id=42")
get_response.ok = True
webmention = await update_webmention(session, source, target, location)
assert webmention.dict() == {
"source": "https://alice.example.com/posts/one",
"target": "https://bob.example.com/posts/two",
"status": "success",
"location": None,
}
get_response.ok = False
webmention = await update_webmention(session, source, target, location)
assert webmention.dict() == {
"source": "https://alice.example.com/posts/one",
"target": "https://bob.example.com/posts/two",
"status": "queue",
"location": None,
}
def test_schedule_relative(mocker: MockerFixture, mode: TimeMode, interval: int):
timer = mocker.patch(f"bge.logic.get{mode.name}Time")
timer.return_value = 0.
scheduler = EventLoopScheduler(mode=mode)
action = mocker.MagicMock()
scheduler.schedule_relative(interval, action, "State")
scheduler.process()
action.assert_not_called()
timer.return_value = interval * 0.5
scheduler.process()
action.assert_not_called()
timer.return_value = interval + 1
scheduler.process()
action.assert_called_with(scheduler, "State")
timer.return_value = interval * 1.2
scheduler.process()
action.assert_called_once()
def test_with_report(
self,
test_testrun_view: TestRunView,
mocker: MockerFixture,
test_testrun_id: int,
column_name: str,
status: TestRunStatus,
report_status: TestReportStatus,
test_testrun_report: Optional[str],
test_testrun_button_css_class: str,
) -> None:
result = result_report_formatter(
view=test_testrun_view,
context=mocker.MagicMock(),
model=TestRun( # type: ignore
id=test_testrun_id,
status=status,
report_status=report_status,
report=test_testrun_report),
name=column_name,
)
if test_testrun_report is None:
raise RuntimeError
assert result == Markup(
f"<form action='{get_report_index_link(test_testrun_report)}' method='POST' target='_blank'>"
f"<input type='hidden' name='run_id' value='{test_testrun_id}' />"
f"<fieldset title='Go to report'>"
f"<button class='link-button {test_testrun_button_css_class}' type='submit'>{status}</button>"
"</fieldset>"
"</form>")
async def test_run(
mocker: MockerFixture,
root: Path,
) -> None:
"""
Test ``run``.
"""
builder = mocker.MagicMock()
builder.process_post = mocker.AsyncMock()
builder.process_site = mocker.AsyncMock()
mocker.patch("nefelibata.cli.init.get_config")
mocker.patch("nefelibata.cli.init.get_builders",
return_value={"builder": builder})
_logger = mocker.patch("nefelibata.cli.init._logger")
await init.run(root)
builder.setup.assert_called()
_logger.info.assert_called_with("Blog created!")
assert (root / CONFIG_FILENAME).exists()
assert (root / "posts/first/index.mkd").exists()
# error if running again
with pytest.raises(IOError) as excinfo:
await init.run(root)
assert str(
excinfo.value) == "File /path/to/blog/nefelibata.yaml already exists!"
def test_log_request_with_invalid_content_length(
mocker: MockerFixture, app: DummyApplication) -> None:
registry = app.prometheus_registry
mock_handler = mocker.MagicMock()
mock_handler.get_status.return_value = 200
mock_handler.request.method = "GET"
mock_handler.request.request_time.return_value = 1.234 # seconds
# Without header
app.log_request(mock_handler)
# Empty string
mock_handler._headers.get.return_value = ""
app.log_request(mock_handler)
# Invalid type
mock_handler._headers.get.return_value = []
app.log_request(mock_handler)
assert (registry.get_sample_value(
"mypy_play_http_response_size_bytes_count",
{
"handler": "MagicMock",
"method": "GET"
},
) is None)
assert (registry.get_sample_value(
"mypy_play_http_response_size_bytes_sum",
{
"handler": "MagicMock",
"method": "GET"
},
) is None)
def test_ci_launch_01(
mocker: MockerFixture, platform: Optional[str], secret: Optional[str]
) -> None:
"""test CLI entrypoint for CI launch"""
log_init = mocker.patch("orion_decision.cli.configure_logging", autospec=True)
parser = mocker.patch("orion_decision.cli.parse_ci_launch_args", autospec=True)
chdir = mocker.patch("orion_decision.cli.chdir", autospec=True)
environ = mocker.patch("orion_decision.cli.os_environ", autospec=True)
run = mocker.patch("orion_decision.cli.run", autospec=True)
repo = mocker.patch("orion_decision.cli.GitRepo", autospec=True)
mocker.patch.object(CISecretEnv, "get_secret_data", return_value="secret")
copy: Dict[str, str] = {}
environ.copy.return_value = copy
if platform == "windows":
parser.return_value.job.platform = "windows"
parser.return_value.job.script = ["/mock-test-path", "arg"]
mocker.patch("orion_decision.cli.which", side_effect=lambda x: x)
if secret == "env":
sec = CISecretEnv("secret", "name")
parser.return_value.job.secrets = [sec]
elif secret == "other":
sec = mocker.MagicMock()
parser.return_value.job.secrets = [sec]
with pytest.raises(SystemExit) as exc:
ci_launch()
assert exc.value.code == run.return_value.returncode
assert log_init.call_count == 1
assert parser.call_count == 1
assert log_init.call_args == call(level=parser.return_value.log_level)
assert chdir.call_count == 1
assert repo.call_count == 1
assert repo.call_args == call(
parser.return_value.clone_repo,
parser.return_value.fetch_ref,
parser.return_value.fetch_rev,
)
assert chdir.call_args == call(repo.return_value.path)
assert run.call_count == 1
cmd = parser.return_value.job.script
assert run.call_args == call(cmd, env=environ.copy.return_value, check=True)
# check that env secret is put in env
if secret == "env":
assert isinstance(sec.get_secret_data, MagicMock)
assert sec.get_secret_data.call_count == 1
assert copy[sec.name] == sec.get_secret_data.return_value
# check that non-env secret gets written
elif secret == "other":
assert not copy
assert isinstance(sec, MagicMock)
assert sec.write.call_count == 1
def test_assert_response_status_with_404_response_and_404_is_allowed_should_not_raise(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 404
# act
assert_response_status(response, True)
def test_update_calendar_create(mocker: MockerFixture) -> None:
"""
Test ``update_calendar`` when the calendar doesn't exist.
"""
client = mocker.MagicMock()
client.principal.return_value.calendar.side_effect = Exception("Not found")
mocker.patch(
"nefelibata.assistants.rsvp_calendar.caldav.error.NotFoundError",
Exception,
)
event = mocker.MagicMock()
update_calendar(client, "Personal", event)
client.principal.return_value.make_calendar.assert_called_with(
name="Personal")
def mock_client_session(mocker: pytest_mock.MockerFixture,
mock_response: Any) -> MagicMock:
session: MagicMock = mocker.MagicMock()
cast(Any, session).__aenter__.return_value = session
session.get = mocker.Mock(return_value=mock_response)
session.post = mocker.Mock(return_value=mock_response)
return session
async def test_finish_deployment(mocker: MockerFixture, gstate: GlobalState):
from gravel.controllers.nodes.conn import ConnMgr
from gravel.controllers.nodes.deployment import NodeDeployment
fake_connmgr: ConnMgr = cast(ConnMgr, mocker.MagicMock())
deployment = NodeDeployment(gstate, fake_connmgr)
deployment.state.mark_bootstrap()
deployment.finish_deployment()
assert deployment.state.deployed
def test_assert_response_status_with_400_response_should_raise_input_error(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 400
# act
with raises(InputError):
assert_response_status(response)
def test_assert_response_status_with_403_response_should_raise_not_authorized_error(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 403
# act
with raises(NotAuthorizedError):
assert_response_status(response)
def test_assert_response_status_with_401_response_should_raise_invalid_authorization_error(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 401
# act
with raises(InvalidAuthorizationError):
assert_response_status(response)
def test_assert_response_status_with_502_response_should_raise_server_error(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 502
# act
with raises(ServerError):
assert_response_status(response)
def test_assert_response_status_with_404_response_should_raise_not_found_error(
mocker: MockerFixture):
# arrange
response = mocker.MagicMock()
response.status_code = 404
# act
with raises(NotFoundError):
assert_response_status(response)
def test_postgres_db_insert_data_raises_exception_if_data_is_not_json_decodable(
mocker: MockerFixture):
mocker.patch('db.postgres_db.Postgres', autospec=True)
logger_patched = mocker.patch.object(logger, 'error', autospec=True)
db_client = PgDatabaseClient(mocker.MagicMock())
db_client.insert_data("")
logger_patched.assert_called_once_with(
"Cannot save data to db, following error occurred Expecting value: line 1 "
"column 1 (char 0)")
async def test_request_without_auth(mocker: pytest_mock.MockerFixture):
m_auth = mocker.MagicMock(side_effect=lambda args, kwargs: args)
items = {
"example.com": pybotters.auth.Item("example", m_auth),
}
mocker.patch.object(pybotters.auth.Hosts, "items", items)
m_sesison = mocker.MagicMock()
m_sesison.__dict__["_apis"] = {}
req = ClientRequest(
"GET",
URL("http://example.com"),
params={"foo": "bar"},
session=m_sesison,
auth=None,
)
assert req.url == URL("http://example.com?foo=bar")
assert not m_auth.called
def test_with_url(self, test_draft_view: DraftView, mocker: MockerFixture,
column_name: str, test_testrun_id: int,
test_prurl: str) -> None:
assert draft_prurl_formatter(
view=test_draft_view,
context=mocker.MagicMock(),
model=db.Draft(**{column_name: test_prurl}), # type: ignore
name=column_name,
) == Markup(
f"<a href='{URL(test_prurl).human_repr()}'>{test_prurl}</a>")
