def create_guest_groups(user: MrMapUser = None, how_much_groups: int = 1):
# Check for already existing groups to fetch the next sequence integer
existing_groups = MrMapGroup.objects.filter(
name__icontains="GuestGroup").order_by("-name")
if existing_groups.count() > 0:
# Get last incremented sequence id from name
first = existing_groups.first()
first_num = int(first.name.replace("GuestGroup", ""))
else:
first_num = -1
if user is not None:
groups = baker.make_recipe(
'tests.baker_recipes.structure_app.guest_group',
created_by=user,
_quantity=how_much_groups,
name=seq("GuestGroup", increment_by=1, start=first_num + 1))
else:
groups = baker.make_recipe(
'tests.baker_recipes.structure_app.guest_group',
_quantity=how_much_groups,
name=seq("GuestGroup", increment_by=1, start=first_num + 1))
return groups
def test_generate_agent_tasks_by_location(self):
from .tasks import generate_agent_tasks_by_location_task
# setup data
policy = baker.make("automation.Policy", active=True)
tasks = baker.make("autotasks.AutomatedTask",
policy=policy,
name=seq("Task"),
_quantity=3)
clients = baker.make(
"clients.Client",
client=seq("Default"),
_quantity=2,
server_policy=policy,
workstation_policy=policy,
)
baker.make("clients.Site",
client=cycle(clients),
site=seq("Default"),
_quantity=4)
server_agent = baker.make_recipe("agents.server_agent",
client="Default1",
site="Default1")
workstation_agent = baker.make_recipe("agents.workstation_agent",
client="Default1",
site="Default3")
agent1 = baker.make_recipe("agents.agent",
client="Default2",
site="Default2")
agent2 = baker.make_recipe("agents.agent",
client="Default2",
site="Default4")
generate_agent_tasks_by_location_task(
{
"client": "Default1",
"site": "Default1"
}, "server", clear=True)
# all servers in Default1 and site Default1 should have 3 tasks
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).autotasks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).autotasks.count(), 3)
self.assertEqual(Agent.objects.get(pk=agent1.id).autotasks.count(), 0)
self.assertEqual(Agent.objects.get(pk=agent2.id).autotasks.count(), 0)
generate_agent_tasks_by_location_task({"client": "Default1"},
"workstation",
clear=True)
# all workstations in Default1 should have 3 tasks
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).autotasks.count(), 3)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).autotasks.count(), 3)
self.assertEqual(Agent.objects.get(pk=agent1.id).autotasks.count(), 0)
self.assertEqual(Agent.objects.get(pk=agent2.id).autotasks.count(), 0)
def test_generating_policy_checks_for_all_agents(self):
from .tasks import generate_all_agent_checks_task
from core.models import CoreSettings
# setup data
policy = baker.make("automation.Policy", active=True)
self.create_checks(policy=policy)
clients = baker.make("clients.Client",
client=seq("Default"),
_quantity=2)
baker.make("clients.Site",
client=cycle(clients),
site=seq("Default"),
_quantity=4)
server_agent = baker.make_recipe("agents.server_agent",
client="Default1",
site="Default1")
workstation_agent = baker.make_recipe("agents.workstation_agent",
client="Default1",
site="Default3")
agent1 = baker.make_recipe("agents.agent",
client="Default2",
site="Default2")
agent2 = baker.make_recipe("agents.agent",
client="Default2",
site="Default4")
core = CoreSettings.objects.first()
core.server_policy = policy
core.workstation_policy = policy
core.save()
generate_all_agent_checks_task("server", clear=True, create_tasks=True)
# all servers should have 7 checks
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=agent1.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=agent2.id).agentchecks.count(), 0)
generate_all_agent_checks_task("workstation",
clear=True,
create_tasks=True)
# all agents should have 7 checks now
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=agent1.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=agent2.id).agentchecks.count(), 7)
def setUp(self):
self.sponsorship = baker.make(Sponsorship, _fill_optional="sponsor")
baker.make(
SponsorshipBenefit,
program__name="PSF",
name=seq("benefit"),
order=seq(1),
_quantity=3,
)
self.sponsorship_benefits = SponsorshipBenefit.objects.all()
def test_schema_as_ordered_dict(self):
table = baker.make(Table)
fields = baker.make(
"core.Field",
table=table,
name=seq("field_"),
dataset=table.dataset,
order=seq(1),
_quantity=10,
)
assert isinstance(table.schema, OrderedDict)
field_names = list(table.schema.keys())
for i, field in enumerate(fields):
assert field.name == field_names[i]
def setUp(self):
"""init with one journal, and 10 articles published by this journal"""
self.journal = baker.make(Journal, name="Astrophysical Journal")
self.articles = baker.make(Article,
title=seq('great paper #'),
journal=self.journal,
_quantity=10)
def test_generate_agent_tasks(self):
from .tasks import generate_agent_tasks_from_policies_task
# create test data
policy = baker.make("automation.Policy", active=True)
tasks = baker.make("autotasks.AutomatedTask",
policy=policy,
name=seq("Task"),
_quantity=3)
agent = baker.make_recipe("agents.server_agent", policy=policy)
generate_agent_tasks_from_policies_task(policy.id) # type: ignore
agent_tasks = Agent.objects.get(pk=agent.id).autotasks.all()
# make sure there are 3 agent tasks
self.assertEqual(len(agent_tasks), 3)
for task in agent_tasks:
self.assertTrue(task.managed_by_policy)
if task.name == "Task1":
self.assertEqual(task.parent_task, tasks[0].id) # type: ignore
self.assertEqual(task.name, tasks[0].name) # type: ignore
if task.name == "Task2":
self.assertEqual(task.parent_task, tasks[1].id) # type: ignore
self.assertEqual(task.name, tasks[1].name) # type: ignore
if task.name == "Task3":
self.assertEqual(task.parent_task, tasks[2].id) # type: ignore
self.assertEqual(task.name, tasks[2].name) # type: ignore
def test_defining_recipes_str(self):
from model_bakery.recipe import seq
p = Recipe('generic.Person', name=seq('foo'))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail('%s' % e)
def test_defining_recipes_str(self):
from model_bakery.recipe import seq
p = Recipe("generic.Person", name=seq("foo"))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail("%s" % e)
def setUp(self):
self.setup_clients()
# generate 3 spots with locatie_ids test_1, test_2 and test_3
baker.prepare(
Document) # because of this line the next bakery will work
baker.make(Spot,
locatie_id=seq("test_"),
actiehouders="Unknown",
_quantity=3)
self.spot_with_docs = baker.make(Spot)
baker.make(Document, spot=self.spot_with_docs, _quantity=3)
def test_generate_agent_tasks_by_location(self):
from .tasks import generate_agent_tasks_by_location_task
# setup data
policy = baker.make("automation.Policy", active=True)
baker.make("autotasks.AutomatedTask",
policy=policy,
name=seq("Task"),
_quantity=3)
clients = baker.make(
"clients.Client",
_quantity=2,
server_policy=policy,
workstation_policy=policy,
)
sites = baker.make("clients.Site", client=cycle(clients), _quantity=4)
server_agent = baker.make_recipe("agents.server_agent", site=sites[0])
workstation_agent = baker.make_recipe("agents.workstation_agent",
site=sites[2])
agent1 = baker.make_recipe("agents.agent", site=sites[1])
agent2 = baker.make_recipe("agents.agent", site=sites[3])
generate_agent_tasks_by_location_task({"site_id": sites[0].id},
"server")
# all servers in site1 and site2 should have 3 tasks
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).autotasks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).autotasks.count(), 3)
self.assertEqual(Agent.objects.get(pk=agent1.id).autotasks.count(), 0)
self.assertEqual(Agent.objects.get(pk=agent2.id).autotasks.count(), 0)
generate_agent_tasks_by_location_task(
{"site__client_id": clients[0].id}, "workstation")
# all workstations in Default1 should have 3 tasks
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).autotasks.count(), 3)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).autotasks.count(), 3)
self.assertEqual(Agent.objects.get(pk=agent1.id).autotasks.count(), 0)
self.assertEqual(Agent.objects.get(pk=agent2.id).autotasks.count(), 0)
def test_generating_agent_policy_checks_by_location(
self, generate_agent_checks_by_location_task):
from automation.tasks import (
generate_agent_checks_by_location_task as generate_agent_checks, )
# setup data
policy = baker.make("automation.Policy", active=True)
self.create_checks(policy=policy)
baker.make("autotasks.AutomatedTask",
policy=policy,
name=seq("Task"),
_quantity=3)
server_agent = baker.make_recipe("agents.server_agent")
workstation_agent = baker.make_recipe("agents.workstation_agent")
# no checks should be preset on agents
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
# set workstation policy on client and policy checks should be there
workstation_agent.client.workstation_policy = policy
workstation_agent.client.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site__client_id": workstation_agent.client.pk},
mon_type="workstation",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site__client_id": workstation_agent.client.pk},
mon_type="workstation",
create_tasks=True,
)
# make sure the checks were added
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
# remove workstation policy from client
workstation_agent.client.workstation_policy = None
workstation_agent.client.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site__client_id": workstation_agent.client.pk},
mon_type="workstation",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site__client_id": workstation_agent.client.pk},
mon_type="workstation",
create_tasks=True,
)
# make sure the checks were removed
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
# set server policy on client and policy checks should be there
server_agent.client.server_policy = policy
server_agent.client.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site__client_id": server_agent.client.pk},
mon_type="server",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site__client_id": server_agent.client.pk},
mon_type="server",
create_tasks=True,
)
# make sure checks were added
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
# remove server policy from client
server_agent.client.server_policy = None
server_agent.client.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site__client_id": server_agent.client.pk},
mon_type="server",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site__client_id": server_agent.client.pk},
mon_type="server",
create_tasks=True,
)
# make sure checks were removed
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
# set workstation policy on site and policy checks should be there
workstation_agent.site.workstation_policy = policy
workstation_agent.site.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site_id": workstation_agent.site.pk},
mon_type="workstation",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site_id": workstation_agent.site.pk},
mon_type="workstation",
create_tasks=True,
)
# make sure checks were added on workstation
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
# remove workstation policy from site
workstation_agent.site.workstation_policy = None
workstation_agent.site.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site_id": workstation_agent.site.pk},
mon_type="workstation",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site_id": workstation_agent.site.pk},
mon_type="workstation",
create_tasks=True,
)
# make sure checks were removed
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
# set server policy on site and policy checks should be there
server_agent.site.server_policy = policy
server_agent.site.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site_id": server_agent.site.pk},
mon_type="server",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site_id": server_agent.site.pk},
mon_type="server",
create_tasks=True,
)
# make sure checks were added
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
# remove server policy from site
server_agent.site.server_policy = None
server_agent.site.save()
# should trigger task in save method on core
generate_agent_checks_by_location_task.assert_called_with(
location={"site_id": server_agent.site.pk},
mon_type="server",
create_tasks=True,
)
generate_agent_checks_by_location_task.reset_mock()
generate_agent_checks(
location={"site_id": server_agent.site.pk},
mon_type="server",
create_tasks=True,
)
# make sure checks were removed
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
def test_options_filter(self):
url = "/logs/auditlogs/optionsfilter/"
baker.make_recipe("agents.agent",
hostname=seq("AgentHostname"),
_quantity=5)
baker.make_recipe("agents.agent", hostname=seq("Server"), _quantity=3)
baker.make("accounts.User", username=seq("Username"), _quantity=7)
baker.make("accounts.User", username=seq("soemthing"), _quantity=3)
data = [
{
"req": {
"type": "agent",
"pattern": "AgeNt"
},
"count": 5
},
{
"req": {
"type": "agent",
"pattern": "AgentHostname1"
},
"count": 1
},
{
"req": {
"type": "agent",
"pattern": "hasjhd"
},
"count": 0
},
{
"req": {
"type": "user",
"pattern": "UsEr"
},
"count": 7
},
{
"req": {
"type": "user",
"pattern": "UserName1"
},
"count": 1
},
{
"req": {
"type": "user",
"pattern": "dfdsadf"
},
"count": 0
},
]
for req in data:
resp = self.client.post(url, req["req"], format="json")
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.data), req["count"])
# test for invalid payload. needs to have either type: user or agent
invalid_data = {"type": "object", "pattern": "SomeString"}
resp = self.client.post(url, invalid_data, format="json")
self.assertEqual(resp.status_code, 400)
self.check_not_authenticated("post", url)
def create_audit_records(self):
# create clients for client filter
site = baker.make("clients.Site")
baker.make_recipe("agents.agent", site=site, hostname="AgentHostname1")
# user jim agent logs
baker.make_recipe(
"logs.agent_logs",
username="******",
agent="AgentHostname1",
entry_time=seq(datetime.now(), timedelta(days=3)),
_quantity=15,
)
baker.make_recipe(
"logs.agent_logs",
username="******",
agent="AgentHostname2",
entry_time=seq(datetime.now(), timedelta(days=100)),
_quantity=8,
)
# user james agent logs
baker.make_recipe(
"logs.agent_logs",
username="******",
agent="AgentHostname1",
entry_time=seq(datetime.now(), timedelta(days=55)),
_quantity=7,
)
baker.make_recipe(
"logs.agent_logs",
username="******",
agent="AgentHostname2",
entry_time=seq(datetime.now(), timedelta(days=20)),
_quantity=10,
)
# generate agent logs with random usernames
baker.make_recipe(
"logs.agent_logs",
agent=seq("AgentHostname"),
entry_time=seq(datetime.now(), timedelta(days=29)),
_quantity=5,
)
# generate random object data
baker.make_recipe(
"logs.object_logs",
username="******",
entry_time=seq(datetime.now(), timedelta(days=5)),
_quantity=17,
)
# generate login data for james
baker.make_recipe(
"logs.login_logs",
username="******",
entry_time=seq(datetime.now(), timedelta(days=7)),
_quantity=11,
)
# generate login data for jim
baker.make_recipe(
"logs.login_logs",
username="******",
entry_time=seq(datetime.now(), timedelta(days=11)),
_quantity=13,
)
return site
from model_bakery.recipe import Recipe
from faker import Faker
fake = Faker()
enrollment = Recipe(
Enrolment,
site=Site.objects.get_current,
enrollment_identifier=None,
subject_identifier=None,
report_datetime=get_utcnow(),
first_name="OLIVER",
last_name="MTUKUDZI",
initials="OM",
dob=get_utcnow().date() - relativedelta(years=25),
is_dob_estimated=NO,
gender="M",
identity=seq("12315678"),
confirm_identity=seq("12315678"),
identity_type=HOSPITAL_NUMBER,
crf_status=COMPLETE,
user_created="erikvw",
)
basicindicators = Recipe(BasicIndicators, crf_status=COMPLETE)
bloodresults = Recipe(BloodResults, crf_status=COMPLETE)
medications = Recipe(HivReview, crf_status=COMPLETE)
investigations = Recipe(Investigations, crf_status=COMPLETE)
diabetesreview = Recipe(DiabetesReview, crf_status=COMPLETE)
hypertensionreview = Recipe(HypertensionReview, crf_status=COMPLETE)
from model_bakery import seq
from model_bakery.recipe import Recipe, foreign_key, related
from service.helper.enums import OGCServiceEnum, OGCServiceVersionEnum, MetadataEnum, DocumentEnum, OGCOperationEnum
from service.models import Metadata, Service, ServiceType, Layer, FeatureType, Keyword, Category, \
Document, RequestOperation, MimeType, ProxyLog, Dataset, AllowedOperation, OGCOperation
from tests.baker_recipes.structure_app.baker_recipes import superadmin_group, superadmin_orga
from django.utils import timezone
mimetype = Recipe(MimeType, mime_type="image/png")
active_wms_service_metadata = Recipe(
Metadata,
title=seq("metadata_wms_"),
identifier=seq("metadata_wms"),
is_active=True,
metadata_type=MetadataEnum.SERVICE.value,
created_by=foreign_key(superadmin_group),
formats=related(mimetype),
)
active_wms_layer_metadata = active_wms_service_metadata.extend(
metadata_type=MetadataEnum.LAYER.value,
identifier=seq("metadata_wms_layer"),
formats=related(mimetype),
)
active_wfs_service_metadata = Recipe(
Metadata,
title=seq("metadata_wfs_"),
identifier=seq("metadata_wfs"),
is_active=True,
salt = str(os.urandom(25).hex())
PASSWORD = get_password_data().get('valid')
EMAIL = "*****@*****.**"
god_user = Recipe(
MrMapUser,
username="******",
email="*****@*****.**",
salt=salt,
password=make_password("354Dez25!"),
is_active=True,
)
superadmin_orga = Recipe(Organization,
organization_name=seq("SuperOrganization"),
is_auto_generated=False)
superadmin_group = Recipe(MrMapGroup,
name=SUPERUSER_GROUP_NAME,
created_by=foreign_key(god_user),
organization=foreign_key(superadmin_orga))
public_group = Recipe(
MrMapGroup,
name=PUBLIC_GROUP_NAME,
description="Public",
is_public_group=True,
created_by=foreign_key(god_user),
)
def test_policy_related(self):
# Get Site and Client from an agent in list
clients = baker.make("clients.Client",
client=seq("Client"),
_quantity=5)
sites = baker.make("clients.Site",
client=cycle(clients),
site=seq("Site"),
_quantity=25)
server_agents = baker.make_recipe(
"agents.server_agent",
client=cycle([x.client for x in clients]),
site=seq("Site"),
_quantity=25,
)
workstation_agents = baker.make_recipe(
"agents.workstation_agent",
client=cycle([x.client for x in clients]),
site=seq("Site"),
_quantity=25,
)
server_client = clients[3]
server_site = server_client.sites.all()[3]
workstation_client = clients[1]
workstation_site = server_client.sites.all()[2]
server_agent = baker.make_recipe("agents.server_agent",
client=server_client.client,
site=server_site.site)
workstation_agent = baker.make_recipe(
"agents.workstation_agent",
client=workstation_client.client,
site=workstation_site.site,
)
policy = baker.make("automation.Policy", active=True)
# Add Client to Policy
policy.server_clients.add(server_client)
policy.workstation_clients.add(workstation_client)
resp = self.client.get(f"/automation/policies/{policy.pk}/related/",
format="json")
self.assertEqual(resp.status_code, 200)
self.assertEquals(len(resp.data["server_clients"]), 1)
self.assertEquals(len(resp.data["server_sites"]), 5)
self.assertEquals(len(resp.data["workstation_clients"]), 1)
self.assertEquals(len(resp.data["workstation_sites"]), 5)
self.assertEquals(len(resp.data["agents"]), 12)
# Add Site to Policy and the agents and sites length shouldn't change
policy.server_sites.add(server_site)
policy.workstation_sites.add(workstation_site)
self.assertEquals(len(resp.data["server_sites"]), 5)
self.assertEquals(len(resp.data["workstation_sites"]), 5)
self.assertEquals(len(resp.data["agents"]), 12)
# Add Agent to Policy and the agents length shouldn't change
policy.agents.add(server_agent)
policy.agents.add(workstation_agent)
self.assertEquals(len(resp.data["agents"]), 12)
def test_reset_patch_policy(self):
url = "/automation/winupdatepolicy/reset/"
inherit_fields = {
"critical": "inherit",
"important": "inherit",
"moderate": "inherit",
"low": "inherit",
"other": "inherit",
"run_time_frequency": "inherit",
"reboot_after_install": "inherit",
"reprocess_failed_inherit": True,
}
# create agents in sites
clients = baker.make("clients.Client",
client=seq("Client"),
_quantity=3)
sites = baker.make("clients.Site",
client=cycle(clients),
site=seq("Site"),
_quantity=6)
agents = baker.make_recipe(
"agents.agent",
client=cycle([x.client for x in clients]),
site=cycle([x.site for x in sites]),
_quantity=6,
)
# create patch policies
patch_policies = baker.make_recipe("winupdate.winupdate_approve",
agent=cycle(agents),
_quantity=6)
# test reset agents in site
data = {"client": clients[0].client, "site": "Site0"}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
agents = Agent.objects.filter(client=clients[0].client, site="Site0")
for agent in agents:
for k, v in inherit_fields.items():
self.assertEqual(getattr(agent.winupdatepolicy.get(), k), v)
# test reset agents in client
data = {"client": clients[1].client}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
agents = Agent.objects.filter(client=clients[1].client)
for agent in agents:
for k, v in inherit_fields.items():
self.assertEqual(getattr(agent.winupdatepolicy.get(), k), v)
# test reset all agents
data = {}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
agents = Agent.objects.all()
for agent in agents:
for k, v in inherit_fields.items():
self.assertEqual(getattr(agent.winupdatepolicy.get(), k), v)
self.check_not_authenticated("patch", url)
def other_events():
return baker.make(Event,
title=seq("Title "),
event_date=default_date,
_quantity=3)
def test_generating_agent_policy_checks_by_location(self):
from .tasks import generate_agent_checks_by_location_task
# setup data
policy = baker.make("automation.Policy", active=True)
self.create_checks(policy=policy)
clients = baker.make(
"clients.Client",
client=seq("Default"),
_quantity=2,
server_policy=policy,
workstation_policy=policy,
)
baker.make("clients.Site",
client=cycle(clients),
site=seq("Default"),
_quantity=4)
server_agent = baker.make_recipe("agents.server_agent",
client="Default1",
site="Default1")
workstation_agent = baker.make_recipe("agents.workstation_agent",
client="Default1",
site="Default3")
agent1 = baker.make_recipe("agents.agent",
client="Default2",
site="Default2")
agent2 = baker.make_recipe("agents.agent",
client="Default2",
site="Default4")
generate_agent_checks_by_location_task(
{
"client": "Default1",
"site": "Default1"
},
"server",
clear=True,
create_tasks=True,
)
# server_agent should have policy checks and the other agents should not
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=agent1.id).agentchecks.count(), 0)
generate_agent_checks_by_location_task({"client": "Default1"},
"workstation",
clear=True,
create_tasks=True)
# workstation_agent should now have policy checks and the other agents should not
self.assertEqual(
Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
self.assertEqual(
Agent.objects.get(pk=agent1.id).agentchecks.count(), 0)
self.assertEqual(
Agent.objects.get(pk=agent2.id).agentchecks.count(), 0)
def events(my_user):
return baker.make(Event,
title=seq("Title "),
owner=my_user,
event_date=default_date,
_quantity=3)
from model_bakery import baker, seq
from model_bakery.recipe import Recipe
from .models import Journal, Article
from itertools import cycle
big4 = [
"Astrophysical Journal", "Monthly Notice", "Astronomical Journal",
"Astronomy and Astrophysics"
]
journal_recipe = Recipe(Journal, name=cycle(big4))
article_recipe = Recipe(
Article,
title=seq('astronomy paper #'),
#journal = baker.make_recipe('forum.journal_recipe')
journal=journal_recipe.make)
def create_pending_task(group: MrMapGroup, how_much_pending_tasks: int = 1):
return baker.make_recipe('tests.baker_recipes.structure_app.pending_task',
task_id=seq(1),
#created_by=group,
_quantity=how_much_pending_tasks)
def passed_events(my_user):
return baker.make(Event,
title=seq("Title "),
owner=my_user,
event_date=passed_date,
_quantity=3)
from model_bakery import seq
from model_bakery.recipe import Recipe, foreign_key
from django.utils import timezone
from monitoring.models import MonitoringRun, MonitoringResult
from monitoring.settings import WARNING_RESPONSE_TIME
from tests.baker_recipes.service_app.baker_recipes import active_wms_service_metadata
monitoring_run = Recipe(
MonitoringRun,
end=timezone.now(),
duration=timezone.timedelta(seconds=1),
)
monitoring_result = Recipe(
MonitoringResult,
metadata=foreign_key(active_wms_service_metadata),
duration=timezone.timedelta(milliseconds=WARNING_RESPONSE_TIME-1),
status_code=200,
available=True,
monitored_uri=seq('example.com'),
monitoring_run=foreign_key(monitoring_run),
)
