taskwarrior-grocy/tests/test_grocy.py

import uuid
import datetime
import pytest
import sys
import mock
from twservices.apps import RestService, TaskService
from pytest_mock import mocker


sys.path.append(".")

from twservices.apps.grocy import Grocy 

#def test_get_grocy_tw_tasks(mocker, test_mock_tw_instance):
#    expect_filters = {
#        'and':  [('%s.any' % key, none) for key in list(grocy.udas.keys())],
#        'or': [('status', 'pending'), ('status', 'waiting')]
#    }
#    mocker.spy(test_mock_tw_instance, 'filter_tasks')
#
#    grocy = grocy()
#    grocy.set_taskwarrior(test_mock_tw_instance)
#    actual_tasks = grocy.get_grocy_tw_tasks()
#
#    assert actual_tasks is not none
#    assert grocy.get_grocy_tw_tasks.called.assert_called_with(expect_filters) is true 

@pytest.fixture(scope='function')
def setup_grocy_args():
    grocy_args = {
            'token': 'e96a89a5',
            'api': 'http://example.grocy.com',
            'category': 'grocy' 
    }
    return grocy_args


def test_get_category(mocker, setup_grocy_args):
    expected_category = setup_grocy_args['category']
    expected_token = setup_grocy_args['token']
    expected_grocy_categories = [{'name': expected_category}, {'name': 'test'}]

    mocker.patch.object(RestService, '__init__')
    mocker.patch.object(RestService, 'get')
    mocker.patch.object(RestService, 'addHeader')
    RestService.__init__.return_value = None
    RestService.get.return_value = expected_grocy_categories 

    grocy = Grocy(**setup_grocy_args)
    actual_category = grocy.get_category()
    RestService.addHeader.assert_called_with(Grocy.API_KEY_HEADER, expected_token)
    assert actual_category == {'name': expected_category }
   
def test_create_category(mocker, setup_grocy_args):
    expected_category = setup_grocy_args['category']
    expected_post_response = {'success': True, 'error': ''}

    mocker.patch.object(RestService, '__init__')
    mocker.patch.object(RestService, 'post')
    mocker.patch.object(RestService, 'addHeader')
    RestService.__init__.return_value = None
    RestService.post.return_value = expected_post_response
    mocker.patch.object(RestService, 'addHeader')

    grocy = Grocy(**setup_grocy_args)
    grocy.create_category()
    RestService.post.assert_called_with(Grocy.ADD_CATEGORY_ENDPOINT, expected_category)

def test_to_grocy(mocker, setup_grocy_args):
    mocker.patch.object(Grocy, 'get_category')
    notes_arr = ['This is line1', 'This is line2']
    notes_string = ''
    entry_time = datetime.time(18,22,00)
    entry_date = datetime.date(2019,1,16)
    due_time = datetime.time(18,26,00)
    due_date = datetime.date(2019,1,20)
    for note in notes_arr:
        notes_string+= '{}\n'.format(note) 

    expected_task = {
        Grocy.UDA_GROCY_ID: '1337',
        Grocy.UDA_GROCY_ASSIGNED_TO_USER_ID : '1',
        TaskService.UUID: '1a727026-9611-4d8e-ba4d-d5dc6eaf7054',
        TaskService.DESCRIPTION: 'This is a task from taskwarrior',
        TaskService.TAGS : setup_grocy_args['category'],
        TaskService.ANNOTATIONS: notes_arr,
        TaskService.ENTRY: datetime.datetime.combine(entry_date,entry_time),
        TaskService.DUE:  datetime.datetime.combine(entry_date,entry_time),        
        TaskService.DONE: '1' 
    }
    expected_grocy_task = {
        Grocy.ID : expected_task[Grocy.UDA_GROCY_ID],
        Grocy.UDA_GROCY_TW_UUID: expected_task[TaskService.UUID],
        Grocy.ASSIGNED_TO_USER_ID: expected_task[Grocy.UDA_GROCY_ASSIGNED_TO_USER_ID],
        Grocy.NAME: expected_task[TaskService.DESCRIPTION],
        Grocy.CATEGORY: expected_task[TaskService.TAGS],
        Grocy.DESCRIPTION: notes_string,
        Grocy.ROW_CREATED_TIMESTAMP: expected_task[TaskService.ENTRY].strftime('%Y-%m-%d %H:%M:%S'),
        Grocy.DUE_DATE: expected_task[TaskService.DUE].strftime('%Y-%m-%d'),
        Grocy.DONE: expected_task[TaskService.DONE]
    }
    print('expected_grocy_task {}'.format(expected_grocy_task))

    Grocy.get_category.return_value = {'name': setup_grocy_args['category']}
    grocy = Grocy(**setup_grocy_args)
    actual_grocy_task = grocy.to_grocy(expected_task)
    print('actual_grocy_task {}'.format(actual_grocy_task))
    assert expected_grocy_task == actual_grocy_task