def test_new_init_data_providers(monkeypatch):
"""Test creating new provider with new provider list."""
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
data_providers.init(query_provider="LocalData", providers=[])
dprov = data_providers.DataProviders.current()
data_providers.init(query_provider="LocalData", providers=[])
dprov2 = data_providers.DataProviders.current()
check.equal(dprov2, dprov)
# specify provider
dprov = data_providers.DataProviders(query_provider="LocalData")
data_providers.init(query_provider="LocalData", providers=["tilookup"])
msticnb = sys.modules["msticnb"]
dprov2 = data_providers.DataProviders.current()
pkg_providers = getattr(msticnb, "data_providers")
check.not_equal(dprov2, dprov)
check.is_in("LocalData", dprov2.providers)
check.is_in("tilookup", dprov2.providers)
check.is_not_in("geolitelookup", dprov2.providers)
check.is_not_in("ipstacklookup", dprov2.providers)
check.is_in("LocalData", pkg_providers)
check.is_in("tilookup", pkg_providers)
check.is_not_in("geolitelookup", pkg_providers)
check.is_not_in("ipstacklookup", pkg_providers)
check.is_instance(dprov2.providers["tilookup"], TILookup)
def test_obfuscate_df():
"""Test obfuscation on DataFrame."""
win_procs = pd.read_pickle(
Path(TEST_DATA_PATH).joinpath("win_proc_test.pkl"))
out_df = data_obfus.obfuscate_df(win_procs)
check.equal(len(out_df), len(win_procs))
for idx, row in win_procs.loc[:5].iterrows():
for mapped_col in win_procs.columns:
if data_obfus.OBFUS_COL_MAP.get(mapped_col) == "sid":
# SIDs can be unchanged if well-known SID
continue
if mapped_col in data_obfus.OBFUS_COL_MAP:
check.not_equal(row[mapped_col], out_df.loc[idx][mapped_col])
else:
check.equal(row[mapped_col], out_df.loc[idx][mapped_col])
comp_uc, comp_ch = data_obfus.check_obfuscation(out_df,
win_procs,
index=idx)
n_changed = len([
col for col in win_procs.columns if col in data_obfus.OBFUS_COL_MAP
])
n_unchanged = len(win_procs.columns) - n_changed
# number of unchanged might be one less since some SIDs are not hashed
check.is_true(len(comp_uc) in [n_unchanged, n_unchanged + 1])
check.is_true(len(comp_ch) in [n_changed, n_changed - 1])
def test_entity_merge():
"""Entity comparison and merging."""
host1 = Host(HostName="host1",
DnsDomain="contoso.com",
OSFamily=OSFamily.Windows)
host2 = Host(HostName="host1",
DnsDomain="contoso.com",
IsDomainJoined=True)
host3 = Host(HostName="host3", DnsDomain="contoso.com")
check.not_equal(host1, host2)
check.not_equal(host1, host3)
check.is_true(host1.is_equivalent(host2))
check.is_false(host1.is_equivalent(host3))
check.is_false(host2.is_equivalent(host3))
check.is_true(host1.can_merge(host2))
check.is_false(host1.can_merge(host3))
host4 = host1.merge(host2)
check.equal(host4.HostName, "host1")
check.equal(host4.OSFamily, OSFamily.Windows)
check.equal(host4.DnsDomain, "contoso.com")
check.is_true(host4.IsDomainJoined)
def test_consume_fuel_card_balance_float(db, api, data):
user_name = data['USER_WITH_TWO_CARDS'][0]
user_id = db.get_user_id(user_name)
card_number = data['USED_CARD']
balance = float(data['AMOUNT'])
res = api.consume_fuel_card(user_id, card_number, balance)
check.not_equal(200, res['code'])
check.not_equal('消费成功!', res['msg'])
check.is_false(res['success'])
def test_classify_frames():
frame_list1 = example_job2.classify_frames()
frame_list = example_job1.classify_frames()
check.equal(frame_list1[0][0], 0)
check.less(frame_list1[0][1], 0.7)
check.not_equal(frame_list1[1][0], 5)
check.greater(frame_list1[1][1], 0.7)
check.equal(frame_list[0][0], 0)
check.less(frame_list[0][1], 0.7)
check.not_equal(frame_list[1][0], 4)
check.greater(frame_list[1][1], 0.7)
def test_different_seed_different_requirements_graph(self):
env = RandomCraftingEnv(seed=42, **self.env_settings)
env2 = RandomCraftingEnv(seed=43, **self.env_settings)
check.not_equal(env.rng_seeds, env2.rng_seeds)
check.is_false(
is_isomorphic(
env.world.get_requirements_graph(),
env2.world.get_requirements_graph(),
)
)
def test_extract_header_nosip():
header = fits.Header.fromstring(_base_header + _wcs_no_sip, sep='\n')
h, wcs = extract_header_wcs(header)
check.is_instance(wcs, WCS)
check.equal(wcs.wcs.ctype[0], 'RA---TAN')
check.equal(wcs.wcs.ctype[1], 'DEC--TAN')
check.is_instance(h, fits.Header)
for i in _comon_wcs_keys:
check.is_not_in(f'{i}1', h.keys())
check.is_not_in(f'{i}2', h.keys())
check.is_in('DATE-OBS', h.keys())
check.is_false(h is header)
check.not_equal(h, header)
def test_class_doc():
"""Test class documentation."""
for _, nblt in nblts.iter_classes():
html_doc = nblt.get_help()
check.not_equal(html_doc, "No documentation available.")
check.greater(len(html_doc), 100)
md_doc = nblt.get_help(fmt="md")
html_doc2 = markdown(md_doc)
check.equal(html_doc, html_doc2)
_html_parser = etree.HTMLParser(recover=False)
elem_tree = etree.parse(StringIO(html_doc), _html_parser)
check.is_not_none(elem_tree)
def test_pandas_accessor():
"""Test obfuscation with pandas accessor."""
win_procs = pd.read_pickle(Path(TEST_DATA_PATH).joinpath("win_proc_test.pkl"))
out_df = win_procs.mp_mask.mask()
check.equal(len(out_df), len(win_procs))
for idx, row in win_procs.loc[:2].iterrows():
for mapped_col in win_procs.columns:
if data_obfus.OBFUS_COL_MAP.get(mapped_col) == "sid":
# SIDs can be unchanged if well-known SID
continue
if mapped_col in data_obfus.OBFUS_COL_MAP:
check.not_equal(row[mapped_col], out_df.loc[idx][mapped_col])
else:
check.equal(row[mapped_col], out_df.loc[idx][mapped_col])
def test_auth(self):
test_url = self.test_data['get_files_url']
# no headers
res1 = requests.post(test_url)
# no authorization headers
res2 = requests.post(test_url, headers=self.test_data['invalid_headers']['no_authorization'])
# invalid scheme
res3 = requests.post(test_url, headers=self.test_data['invalid_headers']['invalid_scheme'])
# invalid token
res4 = requests.post(test_url, headers=self.test_data['invalid_headers']['invalid_token'])
# valid token ( no data sent)
res5 = requests.post(test_url, headers=self.test_data['headers'])
check.equal(res1.status_code, 401)
check.equal(res2.status_code, 401)
check.equal(res3.status_code, 401)
check.equal(res4.status_code, 401)
check.not_equal(res5.status_code, 401)
def test_file_browser():
"""Function_docstring."""
f_brow = FileBrowser(".", select_cb=_callback)
starting_folder = f_brow.current_folder
check.greater(len(f_brow.select_file.options), 0)
check.greater(len(f_brow.select_folder.options), 0)
check.is_in("..", f_brow.select_folder.options)
curr_files = f_brow.select_file.options
check.equal(curr_files, f_brow.select_file.options)
f_brow._open_folder(tgt_folder="msticpy")
check.not_equal(curr_files, f_brow.select_file.options)
f_brow.txt_path.value = str(starting_folder)
f_brow._enter_folder(event=None)
check.greater(len(f_brow.select_file.options), 0)
f_brow.select_file.selected_index = 1
f_brow._return_file(btn=None)
check.equal(file_name, f_brow.file)
f_brow.txt_search.value = "*.py"
f_brow._search(f_brow.btn_search)
check.greater(len(f_brow.select_search.options), 0)
def test_add_sub_data_providers(monkeypatch):
"""Test intializing adding and subtracting providers."""
monkeypatch.setattr(data_providers, "GeoLiteLookup", GeoIPLiteMock)
dprov = data_providers.DataProviders(query_provider="LocalData")
data_providers.init(query_provider="LocalData", providers=["tilookup"])
msticnb = sys.modules["msticnb"]
dprov2 = data_providers.DataProviders.current()
# Add and remove a provider from defaults
data_providers.init(
query_provider="LocalData", providers=["+ipstacklookup", "-geolitelookup"]
)
dprov3 = data_providers.DataProviders.current()
pkg_providers = getattr(msticnb, "data_providers")
check.not_equal(dprov3, dprov)
check.not_equal(dprov3, dprov2)
check.is_in("ipstacklookup", dprov3.providers)
check.is_not_in("geolitelookup", dprov3.providers)
check.is_in("tilookup", dprov3.providers)
check.is_in("ipstacklookup", pkg_providers)
check.is_not_in("geolitelookup", pkg_providers)
check.is_in("tilookup", pkg_providers)
def test_not_equal():
check.not_equal(1, 2)
def check_arr(arr, a):
arr_flags = arr.flags
a_flags = a.flags
for i in [
'C_CONTIGUOUS', 'F_CONTIGUOUS', 'WRITEABLE', 'ALIGNED',
'WRITEBACKIFCOPY', 'UPDATEIFCOPY', 'FNC', 'FORC', 'BEHAVED',
'CARRAY', 'FARRAY'
]:
check.equal(arr_flags[i], a_flags[i])
for i in ['OWNDATA']:
if memmap:
check.not_equal(arr_flags[i], a_flags[i])
else:
check.equal(arr_flags[i], a_flags[i])
if memmap:
check.is_instance(a.base, mmap.mmap)
else:
check.is_true(a.base is None)
check.equal(arr.shape, a.shape)
check.equal(arr.strides, a.strides)
check.equal(arr.ndim, a.ndim)
check.equal(arr.data, a.data)
check.equal(arr.size, a.size)
check.equal(arr.itemsize, a.itemsize)
check.equal(arr.nbytes, a.nbytes)
check.equal(arr.dtype, a.dtype)
check.is_instance(a.tolist(), list)
check.equal(arr.tolist(), a.tolist())
check.is_instance(a.tostring(), bytes)
check.equal(arr.tostring(), a.tostring())
check.is_instance(a.tobytes(), bytes)
check.equal(arr.tobytes(), a.tobytes())
check.is_instance(a.dumps(), bytes)
# FIXME: check.equal(arr.dumps(), a.dumps())
npt.assert_array_equal(arr.T, a.T)
npt.assert_array_equal(arr.transpose(), a.transpose())
npt.assert_array_equal(arr.flatten(), a.flatten())
npt.assert_array_equal(arr.ravel(), a.ravel())
npt.assert_array_equal(arr.squeeze(), a.squeeze())
npt.assert_array_equal(arr.argsort(), a.argsort())
npt.assert_array_equal(arr.argpartition(1), a.argpartition(1))
npt.assert_array_equal(arr.nonzero(), a.nonzero())
check.equal(arr.max(), a.max())
check.equal(arr.argmax(), a.argmax())
check.equal(arr.min(), a.min())
check.equal(arr.argmin(), a.argmin())
npt.assert_array_equal(arr.max(axis=0), a.max(axis=0))
npt.assert_array_equal(arr.min(axis=0), a.min(axis=0))
npt.assert_array_equal(arr.argmax(axis=0), a.argmax(axis=0))
npt.assert_array_equal(arr.argmin(axis=0), a.argmin(axis=0))
npt.assert_array_equal(arr.real, a.real)
npt.assert_array_equal(arr.imag, a.imag)
npt.assert_array_equal(arr.round(), a.round())
check.equal(arr.sum(), a.sum())
npt.assert_array_equal(arr.sum(axis=0), a.sum(axis=0))
npt.assert_array_equal(arr.cumsum(), a.cumsum())
npt.assert_array_equal(arr.cumsum(axis=0), a.cumsum(axis=0))
check.equal(arr.mean(), a.mean())
npt.assert_array_equal(arr.mean(axis=0), a.mean(axis=0))
check.equal(arr.var(), a.var())
npt.assert_array_equal(arr.var(axis=0), a.var(axis=0))
check.equal(arr.std(), a.std())
npt.assert_array_equal(arr.std(axis=0), a.std(axis=0))
check.equal(arr.prod(), a.prod())
npt.assert_array_equal(arr.prod(axis=0), a.prod(axis=0))
npt.assert_array_equal(arr.cumprod(), a.cumprod())
npt.assert_array_equal(arr.cumprod(axis=0), a.cumprod(axis=0))
for i, j in zip(arr.flat, a.flat):
check.equal(i, j)
for i in range(9):
check.equal(arr.item(i), a.item(i))
npt.assert_array_equal(arr.astype(bool), a.astype(bool))
npt.assert_array_equal(arr.astype(int), a.astype(int))
check.equal(arr.all(), a.all())
check.equal(arr.any(), a.any())
