Ejemplo n.º 1
0
    def test_date_range_search(self):
        """Test date range search"""
        # No entries in database

        # Start and end date for the date range search
        date_1 = datetime.date(2019, 3, 1)
        date_2 = datetime.date(2019, 4, 3)

        # Query the database
        search_result = work_log_db.date_range_search(date_1, date_2)

        # Assert nothing returned back from the search
        self.assertEqual(search_result, [])

        # Add 3 entries with different dates but within the range
        work_log_db.add_entry(self.log_entry_dr_1)
        work_log_db.add_entry(self.log_entry_dr_2)
        work_log_db.add_entry(self.log_entry_dr_3)

        # Add 1 entry with a date outside of the search range
        work_log_db.add_entry(self.new_log_entry)

        # Query by database date range
        result = Entry.select().where(Entry.date.between(date_1, date_2))

        # Should return the 3 entries that are in the search range
        search_result = work_log_db.date_range_search(date_1, date_2)

        # Assert number of entries from search result equals number
        # added to database minus 1
        self.assertEqual(len(search_result), Entry.select().count() - 1)

        # Assert first entry added (earliest date) equals last entry
        # from search result since results are returned in descending
        # order from the date_range_search
        self.assertEqual(result[0].employee_name,
                         search_result[2]["employee_name"])
        self.assertEqual(result[0].date, search_result[2]["date"])
        self.assertEqual(result[0].task_name, search_result[2]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[2]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[2]["optional_notes"])

        # Assert 2nd entry added equals middle list item
        self.assertEqual(result[1].employee_name,
                         search_result[1]["employee_name"])
        self.assertEqual(result[1].date, search_result[1]["date"])
        self.assertEqual(result[1].task_name, search_result[1]["task_name"])
        self.assertEqual(result[1].time_spent, search_result[1]["time_spent"])
        self.assertEqual(result[1].optional_notes,
                         search_result[1]["optional_notes"])

        # Assert 3rd entry added equals first list item
        self.assertEqual(result[2].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[2].date, search_result[0]["date"])
        self.assertEqual(result[2].task_name, search_result[0]["task_name"])
        self.assertEqual(result[2].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[2].optional_notes,
                         search_result[0]["optional_notes"])
Ejemplo n.º 2
0
    def test_edit_entry(self):
        """Test entry to see if it's been edited in database"""
        # Add entry 1 to database and then edit it
        work_log_db.add_entry(self.log_entry)
        work_log_db.edit_entry(self.log_entry, self.new_log_entry)

        # Count number of entries in the database
        result = Entry.select().count()

        # Assert there is 1 entry in the database
        self.assertEqual(result, 1)

        # Query the edited entry from the database
        result = Entry.select().where(
            Entry.employee_name == self.employee_name_new
            and Entry.date == self.date_new
            and Entry.task_name == self.task_name_new
            and Entry.time_spent == self.time_spent_new
            and Entry.optional_notes == self.optional_notes_new)

        # Shows what's in the database is equal to the edited entry
        self.assertEqual(result[0].employee_name, self.employee_name_new)
        self.assertEqual(result[0].date, self.date_new)
        self.assertEqual(result[0].task_name, self.task_name_new)
        self.assertEqual(result[0].time_spent, self.time_spent_new)
        self.assertEqual(result[0].optional_notes, self.optional_notes_new)
Ejemplo n.º 3
0
    def test_delete_entry(self):
        """Test if entry has been deleted from the database"""
        # No entries in the database

        # Count number of entries in the database
        result = Entry.select().count()

        # Assert no entries
        self.assertEqual(result, 0)

        # Add entry to database
        work_log_db.add_entry(self.log_entry)

        # Count number of entries in the database
        result = Entry.select().count()

        # Assert there is 1 entry in the database
        self.assertEqual(result, 1)

        # Delete entry from database
        work_log_db.delete_entry(self.log_entry)

        # Count number of entries in the database
        result = Entry.select().count()

        # Assert no entries
        self.assertEqual(result, 0)
Ejemplo n.º 4
0
    def test_employee_name_search(self):
        """Test employee name search"""
        # Nothing added to database yet
        search_result = work_log_db.employee_name_search('John Smith')
        self.assertEqual(search_result, [])

        # Add entry to database
        work_log_db.add_entry(self.log_entry)  # 2019/3/20

        # Search by name
        search_result = work_log_db.employee_name_search('John Smith')

        # Assert search result is not []
        self.assertNotEqual(search_result, [])

        # Query entry from database
        result = Entry.select().where(
            Entry.employee_name == self.employee_name
            and Entry.date == self.date and Entry.task_name == self.task_name
            and Entry.time_spent == self.time_spent
            and Entry.optional_notes == self.optional_notes)

        # Entry added should equal search_result
        self.assertEqual(result[0].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[0].date, search_result[0]["date"])
        self.assertEqual(result[0].task_name, search_result[0]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[0]["optional_notes"])

        # Add another entry to database with a different date but
        # with the same name
        # Entries are returned back in descending order by date
        work_log_db.add_entry(self.log_entry_dr_3)  # 2019/4/3

        # Search by name
        search_result = work_log_db.employee_name_search('John Smith')

        # Query log_entry_dr_3
        result = Entry.select().where(Entry.date == self.date_dr_3)

        # Entry added should be first in search results
        self.assertEqual(result[0].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[0].date, search_result[0]["date"])
        self.assertEqual(result[0].task_name, search_result[0]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[0]["optional_notes"])
