def setUp(self):
self.recipe = Recipes()
self.recipe_data = {
"ingredients": ["one", "two", "three"],
"procedure": ["one", "two", "three"],
"pic": "/recipe1.png"
}
def get(id: int):
"""
given a id, this method will return the
corresponding recipe
:param id: int from url
:return: json
"""
filename = Path(__file__).parent / "recipe-data.csv"
files = import_file.Files()
recipe_load = files.import_from_csv(filename)
recipes = Recipes(recipe_load)
a_recipe = recipes.filter_recipes_id(id)
return jsonify(a_recipe)
class TestRecipes:
def setup_method(self):
self.files = Files()
self.test_filename = Path(__file__).parent / "test_recipe-data.csv"
recipe_load = self.files.import_from_csv(self.test_filename)
self.recipes = Recipes(recipe_load)
def test_filter_recipes_id(self):
a_recipe = self.recipes.filter_recipes_id(1)
assert "test1" in a_recipe
def test_filter_recipes_cuisine(self):
filtered_recipes, total = self.recipes.filter_recipes_cuisine(
"test3", 1, 1)
assert len(filtered_recipes) == 1
assert total == 1
def timerSavePartialProcess(self):
from app.recipes import Recipes
self.app.recipes = Recipes(self.app, self.config)
self.app.recipes.updateUnfinishedRecipe(
self.currentStep['recipe_id'], self.currentStep['name'],
self.currentStep['number'], self.currentStep['mash_total_time'],
self.app.mashTun.getWaterLevel(), self.mashTunTimeProbe,
self.app.boilKettle.getWaterLevel(), self.boilKettleTimeProbe)
def put(id: int):
"""
updates a recipe given id and property to update
:param id: int from url
:return: json
"""
parser = reqparse.RequestParser()
parser.add_argument("title", type=str)
args = parser.parse_args()
if args:
filename = Path(__file__).parent / "recipe-data.csv"
files = import_file.Files()
recipe_load = files.import_from_csv(filename)
recipes = Recipes(recipe_load)
a_recipe = recipes.update_recipe(id, args)
files.export_to_csv(recipes, filename)
return jsonify(a_recipe)
else:
return abort(404)
def stop(self):
from app.recipes import Recipes
self.app.recipes = Recipes(self.app, self.config)
self.app.recipes.deleteUnfinishedRecipe()
self.app.mashTun.stopHeating()
self.app.boilKettle.stopHeating()
self.app.pump.moveWater(action=waterActionsEnum.FINISHED)
self.app.logger.info(
'==============================================================================='
)
self.initialize()
def get(cuisine: str):
"""
returns a filtered json file of cuisine
:param cuisine: GET from url
:return: json
"""
parser = reqparse.RequestParser()
parser.add_argument("page", type=int)
parser.add_argument("items", type=int)
page = (
parser.parse_args()["page"] if parser.parse_args()["page"] else 1
)
items = (
parser.parse_args()["items"]
if parser.parse_args()["items"]
else 1
)
# Creates dict of recipe data
filename = Path(__file__).parent / "recipe-data.csv"
files = import_file.Files()
recipe_load = files.import_from_csv(filename)
recipes = Recipes(recipe_load)
filtered_recipes, total = recipes.filter_recipes_cuisine(
cuisine, page, items
)
# Creates dict of metadata
metadata = Metadata()
metadata = metadata.get_metadata(items, page, total)
# return recipes data and metadata
results = {"metadata": metadata, "recipes": filtered_recipes}
if page > round(total / items):
return abort(404)
else:
return jsonify(results)
def setup_method(self):
self.files = Files()
self.test_filename = Path(__file__).parent / "test_recipe-data.csv"
recipe_load = self.files.import_from_csv(self.test_filename)
self.recipes = Recipes(recipe_load)
app.logger = logging.getLogger('RagnarokLogger')
app.logger.setLevel(logging.DEBUG)
handler = logging.handlers.RotatingFileHandler(LOG_FILENAME, maxBytes=200000, backupCount=5)
handler.setLevel(logging.DEBUG)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.WARNING)
stream_handler.setFormatter(outFormatter)
app.logger.addHandler(stream_handler)
app.logger.info('===============================================================================')
app.recipes = Recipes(app, config)
app.sound = Sound(app, config)
app.started = False
# Jobs scheduler
executors = {
'default': ThreadPoolExecutor(20),
'processpool': ProcessPoolExecutor(5)
}
job_defaults = {
'coalesce': True,
'max_instances': 3
}
app.jobs = AsyncIOScheduler(executors=executors, job_defaults=job_defaults)
app.jobs.start()
"""
This test suit contains the unittest for
the recipes and categories CRUD features
"""
from unittest import TestCase
from app.recipes import Categories, CATEGORIES, Recipes
from app import APP
CATEGORY = Categories()
RECIPE = Recipes()
class CategoriesTestCase(TestCase):
"""This class comprises of the categories unit tests"""
def setUp(self):
"""Set up tests"""
CATEGORIES.clear()
self.user_email = "*****@*****.**"
self.username = "******"
self.user_password = "******"
APP.config['TESTING'] = True
self.test_app = APP.test_client()
def tearDown(self):
"""The following is done at the end of each test"""
self.logout()
def signup(self):
"""This is the signup helper method"""
return self.test_app.post('/signup',
data=dict(email=self.user_email,
from app.webSocket import webSocket
from app.cooking import Cooking
from app.hardware.kettle import kettle
from app.hardware.valve import valve
from app.hardware.pump import pump
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from app.database import Database
from app.recipes import Recipes
import configparser
config = configparser.ConfigParser()
config.read('app/config/config.cfg')
app = web.Application()
app.DB = Database(app, config)
app.recipes = Recipes(app)
# Jobs scheduler
app.jobs = AsyncIOScheduler()
app.jobs.start()
# Main cooking process
app.cooking = Cooking(app, config)
# Hardware
app.mashTun = kettle(app, config['MASH_TUN_PINS'], 'MashTun')
app.boilKettle = kettle(app, config['BOIL_KETTLE_PINS'], 'BoilKettle')
app.pump = pump(app, config, 'Pump')
app.outletValveDump = valve(app, 'OutletValveDump')
class RecipeTest(unittest.TestCase):
def setUp(self):
self.recipe = Recipes()
self.recipe_data = {
"ingredients": ["one", "two", "three"],
"procedure": ["one", "two", "three"],
"pic": "/recipe1.png"
}
def testrecipeadd(self):
self.recipe.addRecipes("testrecipe", self.recipe_data)
self.assertEqual(1, len(self.recipe.getRecipes()))
def testrecipedublicate(self):
self.recipe.addRecipes("testrecipe", self.recipe_data)
self.assertEqual(1, len(self.recipe.getRecipes()))
self.assertEqual(
"Dublicate recipe",
self.recipe.addRecipes("testrecipe", self.recipe_data))
def testmultiplerecipecreation(self):
self.recipe.addRecipes("testrecipe", self.recipe_data)
self.assertEqual(1, len(self.recipe.getRecipes()))
self.recipe.addRecipes("new testrecipe", self.recipe_data)
self.assertEqual(2, len(self.recipe.getRecipes()))
def testdeleterecipe(self):
self.recipe.addRecipes("testrecipe", self.recipe_data)
self.assertEqual(1, len(self.recipe.getRecipes()))
self.recipe.addRecipes("new testrecipe", self.recipe_data)
self.assertEqual(2, len(self.recipe.getRecipes()))
self.recipe.deleteRecipe("testrecipe")
self.assertEqual(1, len(self.recipe.getRecipes()))
def testgetsinglerecipe(self):
self.recipe.addRecipes("testrecipe", self.recipe)
self.assertEqual(1, len(self.recipe.getRecipes()))
self.assertIn("testrecipe", self.recipe.getRecipy("testrecipe"))
def testupdatecategory(self):
self.recipe.addRecipes("testrecipe", self.recipe)
self.assertEqual(1, len(self.recipe.getRecipes()))
new_data = {
"ingredients": ["one1", "two1", "three1"],
"procedure": ["one1", "two1", "three1"],
"pic": "/recipe12.png"
}
self.recipe.updateRecipe("testrecipe", new_data)
self.assertIn(
"/recipe12.png",
self.recipe.getRecipy("testrecipe").get("testrecipe").get("pic"))