Python Todo Examples

Example #1

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_with_current_state_equals_todo_state(self):
		states = ['TODO', 'NEXT', 'NOW', 'DELEGATED', 'DONE']
		current_state = 'TODO'
		self.assertEquals(Todo._get_next_state(current_state, states), 'NEXT')

		current_state = 'NEXT'
		self.assertEquals(Todo._get_next_state(current_state, states), 'NOW')

Example #2

File: test_plugin_todo.py Project: akstrfn/vim-orgmode

    def test_todo_toggle_NOTODO(self):
        vim.current.window.cursor = (2, 0)
        vim.current.buffer[1] = u_encode(u'** NOTODO Überschrift 1.1')

        Todo.toggle_todo_state()
        self.assertEqual(vim.current.buffer[1],
                         u_encode(u'** TODO NOTODO Überschrift 1.1'))

Example #3

	def test_get_next_state_with_current_state_equals_todo_state(self):
		states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
		current_state = u'TODO'
		self.assertEquals(Todo._get_next_state(current_state, states), u'NEXT')

		current_state = u'NEXT'
		self.assertEquals(Todo._get_next_state(current_state, states), u'NOW')

Example #4

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_with_invalid_current_state(self):
		states = ['TODO', 'DONE']
		current_state = 'STI'
		self.assertEquals(Todo._get_next_state(current_state, states), 'TODO')

		states = ['TODO', 'NEXT', 'DELEGATED', 'DONE']
		self.assertEquals(Todo._get_next_state(current_state, states), 'TODO')
		states = ['NEXT', 'DELEGATED', 'DONE']
		self.assertEquals(Todo._get_next_state(current_state, states), 'NEXT')

Example #5

	def test_toggle_todo_with_no_heading(self):
		# nothing should happen
		vim.current.window.cursor = (1, 0)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[0], u'')
		# and repeat it -> it should not change
		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[0], u'')

Example #6

File: test_todo.py Project: Sophrinix/vim-orgmode

	def test_get_next_state_backward_with_no_current_state(self):
		states = [((u'TODO', ), (u'DONE', ))]
		current_state = u''
		self.assertEquals(Todo._get_next_state(current_state, states, False), u'DONE')

		states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states, False), u'DONE')

		states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states, False), u'DONE')

Example #7

	def test_get_next_state_with_invalid_current_state(self):
		states = [((u'TODO', ), (u'DONE', ))]
		current_state = u'STI'
		self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')

		states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')

		states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states), u'NEXT')

Example #8

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_backward_with_no_current_state(self):
		states = ['TODO', 'DONE']
		current_state = ''
		self.assertEquals(Todo._get_next_state(current_state, states, False), 'DONE')

		states = ['TODO', 'NEXT', 'DELEGATED', 'DONE']
		self.assertEquals(Todo._get_next_state(current_state, states, False), 'DONE')

		states = ['NEXT', 'DELEGATED', 'DONE']
		self.assertEquals(Todo._get_next_state(current_state, states, False), 'DONE')

Example #9

File: test_todo.py Project: Sophrinix/vim-orgmode

	def test_get_next_state_backward_with_invalid_current_state(self):
		states = [((u'TODO', ), (u'DONE', ))]
		current_state = u'STI'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, u'DONE')

		states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, u'DONE')

		states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, u'DONE')

Example #10

File: test_todo.py Project: mirrormirror/vim-orgmode

    def test_get_next_state_backward_with_invalid_current_state(self):
        states = [((u'TODO', ), (u'DONE', ))]
        current_state = u'STI'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DONE')

        states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DONE')

        states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DONE')

Example #11

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_backward_with_invalid_current_state(self):
		states = ['TODO', 'DONE']
		current_state = 'STI'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'DONE')

		states = ['TODO', 'NEXT', 'DELEGATED', 'DONE']
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'DONE')

		states = ['NEXT', 'DELEGATED', 'DONE']
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'DONE')

Example #12

	def test_get_next_state_backward_with_no_current_state(self):
		states = [((u'TODO', ), (u'DONE', ))]
		current_state = u''
		self.assertEquals(Todo._get_next_state(current_state, states,
				Direction.BACKWARD), u'DONE')

		states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states,
				Direction.BACKWARD), u'DONE')

		states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
		self.assertEquals(Todo._get_next_state(current_state, states,
				Direction.BACKWARD), u'DONE')

Example #13

	def test_get_next_keyword_sequence(self):
		states = [((u'TODO(t)', u'NEXT(n)', u'NOW(w)'), (u'DELEGATED(g)', u'DONE(d)')), ((u'QA(q)', ), (u'RELEASED(r)', ))]
		current_state = None
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'TODO')

		current_state = None
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD, next_set=True)
		self.assertEquals(result, None)

		current_state = u'TODO'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD, next_set=True)
		self.assertEquals(result, u'TODO')

		current_state = u'TODO'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'QA')

		current_state = u'NOW'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'QA')

		current_state = u'DELEGATED'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'QA')

		current_state = u'QA'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD, next_set=True)
		self.assertEquals(result, u'TODO')

		current_state = u'QA'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'QA')

		current_state = u'RELEASED'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD, next_set=True)
		self.assertEquals(result, u'RELEASED')

		current_state = u'RELEASED'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD, next_set=True)
		self.assertEquals(result, u'TODO')

