def test_splunk_saved_searches(splunk_client):
"""Check saved searches."""
splunk_client.connect = cli_connect
sp_driver = SplunkDriver()
# trying to get these before connecting should throw
with pytest.raises(MsticpyNotConnectedError) as mp_ex:
sp_driver._get_saved_searches()
check.is_false(sp_driver.connected)
check.is_none(sp_driver._saved_searches)
check.is_in("not connected to Splunk.", mp_ex.value.args)
sp_driver.connect(host="localhost", username="******",
password="******") # nosec
check.is_true(sp_driver.connected)
check.is_instance(sp_driver._saved_searches, pd.DataFrame)
for _, search in sp_driver._saved_searches.iterrows():
check.is_true(search["name"].startswith("query"))
check.equal(search["query"], "get stuff from somewhere")
queries, name = sp_driver.service_queries
check.equal(name, "SavedSearches")
check.is_instance(queries, dict)
for name, query in queries.items():
check.is_true(name.startswith("query"))
check.equal(query, "search get stuff from somewhere")
def test_splunk_saved_searches(splunk_client):
"""Check saved searches."""
splunk_client.connect = cli_connect
sp_driver = SplunkDriver()
# trying to get these before connecting should throw
with pytest.raises(MsticpyNotConnectedError) as mp_ex:
sp_driver._get_saved_searches()
check.is_false(sp_driver.connected)
check.is_none(sp_driver._saved_searches)
check.is_in("not connected to Splunk.", mp_ex.value.args)
# [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Test code")]
sp_driver.connect(host="localhost", username="******", password=_FAKE_STRING) # nosec
check.is_true(sp_driver.connected)
check.is_instance(sp_driver._saved_searches, pd.DataFrame)
for _, search in sp_driver._saved_searches.iterrows():
check.is_true(search["name"].startswith("query"))
check.equal(search["query"], "get stuff from somewhere")
queries, name = sp_driver.service_queries
check.equal(name, "SavedSearches")
check.is_instance(queries, dict)
for name, query in queries.items():
check.is_true(name.startswith("query"))
check.equal(query, "search get stuff from somewhere")
def test_notebooklet_create(monkeypatch):
"""Test method."""
# Should run because required providers are loaded
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
data_providers.init(query_provider="LocalData",
providers=["tilookup", "geolitelookup"])
for _, nblt in nblts.iter_classes():
new_nblt = nblt()
check.is_instance(new_nblt, Notebooklet)
check.is_none(new_nblt.result)
# Should throw a warning because of unrecognized provider
data_providers.init(query_provider="LocalData")
with pytest.raises(MsticnbDataProviderError) as err:
for _, nblt in nblts.iter_classes():
curr_provs = nblt.metadata.req_providers
bad_provs = [*curr_provs, "bad_provider"]
try:
nblt.metadata.req_providers = bad_provs
new_nblt = nblt()
check.is_instance(new_nblt, Notebooklet)
check.is_none(new_nblt.result)
finally:
nblt.metadata.req_providers = curr_provs
check.is_in("bad_provider", err.value.args[0])
test_nb = TstNBSummary()
check.is_not_none(test_nb.get_provider("LocalData"))
with pytest.raises(MsticnbDataProviderError):
test_nb.get_provider("otherprovider")
def test_notebooklet_options(monkeypatch):
"""Test option logic for notebooklet."""
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
data_providers.init(query_provider="LocalData",
providers=["tilookup", "geolitelookup"])
nb_test = TstNBSummary()
# default options
nb_res = nb_test.run()
check.is_not_none(nb_res.default_property)
check.is_none(nb_res.optional_property)
# add optional option
nb_res = nb_test.run(options=["+optional_opt"])
check.is_not_none(nb_res.default_property)
check.is_not_none(nb_res.optional_property)
# remove default option
nb_res = nb_test.run(options=["-default_opt"])
check.is_none(nb_res.default_property)
check.is_none(nb_res.optional_property)
# specific options
nb_res = nb_test.run(options=["heartbest", "azure_net"])
check.is_none(nb_res.default_property)
check.is_none(nb_res.optional_property)
# invalid option
f_stream = StringIO()
with redirect_stdout(f_stream):
nb_test.run(options=["invalid_opt"])
output = str(f_stream.getvalue())
check.is_in("Invalid options ['invalid_opt']", output)
def test_extract_header_nowcs():
header = fits.Header.fromstring(_base_header, sep='\n')
h, wcs = extract_header_wcs(header)
check.is_none(wcs)
check.is_instance(h, fits.Header)
check.equal(h, header)
check.is_false(h is header)
def test_ip_summary_notebooklet_internal(monkeypatch):
"""Test basic run of notebooklet."""
test_data = str(Path(TEST_DATA_PATH).absolute())
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
monkeypatch.setattr(data_providers, "TILookup", TILookupMock)
data_providers.init(
query_provider="LocalData",
LocalData_data_paths=[test_data],
LocalData_query_paths=[test_data],
providers=["tilookup", "geolitelookup"],
)
test_nb = nblts.azsent.network.IpAddressSummary()
tspan = TimeSpan(period="1D")
test_nb.query_provider.schema.update({tab: {} for tab in DEF_PROV_TABLES})
result = test_nb.run(value="40.76.43.124", timespan=tspan)
check.is_not_none(result.ip_entity)
check.equal(result.ip_type, "Public")
check.equal(result.ip_origin, "Internal")
check.is_not_none(result.whois)
check.is_instance(result.related_alerts, pd.DataFrame)
check.is_instance(result.heartbeat, pd.DataFrame)
check.is_instance(result.az_network_if, pd.DataFrame)
check.is_none(result.passive_dns)
check.is_none(result.ti_results)
def test_on_step_end(self, mocker):
""" should update episode_metrics for the current agent and
steps_cycle_metrics for all agents on_step_end. """
mocker.patch(self.logging_callback_path +
'._update_metrics_all_agents')
mocker.patch(self.logging_callback_path + '._update_metrics')
logging_callback = LoggingCallback()
logging_callback.n_agents = 1
logging_callback.on_step_end(step=7)
args, kwargs = logging_callback._update_metrics.call_args
check.equal(args[1], 'episode')
check.is_false(kwargs.get('reset'))
check.is_none(kwargs.get('agent_id'))
args, kwargs = logging_callback._update_metrics_all_agents.call_args
check.equal(args[1], 'steps_cycle')
check.is_false(kwargs.get('reset'))
# Multi agents
logging_callback = LoggingCallback()
logging_callback.n_agents = 5
logging_callback.on_step_end(step=7, logs={'agent_id': 3})
args, kwargs = logging_callback._update_metrics.call_args
check.equal(args[1], 'episode')
check.is_false(kwargs.get('reset'))
check.equal(kwargs.get('agent_id'), 3)
args, kwargs = logging_callback._update_metrics_all_agents.call_args
check.equal(args[1], 'steps_cycle')
check.is_false(kwargs.get('reset'))
def test_params(data, expected):
check.equal(data.get_age(), expected["age"])
check.equal(data.get_goals(), expected["goals"])
check.equal(data.get_cards(), expected["cards"])
check.equal(data.get_position(), expected["position"])
check.equal(data.get_name(), expected["name"])
check.is_none(data.get_club())
check.equal(data.get_field_number(), expected["field_number"])
def test_clear(qtbot, page):
widget = QWidget()
qtbot.addWidget(widget)
page.central_layout.addWidget(widget)
page.clear()
check.is_none(widget.parent())
check.equal(page.central_layout.count(), 0)
def test_initial_values_for_user():
p = Player("Ronaldinho", "attacker", 23)
check.equal(p.get_age(), 23)
check.equal(p.get_goals(), 0)
check.equal(p.get_cards(), 0)
check.equal(p.get_position(), "attacker")
check.equal(p.get_name(), "Ronaldinho")
check.is_none(p.get_club())
check.equal(p.get_field_number(), 0)
def test_extract_invalid_wcs_header():
# It should no raise, just return empty wcs
# No header change too
header = fits.Header.fromstring(_base_header + _invalid_wcs, sep='\n')
h, wcs = extract_header_wcs(header)
check.is_none(wcs)
check.is_instance(h, fits.Header)
check.equal(h, header)
check.is_false(h is header)
def test_checkboxLegend_line():
"""Test legend with lines"""
line, = plt.plot([1, 2], [1, 2], color='r', lw=2)
legend = plt.legend([line], ["line"],
handler_map={line: VisibilityHandler()})
line_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
line)
line_handler = line_handle.handler
checked = line_handle.is_checked()
check.is_none(line_handler)
check.equal(checked, True)
def test_checkboxLegend_patch():
"""Test legend with patches"""
rect = mpatches.Rectangle((0, 0), 0.5, 0.5, label="rect")
ax = plt.gca()
ax.add_patch(rect)
legend = plt.legend([rect], ["rect"],
handler_map={rect: VisibilityHandler()})
rect_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
rect)
rect_handler = rect_handle.handler
checked = rect_handle.is_checked()
check.is_none(rect_handler)
check.equal(checked, True)
def test_checkboxLegend_text():
"""Test legend with text"""
ax = plt.gca()
line, = plt.plot([1, 2], [1, 2], color='r', lw=2)
text = plt.text(1, 1.5, "text on plot")
legend = plt.legend([text], ["text"],
handler_map={text: VisibilityHandler(handler=None)})
text_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
text)
text_handler = text_handle.handler
checked = text_handle.is_checked()
check.is_none(text_handler)
check.equal(checked, True)
def test_classify_img():
image_dir = '/sampleImage/'
# Changes to tests:
# we changed the images classified due to the limitations of our ML model
# since the model is only trained on 1000 object categories
# we will create a helper function in the next iteration
# to test for semantic simularity and get better search results
image_names = [
'banana',
'basketball',
'carton',
'cucumber',
'fountain',
'golden_retriever',
'goldfish',
'passenger_car',
'pop_bottle',
'seashore',
'space_shuttle',
'sports_car',
'suit',
'tabby',
'volcano'
]
# Changes to tests:
# wrong_names is a rotation of original image_names
# as it is unlikely that basketball
# will be in the classification dict for banana and so on
wrong_names = image_names[1:] + image_names[:1]
img_ext = '.jpg'
# instead of simply using os.getcwd(), we use full_path so that pytest will
# find the images regardless of where you run pytest
# (like in test/ as opposed to main dir)
full_path = os.path.realpath(__file__)
test_folder = os.path.dirname(full_path)
w = Worker()
check.is_none(w.classify_img(None))
for idx, name in enumerate(image_names):
img = Image.open(test_folder + image_dir + name + img_ext)
# should all be true
# (that 'banana' is in classification dict for 'banana.jpg' and so on)
check.is_in(name, w.classify_img(img))
# now let's try assertions that should definitely be wrong
# (that 'volcano' is in the classification dict for 'banana.jpg')
check.is_not_in(wrong_names[idx], w.classify_img(img))
def test_on_run_begin(self, mocker):
""" should set n_agents on_run_begin. """
class DummyPlayground():
"""DummyPlaygrounf"""
def __init__(self, n_agents):
self.agents = [None] * n_agents
n_agents = 5
mocker.patch(self.logging_callback_path + '', return_value=n_agents)
logging_callback = LoggingCallback()
logging_callback.playground = DummyPlayground(n_agents)
check.is_none(logging_callback.n_agents)
logging_callback.on_run_begin()
check.equal(logging_callback.n_agents, n_agents)
def test_constructor():
# Currently, when the GUI object is created, we are only allowing
# the default values to be used.
# test default constructor with no parameters
test_gui = GUI()
check.equal(test_gui.video_path, '')
check.equal(test_gui.settings, {
'conf': .5,
'poll': 5,
'anti': 5,
'runtime': 1,
'search': []
})
check.is_none(test_gui.job)
def compare_tables(table, ref):
for row_num in range(table.num_rows):
for col_num in range(table.num_cols):
if ref[row_num][col_num] is None:
check.is_none(
table.cell(row_num, col_num).formula,
f"!existsy@[{row_num},{col_num}]",
)
else:
check.is_not_none(
table.cell(row_num, col_num).formula,
f"exists@[{row_num},{col_num}]",
)
check.equal(
table.cell(row_num, col_num).formula,
ref[row_num][col_num],
f"formula@[{row_num},{col_num}]",
)
def test_splunk_fired_alerts(splunk_client):
"""Check fired alerts."""
splunk_client.connect = cli_connect
sp_driver = SplunkDriver()
# trying to get these before connecting should throw
with pytest.raises(MsticpyNotConnectedError) as mp_ex:
sp_driver._get_fired_alerts()
check.is_false(sp_driver.connected)
check.is_none(sp_driver._fired_alerts)
check.is_in("not connected to Splunk.", mp_ex.value.args)
sp_driver.connect(host="localhost", username="******",
password="******") # nosec
check.is_true(sp_driver.connected)
check.is_instance(sp_driver._fired_alerts, pd.DataFrame)
for _, alert in sp_driver._fired_alerts.iterrows():
check.is_true(alert["name"].startswith("alert"))
check.equal(alert["count"], 10)
def test_splunk_fired_alerts(splunk_client):
"""Check fired alerts."""
splunk_client.connect = cli_connect
sp_driver = SplunkDriver()
# trying to get these before connecting should throw
with pytest.raises(MsticpyNotConnectedError) as mp_ex:
sp_driver._get_fired_alerts()
check.is_false(sp_driver.connected)
check.is_none(sp_driver._fired_alerts)
check.is_in("not connected to Splunk.", mp_ex.value.args)
# [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Test code")]
sp_driver.connect(host="localhost", username="******", password=_FAKE_STRING) # nosec
check.is_true(sp_driver.connected)
check.is_instance(sp_driver._fired_alerts, pd.DataFrame)
for _, alert in sp_driver._fired_alerts.iterrows():
check.is_true(alert["name"].startswith("alert"))
check.equal(alert["count"], 10)
def test_checkboxLegend_multiple():
"""Test with multiple handlers"""
ax = plt.gca()
line, = plt.plot([1, 2], [1, 2], color='r', lw=2)
text = plt.text(1, 1.5, "text on plot")
rect = mpatches.Rectangle((1.5, 1.4), 0.5, 0.5, label="rect")
rect.set_visible(0)
ax.add_patch(rect)
legend = plt.legend(
[text, line, rect], ["text", "line", "rect"],
handler_map={
text: VisibilityHandler(),
line: VisibilityHandler(),
rect: VisibilityHandler()
})
line_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
line)
line_handler = line_handle.handler
rect_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
rect)
rect_handler = rect_handle.handler
line_checked = line_handle.is_checked()
rect_checked = rect_handle.is_checked()
text_handle = legend.get_legend_handler(legend.get_legend_handler_map(),
text)
text_handler = text_handle.handler
text_checked = text_handle.is_checked()
check.is_none(line_handler)
check.is_none(rect_handler)
check.is_none(text_handler)
check.equal(line_checked, True)
check.equal(rect_checked, False)
check.equal(text_checked, True)
def test_tee(test_df, monkeypatch):
"""Test mp_pivot.tee_exec accessor."""
ipython = _IPython()
def _m_get_ipython():
"""Path get_ipython."""
return ipython
monkeypatch.setattr(pivot_pd_accessor, "get_ipython", _m_get_ipython)
# with pytest.warns(UserWarning):
# Try with variable that already exists
test_df.mp_pivot.tee(var_name="test_var")
check.is_none(ipython.ns_table["user_local"]["test_var"])
test_df.mp_pivot.tee(var_name="test_var", clobber=True)
print(ipython.ns_table["user_local"]["test_var"])
print(type(ipython.ns_table["user_local"]["test_var"]))
check.is_instance(ipython.ns_table["user_local"]["test_var"], pd.DataFrame)
check.is_true(
test_df.compare(ipython.ns_table["user_local"]["test_var"]).empty)
def test_combobox_activated(qtbot):
record = []
def set_record(_, b):
record.append(b)
delegate = ComboBoxDelegate(None, ["a", "b", "c"])
delegate.setModelData = set_record
dummy = QMainWindow()
cb = delegate.createEditor(dummy, None, None)
qtbot.addWidget(cb)
app = QApplication.instance()
app.setActiveWindow(dummy)
cb.setFocus()
cb.activated.emit(12)
check.is_none(app.focusWidget())
check_allclose(record, [12])
def test_account_summary_notebooklet(monkeypatch):
"""Test basic run of notebooklet."""
test_data = str(Path(TEST_DATA_PATH).absolute())
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
data_providers.init(
"LocalData",
providers=["-tilookup"],
LocalData_data_paths=[test_data],
LocalData_query_paths=[test_data],
)
test_nb = nblts.azsent.account.AccountSummary()
tspan = TimeSpan(period="1D")
result = test_nb.run(value="accountname", timespan=tspan)
check.is_not_none(result.account_selector)
acct_select = test_nb.browse_accounts()
check.is_instance(acct_select, nbwidgets.SelectItem)
select_opts = result.account_selector._item_dict
disp_account = result.account_selector.item_action
for acct_item in select_opts.values():
# Programatically select the item list control
select_item = [
key for key, value in select_opts.items() if value == acct_item
]
if select_item:
result.account_selector._wgt_select.value = select_item[0]
disp_account(acct_item)
check.is_instance(result.account_activity, pd.DataFrame)
check.is_instance(result.related_alerts, pd.DataFrame)
check.is_instance(result.related_bookmarks, pd.DataFrame)
check.is_instance(result.alert_timeline, LayoutDOM)
check.is_instance(result.account_entity, entities.Account)
alert_select = test_nb.browse_alerts()
check.is_instance(alert_select, nbwidgets.SelectAlert)
bm_select = test_nb.browse_bookmarks()
assert isinstance(bm_select, nbwidgets.SelectItem)
test_nb.get_additional_data()
check.is_instance(result.account_timeline_by_ip, LayoutDOM)
if "Windows" in acct_item or "Linux" in acct_item:
check.is_instance(result.host_logons, pd.DataFrame)
check.is_instance(result.host_logon_summary, pd.DataFrame)
check.is_none(result.azure_activity)
check.is_none(result.azure_activity_summary)
check.is_none(result.azure_timeline_by_provider)
check.is_none(result.azure_timeline_by_operation)
vwr = result.view_events(
attrib="host_logons",
summary_cols=["Computer", "LogonResult", "LogonType"],
)
else:
check.is_none(result.host_logons)
check.is_none(result.host_logon_summary)
check.is_instance(result.azure_activity, pd.DataFrame)
check.is_instance(result.azure_activity_summary, pd.DataFrame)
check.is_instance(result.azure_timeline_by_provider, LayoutDOM)
check.is_instance(result.azure_timeline_by_operation, LayoutDOM)
vwr = result.view_events(
attrib="azure_activity",
summary_cols=["Source", "Operation", "IPAddress"],
)
check.is_instance(vwr, nbwidgets.SelectItem)
result.display_alert_timeline()
result.browse_accounts()
result.browse_alerts()
result.browse_bookmarks()
result.az_activity_timeline_by_provider()
result.az_activity_timeline_by_ip()
result.az_activity_timeline_by_operation()
result.host_logon_timeline()
check.is_not_none(result.get_geoip_map())
def test_is_none():
a = None
check.is_none(a)
def test_init(self):
""" should instanciate correctly. """
callbacks = CallbackList(self.callbacks)
check.equal(callbacks.params, {})
check.is_none(callbacks.playground)
def test_render():
# The theory behind test_render is that the unit tests
# will test whether render() can put underlying changes
# of the GUI onto the screen correctly.
# I will be creating a GUI object, rendering it, leaving it on the screen,
# then killing it. Then, I will change the underlying paramters
# then re-render another window.
# In reality, render() cannot be called or else it messes with the
# travis build. We will have to figure out a better solution
# in iteration 2.
# Another side note is that by the point of rendering the window,
# all the inputs will be valid. This is because the GUI technically
# limits the users to edit the settings within a valid range. However,
# invalid inputs will also be included in testing.
#
# The majority of invalid input testing will be in set_settings and get_settings.
# Good inputs (changes in the paratmeters that are valid) are included
# to test that the GUI does NOT throw an error message when a valid input
# is given.
# If an input is invalid, then the GUI will render the default settings in the GUI.
# Please note that you cannot touch any of the sliders or values in the GUI between test cases.
# You must either click "Kill this Window" or click the red X to move to the next test case.
# First, create a test GUI and make sure the default values are correct when generated.
test_gui = GUI()
check.equal(test_gui.video_path, '')
check.equal(test_gui.settings, {
'conf': .5,
'poll': 5,
'anti': 5,
'runtime': 1,
'search': []
})
check.is_none(test_gui.job)
# change the video path and settings to some valid input that a user would use
test_gui.video_path = './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
test_gui.set_settings(
{
'conf': .5,
'poll': 3,
'anti': 1,
'runtime': 10,
'search': ['child']
}, test_gui.video_path)
# assert that these changes have gone through
check.equal(test_gui.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(
test_gui.get_settings(), {
'settings': {
'conf': .5,
'poll': 3,
'anti': 1,
'runtime': 10,
'search': ['child']
},
'video': './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
})
check.is_none(test_gui.job)
#test_gui.render()
# change the video_path, settings, and job to another valid input that a user would use
test_gui.video_path = './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
test_gui.set_settings(
{
'conf': 0.2,
'poll': 1,
'anti': 1,
'runtime': 10,
'search': ["child, kid, ball"]
}, test_gui.video_path)
# create a test job object to use as the test_gui.job parameter
#test_job1 = Job(test_gui.get_settings())
#test_gui.job = test_job1
# assert that these changes have gone through
check.equal(test_gui.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(
test_gui.settings, {
'conf': 0.2,
'poll': 1,
'anti': 1,
'runtime': 10,
'search': ["child, kid, ball"]
})
#check.equal(test_gui.job, test_job1)
#test_gui.render()
# change the video path to a very very long video path.
test_gui.video_path = './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
test_gui.set_settings(test_gui.settings, test_gui.video_path)
# make sure the other two parameters have not changed, but video path has changed
check.equal(test_gui.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(
test_gui.settings, {
'conf': 0.2,
'poll': 1,
'anti': 1,
'runtime': 10,
'search': ["child, kid, ball"]
})
#check.equal(test_gui.job, test_job1)
#test_gui.render()
# change the video path to an empty one
test_gui.video_path = ''
test_gui.set_settings(test_gui.settings, test_gui.video_path)
# make sure the correct parameters have changed, and the others have remained the same
check.equal(test_gui.video_path, '')
check.equal(
test_gui.settings, {
'conf': 0.2,
'poll': 1,
'anti': 1,
'runtime': 10,
'search': ["child, kid, ball"]
})
#check.equal(test_gui.job, test_job1)
#test_gui.render()
# change video path to an invalid value or type
# the point of this test to make sure that the GUI realizes the invalid input
# and instead displays the default values.
# Because these types of errors will be caught by the logic unit tests,
# most of this testing is done in test_set_settings.
# Below is an invalid input as the video path is a number, not a string
test_gui.set_settings(
{
'conf': 0.2,
'poll': 1,
'anti': 1,
'runtime': 10,
'search': ["child, kid, ball"]
}, 2)
# make sure that the parameters have been reset to the default value.
check.equal(test_gui.video_path, '')
check.equal(test_gui.settings, {
'conf': .5,
'poll': 5,
'anti': 5,
'runtime': 1,
'search': []
})
#check.equal(test_gui.job, test_job1)
#test_gui.render()
# Here, we will start testing more levels of the settings parameter in specific.
# Valid inputs for settings should not throw a GUI error message and
# instead display the correct image for the GUI.
# Incorrect inputs for settings should be reset to the default settings and
# GUI should display the defaults.
# create a clean new GUI object
test_gui2 = GUI()
# change the video_path to a normal one, make sure GUI displays the new settings
test_gui2.video_path = './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
test_gui2.settings = {
'conf': .75,
'poll': 571,
'anti': 462,
'runtime': 10,
'search': ["comptuter"]
}
test_gui2.set_settings(test_gui2.settings, test_gui2.video_path)
# make sure that these parameters have been appropriately changed
check.equal(test_gui2.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(
test_gui2.settings, {
'conf': .75,
'poll': 571,
'anti': 462,
'runtime': 10,
'search': ["comptuter"]
})
check.is_none(test_gui2.job)
#test_gui2.render()
# change the settings used so there are some invalid values (negative settings)
test_gui2.settings = {
'conf': -10,
'poll': -1,
'anti': -5,
'runtime': 10,
'search': ["uhhhh"]
}
test_gui2.set_settings(test_gui2.settings, test_gui2.video_path)
# assert that these changes do not go through and the default settings are implemented
check.equal(test_gui2.video_path, '')
check.equal(test_gui2.settings, {
'conf': .5,
'poll': 5,
'anti': 5,
'runtime': 1,
'search': []
})
check.is_none(test_gui2.job)
#test_gui2.render()
# change the settings to the wrong type
test_gui2.settings = {
'conf': 'hello',
'poll': 'nice',
'anti': 'should not work',
'runtime': 'woof',
'search': ["seach term"]
}
test_gui2.set_settings(test_gui2.settings, test_gui2.video_path)
# assert that these changes do not go through and the default settings are rendered
check.equal(test_gui2.video_path, '')
check.equal(test_gui2.settings, {
'conf': .5,
'poll': 5,
'anti': 5,
'runtime': 1,
'search': []
})
check.is_none(test_gui2.job)
#test_gui2.render()
# Here, we will be changing the parameters for the job object.
# All of the following job objects should be valid and should run.
# create a new GUI object
test_gui3 = GUI()
# change the video_path to something other an empty
test_gui3.video_path = './test/sampleVideo/SampleVideo_1280x720_1mb.mp4'
# make the settings something valid for set_settings
test_gui3.settings = {
'conf': .73,
'poll': 93,
'anti': 146,
'runtime': 10,
'search': ['boy']
}
test_gui3.set_settings(test_gui3.settings, test_gui3.video_path)
# make sure that the job is empty, and the new settings have been achieved.
check.equal(test_gui3.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(test_gui3.settings, {
'conf': .73,
'poll': 93,
'anti': 146,
'runtime': 10,
'search': ['boy']
})
check.is_none(test_gui3.job)
#test_gui3.render()
# create a new Job object with the updated settings and path.
#test_job3 = Job({'settings': test_gui3.settings, 'video': test_gui3.video_path})
# change the value of the GUI's job
#test_gui3.job = test_job3
# make sure job has changed, but all the other settings stay the same
check.equal(test_gui3.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(test_gui3.settings, {
'conf': .73,
'poll': 93,
'anti': 146,
'runtime': 10,
'search': ['boy']
})
#check.equal(test_gui3.job, test_job3)
#test_gui3.render()
# change the job back to None
test_gui3.job = None
# make sure Job has returned to None, but the other settings remain.
check.equal(test_gui3.video_path,
'./test/sampleVideo/SampleVideo_1280x720_1mb.mp4')
check.equal(test_gui3.settings, {
'conf': .73,
'poll': 93,
'anti': 146,
'runtime': 10,
'search': ['boy']
})
check.is_none(test_gui3.job)
def test_unit_property_none(unit):
# Check None and dimensionless_unscaled
c = DummyClass(unit)
check.is_none(c._unit)
