def test_get_by_subnet(self, apiobj):
"""Pass."""
specfield = "specific_data.data.network_interfaces.subnets"
findfield = "specific_data.data.network_interfaces.ips"
withfields = [findfield, specfield]
asset = self.get_single_asset(apiobj=apiobj,
with_fields=withfields,
fields=withfields)
assert specfield in asset, list(asset)
asset_value = asset[specfield]
value = tools.listify(obj=asset_value)[0]
found = apiobj.get_by_subnet(
value=value,
max_rows=1,
fields=findfield,
query_post=" and {}".format(QUERY_FIELD_EXISTS(field=findfield)),
)
assert isinstance(found, tools.LIST)
found_value = tools.listify(obj=found[0][findfield])[0]
assert found_value == tools.listify(obj=asset[findfield],
dictkeys=False)[0]
def do_checks(self, user_row, user, checks):
"""Pass."""
for check in checks:
user_row[check["col"]] = False
if not user:
user_row[COL_DVCLINK] = "NO USER FOUND"
return [user_row]
dvcs = self.find_dvcs(user=user)
if not dvcs:
user_row[COL_DVCLINK] = "NO ASSOCIATED DEVICES FOUND"
return [user_row]
user_dvc_rows = []
for dvc in dvcs:
agent_vers = dvc.get(AGENT_VERS)
user_row_dvc = copy.deepcopy(user_row)
user_dvc_rows.append(user_row_dvc)
user_row_dvc[COL_DVCLINK] = self.get_axon_link(asset=dvc,
type="devices")
user_row_dvc[COL_DVCNAME] = "\n".join(listify(dvc.get(NAME)))
user_row_dvc[COL_DVCHOSTNAME] = "\n".join(
listify(dvc.get(HOSTNAME)))
user_row_dvc[COL_DVCIP] = "\n".join(listify(dvc.get(IPS)))
user_row_dvc[COL_DVCOS] = "\n".join(listify(dvc.get(OS_STR)))
user_row_dvc[COL_DVCAGENTS] = self.get_agent_vers(
agent_vers=agent_vers)
for check in checks:
user_row_dvc[check["col"]] = self.do_check(agent_vers, check)
return user_dvc_rows
def get_by_specifics(self, apiobj, specfield, specmethod):
"""Pass."""
asset = self.get_single_asset(apiobj=apiobj, fields=specfield)
asset_value = asset[specfield]
value = tools.listify(obj=asset_value)[0]
query_post = "and {}".format(QUERY_FIELD_EXISTS(field=specfield))
found = getattr(apiobj, specmethod)(value=value,
query_post=query_post,
match_count=1,
fields=specfield)
assert isinstance(found, dict)
found_value = found[specfield]
assert tools.listify(found_value) == tools.listify(asset_value)
def test_get_by_field_value_list(self, apiobj):
"""Pass."""
asset = self.get_single_asset(apiobj=apiobj,
fields=apiobj._default_fields)
assert isinstance(asset, dict)
field = apiobj.TEST_DATA["single_field"]["exp"]
value = asset[field]
value_list = tools.listify(value)
assert value
found = apiobj.get_by_value(value=value_list,
field=field,
fields=apiobj._default_fields,
match_count=1)
found_value = found[field]
assert tools.listify(found_value) == value_list
def get_single_asset(self,
apiobj,
with_fields=None,
fields=None,
query=None,
refetch=None):
"""Pass."""
if not query and refetch:
query = QUERY_ID(**refetch)
if not query:
if not with_fields:
with_fields = apiobj._default_fields
query_fields = tools.listify(with_fields)
query_fields = [x for x in query_fields if x not in ["labels"]]
query_lines = [QUERY_FIELD_EXISTS(field=x) for x in query_fields]
query = " and ".join(query_lines)
if not fields:
fields = apiobj._default_fields
data = apiobj._get(query=query, fields=fields, page_size=1)
assert isinstance(data, dict)
assets = data["assets"]
assert len(assets) == 1
assert isinstance(assets, tools.LIST)
asset = assets[0]
return asset
def find_user(self, user_row, idx, username):
"""Pass."""
row_txt = f"for username {username!r} in row {idx + 1}"
if not username:
self.spew_warn(f"Empty value {row_txt}")
user_row[COL_USERLINK] = "Empty username"
return
found = [
x for x in self.user_assets if username in listify(x.get(USERNAME))
]
if not found:
self.spew_warn(f"No user found {row_txt}")
user_row[COL_USERLINK] = "No user found"
return
if len(found) > 1:
self.spew_warn(f"Found more than one user {row_txt}")
user_row[
COL_USERLINK] = f"More than one matching user found ({len(found)})"
return
user = found[0]
user_row[COL_USERLINK] = self.get_axon_link(asset=user, type="users")
user["row"] = user_row
user["row_username"] = username
user["row_idx"] = idx
user["row_txt"] = row_txt
return user
def get_value(asset: dict, field: str, pre: str = "specific_data.data"):
value = listify(asset.get(f"{pre}.{field}", []))
value = sorted(list(set([x for x in value if x])))
if len(value) == 0:
return ""
if len(value) == 1:
return value[0]
return value
def get_agent_vers(self, agent_vers):
"""Pass."""
lines = []
for agent_ver in listify(agent_vers):
name = agent_ver.get("adapter_name") or ""
status = agent_ver.get("agent_status") or ""
version = agent_ver.get("agent_version") or ""
lines.append(f"name: {name}, version: {version}, status: {status}")
return "\n".join(lines)
def parse_user(user, client):
ass_dvcs = listify(user.get(ASS_DVC_FIELD, []))
# username = listify(asset.get("specific_data.data.username"), [])
if not ass_dvcs:
# print(f"NO associated devices found for user {username}")
return
for ass_dvc in ass_dvcs:
dvc = parse_ass_dvc(user=user, ass_dvc=ass_dvc, client=client)
check_agents(user=user, dvc=dvc)
def validate_raw_data(self, apiobj, row, field):
adapters = row["adapters"]
raw_datas = row[field]
assert isinstance(raw_datas, (dict, list)) and raw_datas
raw_datas = listify(raw_datas)
for raw_data in raw_datas:
assert isinstance(raw_data["data"], dict)
assert isinstance(raw_data["plugin_name"],
str) and raw_data["plugin_name"]
assert isinstance(raw_data["client_used"],
str) and raw_data["client_used"]
assert raw_data["plugin_name"] in adapters
def test_get_by_field_value_regex(self, apiobj):
"""Pass."""
field = apiobj.TEST_DATA["single_field"]["exp"]
value_re = "[a-zA-Z]"
found = apiobj.get_by_value(value=value_re,
value_regex=True,
field=field,
match_count=1,
max_rows=1)
assert isinstance(found, dict)
assert any([
re.search(value_re, f)
for f in tools.listify(obj=found[field], dictkeys=False)
])
def parse_ass_dvc(user, ass_dvc, client):
username = listify(user.get("specific_data.data.username"), [])
caption = ass_dvc.get("device_caption")
query = FIND_DVC_QUERY_TMPL.format(value=caption)
found = client.devices.get(query=query, fields=DVC_FIELDS)
# NEED TO PASS devices apiobj
if not found:
print(f"No devices found that match associated device {caption} for " f"user {username}")
return
if len(found) > 1:
print(
f"Too many devices ({len(found)}) found that match associated device "
f"{caption} for user {username}"
)
return
return found[0]
def _read_csv(self, path, required):
"""Pass."""
path, content = path_read(obj=path)
content = bom_strip(content=content)
reader = csv.DictReader(io.StringIO(content))
rows = [x for x in reader]
if not rows:
self.spew_error("No rows supplied in CSV!")
columns = listify(reader.fieldnames)
self.spew_debug(f"CSV file {path} has columns {columns}")
missing = [x for x in required if x not in columns]
if missing:
missing = ", ".join(missing)
self.spew_error(
f"Missing required columns {missing} in CSV file {path}")
return columns, rows
def find_dvcs(self, user):
"""Pass."""
row_txt = user["row_txt"]
dvcs = listify(user.get(ASS_DVC))
found = []
for dvc in dvcs:
wiz_entries = self.dvc_wiz_entries(dvc=dvc)
query = self.devices.wizard.parse(wiz_entries)["query"]
self.spew_debug(
f"Looking for devices searching for {dvc!r} using query {query}"
)
dvcs = self.devices.get(
query=query,
field_null=True,
fields_default=False,
fields=FIELDS_DEVICE,
field_compress=True,
)
self.spew_debug(
f"Found {len(dvcs)} devices searching for {dvc!r} {row_txt}")
found += dvcs
self.spew_info(f"Found {len(found)} devices {row_txt}")
return found
def test_get_by_subnet_not(self, apiobj):
"""Pass."""
specfield = "specific_data.data.network_interfaces.subnets"
findfield = "specific_data.data.network_interfaces.ips"
withfields = [findfield, specfield]
asset = self.get_single_asset(apiobj=apiobj,
with_fields=withfields,
fields=withfields)
assert specfield in asset, list(asset)
asset_value = asset[specfield]
value = tools.listify(obj=asset_value)[0]
found = apiobj.get_by_subnet(
value=value,
value_not=True,
max_rows=1,
fields=findfield,
query_post=" and {}".format(QUERY_FIELD_EXISTS(field=findfield)),
)
# could do value checking here, but we'd have to get every asset
# lets not do that...
assert isinstance(found, tools.LIST)
def test_str(self):
"""Simple test."""
x = listify(obj="1")
assert x == ["1"]
def test_int(self):
"""Simple test."""
x = listify(obj=1)
assert x == [1]
def test_list(self):
"""Simple test."""
x = listify(obj=[1, 2])
assert x == [1, 2]
def test_tuple(self):
"""Simple test."""
x = listify(obj=(1, 2))
assert x == [1, 2]
def test_dict_notkeys(self):
"""Simple test."""
x = listify(obj={"x": 1, "y": 1}, dictkeys=False)
assert x == [{"x": 1, "y": 1}]
def test_dict_keys(self):
"""Simple test."""
x = listify(obj={"x": 1, "y": 1}, dictkeys=True)
assert x == ["x", "y"]
def check_agents(user, dvc):
agents = listify(dvc.get(AGENT_VERSIONS_FIELD, []))
for agent in agents:
for check in AGENT_CHECKS:
pass
def test_none(self):
"""Simple test."""
x = listify(obj=None)
assert x == []
def get_field_values(rows, field):
"""Pass."""
values = [x[field] for x in rows if x.get(field)]
values = [x for y in values for x in listify(y)]
return values
def get_field_vals(rows, field):
"""Test utility."""
values = [x[field] for x in listify(rows) if x.get(field)]
values = [x for y in values for x in listify(y)]
return values