Example #14

File: test_plugin_todo.py Project: akstrfn/vim-orgmode

    def test_circle_through_todo_states_with_more_states(self):
        # * Heading 1 -->
        # * TODO Heading 1 -->
        # * STARTED Heading 1 -->
        # * DONE Heading 1 -->
        # * Heading 1 -->
        vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [
            u_encode(u'TODO'),
            u_encode(u'STARTED'),
            u_encode(u'DONE'),
            u_encode(u'|')
        ]
        vim.current.window.cursor = (2, 0)

        Todo.toggle_todo_state()
        self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')

        Todo.toggle_todo_state()
        self.assertEqual(vim.current.buffer[1], u'* STARTED Heading 1')

        Todo.toggle_todo_state()
        self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')

        Todo.toggle_todo_state()
        self.assertEqual(vim.current.buffer[1], u'* Heading 1')

Example #15

File: test_plugin_todo.py Project: akstrfn/vim-orgmode

 def test_get_next_state_backward_with_current_state_equals_todo_state(
         self):
     states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
     current_state = u'TODO'
     result = Todo._get_next_state(current_state, states,
                                   Direction.BACKWARD)
     self.assertEquals(result, None)

Example #16

File: test_todo.py Project: Sophrinix/vim-orgmode

	def test_get_next_state_in_current_sequence_with_access_keys(self):
		states = [((u'TODO(t)', u'NEXT(n)', u'NOW(w)'), (u'DELEGATED(g)', u'DONE(d)')), ((u'QA(q)', ), (u'RELEASED(r)', ))]
		current_state = u'QA'
		result = Todo._get_next_state(current_state, states, True)
		self.assertEquals(result, u'RELEASED')

		current_state = u'NEXT'
		result = Todo._get_next_state(current_state, states, True)
		self.assertEquals(result, u'NOW')

		current_state = u'TODO'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, None)

		current_state = None
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, u'DONE')

Example #17

File: test_todo.py Project: mirrormirror/vim-orgmode

    def test_get_next_state_in_current_sequence_with_access_keys(self):
        states = [((u'TODO(t)', u'NEXT(n)', u'NOW(w)'), (u'DELEGATED(g)',
                                                         u'DONE(d)')),
                  ((u'QA(q)', ), (u'RELEASED(r)', ))]
        current_state = u'QA'
        result = Todo._get_next_state(current_state, states, True)
        self.assertEquals(result, u'RELEASED')

        current_state = u'NEXT'
        result = Todo._get_next_state(current_state, states, True)
        self.assertEquals(result, u'NOW')

        current_state = u'TODO'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, None)

        current_state = None
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DONE')

Example #18

File: test_plugin_todo.py Project: Yixf-Self/vim-orgmode

	def test_get_next_state_backward_misc(self):
		states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
		current_state = u'DONE'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, u'DELEGATED')

		current_state = u'DELEGATED'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, u'NOW')

		current_state = u'NOW'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, u'NEXT')

		current_state = u'NEXT'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, u'TODO')

		current_state = u'TODO'
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, None)

		current_state = None
		result = Todo._get_next_state(current_state, states,
				Direction.BACKWARD)
		self.assertEquals(result, u'DONE')

Example #19

File: test_todo.py Project: mirrormirror/vim-orgmode

    def test_get_next_state_backward_misc(self):
        states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
        current_state = u'DONE'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DELEGATED')

        current_state = u'DELEGATED'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'NOW')

        current_state = u'NOW'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'NEXT')

        current_state = u'NEXT'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'TODO')

        current_state = u'TODO'
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, None)

        current_state = None
        result = Todo._get_next_state(current_state, states, False)
        self.assertEquals(result, u'DONE')

Example #20

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_backward_misc(self):
		states = ['TODO', 'NEXT', 'NOW', 'DELEGATED', 'DONE']
		current_state = 'DONE'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'DELEGATED')

		current_state = 'DELEGATED'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'NOW')

		current_state = 'NOW'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'NEXT')

		current_state = 'NEXT'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'TODO')

		current_state = 'TODO'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, None)

		current_state = None
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, 'DONE')

Example #21

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_current_state(self):
		states = ['TODO', 'INPROGRESS', 'DUMMY', 'DONE']

		heading_text = ''
		expected = None, ''
		result = Todo._split_heading(heading_text, states)
		self.assertEqual(result, expected)

		heading_text = None
		expected = None, ''
		result = Todo._split_heading(heading_text, states)
		self.assertEqual(result, expected)

		heading_text = 'Heading asdf'
		expected = (None, heading_text)
		result = Todo._split_heading(heading_text, states)
		self.assertEqual(result, expected)

		heading_text = 'TODO Heaging asdf'
		expected = 'TODO', 'Heaging asdf'
		result = Todo._split_heading(heading_text, states)
		self.assertEqual(result, expected)