Ejemplo n.º 5
0
    def test_time_spent_search(self):
        """Test time spent search"""
        # Nothing in database yet so search result should return []
        search_result = work_log_db.time_spent_search(5)
        self.assertEqual(search_result, [])

        # Add 2 entries with the same time_spent and one with a
        # different time spent
        work_log_db.add_entry(self.log_entry_1)
        work_log_db.add_entry(self.log_entry_2)
        work_log_db.add_entry(self.new_log_entry)  # Has different time spent

        # Query database
        search_result = work_log_db.time_spent_search(5)

        # Assert that length of search result equals count from database
        result = Entry.select().where(
            Entry.time_spent == self.time_spent_1).count()
        self.assertEqual(len(search_result), result)

        # Assert that length of search result equals 2
        self.assertEqual(len(search_result), 2)

        # Returns entries where time_spent is 5
        result = Entry.select().where(Entry.time_spent == self.time_spent_1)

        # First entry added should equal search result's first entry
        self.assertEqual(result[0].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[0].date, search_result[0]["date"])
        self.assertEqual(result[0].task_name, search_result[0]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[0]["optional_notes"])

        # Second entry added should equal search result's second entry
        self.assertEqual(result[1].employee_name,
                         search_result[1]["employee_name"])
        self.assertEqual(result[1].date, search_result[1]["date"])
        self.assertEqual(result[1].task_name, search_result[1]["task_name"])
        self.assertEqual(result[1].time_spent, search_result[1]["time_spent"])
        self.assertEqual(result[1].optional_notes,
                         search_result[1]["optional_notes"])
Ejemplo n.º 6
0
    def test_add_entry(self):
        """Test add_entry from work_log_db.py"""
        # No entries in database

        # Query database
        result = Entry.select().where(
            Entry.employee_name == self.employee_name
            and Entry.date == self.date and Entry.task_name == self.task_name
            and Entry.time_spent == self.time_spent
            and Entry.optional_notes == self.optional_notes)

        # Check to see if in database
        if result.exists():
            result = True
        else:
            result = False

        # Assert no entries in the database
        self.assertFalse(result)

        # Add entry to database
        work_log_db.add_entry(self.log_entry)

        # Query database
        result = Entry.select().where(
            Entry.employee_name == self.employee_name
            and Entry.date == self.date and Entry.task_name == self.task_name
            and Entry.time_spent == self.time_spent
            and Entry.optional_notes == self.optional_notes)

        # Assert entry in database
        self.assertEqual(result[0].employee_name, self.employee_name)
        self.assertEqual(result[0].date, self.date)
        self.assertEqual(result[0].task_name, self.task_name)
        self.assertEqual(result[0].time_spent, self.time_spent)
        self.assertEqual(result[0].optional_notes, self.optional_notes)
Ejemplo n.º 7
0
    def test_exact_search(self):
        """Test exact search"""
        # Nothing added to database yet.  Search should return []
        search_result = work_log_db.exact_search('add')
        self.assertEqual(search_result, [])

        # Nothing added to database yet.  Search should return []
        search_result = work_log_db.exact_search('app')
        self.assertEqual(search_result, [])

        # Add entry to database
        work_log_db.add_entry(self.log_entry)

        # Entry contains word "add" in the task name
        search_result = work_log_db.exact_search('add')
        self.assertNotEqual(search_result, [])

        # Optional notes contain "apples"
        search_result = work_log_db.exact_search('app')
        self.assertNotEqual(search_result, [])

        # Returns entry that was added to the database
        result = Entry.select().where(
            Entry.employee_name == self.employee_name
            and Entry.date == self.date and Entry.task_name == self.task_name
            and Entry.time_spent == self.time_spent
            and Entry.optional_notes == self.optional_notes)

        # Entry added should equal search_result
        self.assertEqual(result[0].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[0].date, search_result[0]["date"])
        self.assertEqual(result[0].task_name, search_result[0]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[0]["optional_notes"])
Ejemplo n.º 8
0
    def test_exact_date_search(self):
        """Test exact date search"""
        # Add 2 log entries with the same date and one that differs by date
        work_log_db.add_entry(self.log_entry_1)
        work_log_db.add_entry(self.log_entry_2)
        work_log_db.add_entry(self.new_log_entry)  # This log entry differs

        # Query the database for entries with that date
        result = Entry.select().where(Entry.date == self.date_1)

        # Assert there are 2 entries with the date queried
        self.assertEqual(result.count(), 2)

        # Use exact_date_search
        search_result = work_log_db.exact_date_search(self.date_1)

        #  Assert count from database equals count from exact_date_search
        self.assertEqual(result.count(), len(search_result))

        # Entry 1 in database equals entry 1 from exact_date_search
        self.assertEqual(result[0].employee_name,
                         search_result[0]["employee_name"])
        self.assertEqual(result[0].date, search_result[0]["date"])
        self.assertEqual(result[0].task_name, search_result[0]["task_name"])
        self.assertEqual(result[0].time_spent, search_result[0]["time_spent"])
        self.assertEqual(result[0].optional_notes,
                         search_result[0]["optional_notes"])

        # Entry 2 in database equals entry 2 from exact_date_search
        self.assertEqual(result[1].employee_name,
                         search_result[1]["employee_name"])
        self.assertEqual(result[1].date, search_result[1]["date"])
        self.assertEqual(result[1].task_name, search_result[1]["task_name"])
        self.assertEqual(result[1].time_spent, search_result[1]["time_spent"])
        self.assertEqual(result[1].optional_notes,
                         search_result[1]["optional_notes"])