def test_find_by_search_term(self, mock_get_search_term, _):
        iter_num = 5
        entries = [create_random_entry() for _ in range(iter_num)]
        for (index, entry) in enumerate(entries, start=1):
            for _ in range(index):
                Entry.create(name=entry['name'],
                             task=entry['task'],
                             spent_minutes=entry['spent_minutes'],
                             notes=entry['notes'])

        for (index, entry) in enumerate(entries, start=1):
            search_term = random.choice([entry['task'],
                                         entry['notes']]).lower()
            length = len(search_term)
            start = random.randint(0, length - 1)
            end = random.randint(start + 1, length)
            substring = search_term[start:end]
            mock_get_search_term.return_value = substring
            matched_entries = worklog_db.find_by_search_term()
            self.assertGreaterEqual(len(matched_entries), index)
            for matched_entry in matched_entries:
                self.assertTrue(
                    (substring in matched_entry.task.lower())
                    or (substring in matched_entry.notes.lower()),
                    "{} not in {} or {}".format(substring, matched_entry.task,
                                                matched_entry.notes))
 def create_entries():
     Entry.create(
         employee_name=DATA["employee_name"],
         minutes=DATA["minutes"],
         task_name=DATA["task_name"],
         notes=DATA["notes"],
         date=DATA["date"]
     )
Example #3
0
 def test_print_entries(self):
     # Test if entries print to the screen and if the menu works [n, b].
     # Eventually the script will return to the main menu [r] and quit [3].
     Entry.create(**TEST_ENTRY)
     results = Entry.select()
     self.test_values = (value for value in ["n", "b", "r", "3"])
     with patch("builtins.input", self.mock_input):
         app.print_entries(results)
    def test_check_employee_name_match(self):
        with test_database(TEST_DB, (Entry,)):
            self.create_entries()
            Entry.create(**DATA)
            entries = Entry.select()

            with mock.patch('builtins.input', side_effect=["Mike"]):
                test = worklog_db.check_employee_name_match(entries)
                self.assertEqual(test.count(), 2)
Example #5
0
def new():
    form = EntryForm()
    if form.validate_on_submit():
        Entry.create(title=form.title.data,
                     date=form.date.data,
                     timespent=form.timespent.data,
                     body=form.body.data,
                     resources=form.resources.data)
        return redirect(url_for('index'))
    return render_template('new.html', form=form)
def add_entry():
    """Add an entry"""
    clear_screen()
    print("Add a new entry")
    name = get_name()
    task = get_task()
    spent_minutes = get_spent_minutes()
    notes = get_notes()
    Entry.create(name=name,
                 task=task,
                 spent_minutes=spent_minutes,
                 notes=notes)
 def test_creation(self):
     Entry.create(name='Josh',
                  task='Fix bug',
                  spent_minutes=20,
                  notes='fun')
     entries = Entry.select()
     self.assertEqual(len(entries), 1)
     entry = entries.get()
     self.assertEqual(entry.name, 'Josh')
     self.assertEqual(entry.task, 'Fix bug')
     self.assertEqual(entry.spent_minutes, 20)
     self.assertEqual(entry.notes, 'fun')
    def test_display_nav_options(self):
        p = "[P] - Previous entry"
        n = "[N] - Next entry"
        q = "[Q] - Return to Main Menu"

        with test_database(TEST_DB, (Entry,)):
            self.create_entries()
            entries = Entry.select()
            Entry.create(**DATA)
            index = 0
            menu = [n, q]

            worklog_db.display_nav_options(index, entries)
            self.assertNotIn(p, menu)
Example #9
0
    def test_display_nav_menu(self):
        a = "A) Previous Entry"
        b = "B) Next Entry"
        e = "E) Return to Main Menu"

        with test_database(test_db, (Entry, )):
            self.entry_creator()
            entries = Entry.select()
            Entry.create(**TEST2)
            index = 0
            menu = [b, e]

            work_log.display_nav_menu(index, entries)
            self.assertNotIn(a, menu)
Example #10
0
    def test_find_by_employee(self):
        # Test if an entry can be found through a single name.
        entry_1 = Entry.create(**TEST_ENTRY)
        self.test_values = (value for value in [entry_1.employee])
        with patch("builtins.input", self.mock_input):
            results = app.find_by_employee()
        self.assertEqual(results[0], entry_1)

        # If the user types in [m] and there are two employees with that
        # letter in their name, test if the user can select an option [2].
        entry_2 = Entry.create(**TEST_ENTRY_2)
        self.test_values = (value for value in ["m", "2"])
        with patch("builtins.input", self.mock_input):
            results = app.find_by_employee()
        self.assertEqual(results[0], entry_2)
Example #11
0
 def update(self, text):
     entry = Entry.create(owner_id=self.id,
                          content=text)
     entry.save()
     self.timeline.insert(0, (entry.id,
                              entry.created_time))
     self.save()
