def test_apply_raise(self):
print("test_apply_raise")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
self.emp_1.apply_raise()
self.emp_2.apply_raise()
self.assertEqual(self.emp_1.pay, 52500)
self.assertEqual(self.emp_2.pay, 63000)
def setUp(self):
"""
Create an employee profile and custom raise amounts
"""
first_name = 'Tom'
last_name = 'Kelly'
salary = 20000
self.profile = Employee(first_name, last_name, salary)
self.default = 25000
self.bump = 27000
class TestEmployeeRaise(unittest.TestCase):
def setUp(self):
self.senior_employee = Employee('Antwan', 'Lowe', 90000)
#self.new_employee = Employee('Shanice','Matthew', '70000', 'Burkes')
def test_give_default_raise(self):
self.senior_employee.give_raise()
self.assertEqual(self.senior_employee.salary, 95000)
def test_custom_raise(self):
self.senior_employee.give_raise(7000)
self.assertEqual(self.senior_employee.salary, 97000)
class TestEmployee(unittest.TestCase):
"""docstring for TestEmployee"""
def setUp(self):
self.employee = Employee('jose', 'macias', 100000)
def test_give_default_raise(self):
self.employee.give_raise()
self.assertEqual(self.employee.annual_salary, 105000)
def test_give_custom_raise(self):
self.employee.give_raise(400)
self.assertEqual(self.employee.annual_salary, 100400)
def test_fullname(self):
print("test_fullname")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
self.assertEqual(self.emp_1.fullname, "Corey Schafer")
self.assertEqual(self.emp_2.fullname, "Sue Smith")
self.emp_1.first = "John"
self.emp_2.first = "Jane"
self.assertEqual(self.emp_1.fullname, "John Schafer")
self.assertEqual(self.emp_2.fullname, "Jane Smith")
class TestEmployee(unittest.TestCase):
"""tests for Employee"""
def setUp(self):
self.an_employee = Employee('bob', 'cratchett', 5000)
def test_give_raise_default(self):
"""test give_raise with default value"""
self.an_employee.give_raise()
self.assertEqual(self.an_employee.annual_salary, 10000)
def test_give_custom_raise(self):
"""test give_raise of £1 #tight"""
self.an_employee.give_raise(1)
self.assertEqual(self.an_employee.annual_salary, 5001)
def _new_employee(self, salary, contract, tracked_hours):
if contract == 'hourly':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Hourly(salary), HourlyCalculator(), cards)
if contract == 'voluntary':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Voluntary(), VoluntaryCalculator(), cards)
if contract == 'fixed':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Fixed(salary), FixedCalculator(), cards)
pass
class TestEmployee(unittest.TestCase):
def setUp(self):
"""Create an employee to test all methods."""
self.tyson = Employee('Tyson', 'Nguyen', 20000)
def test_give_default_raise(self):
"""Test to see if default value adds to the salary."""
self.tyson.give_raise()
self.assertEqual(self.tyson.salary, 25000)
def test_give_custom_raise(self):
"""Test a custom value for raise to salary works."""
self.tyson.give_raise(10000)
self.assertEqual(self.tyson.salary, 30000)
class TestEmployees(unittest.TestCase):
"""Tests for employees.py"""
def SetUp(self):
fname = 'Test'
lname = 'Dude'
salary = 5000
self.test_dude = Employee(fname, lname, salary)
def test_give_default_raise(self):
self.test_dude.give_raise()
self.assertEqual(self.test_dude.salary, 10000)
def test_give_custom_raise(self):
self.test_dude.give_raise(10000)
self.assertEqual(self.test_dude.salary, 15000)
def test_who_owns_dl(self):
conf = config.get()
Employee.retrieve_records({'VP_LIST': []}, use_cache=True)
instances = cloudability.get_rightsizing_data(
conf['cloudability_api_key'])['result']
accounted_emails = set(map(lambda i: owner_by_email(i, {}), instances))
dls = set(
filter(lambda s: (s or "").lower().startswith('dl-'),
accounted_emails))
for dl in dls:
owner = Employee.who_owns_dl(conf, dl)
self.assertTrue(owner is not None, "dl:{} has no owner".format(dl))
self.assertFalse(type(owner) == list)
# TODO take from config
result = Employee.who_owns_dl(conf, '<some dl>')
self.assertTrue(result is not None)
def fix():
"""Handles requests to correct an employee's status, then redirects
to their page."""
try:
employee = Employee.get(request.query['employee'])
except LookupError:
return error('No employee was specified')
employee.fix()
return redirect("/employed?employee=" + employee.name)
class TestEmployeeRaise(unittest.TestCase):
"""Test for the class Employee"""
def setUp(self):
"""
Create an employee profile and custom raise amounts
"""
first_name = 'Tom'
last_name = 'Kelly'
salary = 20000
self.profile = Employee(first_name, last_name, salary)
self.default = 25000
self.bump = 27000
def test_give_default_raise(self):
"""Test the default raise amount"""
self.assertEqual(self.default, self.profile.give_raise())
def test_give_custom_raise(self):
"""Test the custom raise amount"""
self.assertEqual(self.bump, self.profile.give_raise(7000))
class TestHourlyCalculator(unittest.TestCase):
def setUp(self):
self.calculator = HourlyCalculator()
self.contract = Hourly(10)
self.employee = Employee(self.contract, self.calculator, [])
def test_with_employee_with_one_card(self):
self.employee.add_card(Card(10))
result = self.calculator.calculate(self.employee)
expected = 100
self.assertEqual(expected, result)
def test_with_employee_with_thre_cards(self):
self.employee.add_card(Card(10))
self.employee.add_card(Card(20))
self.employee.add_card(Card(5))
result = self.calculator.calculate(self.employee)
expected = 350
self.assertEqual(expected, result)
def test_with_employee_with_no_cards(self):
result = self.calculator.calculate(self.employee)
expected = 0
self.assertEqual(expected, result)
def employed():
"""Renders a page indicating whether an employee still has a job."""
try:
employee = Employee.get(request.query['employee'])
except LookupError:
return error('No employee was specified')
return template(
'employed.html',
employee=employee.name,
has_a_job=employee.has_a_job,
company=getenv("COMPANY_NAME", "My Company"),
year=date.today().year,
)
def all_employee_handler():
if request.method == 'GET':
data = mgr.get_all()
if data is None:
return jsonify({"error": "cannot get all employees"})
return jsonify({'data': data})
elif request.method == 'POST':
data = request.json['data']
emp = Employee(data['name'], data['address'], data['salary'],
data['salary'])
data = mgr.addEmployee(emp)
print data
if data is None:
return jsonify({"error": "cound not add employee"})
return jsonify({'id': data})
def add_or_update(self):
things_to_check = {
'id': self.check_id(),
'name': self.check_name(),
'department': self.check_department(),
'title': self.check_title()
}
# Check for valid inputs and display the appropriate error message
try:
global msg
if all(things_to_check.values()):
employee_object = Employee(name, id_number, department, title)
if self.update:
self.update_info(id_number, name, department, title)
if self.found and self.confirm_selection(id_number):
self.confirmation_msg(
f'Employee {id_number} has been updated!')
else:
pass
elif self.add:
self.add_info(id_number, employee_object)
if not self.found:
self.confirmation_msg(
f'Employee {id_number} has been added!')
else:
pass
self.found = False
else:
msg = ''
if not things_to_check['id']:
msg += 'Invalid ID format!\n'
if not things_to_check['name']:
msg += 'Invalid Name format!\n'
if not things_to_check['department']:
msg += 'Invalid Department format!\n'
if not things_to_check['title']:
msg += 'Invalid Title format!\n'
self.error_msg(msg)
msg = ''
except TypeError:
msg += 'One or more columns requires an input!\n'
self.error_msg(msg)
msg = ''
def test_get_vp(self):
Employee.retrieve_records({'VP_LIST': []}, use_cache=True)
conf = config.get()
# TODO take from config
vp = Employee.get_vp_saml(conf, employee_saml_account='<someone>')
self.assertEqual('<someone_else>', vp.account_name)
from employees import Employee
from company import Company
if __name__ == '__main__':
# Create a Company
ThePoopStore = Company("The Poop Store", "7/17/77")
# Create some EMPLOYEES
raf = Employee("Raf", "Pooper Scooper", "01/27/2018")
meghan = Employee("Meghan", "Sharking", "02/01/2018")
deanna = Employee("Deanne", "Guru'ing", "5/15/2017")
erin = Employee("Erin", "Food", "08/29/2016")
# Add EMPLOYEES into the AGGREGATE instance variable of the COMPANY
ThePoopStore.employees.add(raf)
ThePoopStore.employees.add(meghan)
ThePoopStore.employees.add(deanna)
ThePoopStore.employees.add(erin)
print(ThePoopStore)
def SetUp(self):
fname = 'Test'
lname = 'Dude'
salary = 5000
self.test_dude = Employee(fname, lname, salary)
def setUp(self):
print("setUp")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
# manager = employees[0]
# manager.payroll = HourlyPolicy(55)
# productivity_system.track(employees, 40)
# payroll_system.calculate_payroll(employees)
#
# em = Employee(1, 2, 3, 4, 5)
import json
from hr import calculate_payroll, LTDPolicy
from productivity import track
from employees import employee_database, Employee
def print_dict(d):
print(json.dumps(d, indent=2))
employees = employee_database.employees
sales_employee = employees[2]
ltd_policy = LTDPolicy()
sales_employee.apply_payroll_policy(ltd_policy)
track(employees, 40)
calculate_payroll(employees)
temp_secretary = Employee(5)
print('Temporary Secretary:')
print_dict(temp_secretary.to_dict())
from employees import Employee
from companies import Company
John = Employee("John Long", "Front End Developer")
Bishop = Employee("Ryan Bishop", "Full Stack Developer")
Jeremiah = Employee("Jeremiah Bell", "Dilletante")
Trey = Employee("Trey Suiter", "Motivational Speaker")
Brenda = Employee("Brenda Long", "UI/UX specialist")
Eventbrite = Company("Eventbrite", "Tech")
NSS = Company("Nashville Software School", "Creating Developers")
NSS.add_employee(John)
NSS.add_employee(Trey)
Eventbrite.add_employee(Brenda)
Eventbrite.add_employee(Jeremiah)
Eventbrite.add_employee(Bishop)
NSS.about_company()
Eventbrite.about_company()
class TestEmployee(unittest.TestCase):
@classmethod
def setUpClass(cls):
print("setUpClass")
@classmethod
def tearDownClass(cls):
print("tearDownClass")
def setUp(self):
print("setUp")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
def tearDown(self):
print("tearDown\n")
def test_email(self):
print("test_email")
self.assertEqual(self.emp_1.email, "*****@*****.**")
self.assertEqual(self.emp_2.email, "*****@*****.**")
self.emp_1.first = "John"
self.emp_2.first = "Jane"
self.assertEqual(self.emp_1.email, "*****@*****.**")
self.assertEqual(self.emp_2.email, "*****@*****.**")
def test_fullname(self):
print("test_fullname")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
self.assertEqual(self.emp_1.fullname, "Corey Schafer")
self.assertEqual(self.emp_2.fullname, "Sue Smith")
self.emp_1.first = "John"
self.emp_2.first = "Jane"
self.assertEqual(self.emp_1.fullname, "John Schafer")
self.assertEqual(self.emp_2.fullname, "Jane Smith")
def test_apply_raise(self):
print("test_apply_raise")
self.emp_1 = Employee("Corey", "Schafer", 50000)
self.emp_2 = Employee("Sue", "Smith", 60000)
self.emp_1.apply_raise()
self.emp_2.apply_raise()
self.assertEqual(self.emp_1.pay, 52500)
self.assertEqual(self.emp_2.pay, 63000)
def test_monthly_schedule(self):
with patch("employees.requests.get") as mocked_get:
mocked_get.return_value.ok = True
mocked_get.return_value.text = "Success"
schedule = self.emp_1.monthly_schedule("May")
mocked_get.assert_called_with("http://company.com/Schafer/May")
self.assertEqual(schedule, "Success")
mocked_get.return_value.ok = False
schedule = self.emp_2.monthly_schedule("June")
mocked_get.assert_called_with("http://company.com/Smith/June")
self.assertEqual(schedule, "Bad Response!")
# =================================
# Until now we have been hard-coding values into the query statements but we are most likely to put values from a python variable to the query
# ---------------------------------
# Using the employees module
import sqlite3
from employees import Employee
# ---------------------------------
conn = sqlite3.connect('employees.db')
cur = conn.cursor()
# ---------------------------------
# Creating instances
emp_1 = Employee('Brock', 'Lesnar', 80000)
emp_2 = Employee('John', 'Cena', 90000)
# ---------------------------------
# Inserting employees data to the table
# Using string formatting
cur.execute("INSERT INTO employees VALUES('{}', '{}', {})".format(
emp_1.first, emp_1.last, emp_1.pay))
# This is a bad practice to add values to our database not just sqlite3 but for any database we use
# If we are accepting any values from an end user from a website or something like that then this is venerable to SQL injection i.e. users can set values of variable to something that can break the entire database and reason for that is that it is not properly escaped
# ---------------------------------
# So there are two correct ways to do that
# ---------------------------------
# Frist way
def test_retrieve_records(self):
Employee.retrieve_records({'VP_LIST': []}, use_cache=False)
self.assertTrue(len(Employee.by_account_name) > 0)
def setUp(self):
self.calculator = VoluntaryCalculator()
self.contract = Voluntary()
self.employee = Employee(self.contract, self.calculator, [])
def setUp(self):
self.emp_1 = Employee("narh", "kpodo", 80)
self.emp_2 = Employee("nelson", "mandela", 800)
from companies import Company
from employees import Employee
erin = Employee("Erin Polley", "software developer", "April 27, 2020")
corri = Employee("Corri Golden", "front end engineer", "June 3, 2020")
chase = Employee("Chase Fite", "software engineer", "April 12, 2020")
matt = Employee("Matthew Blagg", "software developer", "May 7, 2020")
guy = Employee("Guy Cherkesky", "company mogul", "March 23, 2020")
eventbrite = Company("EventBrite", "Cummins Station", "Tech")
asurion = Company("Asurion", "Downtown", "Insurance")
asurion.add_people([chase, guy])
eventbrite.add_people([erin, matt, corri])
def print_stuff(business):
print(
f'{business.name} is in the {business.type} industry and has the following employees:'
)
for employee in business.employees:
print(f'*{employee.name}')
print_stuff(asurion)
print_stuff(eventbrite)
from employees import Employee
#here employees.py file and Employee class
#create object of class Employee
sales = Employee()
trainer = Employee()
peon = Employee()
account = Employee()
admin = Employee()
print("Enter details of sale's person")
sales.getdata()
print("Details of sales person")
sales.display()
print("Enter details of Trainer ")
trainer.getdata()
print(" details of Trainer ")
trainer.display()
peon.getdata()
peon.display()
account.getdata()
account.display()
admin.getdata()
admin.display()
def setUp(self):
self.employee = Employee('jose', 'macias', 100000)
def setUp(self):
self.calculator = FixedCalculator()
self.contract = Fixed(10)
self.employee = Employee(self.contract, self.calculator, [])
print(Fore.RED + "()()()()()()()()()()()()()()()()()")
time.sleep(5)
os.system('clear')
def auth_error():
os.system('clear')
print(Fore.RED + "()()()()()()()()()()()()()()()()()")
print(Fore.GREEN + "()() You are not authorized to perform this!")
print(Fore.GREEN + "()() CONTACT ADMIN IF THIS SEEMS INCORRECT!")
print(Fore.RED + "()()()()()()()()()()()()()()()()()")
time.sleep(5)
os.system('clear')
doctor1 = Employee('John', 'Smith', 'doctor1', 'superdoctor', 'Doctor')
admin = Employee('Matthew', 'Cross', 'admin', 'admin', 'Admin')
records = [{
'Doctor': 'John Smith',
'Illness': 'Sore Throat',
'Prescribed': 'Asprin'
}]
patient1 = Patient('1', 'Alice', 'Smith', 23, records)
hospital_patients = [patient1]
hospital_employees = [doctor1, admin]
hospital = Hospital('NEXT', 'Glomac Damansara', hospital_employees,
hospital_patients)
########## DRIVER CODE ##########
##### Variables #####