def mock_values(mocker: MockFixture):
mock_values = mocker.NonCallableMock()
mocker.patch(
PATH.format('get_spreadsheets_values'),
return_value=mock_values,
)
return mock_values
def test_get_spreadsheets_values(mocker: MockFixture):
mock_creds = mocker.create_autospec(Credentials, instance=True)
mocker.patch(PATH.format('get_credentials'), return_value=mock_creds)
mock_resource = mocker.NonCallableMock()
mock_build = mocker.patch(PATH.format('build'), return_value=mock_resource)
mock_values = mock_resource.spreadsheets().values()
values = google_sheets.get_spreadsheets_values()
assert values is mock_values
mock_build.assert_called_once_with('sheets', 'v4', credentials=mock_creds)
def window(model: Model, qtbot: QtBot, mocker: MockFixture):
"""the window."""
message_box = 'usc_lr_timer.app.QtWidgets.QMessageBox.{}'
mocker.patch(message_box.format('question'),
return_value=QtWidgets.QMessageBox.Yes)
mocker.patch(message_box.format('information'))
window = MainWindow(model)
qtbot.add_widget(window)
return window
def test_parse_RequiredArguments(mocker: MockFixture, argv: list):
mocker.patch('sys.argv', argv)
args = parse()
assert len(vars(args)) == 7
assert args.api_endpoint == 'endpoint'
assert args.owner == 'owner'
assert args.repo == 'repo'
assert args.token == 'token'
assert args.mapping is None
assert args.output is None
assert args.write_apiresponse is False
def test_parse_OptionalArguments(mocker: MockFixture, argv: list):
argv.append('--mapping=mapping')
argv.append('--output=output')
argv.append('--write-apiresponse')
mocker.patch('sys.argv', argv)
args = parse()
assert len(vars(args)) == 7
assert args.api_endpoint == 'endpoint'
assert args.owner == 'owner'
assert args.repo == 'repo'
assert args.token == 'token'
assert args.mapping == 'mapping'
assert args.output == 'output'
assert args.write_apiresponse
def mock_ttg(mocker: MockFixture):
mock_ttg = mocker.patch(
PATH.format('talk_to_google.talk_to_google'),
autospec=True,
)
mock_ttg.return_value = Results.success, [['a', '1'], ['b', '2']]
return mock_ttg
def test_get_credentials(mocker: MockFixture):
mock_from_service_account_file = mocker.patch(
PATH.format('service_account.Credentials.from_service_account_file'))
google_sheets.get_credentials()
mock_from_service_account_file.assert_called_once_with(
str(google_sheets.SERVICE_ACCOUNT_FILE),
scopes=['https://www.googleapis.com/auth/spreadsheets'],
)
def test_talk_to_google_cancel(qtbot: QtBot, mocker: MockFixture):
def fn(a, b):
qtbot.wait(600)
mocker.patch(PATH.format('ALLOWED_METHODS'), [fn])
progress = QtWidgets.QProgressDialog('test', 'test', 0, 0)
def exec_(*args, **kwargs):
progress.cancel()
mock_exec = mocker.patch.object(progress, 'exec_', side_effect=exec_)
mock_Progress = mocker.patch(PATH.format('QtWidgets.QProgressDialog'),
return_value=progress)
result, data = talk_to_google.talk_to_google(fn, 1, b=2)
assert result == talk_to_google.Results.canceled
assert data is None
mock_exec.assert_called_once_with()
mock_Progress.assert_called_once_with('Talking to Google...', 'Stop', 0, 0)
def test_getIssuesPerPage_RequestParameters(mocker: MockFixture, emptyRequests: MagicMock):
mocker.patch('requests.get', emptyRequests)
GitbucketApi('endpoint', 'owner', 'repo', 'token').getIssuesPerPage(1)
issues_endpoint, optional_args = emptyRequests.call_args
# Check Request Header
assert 'headers' in optional_args
header = optional_args['headers']
assert header['Authorization'] == 'token token'
assert header['content-type'] == 'application/json'
assert 'params' in optional_args
payload = optional_args['params']
assert payload['page'] == 1
assert payload['state'] == 'open'
assert issues_endpoint[0] == 'endpoint/api/v3/repos/owner/repo/issues'
assert header['Authorization'] == 'token token'
assert header['content-type'] == 'application/json'
def test_talk_to_google_error(qtbot: QtBot, mocker: MockFixture):
def fn(a, b):
raise RuntimeError('Test Exception')
mocker.patch(PATH.format('ALLOWED_METHODS'), [fn])
progress = QtWidgets.QProgressDialog('test', 'test', 0, 0)
def exec_(*args, **kwargs):
while progress.result() != progress.Accepted:
qtbot.wait(200)
mock_exec = mocker.patch.object(progress, 'exec_', side_effect=exec_)
mock_Progress = mocker.patch(PATH.format('QtWidgets.QProgressDialog'),
return_value=progress)
mock_critical = mocker.patch(PATH.format('QtWidgets.QMessageBox.critical'))
result, data = talk_to_google.talk_to_google(fn, 1, b=2)
assert result == talk_to_google.Results.error
assert data is None
mock_exec.assert_called_once_with()
mock_Progress.assert_called_once_with('Talking to Google...', 'Stop', 0, 0)
mock_critical.assert_called_once_with(None, 'Error', 'Test Exception')
def mock_progress(mocker: MockFixture, qtbot: QtBot):
progress = QtWidgets.QProgressDialog('test', 'test', 0, 0)
def exec_(*args, **kwargs):
while progress.result() != progress.Accepted:
qtbot.wait(200)
mocker.patch.object(progress, 'exec_', side_effect=exec_)
mock_Progress = mocker.patch(
'usc_lr_timer.model.talk_to_google.QtWidgets.QProgressDialog',
return_value=progress,
)
return mock_Progress
def mock_talk_to_google(mocker: MockFixture, mock_progress: Mock):
mock_talk_to_google = mocker.patch(
'usc_lr_timer.model.talk_to_google.talk_to_google',
autospec=True,
)
def talk_to_google(method, *args, **kwargs):
if method is google_sheets.get_categories:
return Results.success, ['testing', 'other']
elif method is google_sheets.add_time:
return Results.success, None
else:
raise NotImplementedError
mock_talk_to_google.side_effect = talk_to_google
return mock_talk_to_google
def repository(mocker: MockFixture, env: MockEnv) -> InstalledRepository:
mocker.patch(
"poetry.utils._compat.metadata.Distribution.discover",
return_value=INSTALLED_RESULTS,
)
mocker.patch(
"poetry.core.vcs.git.Git.rev_parse",
return_value="bb058f6b78b2d28ef5d9a5e759cfa179a1a713d6",
)
mocker.patch(
"poetry.core.vcs.git.Git.remote_urls",
side_effect=[
{"remote.origin.url": "https://github.com/sdispater/pendulum.git"},
{"remote.origin.url": "[email protected]:sdispater/pendulum.git"},
],
)
mocker.patch("poetry.repositories.installed_repository._VENDORS", str(VENDOR_DIR))
return InstalledRepository.load(env)
def fake_environ(
mocker: MockFixture, monkeypatch: MonkeyPatch
) -> Iterator[Dict[str, Dict[str, Union[str, int]]]]:
os.environ
environ = dict()
environ["DEBUG"] = "True"
environ["TESTING"] = "True"
environ["SECRET_KEY"] = "43n080musdfjt54t-09sdgr"
environ["REDIS_URL"] = "redis://localhost"
environ["REDIS_ENDPOINT"] = "127.0.0.1"
environ["REDIS_PORT"] = "6379"
environ["REDIS_DB"] = "0"
environ["DATABASE_URL"] = "sqlite:///dev.db"
environ["TEST_DATABASE_URL"] = "sqlite:///test.db"
environ["DEFAULT_MODULE_NAME"] = "ultron8.web"
environ["VARIABLE_NAME"] = "app"
environ["MODULE_NAME"] = "ultron8.web"
environ["APP_MODULE"] = "ultron8.web:app"
# environ["DEFAULT_GUNICORN_CONF"] = /Users/malcolm/dev/bossjones/ultron8/gunicorn_conf.py
# environ["PRE_START_PATH"] = /Users/malcolm/dev/bossjones/ultron8/migrations/gunicorn-prestart.sh
environ["DOMAIN"] = "localhost"
environ["HOST"] = "localhost"
environ["PORT"] = "11267"
environ["LOG_LEVEL"] = logging.DEBUG
environ["BETTER_EXCEPTIONS"] = "1"
environ["SERVER_NAME"] = "localhost:11267"
environ["SERVER_HOST"] = "http://*****:*****@ultron8.com"
environ["FLOWER_AUTH"] = "admin:password"
environ["USERS_OPEN_REGISTRATION"] = "False"
environ["BACKEND_CORS_ORIGINS"] = "*"
mocks = {"environ": mocker.patch("os.environ", environ)}
yield mocks
def test_submit(model: Model, mocker: MockFixture):
mock_ttg = mocker.patch('usc_lr_timer.model.talk_to_google.talk_to_google')
mock_ttg.return_value = Results.success, None
model._name = None
assert model.submit(True) == SubmitResult(None, 'Name not chosen')
model._name = 'Vincent'
assert model.submit(True) == SubmitResult(None, 'Category not chosen')
model._categories = ['', 'testing']
model.set_category_index(1)
model.set_manual_minutes(61)
model.set_manual_seconds(61)
result = SubmitResult(None, 'Minutes must be between 0 and 60')
assert model.submit(True) == result
model.set_manual_minutes(0)
result = SubmitResult(None, 'Seconds must be between 0 and 60')
assert model.submit(True) == result
model.set_manual_seconds(0)
assert model.submit(True) == SubmitResult(None, 'No time recorded')
model.set_manual_seconds(42)
assert model.submit(True) == SubmitResult(Results.success, None)
mock_ttg.assert_called_with(
google_sheets.add_time,
spreadsheet_id='abc123',
name='Vincent',
semester='Fall',
duration=timedelta(seconds=42),
category='testing',
)
assert model.submit(False) == SubmitResult(None, 'No time recorded')
model.increment_duration(24)
assert model.submit(False) == SubmitResult(Results.success, None)
mock_ttg.assert_called_with(
google_sheets.add_time,
spreadsheet_id='abc123',
name='Vincent',
semester='Fall',
duration=timedelta(seconds=24),
category='testing',
)
def evaluate_func_mocker(mocker: MockFixture):
mocker.patch('langmodels.cli.impl.evaluate_on_path')
mocker.patch('langmodels.cli.impl.load_from_path')
return mocker
def mock_journals(mocker: MockFixture, tmpdir: LocalPath):
journals: LocalPath = tmpdir.join('journals.json')
mocker.patch(PATH.format('JOURNALS'), str(journals))
with journals.open('w') as stream:
json.dump({'w': 'x', 'y': 'z'}, stream)
def mock_journals(mocker: MockFixture, tmpdir: LocalPath):
journals: LocalPath = tmpdir.join('journals.json')
mocker.patch('usc_lr_timer.login.JOURNALS', str(journals))
with journals.open('w') as stream:
json.dump({'Law Review': 'abc123', 'RLSJ': 'xyz789'}, stream)
def mock_critical(mocker: MockFixture):
return mocker.patch('usc_lr_timer.login.QtWidgets.QMessageBox.critical')
def model_mock_ttg(mocker: MockFixture):
mock_ttg = mocker.patch('usc_lr_timer.model.talk_to_google.talk_to_google')
mock_ttg.return_value = Results.success, ['testing']
return mock_ttg
def train_func_mocker(mocker: MockFixture):
mocker.patch('langmodels.training.cli.train')
return mocker