async def send_mail(cls, sender: Facade, recipient: Portfolio) -> Mail:
"""Generate one mail to recipient using a facade saving the mail to the outbox."""
builder = CreateMail().perform(sender.data.portfolio, recipient)
message = builder.message(Generate.lipsum_sentence(), Generate.lipsum().decode()).done()
envelope = WrapEnvelope().perform(sender.data.portfolio, recipient, message)
await sender.api.mailbox.save_outbox(envelope)
return message
async def test_link(self):
names = [PurePosixPath("/", Generate.filename(".doc")) for _ in range(10)]
for filename in names:
await self.facade.storage.vault.save(filename, StubDocument())
for filename in names:
self.assertIsInstance(await self.facade.storage.vault.link(
PurePosixPath("/", Generate.filename(".doc")), filename), uuid.UUID)
async def inject_mail(server: Facade, sender: PrivatePortfolio, recipient: Portfolio) -> Mail:
"""Generate one mail to recipient using a facade saving the mail to the outbox."""
message = CreateMail().perform(sender, recipient).message(
Generate.lipsum_sentence(), Generate.lipsum(100).decode()).done()
envelope = WrapEnvelope().perform(sender, recipient, message)
await server.storage.mail.save(
PurePosixPath("/" + str(envelope.id) + Helper.extension(Definitions.COM_ENVELOPE)), envelope)
return message
async def prepare_mail(client: Facade, recipient: Portfolio) -> Mail:
"""Generate one mail to recipient using a facade saving the mail to the outbox."""
message = CreateMail().perform(client.data.portfolio, recipient).message(
Generate.lipsum_sentence(), Generate.lipsum(100).decode()).done()
envelope = WrapEnvelope().perform(client.data.portfolio, recipient, message)
await client.storage.vault.save(
PurePosixPath("/messages/outbox/" + str(envelope.id) + Helper.extension(Definitions.COM_ENVELOPE)), envelope)
return message
async def inject_mail(cls, server: "Facade", sender: "Facade",
recipient: "Portfolio") -> "Mail":
"""Generate one mail to recipient using a facade injecting the mail to the server."""
builder = MessagePolicy.mail(sender.data.portfolio, recipient)
message = builder.message(Generate.lipsum_sentence(),
Generate.lipsum().decode()).done()
envelope = EnvelopePolicy.wrap(sender.data.portfolio, recipient,
message)
await server.storage.mail.save(
DOCUMENT_PATH[DocType.COM_ENVELOPE].format(dir="",
file=envelope.id),
envelope)
return message
async def _setup(cls, app_cls, portfolio: PrivatePortfolio):
"""Set up stub application environment."""
secret = Generate.new_secret()
tmp_dir = TemporaryDirectory()
app = app_cls(Facade(Path(tmp_dir.name), secret, portfolio, Const.A_ROLE_PRIMARY, app_cls.STUB_SERVER))
return cls(tmp_dir, secret, app)
async def setup(cls, app_cls, data):
"""Set up stub application environment."""
secret = Generate.new_secret()
tmp_dir = TemporaryDirectory()
print(app_cls)
app = await app_cls.create(Path(tmp_dir.name), secret, data)
return cls(tmp_dir, secret, app)
async def test_delete(self):
names = [PurePosixPath("/", Generate.filename(".doc")) for _ in range(10)]
for filename in names:
await self.facade.storage.vault.save(filename, StubDocument())
for filename in names:
await self.facade.storage.vault.delete(filename)
self.assertTrue(await self.facade.storage.vault.archive.isfile(filename))
def setUp(self) -> None:
self.secret = os.urandom(32)
self.dir = TemporaryDirectory()
self.home = Path(self.dir.name)
self.facade = Facade(self.home, self.secret,
SetupPersonPortfolio().perform(PersonData(**Generate.church_data()[0])),
role=Const.A_ROLE_PRIMARY, server=False
)
async def test_search(self):
names = [PurePosixPath("/", Generate.filename(".doc")) for _ in range(10)]
for filename in names:
await self.facade.storage.vault.save(filename, StubDocument())
paths = (await self.facade.storage.vault.search()).values()
for filename in names:
self.assertIn(filename, paths)
def __init__(self,
portfolio: PrivatePortfolio,
server: bool,
admin: Signer = False):
self.dir = TemporaryDirectory()
self.secret = Generate.new_secret()
if admin:
self.facade = AdminFacade.setup(admin)
else:
self.facade = Facade(Path(self.dir.name), self.secret, portfolio,
Const.A_ROLE_PRIMARY, server)
async def test_facade(self):
facade = Facade(self.home,
self.secret,
SetupMinistryPortfolio().perform(
MinistryData(**Generate.ministry_data()[0])),
role=Const.A_ROLE_PRIMARY,
server=False)
self.services_client(facade)
self.assertIsInstance(facade, MinistryClientFacade)
self.assertIsInstance(facade.data.portfolio.entity, Ministry)
self.assertIsInstance(facade.data.portfolio.node, Node)
self.extension_type(facade)
facade.close()
facade = Facade(self.home, self.secret)
self.assertIsInstance(facade.data.portfolio.entity, Ministry)
self.assertIsInstance(facade.data.portfolio.node, Node)
self.extension_type(facade)
facade.close()
async def test_facade(self):
facade = Facade(self.home,
self.secret,
SetupChurchPortfolio().perform(
ChurchData(**Generate.church_data()[0])),
role=Const.A_ROLE_PRIMARY,
server=True)
self.services_server(facade)
self.assertIsInstance(facade, ChurchServerFacade)
self.assertIsInstance(facade.data.portfolio.entity, Church)
self.assertIsInstance(facade.data.portfolio.node, Node)
self.extension_type(facade)
facade.close()
facade = Facade(self.home, self.secret)
self.assertIsInstance(facade.data.portfolio.entity, Church)
self.assertIsInstance(facade.data.portfolio.node, Node)
self.extension_type(facade)
facade.close()
async def portfolios():
"""Generate a facade and inject random contacts."""
for person in Generate.person_data(cls.count):
cls._portfolios.append(
SetupPersonOperation.create(person, server=cls.server))
async def create_client(cls) -> "ApplicationContext":
"""Create a stub client."""
return await cls._setup(
StubClient, SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]), server=StubClient.STUB_SERVER))
async def create_server(cls) -> "ApplicationContext":
"""Create a stub server."""
return await cls._setup(
StubServer, SetupChurchPortfolio().perform(
ChurchData(**Generate.church_data()[0]), server=StubServer.STUB_SERVER))
def create_server(cls) -> "FacadeContext":
"""Create a stub server."""
return cls(
SetupChurchPortfolio().perform(
ChurchData(**Generate.church_data()[0]), server=True), True)
async def create_client(cls) -> ApplicationContext:
"""Create a stub client."""
return await ApplicationContext.setup(StubClient, PersonData(**Generate.person_data()[0]))
async def test_save_settings(self):
settings = io.StringIO(Generate.lipsum().decode())
await self.facade.storage.vault.save_settings("monkeys.csv", settings)
def create_client(cls) -> "FacadeContext":
"""Create a stub client."""
return cls(
SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]), server=False), False)
async def create_server(cls) -> ApplicationContext:
"""Create a stub server."""
return await ApplicationContext.setup(StubServer, ChurchData(**Generate.church_data()[0]))
async def test_load_settings(self):
settings = io.StringIO(Generate.lipsum().decode())
await self.facade.storage.vault.save_settings("monkeys.csv", settings)
data = await self.facade.storage.vault.load_settings("monkeys.csv")
self.assertEqual(settings.getvalue(), data.getvalue())