Example #22

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_states_without_seperator(self):
		"""The last element in the todostates shouold be used as DONE-state when no sperator is given"""
		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo, expected_done = ['TODO'], ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'INPROGRESS', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo = ['TODO', 'INPROGRESS']
		expected_done = ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'INPROGRESS',
				'DUMMY', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo  = ['TODO', 'INPROGRESS', 'DUMMY']
		expected_done = ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

Example #23

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_states_with_seperator(self):
		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', '|', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo = ['TODO']
		expected_done = ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'INPROGRESS', '|',
				'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo = ['TODO', 'INPROGRESS']
		expected_done = ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'INPROGRESS',
				'DUMMY', '|',  'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo = ['TODO', 'INPROGRESS', 'DUMMY']
		expected_done = ['DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', 'INPROGRESS',
				'DUMMY', '|', 'DELEGATED', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo =['TODO', 'INPROGRESS', 'DUMMY']
		expected_done = ['DELEGATED', 'DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

		vim.EVALRESULTS['g:org_todo_keywords'] = ['TODO', '|', 'DONEX',
				'DUMMY', 'DELEGATED', 'DONE']
		states_todo, states_done = Todo._get_states()
		expected_todo = ['TODO']
		expected_done = ['DONEX', 'DUMMY', 'DELEGATED', 'DONE']
		self.assertEqual(states_todo, expected_todo)
		self.assertEqual(states_done, expected_done)

Example #24

File: test_plugin_todo.py Project: Yixf-Self/vim-orgmode

	def test_circle_through_todo_states_with_more_states(self):
		# * Heading 1 -->
		# * TODO Heading 1 -->
		# * STARTED Heading 1 -->
		# * DONE Heading 1 -->
		# * Heading 1 -->
		vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'STARTED'), u_encode(u'DONE'),
				u_encode(u'|')]
		vim.current.window.cursor = (2, 0)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* STARTED Heading 1')

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* Heading 1')

Example #25

	def test_toggle_todo_with_cursor_in_text_not_heading(self):
		# nothing should happen
		vim.current.window.cursor = (7, 0)
		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[5], u'** TODO Text 1')
		self.assertEqual(vim.current.window.cursor, (7, 0))

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[5], u'** DONE Text 1')
		self.assertEqual(vim.current.window.cursor, (7, 0))

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[5], u'** Text 1')
		self.assertEqual(vim.current.window.cursor, (7, 0))

Example #26

	def test_toggle_todo_in_heading_with_no_todo_state_different_levels(self):
		# level 1
		vim.current.window.cursor = (2, 0)
		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
		self.assertEqual((2, 0), vim.current.window.cursor)

		# level 2
		vim.current.window.cursor = (3, 0)
		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[2], u'** TODO Text 1')

		# level 2
		vim.current.window.cursor = (4, 4)
		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[3], u'*** TODO Text 2')
		self.assertEqual((4, 9), vim.current.window.cursor)

Example #27

	def test_circle_through_todo_states(self):
		# * Heading 1 -->
		# * TODO Heading 1 -->
		# * DONE Heading 1 -->
		# * Heading 1 -->
		# * TODO Heading 1 -->
		# * DONE Heading 1
		vim.current.window.cursor = (2, 6)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
		self.assertEqual((2, 11), vim.current.window.cursor)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')
		self.assertEqual((2, 11), vim.current.window.cursor)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* Heading 1')
		self.assertEqual((2, 6), vim.current.window.cursor)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
		self.assertEqual((2, 11), vim.current.window.cursor)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')
		self.assertEqual((2, 11), vim.current.window.cursor)

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u'* Heading 1')
		self.assertEqual((2, 6), vim.current.window.cursor)

Example #28

File: test_plugin_todo.py Project: Yixf-Self/vim-orgmode

	def test_todo_toggle_NOTODO(self):
		vim.current.window.cursor = (2, 0)
		vim.current.buffer[1] = u_encode(u'** NOTODO Überschrift 1.1')

		Todo.toggle_todo_state()
		self.assertEqual(vim.current.buffer[1], u_encode(u'** TODO NOTODO Überschrift 1.1'))

Example #29

File: test_todo.py Project: infracanophile/vim-orgmode

	def test_get_next_state_with_jump_from_todo_to_done(self):
		states = ['TODO', 'NEXT', 'NOW', 'DELEGATED', 'DONE']
		current_state = 'NOW'
		self.assertEquals(Todo._get_next_state(current_state, states), 'DELEGATED')

Example #30

File: test_todo.py Project: Sophrinix/vim-orgmode

	def test_get_next_state_backward_with_current_state_equals_todo_state(self):
		states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
		current_state = u'TODO'
		result = Todo._get_next_state(current_state, states, False)
		self.assertEquals(result, None)

Example #31

	def test_get_next_state_in_current_sequence(self):
		states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE')), ((u'QA', ), (u'RELEASED', ))]
		current_state = u'QA'
		result = Todo._get_next_state(current_state, states,
				Direction.FORWARD)
		self.assertEquals(result, u'RELEASED')

Example #32

	def test_get_next_state_with_jump_from_done_to_todo(self):
		states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
		current_state = u'DONE'
		self.assertEquals(Todo._get_next_state(current_state, states), None)