def test_default(self):
registry = Registry()
registry.set('a', 'aaa')
self.assertEqual(registry.default('a', 'bbb'), 'aaa')
self.assertEqual(registry.get('a'), 'aaa')
self.assertEqual(registry.default('c', 'ccc'), 'ccc')
self.assertEqual(registry.get('c', 'ccc'), 'ccc')
def setUp(self):
self._registry = Registry("10.28.1.159", 5001)
self._client = self._registry._client
self.directory = "/test/"
self.service_directory = "/horizon/services/"
self.file = "/test/file1"
self.map = {"name": "service-0"}
def test_default(self):
"""测试设置默认值"""
registry = Registry({'a': 'aaa'})
self.assertEqual(registry.default('a', 'bbb'), 'aaa')
self.assertEqual(registry.get('a'), 'aaa')
self.assertEqual(registry.default('c', 'ccc'), 'ccc')
self.assertEqual(registry.get('c', 'ccc'), 'ccc')
def test_rate_db(self):
dao = DAO(self.dsn)
registry = Registry('test')
registry.save_data("% BTG 1", dao)
self.assertEqual(dao.get_member('test'), [('test', 600, None, None)])
self.assertEqual(dao.get_conditions(), [('test', 1, 'BTG', '%', 1.0)])
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.get_tag_config_mock = MagicMock(
return_value={
'mediaType':
'application/vnd.docker.container.image.v1+json',
'size':
12953,
'digest':
'sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8'
})
self.registry.get_tag_config = self.get_tag_config_mock
self.get_image_age_mock = MagicMock(
return_value="2017-12-27T12:47:33.511765448Z")
self.registry.get_image_age = self.get_image_age_mock
self.list_tags_mock = MagicMock(return_value=["image"])
self.registry.list_tags = self.list_tags_mock
self.get_tag_digest_mock = MagicMock()
self.registry.get_tag_digest = self.get_tag_digest_mock
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200, "MOCK_DIGEST")
def test_keep_tags_by_age_no_keep(self):
self.assertEqual(
get_newer_tags(self.registry, "imagename", 23, ["latest"]), [])
def test_keep_tags_by_age_keep(self):
self.assertEqual(
get_newer_tags(self.registry, "imagename", 24, ["latest"]),
["latest"])
def test_get(self):
"""测试获取配置项"""
registry = Registry({'a': {'aa': 'aaa'}})
self.assertEqual(registry.get(), {'a': {'aa': 'aaa'}})
self.assertEqual(registry.get('a'), {'aa': 'aaa'})
self.assertEqual(registry.get('a.aa'), 'aaa')
self.assertEqual(registry.get('b', ['b']), ['b'])
def certificates_page():
registry_contract = Registry()
certificates = registry_contract.get_all_certificates()
return render_template(
"certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"])
def test_get(self):
registry = Registry()
registry.load({'a': {'aa': 'aaa'}})
self.assertEqual(registry.get(), {'a': {'aa': 'aaa'}})
self.assertEqual(registry.get('a'), {'aa': 'aaa'})
self.assertEqual(registry.get('a.aa'), 'aaa')
self.assertEqual(registry.get('b', ['b']), ['b'])
def __init__(self, program='aria2c', **kwargs):
self.program = program
self.process = None
self.args = Registry(kwargs.get('args'))
self.args.default('rpc-listen-port', '6800')
self.args.default('enable-rpc', 'true')
self.args.default('rpc-allow-origin-all', 'true')
self.args.default('rpc-listen-all', 'true')
def __init__(self, address=("127.0.0.1", 7222), buffer_size=65536):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
registry = Registry()
self._message_receiver = MessageReceiver(
IncomingMessageTranslator(
[registry,
Broadcaster(registry,
MessageSender(OutgoingMessageTranslator(), sock))
]), address, buffer_size)
def __init__(self, args):
self.args = args
Data.__init__(self, self.args.input_file)
self.population = []
for _ in range(self.args.population_size):
self.population.append(Individual(self.items, self.args))
self.elite = Elite(self.args, list(self.items.keys()), self.population)
self.registry = Registry(self.elite)
self.runEvolutive()
def __init__(self, *args, **kwargs):
self.options = Registry(kwargs.get('options', {}))
self.pool = None
self.server = None
self.state = kwargs.get('state', True)
self.options.default('host', '127.0.0.1')
self.options.default('user', 'root')
self.options.default('password', '')
self.options.default('charset', 'utf8')
def test_rate(self):
registry = Registry('test')
user_json, cond_json = registry.proc_cmd("% BTG 1")
user_dic = {'userid': 'test', 'gap': 600}
self.assertEqual(user_json, user_dic)
self.assertEqual(cond_json, {
'userid': 'test',
'%': 1,
'currency': 'BTG'
})
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200, "MOCK_DIGEST")
self.registry.http.return_value.headers = {
'Content-Length': '4935',
'Docker-Content-Digest': 'MOCK_DIGEST_HEADER',
'X-Content-Type-Options': 'nosniff'
}
def __init__(self, **kwargs):
self.options = Registry(kwargs)
self.pool = None
self.server = None
self.state = kwargs.get('state', False)
self.options.default('host', '127.0.0.1')
self.options.default('port', 6379)
self.options.default('db', 0)
self.options.default('decode_responses', True)
def my_certificates_page():
owner = request.form.get("owner") or None
private_key = request.form.get("private_key") or None
registry_contract = Registry(owner)
certificates = registry_contract.get_my_certificates()
return render_template(
"my_certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def test_flat(self):
"""测试扁平处理"""
registry = Registry({
'a': {
'h': 'h',
'i': 'i',
}
})
self.assertEqual(registry.flat(), {
'a.h': 'h',
'a.i': 'i',
})
def test_set(self):
registry = Registry()
registry.set('a', 'a')
registry.set('b', [1, 2])
registry.set('c.h', 'h')
self.assertEqual(registry.get(), {
'a': 'a',
'b': [1, 2],
'c': {
'h': 'h'
}
})
def player():
from registry import Registry, Actors
from entities import Actor
# Player needs the registry to manage the backpack
registry = Registry()
player = Actor(Actors.HERO,
'Player',
'@', (255, 255, 255),
behavior=None,
registry=registry)
player.backpack.clear()
return player
def __init__(self):
imagePath = os.path.join("images", "horizon.png")
self.backgroundImage = view.loadScaledImage(imagePath)
imagePath = os.path.join("images", "title.png")
self.titleImage = view.loadScaledImage(imagePath,
view.TRANSPARENT_COLOUR)
self.playLine = titleFont.getTextImage("PRESS SPACE TO PLAY")
self.titleTicks = self.getTitleTicks()
self.startRegistry = Registry("start", PLAYER_OFF_SCREEN_START, 1)
self.screenImage = None
self.playState = None
self.started = False
self.ticks = 0
def getRegistry(cont, registry):
if cont:
registryHandler.switchToSnapshot()
return registryHandler.registry
if not registry:
#registry = Registry("unit", (4, 6), 1)
#registry = Registry("drops", (12, 7), 5)
#registry = Registry("forest", (11, 8), 3)
#registry = Registry("start", (22, 24), 4)
registry = Registry("start", PLAYER_ON_SCREEN_START, 1)
#registry = Registry("central", (6, 22), 2) # 0.93
registryHandler.setRegistry(registry)
return registry
def test_register_manual_keys():
registry = Registry()
@registry.register(name='python')
class PythonClass(Python):
pass
@registry.register(name='anaconda')
class AnacondaClass(Anaconda):
pass
assert registry['python'] == PythonClass
assert registry['anaconda'] == AnacondaClass
def redeem_certificate_request():
owner = request.form.get("owner")
private_key = request.form.get("private_key")
certificate_id = int(request.form.get("certificate_id"))
registry_contract = Registry(owner, private_key)
registry_contract.redeem_certificate(certificate_id)
certificates = registry_contract.get_my_certificates()
return render_template(
"my_certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def verify_certificate_request():
owner = request.form.get("owner")
private_key = request.form.get("private_key")
certificate_index = request.form.get("certificate_index")
certificate_data = certificates_for_verifying[int(certificate_index)]
registry_contract = Registry(owner, private_key)
registry_contract.verify_certificate(certificate_data)
del certificates_for_verifying[int(certificate_index)]
return render_template(
"agent.html",
certificates=certificates_for_verifying,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def test_load(self):
"""测试加载配置项"""
d = {
'a': 'a',
'b': 1,
'c': {
'h': 'h',
},
'd': [1, 2],
'e': True,
'f': 1.1,
}
registry = Registry()
registry.load(d)
self.assertEqual(registry.get(), d)
def test_merge(self):
registry = Registry()
registry.load({'a': {
'h': 'h',
'i': 'i',
}})
registry.merge('a', {
'g': 'g',
})
self.assertEqual(registry.get(),
{'a': {
'h': 'h',
'i': 'i',
'g': 'g',
}})
def game_map(player, orc, air, candy):
"""Create a level and place the other objects in it."""
from misc import Vector
from dungeon import Dungeon
from registry import Registry
registry = Registry()
dungeon = Dungeon()
dungeon.initialize(player, registry)
level = dungeon.current_level
# Place player and orc in this level
player.place(level, Vector(0, 0))
orc.place(level, Vector(5, 5))
candy.place(level, Vector(1, 0))
air.place(level, Vector(0, 1))
return level
def test_hook(self):
"""测试钩子"""
registry = Registry()
def callback():
registry.set('a', 'aaa')
return True
registry.set_hook('hook', 3, callback)
time.sleep(1)
registry.refresh_hook('hook')
self.assertEqual(registry.get('a'), None)
time.sleep(3)
registry.refresh_hook('hook')
self.assertEqual(registry.get('a'), 'aaa')
def create_certificate_page():
if request.method == "GET":
owner = request.args.get("owner")
private_key = None
elif request.method == "POST":
owner = request.form.get("owner")
private_key = request.form.get("private_key")
certificate_data = request.form.to_dict()
registry_contract = Registry()
registry_contract.set_time_of_destruction(certificate_data)
certificates_for_verifying.append(certificate_data)
return render_template(
"create_certificate.html",
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def main():
# First of all, load the registry
registry = Registry()
# Initialize player, display_manager
player = Actor(Actors.HERO,
"Player",
'@',
Colors.WHITE,
behavior=None,
registry=registry)
# XXX: Give player level boost for testing purposes
player.level = 10
# Initialize Dungeon
dungeon = Dungeon()
dungeon.initialize(player, registry)
# Initialize Display Manager
display_manager = DisplayManager(player, dungeon)
message("Hello world!", Colors.RED)
# Initialize Action Manager
action_manager = ActionManager(player, dungeon)
# Game loop
while not tdl.event.is_window_closed():
display_manager.refresh()
# TODO: Add player and enemy turn states and cycle between both
# Player turn
# TODO: Use game states to handle turns
action_manager.get_user_input()
if action_manager.handle_key_input() is False:
continue
# Enemy turn
for entity in dungeon.current_level.entities:
entity.take_turn(player)
# Check for player death
# TODO: Handle player death as a game state
if player.dead:
# TODO: Show death screen
print("You died!")
return 0
