def test_perform(self):
issuer = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
owner = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
with evaluate("Verified:Create") as report:
verified = CreateVerifiedStatement().perform(issuer, owner)
self.assertIn(verified, issuer.verified_issuer)
self.assertTrue(report)
def test_validate(self):
issuer = SetupPersonPortfolio().perform(PersonData(**Generate.person_data()[0]))
foreign_issuer = issuer.to_portfolio()
owner = SetupPersonPortfolio().perform(PersonData(**Generate.person_data()[0]))
statement = CreateVerifiedStatement().perform(issuer, owner)
with evaluate("Verified:Validate") as report:
ValidateVerifiedStatement().validate(foreign_issuer, statement)
self.assertNotIn(statement, foreign_issuer.verified_issuer)
self.assertTrue(report)
def test_validate(self):
issuer = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
foreign_issuer = issuer.to_portfolio()
owner = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
statement = CreateVerifiedStatement().perform(issuer, owner)
revoked = CreateRevokedStatement().perform(issuer, statement)
with evaluate("Revoked:Accept") as report:
AcceptRevokedStatement().validate(foreign_issuer, revoked)
self.assertIn(revoked, foreign_issuer.revoked_issuer)
self.assertTrue(report)
async def test_05_save(self):
keys = list(self.files.keys())
random.shuffle(keys)
for filename in keys[:self.FILE_COUNT // 4]:
text = Generate.lipsum()
await self.archive.save(filename, text)
self.files[filename] = text
def test_perform(self):
portfolio = CreatePersonEntity().perform(PersonData(**Generate.person_data()[0]))
old_privkeys = copy.deepcopy(portfolio.privkeys)
with evaluate("Keys:New") as report:
_, privkeys = NewKeys().perform(portfolio)
self.assertTrue(report)
self.assertNotEqual(privkeys, old_privkeys)
def setUpClass(cls) -> None:
"""Prepare class-wise environment"""
random.seed(0)
cls.dir = TemporaryDirectory()
cls.secret = os.urandom(32)
cls.filename = Path(cls.dir.name, "test.ar7")
if cls.filename.exists():
raise OSError("File shouldn't be there.")
cls.owner = Generate.uuid()
cls.archive = Archive7.setup(cls.filename, cls.secret, owner=cls.owner)
cls.files = dict()
cls.links = dict()
for _ in range(cls.FILE_COUNT):
filename = PurePosixPath(random.choice(LIPSUM_PATH),
Generate.filename())
cls.files[filename] = Generate.lipsum()
cls.archive.close()
async def test_12_link(self):
keys = list(self.files.keys())
random.shuffle(keys)
for filename in keys[:self.FILE_COUNT // 4]:
linkname = PurePosixPath(random.choice(LIPSUM_PATH),
Generate.filename())
await self.archive.link(linkname, filename)
self.links[linkname] = self.files[filename]
def test_perform(self):
data = MinistryData(**Generate.ministry_data()[0])
with evaluate("Ministry:Create") as report:
portfolio = CreateMinistryEntity().perform(data)
self.assertIsNotNone(portfolio.entity)
self.assertIsNotNone(portfolio.privkeys)
self.assertIsNotNone(portfolio.keys)
self.assertTrue(report)
def test_validate(self):
portfolio = CreatePersonEntity().perform(
PersonData(**Generate.person_data()[0]))
foreign_portfolio = portfolio.to_portfolio()
keys, _ = NewKeys().perform(portfolio)
with evaluate("Person:AcceptNewKeys") as report:
AcceptNewKeys().validate(foreign_portfolio, keys)
self.assertTrue(report)
def test_perform(self):
data = PersonData(**Generate.person_data()[0])
with evaluate("Person:Create") as report:
portfolio = CreatePersonEntity().perform(data)
self.assertIsNotNone(portfolio.entity)
self.assertIsNotNone(portfolio.privkeys)
self.assertIsNotNone(portfolio.keys)
self.assertTrue(report)
def test_perform(self):
data = ChurchData(**Generate.church_data()[0])
with evaluate("Church:Create") as report:
portfolio = CreateChurchEntity().perform(data)
self.assertIsNotNone(portfolio.entity)
self.assertIsNotNone(portfolio.privkeys)
self.assertIsNotNone(portfolio.keys)
self.assertTrue(report)
def test_perform(self):
first, second = Generate.church_data(2)
portfolio = CreateChurchEntity().perform(ChurchData(**first))
new_data(first, second, portfolio.entity.changeables())
data = ChurchData(**second)
with evaluate("Ministry:Update") as report:
entity = UpdateChurchEntity().perform(portfolio, data)
self.assertTrue(report)
def test_perform(self):
first, second = Generate.person_data(2)
portfolio = CreatePersonEntity().perform(PersonData(**first))
new_data(first, second, portfolio.entity.changeables())
data = PersonData(**second)
with evaluate("Person:Update") as report:
entity = UpdatePersonEntity().perform(portfolio, data)
self.assertTrue(report)
async def test_03_rename(self):
keys = list(self.files.keys())
random.shuffle(keys)
for filename in keys[:self.FILE_COUNT // 4]:
name = Generate.filename()
await self.archive.rename(filename, name)
self.files[PurePosixPath(filename.parent,
name)] = self.files[filename]
del self.files[filename]
def test_perform(self):
data = ChurchData(**Generate.church_data()[0])
portfolio = CreateChurchEntity().perform(data)
domain = CreateDomain().perform(portfolio)
CreateNode().current(portfolio, server=True)
with evaluate("Network:Create") as report:
network = CreateNetwork().perform(portfolio)
self.assertIs(network, portfolio.network)
self.assertEqual(network.domain, domain.id)
self.assertEqual(len(network.hosts), 1)
self.assertTrue(report)
def test_validate(self):
first, second = Generate.person_data(2)
portfolio = CreatePersonEntity().perform(PersonData(**first))
foreign_portfolio = copy.deepcopy(portfolio.to_portfolio())
new_data(first, second, portfolio.entity.changeables())
data = PersonData(**second)
entity = UpdatePersonEntity().perform(portfolio, data)
self.assertNotEqual(entity.export(), foreign_portfolio.entity.export())
with evaluate("Person:AcceptUpdated") as report:
AcceptUpdatedEntity().validate(foreign_portfolio, entity)
self.assertTrue(report)
def test_perform(self):
data = PersonData(**Generate.person_data()[0])
portfolio = CreatePersonEntity().perform(data)
CreateDomain().perform(portfolio)
node = CreateNode().current(portfolio, server=True)
self.assertIn(node, portfolio.nodes)
with evaluate("Node:Validate") as report:
ValidateNode().validate(portfolio, node)
self.assertIn(node, portfolio.nodes)
self.assertTrue(report)
def test_perform(self):
issuer = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
owner = SetupPersonPortfolio().perform(
PersonData(**Generate.person_data()[0]))
foreign_issuer = issuer.to_portfolio()
verified = CreateVerifiedStatement().perform(issuer, owner)
AcceptVerifiedStatement().validate(foreign_issuer, verified)
self.assertIn(verified, foreign_issuer.verified_issuer)
revoked = CreateRevokedStatement().perform(issuer, verified)
AcceptRevokedStatement().validate(foreign_issuer, revoked)
self.assertIn(revoked, foreign_issuer.revoked_issuer)
with evaluate("Revoked:Remove") as report:
RemoveRevokedStatement().perform(foreign_issuer, revoked)
self.assertIn(revoked, foreign_issuer.revoked_issuer)
self.assertNotIn(verified, foreign_issuer.verified_issuer)
self.assertTrue(report)
def test_validate(self):
portfolio = CreateChurchEntity().perform(ChurchData(**Generate.church_data()[0]))
CreateDomain().perform(portfolio)
CreateNode().current(portfolio, server=True)
foreign_porfolio = portfolio.to_portfolio()
self.assertIsNone(foreign_porfolio.network)
network = CreateNetwork().perform(portfolio)
with evaluate("Network:Accept") as report:
AcceptNetwork().validate(foreign_porfolio, network)
self.assertIs(network, foreign_porfolio.network)
self.assertTrue(report)
def test_validate(self):
data = PersonData(**Generate.person_data()[0])
portfolio = CreatePersonEntity().perform(data)
ext_portfolio = copy.deepcopy(portfolio)
domain = CreateDomain().perform(portfolio)
self.assertIsNotNone(portfolio.domain)
with evaluate("Domain:Validate") as report:
ValidateDomain().validate(portfolio, domain)
self.assertTrue(report)
self.assertIsNone(ext_portfolio.domain)
with evaluate("Domain:Validate") as report:
ValidateDomain().validate(ext_portfolio, domain)
self.assertTrue(report)
def test_perform(self):
data = PersonData(**Generate.person_data()[0])
portfolio = CreatePersonEntity().perform(data)
with evaluate("Domain:Create") as report:
domain = CreateDomain().perform(portfolio)
self.assertIsNotNone(domain)
self.assertIs(domain, portfolio.domain)
self.assertTrue(report)
with self.assertRaises(DomainCreateException):
CreateDomain().perform(portfolio)
portfolio.freeze()
with self.assertRaises(FrozenPortfolioError):
CreateDomain().perform(portfolio)
def test_validate(self):
portfolio = CreateChurchEntity().perform(ChurchData(**Generate.church_data()[0]))
CreateDomain().perform(portfolio)
CreateNode().current(portfolio, server=True)
foreign_porfolio = portfolio.to_portfolio()
self.assertIsNone(foreign_porfolio.network)
network = CreateNetwork().perform(portfolio)
AcceptNetwork().validate(foreign_porfolio, network)
CreateNode().perform(portfolio, device="test", serial="1234567890", ip=IPv4Address("127.0.0.1"), server=True)
network = UpdateNetwork().perform(portfolio)
with evaluate("Network:Validate") as report:
ValidateNetwork().validate(foreign_porfolio, network)
self.assertIs(network, foreign_porfolio.network)
self.assertTrue(report)
def test_current(self):
data = PersonData(**Generate.person_data()[0])
portfolio = CreatePersonEntity().perform(data)
with self.assertRaises(NodeCreateException):
CreateNode().current(portfolio, server=True)
CreateDomain().perform(portfolio)
with evaluate("Node:Create") as report:
node = CreateNode().current(portfolio, server=True)
self.assertIsNotNone(node)
self.assertIn(node, portfolio.nodes)
self.assertTrue(report)
portfolio.freeze()
with self.assertRaises(FrozenPortfolioError):
CreateNode().current(portfolio, server=True)
def test_perform(self):
portfolio = CreateChurchEntity().perform(
ChurchData(**Generate.church_data()[0]))
domain = CreateDomain().perform(portfolio)
CreateNode().current(portfolio, server=True)
CreateNetwork().perform(portfolio)
CreateNode().perform(portfolio,
device="test",
serial="1234567890",
ip=IPv4Address("127.0.0.1"),
server=True)
with evaluate("Network:Update") as report:
network = UpdateNetwork().perform(portfolio)
self.assertIs(network, portfolio.network)
self.assertEqual(network.domain, domain.id)
self.assertEqual(len(network.hosts), 2)
self.assertTrue(report)
def _populate_test(self):
data = Generate.person_data()[0]
sub = TestSubDocument(
nd={
"name": data["given_name"] + " " + data["family_name"],
"sig": os.urandom(random.randint(20, 30)),
})
doc = TestDocument(
nd={
"id":
uuid.uuid4(),
"ip":
ipaddress.IPv4Address(os.urandom(4)),
"email":
str(data["given_name"] + "." + data["family_name"] +
"@example.com").lower(),
"docs":
sub,
})
return doc
def test_perform(self):
data = ChurchData(**Generate.church_data()[0])
with evaluate("Church:Setup") as report:
portfolio = SetupChurchPortfolio().perform(data, server=True)
self.assertTrue(report)
def test_validate(self):
data = PersonData(**Generate.person_data()[0])
portfolio = SetupPersonPortfolio().perform(data)
with evaluate("Entity:Accpept") as report:
AcceptEntity().validate(portfolio)
self.assertTrue(report)
def test_perform(self):
data = PersonData(**Generate.person_data()[0])
with evaluate("Person:Setup") as report:
portfolio = SetupPersonPortfolio().perform(data)
self.assertTrue(report)
def test_perform(self):
data = MinistryData(**Generate.ministry_data()[0])
with evaluate("Ministry:Setup") as report:
portfolio = SetupMinistryPortfolio().perform(data)
self.assertTrue(report)