Example #12
0
 def test_edit_entry(self):
     # Test if every key can be edited (except for id).
     entry = Entry.create(**TEST_ENTRY)
     entry = {
         "id": entry.id,
         "employee": entry.employee,
         "task": entry.task,
         "time": entry.time,
         "notes": entry.notes,
         "date": entry.date,
     }
     new_values = [
         "employee", "Menno", "task", "Designing", "time", 50, "notes",
         "VVD", "date", "01/01/2001"
     ]
     results = []
     self.test_values = (value for value in new_values)
     for _ in range(len(entry) - 1):
         with patch("builtins.input", self.mock_input):
             results.append(app.edit_entry(entry))
     self.assertEqual(results[0]["employee"], new_values[1])
     self.assertEqual(results[1]["task"], new_values[3])
     self.assertEqual(results[2]["time"], new_values[5])
     self.assertEqual(results[3]["notes"], new_values[7])
     self.assertEqual(results[4]["date"], new_values[9])
Example #13
0
 def test_find_by_term(self):
     # Test if an entry can be found through a title or note.
     entry = Entry.create(**TEST_ENTRY)
     self.test_values = (value for value in [entry.task])
     with patch("builtins.input", self.mock_input):
         results = app.find_by_term()
     self.assertEqual(results[0], entry)
Example #14
0
 def test_find_by_date_range(self):
     # Test if an entry can be found through a date range.
     entry = Entry.create(**TEST_ENTRY)
     self.test_values = (value for value in ["01/01/2019", "12/31/2019"])
     with patch("builtins.input", self.mock_input):
         results = app.find_by_date_range()
     self.assertEqual(results[0], entry)
    def test_find_by_employee(self, mock_get_employee_name, _):
        iter_num = 5
        entries = [create_random_entry() for _ in range(iter_num)]
        for (index, entry) in enumerate(entries, start=1):
            for _ in range(index):
                Entry.create(name=entry['name'],
                             task=entry['task'],
                             spent_minutes=entry['spent_minutes'],
                             notes=entry['notes'])

        for (index, entry) in enumerate(entries, start=1):
            mock_get_employee_name.return_value = entry['name']
            matched_entries = worklog_db.find_by_employee()
            self.assertGreaterEqual(len(matched_entries), index)
            for matched_entry in matched_entries:
                self.assertEqual(matched_entry.name, entry['name'])
 def test_find_by_date(self, mock_get_date_string, _):
     iter_num = 5
     random_dates = [create_random_date() for _ in range(iter_num)]
     for (index, date) in enumerate(random_dates, start=1):
         for _ in range(index):
             entry = create_random_entry()
             Entry.create(name=entry['name'],
                          task=entry['task'],
                          spent_minutes=entry['spent_minutes'],
                          notes=entry['notes'],
                          timestamp=date)
     for (index, date) in enumerate(random_dates, start=1):
         mock_get_date_string.return_value = date.strftime('%m/%d/%Y')
         matched_entries = worklog_db.find_by_date()
         self.assertGreaterEqual(len(matched_entries), index)
         for matched_entry in matched_entries:
             self.assertEqual(matched_entry.timestamp.day, date.day)
             self.assertEqual(matched_entry.timestamp.month, date.month)
             self.assertEqual(matched_entry.timestamp.year, date.year)
 def test_find_by_date_range(self, mock_get_date_string, _, ignore):
     iter_num = 20
     random_dates = [create_random_date() for _ in range(iter_num)]
     for date in random_dates:
         entry = create_random_entry()
         Entry.create(name=entry['name'],
                      task=entry['task'],
                      spent_minutes=entry['spent_minutes'],
                      notes=entry['notes'],
                      timestamp=date)
     for _ in range(iter_num):
         start_date = create_random_date()
         end_date = create_random_date()
         mock_get_date_string.side_effect = [
             start_date.strftime('%m/%d/%Y'),
             end_date.strftime('%m/%d/%Y')
         ]
         matched_entries = worklog_db.find_by_date_range()
         for matched_entry in matched_entries:
             self.assertGreaterEqual(matched_entry.timestamp, start_date)
             self.assertLessEqual(matched_entry.timestamp, end_date)
Example #18
0
 def add_new_entry(self):
     """Append a new Entry to 'self.entries'"""
     clear_screen()
     new_entry = Entry.create()
     if new_entry is None:
         print("Add new entry cancelled.  Returning to main menu...")
         time.sleep(1)
         return None
     self.entries.append(new_entry)
     with open(self.file_name, "a") as file:
         writer = csv.writer(file)
         writer.writerow([
             new_entry.date, new_entry.name, new_entry.minutes,
             new_entry.note
         ])
def create_entry(entry):
    """Create entry in database."""
    Entry.create(**entry)
    return entry
def add_random_entry():
    entry = create_random_entry()
    return Entry.create(name=entry['name'],
                        task=entry['task'],
                        spent_minutes=entry['spent_minutes'],
                        notes=entry['notes'])
def add_entry():
    Entry.create(name=test_name,
                 task=test_task,
                 spent_minutes=test_spent_minutes,
                 notes=test_notes)
Example #22
0
def create_entry(entry):
    Entry.create(**entry)
    return entry
Example #23
0
def add_entry():
    """Add new entry"""
    entry = get_entry_values()
    return Entry.create(**entry)