def test_zoo_pay_worker_no_budget(self):
z = Zoo("Zoo", 200, 2, 2)
z.hire_worker(Vet("John", 23, 100))
z.hire_worker(Keeper("Bill", 28, 150))
res = z.pay_workers()
self.assertEqual(
res, "You have no budget to pay your workers. They are unhappy")
async def start_keeper(params, _loop=None):
backend = None
try:
backend = Backend(params, _loop)
await backend.connect()
geodetector = get_geodetector(params, backend)
frame_engine = Frame(geodetector)
vehicles_engine = Vehicles(backend)
keeper = Keeper(frame_engine, vehicles_engine)
uri = f"ws://{params.wsaddr}{params.wspath}:{params.wsport}"
async with websockets.connect(uri) as websocket:
while True:
message = await websocket.recv()
try:
await keeper.serve(json.loads(message))
except JSONDecodeError:
# todo logging
pass
except error.KeeperError as e:
print(e)
break
except error.KeeperBackendConnectionError as e:
# todo организовать обработку прочик исключений
pass
except error.KeeperError:
pass
finally:
await backend.destroy()
def test_zoo_pay_worker_success(self):
z = Zoo("Zoo", 1500, 2, 2)
z.hire_worker(Vet("John", 23, 100))
z.hire_worker(Keeper("Bill", 28, 150))
res = z.pay_workers()
self.assertEqual(z._Zoo__budget, 1250)
self.assertEqual(
res, "You payed your workers. They are happy. Budget left: 1250")
def main(args):
keeper = Keeper()
if args['download']:
keeper.download()
if args['upload']:
keeper.upload()
def test_restore_check_content(self):
"""Test restoring a file and check contents"""
# Set paths
cwd = os.getcwd()
file_paths = [
cwd + "/tmp/keeper_test_r_check/a/b/file1.txt",
cwd + "/tmp/keeper_test_r_check/a/b/c/file2.txt",
cwd + "/tmp/keeper_test_r_check/a/b/c/file3.txt",
cwd + "/tmp/keeper_test_r_check/a/b/c/e/f4",
cwd + "/tmp/keeper_test_r_check/a/b/d/file5.txt"
]
folder_paths_to_create = [
cwd + "/tmp/keeper_test_r_check/a/b/c/e/",
cwd + "/tmp/keeper_test_r_check/a/b/d"
]
directories_to_backup = [
cwd + "/tmp/keeper_test_r_check/a/b/d/"
]
file_expected_in_restore = os.path.join(
cwd + "/tmp/keeper_test_r_check/a/b/d/file5.txt"
)
# Set sails
keeper = Keeper(system_directories=directories_to_backup,
show_progress=False)
# Create all directories
for path in folder_paths_to_create:
self._create_dir(path)
# Create all files for backup
for path in file_paths:
# Create file
with open(path, "w") as file_handle:
file_handle.write("For Gondor!\n")
# Create backup
keeper.backup(
destination_path=cwd + "/tmp/keeper_test_r_check",
filename="restore_test.tar.gz"
)
# Purge the source directory
self._purge_directory(cwd + "/tmp/keeper_test_r_check/a")
# Restore
keeper.restore(
cwd + "/tmp/keeper_test_r_check/restore_test.tar.gz")
# Get file contents
with open(file_expected_in_restore, 'r') as restored_file:
content = restored_file.read()
logging.debug("content " + content)
self.assertEqual(content, "For Gondor!\n")
# Clean up test files and directories
self._purge_directory(cwd + "/tmp/keeper_test_r_check")
def main():
keeper = Keeper(CONFIG)
options = sys.argv[1:]
comm = keeper.comm(options) if len(options) <= 2 else False
if comm and callable(comm):
print(comm())
else:
print(comm)
def test_worker_status(self):
z = Zoo("My Zoo", 500, 3, 3)
z.hire_worker(Vet("Leo", 35, 100))
z.hire_worker(Keeper("Tigy", 40, 100))
z.hire_worker(Caretaker("Chi", 24, 100))
res = z.workers_status()
self.assertEqual(
res,
"You have 3 workers\n----- 1 Keepers:\nName: Tigy, Age: 40, Salary: 100\n----- 1 Caretakers:\nName: Chi, Age: 24, Salary: 100\n----- 1 Vets:\nName: Leo, Age: 35, Salary: 100"
)
def test_instantiating(self):
"""Test that Keeper class can be instantiated"""
directories = [
"/var/lib/rundeck/data", # database
"/var/lib/rundeck/logs", # execution logs (by far biggest)
"/var/lib/rundeck/.ssh", # ssh keys
"/var/lib/rundeck/var/storage", # key storage files and metadata
"/var/rundeck/projects" # project definitions
]
Keeper(system_directories=directories, show_progress=False)
def setUp(self):
self.original_stream = console.stream
console.stream = sys.stdout
self.keeper_root = 'testkeeper'
shutil.rmtree(self.keeper_root, ignore_errors=True)
try:
os.mkdir(self.keeper_root)
except FileExistsError:
pass
self.keeper = Keeper(self.keeper_root)
def test_raises_exception_on_relative_paths(self):
"""Test that relative paths raise an exception"""
contains_relative_paths = [
"some/path/here",
"some/other/path",
"/this/is/valid/though"
]
with self.assertRaises(Exception):
Keeper(
system_directories=contains_relative_paths,
show_progress=False
)
def test_raises_exception_on_overlapping_dirs_reversed(self):
"""Test that exception is raised for overlapping dirs.
For example /tmp/a/b,/tmp/a/b/c should fail
"""
# Set bad directories
bad_directories = [
"/tmp/keeper_python_unittest_raises/a/b",
"/tmp/keeper_python_unittest_raises/a/b/c"
]
# Set sails
with self.assertRaises(Exception):
Keeper(system_directories=bad_directories, show_progress=False)
def test_cleanup_pending_add_buffered_stream(self):
# Temporarily ignore warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
stream = self.keeper.add_buffered_stream()
stream.write(b"The very hungry caterpillar")
self.assertIs(stream.key, None)
# deliberately omitted close causes an intentional ResourceWarning
self.assertEqual(len(self.keeper), 0)
self.keeper = Keeper(self.keeper_root)
stream = self.keeper.add_buffered_stream()
stream.write(b"The very hungry caterpillar")
stream.close()
self.assertEqual(len(self.keeper), 1)
def __init__(self, config_file, nbr_total_item):
"""Constructeur.
Argument(2):
config_file : structure du labyrinthe
nbr_total_item : nombre total d'objet présent dans la structure"""
pygame.init()
self.window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_WIDTH))
pygame.display.set_caption("P3 : labyrinthe")
font = pygame.font.Font(None, 64)
self.text_victoire = font.render("Victoire !", 1, (0, 255, 0))
self.text_defeat = font.render("Défaite !", 1, (255, 0, 0))
self.level = Gameboard(config_file, nbr_total_item)
self.character = Character(self.level)
self.keeper = Keeper()
i = 0
while i < nbr_total_item:
self.item = Item(self.level.gameboard)
self.level.gameboard[self.item.pos_y][self.item.pos_x] = "I"
i += 1
def main():
try:
if args.conf:
log.info("Reading conf from {}".format(args.conf))
with open(args.conf, 'r') as pipes_file:
conf = json.load(pipes_file,
object_pairs_hook=collections.OrderedDict)
simulators = []
cache = Cache(args.db)
admin_user = cache["users"]["admin"]
admin_user["auth_url"] = cache["api"]["auth_url"]
admin_factory = ClientFactory(admin_user)
admin_keeper = Keeper(cache, admin_factory)
if args.clean:
log.info("Starting cleanup")
admin_keeper.clean(args.clean)
sys.exit()
# This section for default initialization of cirros image
log.debug("Caching default cirros image")
(cache["glance"]["images"][admin_keeper.get(
"glance", "images", "name",
lambda x: x == "cirros-0.3.4-x86_64-uec")[0].id]) = False
for flavor in admin_factory.nova().flavors.list():
log.debug(
"Caching flavor with name {name}".format(name=flavor.name))
(cache["nova"]["flavors"][flavor.id]) = False
for pipe_name, pipe in conf.iteritems():
simulators.append(Simulator(pipe_name, pipe, cache, admin_keeper))
for simulator in simulators:
simulator.simulate()
except KeyboardInterrupt:
print('\nThe process was interrupted by the user')
raise SystemExit
# Copyright: (c) CNYS 2015
# Licence: <your licence>
#-------------------------------------------------------------------------------
#class imports
from maze import Maze
from keeper import Keeper
from crate import Crate
#add in the pygame imports
import random, sys, copy, os, pygame
from pygame.locals import *
score = 0
moves = 0
maze = Maze()
keeper = Keeper("^", 4, 1)
crate1 = Crate("/", 4, 2)
maze.placeCrate("/", 4, 2)
FPS = 30 # frames per second to update the screen
WINWIDTH = 800 # width of the program's window, in pixels
WINHEIGHT = 600 # height in pixels
HALF_WINWIDTH = int(WINWIDTH / 2) #you need to know 1/2 sizes so you can
HALF_WINHEIGHT = int(WINHEIGHT / 2) #place things centrally
# The total width and height of each tile in pixels.
TILEWIDTH = 32
TILEHEIGHT = 32
TILEFLOORHEIGHT = 32
from flask import Flask, Blueprint, request, Response, jsonify
from flask_api import status
from keeper import Keeper
app = Flask(__name__)
keep = Keeper()
@app.route('/<list_id>', methods=['GET'])
def listItems(list_id):
return jsonify(
uncheckedItems = keep.getUncheckedItems(list_id),
checkedItems = keep.getCheckedItems(list_id)
), status.HTTP_200_OK
@app.route('/<list_id>', methods=['POST'])
def addListItem(list_id):
content = request.json
item = content['item']
keep.addItem(list_id, item)
return jsonify(
addedItem = item,
), status.HTTP_200_OK
@app.route('/<list_id>', methods=['PUT'])
def checkUncheck(list_id):
content = request.json
item = content['item']
keep.modifyCheckState(list_id, item)
def test_keeper_repr(self):
k = Keeper("ally", 36, 190)
res = str(k)
self.assertEqual(res, "Name: ally, Age: 36, Salary: 190")
import sys
from keeper import Keeper
if __name__ == '__main__':
Keeper(sys.argv[1:]).main()
def test_backup(self):
"""Test creating a backup file from a set of directories"""
cwd = os.getcwd()
# Set paths
file_paths = [
cwd + "/tmp/keeper_test_backup/house/room/file1.txt",
cwd + "/tmp/keeper_test_backup/house/room/desk/file2.txt",
cwd + "/tmp/keeper_test_backup/house/room/desk/file3.txt",
cwd + "/tmp/keeper_test_backup/house/room/desk/drawer/file4",
cwd + "/tmp/keeper_test_backup/house/room/locker/file5.txt"
]
folder_paths_to_create = [
cwd + "/tmp/keeper_test_backup/house/room/desk/drawer",
cwd + "/tmp/keeper_test_backup/house/room/locker"
]
directories_to_backup = [
cwd + "/tmp/keeper_test_backup/house/room/desk/drawer",
cwd + "/tmp/keeper_test_backup/house/room/locker"
]
files_expected_in_tar = [
os.path.join(
cwd.strip("/"),
"tmp/keeper_test_backup/house/room/desk/drawer"
),
os.path.join(
cwd.strip("/"),
"tmp/keeper_test_backup/house/room/desk/drawer/file4"
),
os.path.join(
cwd.strip("/"),
"tmp/keeper_test_backup/house/room/locker"
),
os.path.join(
cwd.strip("/"),
"tmp/keeper_test_backup/house/room/locker/file5.txt"
)
]
# Set sails
keeper = Keeper(system_directories=directories_to_backup,
show_progress=False)
# Create all directories
for path in folder_paths_to_create:
self._create_dir(path)
# Create all files for backup test
for path in file_paths:
# Create file
with open(path, "w") as file_handle:
file_handle.write("For Gondor!\n")
# Create backup
keeper.backup(
destination_path=cwd + "/tmp/keeper_test_backup",
filename="backup_test.tar.gz"
)
# Get list of all file paths inside tar file
files_in_tar = self._list_files_in_tar(
cwd + "/tmp/keeper_test_backup/backup_test.tar.gz")
# tar file can't be empty
self.assertNotEqual(len(files_in_tar), 0)
# Normpath the paths
# NOTE: I don't know why this is necessary
files_expected_in_tar = [
os.path.normpath(p) for p in files_expected_in_tar
]
files_in_tar = [
os.path.normpath(p) for p in files_in_tar
]
# Compare tar file and list of files
self.assertEqual(files_expected_in_tar,
files_in_tar)
# Recursively remove all directories and files used in test
self._purge_directory(cwd + "/tmp/keeper_test_backup")
def test_keeper_init(self):
k = Keeper("john", 21, 200)
self.assertEqual(k.name, "john")
self.assertEqual(k.age, 21)
self.assertEqual(k.salary, 200)
def test_restore(self):
"""Test restoring a set of directories and files from a backup file"""
# Set paths
cwd = os.getcwd()
file_paths = [
cwd + "/tmp/keeper_test_restore/hotel/lobby/file1.txt",
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/file2.txt",
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/file3.txt",
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/drawer/f4",
cwd + "/tmp/keeper_test_restore/hotel/lobby/locker/file5.txt"
]
folder_paths_to_create = [
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/drawer/",
cwd + "/tmp/keeper_test_restore/hotel/lobby/locker"
]
directories_to_backup = [
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/drawer/",
cwd + "/tmp/keeper_test_restore/hotel/lobby/locker/"
]
files_expected_in_restore = [
cwd + "/tmp/keeper_test_restore/hotel/lobby/desk/drawer/f4",
cwd + "/tmp/keeper_test_restore/hotel/lobby/locker/file5.txt"
]
# Set sails
keeper = Keeper(system_directories=directories_to_backup,
show_progress=False)
# Create all directories
for path in folder_paths_to_create:
self._create_dir(path)
# Create all files for backup
for path in file_paths:
# Create file
with open(path, "w") as file_handle:
file_handle.write("For Gondor!\n")
# Create backup
keeper.backup(
destination_path=cwd + "/tmp/keeper_test_restore",
filename="restore_test.tar.gz"
)
# Purge the source directory
self._purge_directory(cwd + "/tmp/keeper_test_restore/hotel")
# Restore
keeper.restore(
cwd + "/tmp/keeper_test_restore/restore_test.tar.gz")
# List all directories
restored = cwd + "/tmp/keeper_test_restore/hotel"
files_found = []
for root, dirs, files in os.walk(restored):
for f in files:
files_found.append(os.path.join(root, f))
self.assertEqual(files_found, files_expected_in_restore)
# Clean up test files and directories
self._purge_directory(cwd + "/tmp/keeper_test_restore")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--conf', dest='conf',
default='/etc/spamostack/conf.json',
help='Path to the config file with pipes')
parser.add_argument('--db', dest='db', default='./db',
help='Path to the database directory')
parser.add_argument('--verbose', action='store_true',
help='Increase verbose output')
parser.add_argument('--clean', dest='clean', nargs='+',
help='Path to the database directory')
args = parser.parse_args()
log = logging.getLogger(__name__)
if args.verbose:
log.setLevel(logging.DEBUG)
level = 'DEBUG'
else:
log.setLevel(logging.INFO)
level = 'INFO'
log.addHandler(logger.SpamStreamHandler())
coloredlogs.install(level=level)
try:
log.info("Reading conf from {}".format(args.conf))
with open(args.conf, 'r') as pipes_file:
conf = json.load(pipes_file,
object_pairs_hook=collections.OrderedDict)
simulators = []
cache = Cache(args.db)
users = cache["users"]
admin_user = users["admin"]
api = cache["api"]
admin_user["auth_url"] = api["auth_url"]
admin_factory = ClientFactory(admin_user)
admin_keeper = Keeper(cache, admin_factory)
if args.clean:
log.info("Starting cleanup")
admin_keeper.clean(args.clean)
sys.exit()
# This section for default initialization of cirros image
log.debug("Caching default cirros image")
(cache["glance"]["images"]
[admin_keeper.get(
"glance", "images", "name",
lambda x: x == "cirros-0.3.4-x86_64-uec")[0].id]) = False
for flavor in admin_factory.nova().flavors.list():
log.debug("Caching flavor with name {name}".
format(name=flavor.name))
(cache["nova"]["flavors"][flavor.id]) = False
for pipe_name, pipe in conf.iteritems():
simulators.append(Simulator(pipe_name, pipe, cache, admin_keeper))
for simulator in simulators:
simulator.simulate()
except KeyboardInterrupt:
print('\nThe process was interrupted by the user')
raise SystemExit
def test_zoo_fire_worker_success(self):
z = Zoo("Zoo", 1500, 1, 1)
z.hire_worker(Keeper("K", 45, 100))
res = z.fire_worker("K")
self.assertEqual(res, "K fired successfully")
self.assertEqual(z.workers, [])
# Animals creation
animals = [
Cheetah("Cheeto", "Male", 2),
Cheetah("Cheetia", "Female", 1),
Lion("Simba", "Male", 4),
Tiger("Zuba", "Male", 3),
Tiger("Tigeria", "Female", 1),
Lion("Nala", "Female", 4)
]
# Animal prices
prices = [200, 190, 204, 156, 211, 140]
# Workers creation
workers = [
Keeper("John", 26, 100),
Keeper("Adam", 29, 80),
Keeper("Anna", 31, 95),
Caretaker("Bill", 21, 68),
Caretaker("Marie", 32, 105),
Caretaker("Stacy", 35, 140),
Vet("Peter", 40, 300),
Vet("Kasey", 37, 280),
Vet("Sam", 29, 220)
]
# Adding all animals
for i in range(len(animals)):
animal = animals[i]
price = prices[i]
print(zoo.add_animal(animal, price))
def test_restore_does_not_overwrite(self):
"""Test that existing files are not overwritten by restore"""
cwd = os.getcwd()
base = cwd + "/tmp/keeper_python_unittest_restore_no_overwrite"
# Set paths
file_paths = [
base + "/hotel/lobby/file1.txt",
base + "/hotel/lobby/desk/file2.txt",
base + "/hotel/lobby/desk/file3.txt",
base + "/hotel/lobby/desk/drawer/f4",
base + "/hotel/lobby/locker/file5.txt"
]
folder_paths_to_create = [
base + "/hotel/lobby/desk/drawer/",
base + "/hotel/lobby/locker"
]
directories_to_backup = [
base + "/hotel/lobby/desk/drawer/",
base + "/hotel/lobby/locker/"
]
files_expected_in_restore = [
base + "/hotel/lobby/desk/drawer/f4",
base + "/hotel/lobby/locker/file5.txt"
]
# Set sails
keeper = Keeper(system_directories=directories_to_backup,
show_progress=False)
# Create all directories
for path in folder_paths_to_create:
self._create_dir(path)
# Create all files for backup
for path in file_paths:
# Create file
with open(path, "w") as file_handle:
file_handle.write("For Gondor!\n")
# Create backup
keeper.backup(
destination_path=base,
filename="restore_test.tar.gz"
)
# Write to files again
for name in files_expected_in_restore:
with open(name, "w") as file_handle:
file_handle.write("new version\n")
# Restore should raise exception on existing file
with self.assertRaises(Exception):
keeper.restore(base + "/restore_test.tar.gz")
# Get file contents
files_content = []
for name in files_expected_in_restore:
with open(name, "r") as file_handle:
content = file_handle.read()
files_content.append(content)
self.assertEqual(
files_content,
[
"new version\n",
"new version\n"
]
)
# Purge the test directory
self._purge_directory(base)
