test/main_model_test.py

   1 from __future__ import absolute_import, division, unicode_literals
   2
   3 import os
   4 import unittest
   5
   6 import mock
   7
   8 from cola import core
   9 from cola import git
  10 from cola.models import main
  11
  12 from . import helper
  13
  14
  15 class MainModelTestCase(helper.GitRepositoryTestCase):
  16     """Tests the MainModel class."""
  17
  18     def test_project(self):
  19         """Test the 'project' attribute."""
  20         project = os.path.basename(self.test_path())
  21         self.model.set_worktree(core.getcwd())
  22         self.assertEqual(self.model.project, project)
  23
  24     def test_local_branches(self):
  25         """Test the 'local_branches' attribute."""
  26         self.commit_files()
  27         self.model.update_status()
  28         self.assertEqual(self.model.local_branches, ['main'])
  29
  30     def test_remote_branches(self):
  31         """Test the 'remote_branches' attribute."""
  32         self.model.update_status()
  33         self.assertEqual(self.model.remote_branches, [])
  34
  35         self.commit_files()
  36         self.run_git('remote', 'add', 'origin', '.')
  37         self.run_git('fetch', 'origin')
  38         self.model.update_status()
  39         self.assertEqual(self.model.remote_branches, ['origin/main'])
  40
  41     def test_modified(self):
  42         """Test the 'modified' attribute."""
  43         self.write_file('A', 'change')
  44         self.model.update_status()
  45         self.assertEqual(self.model.modified, ['A'])
  46
  47     def test_unstaged(self):
  48         """Test the 'unstaged' attribute."""
  49         self.write_file('A', 'change')
  50         self.write_file('C', 'C')
  51         self.model.update_status()
  52         self.assertEqual(self.model.unstaged, ['A', 'C'])
  53
  54     def test_untracked(self):
  55         """Test the 'untracked' attribute."""
  56         self.write_file('C', 'C')
  57         self.model.update_status()
  58         self.assertEqual(self.model.untracked, ['C'])
  59
  60     def test_remotes(self):
  61         """Test the 'remote' attribute."""
  62         self.run_git('remote', 'add', 'origin', '.')
  63         self.model.update_status()
  64         self.assertEqual(self.model.remotes, ['origin'])
  65
  66     def test_currentbranch(self):
  67         """Test the 'currentbranch' attribute."""
  68         self.run_git('checkout', '-b', 'test')
  69         self.model.update_status()
  70         self.assertEqual(self.model.currentbranch, 'test')
  71
  72     def test_tags(self):
  73         """Test the 'tags' attribute."""
  74         self.commit_files()
  75         self.run_git('tag', 'test')
  76         self.model.update_status()
  77         self.assertEqual(self.model.tags, ['test'])
  78
  79
  80 class RemoteArgsTestCase(unittest.TestCase):
  81     def setUp(self):
  82         self.context = context = mock.Mock()
  83         context.git = git.create()
  84         self.remote = 'server'
  85         self.local_branch = 'local'
  86         self.remote_branch = 'remote'
  87
  88     def test_remote_args_fetch(self):
  89         # Fetch
  90         (args, kwargs) = main.remote_args(
  91             self.context,
  92             self.remote,
  93             local_branch=self.local_branch,
  94             remote_branch=self.remote_branch,
  95         )
  96
  97         self.assertEqual(args, [self.remote, 'remote:local'])
  98         self.assertTrue(kwargs['verbose'])
  99         self.assertFalse('tags' in kwargs)
 100         self.assertFalse('rebase' in kwargs)
 101
 102     def test_remote_args_fetch_tags(self):
 103         # Fetch tags
 104         (args, kwargs) = main.remote_args(
 105             self.context,
 106             self.remote,
 107             tags=True,
 108             local_branch=self.local_branch,
 109             remote_branch=self.remote_branch,
 110         )
 111
 112         self.assertEqual(args, [self.remote, 'remote:local'])
 113         self.assertTrue(kwargs['verbose'])
 114         self.assertTrue(kwargs['tags'])
 115         self.assertFalse('rebase' in kwargs)
 116
 117     def test_remote_args_pull(self):
 118         # Pull
 119         (args, kwargs) = main.remote_args(
 120             self.context,
 121             self.remote,
 122             pull=True,
 123             local_branch='',
 124             remote_branch=self.remote_branch,
 125         )
 126
 127         self.assertEqual(args, [self.remote, 'remote'])
 128         self.assertTrue(kwargs['verbose'])
 129         self.assertFalse('rebase' in kwargs)
 130         self.assertFalse('tags' in kwargs)
 131
 132     def test_remote_args_pull_rebase(self):
 133         # Rebasing pull
 134         (args, kwargs) = main.remote_args(
 135             self.context,
 136             self.remote,
 137             pull=True,
 138             rebase=True,
 139             local_branch='',
 140             remote_branch=self.remote_branch,
 141         )
 142
 143         self.assertEqual(args, [self.remote, 'remote'])
 144         self.assertTrue(kwargs['verbose'])
 145         self.assertTrue(kwargs['rebase'])
 146         self.assertFalse('tags' in kwargs)
 147
 148     def test_remote_args_push(self):
 149         # Push, swap local and remote
 150         (args, kwargs) = main.remote_args(
 151             self.context,
 152             self.remote,
 153             local_branch=self.remote_branch,
 154             remote_branch=self.local_branch,
 155         )
 156
 157         self.assertEqual(args, [self.remote, 'local:remote'])
 158         self.assertTrue(kwargs['verbose'])
 159         self.assertFalse('tags' in kwargs)
 160         self.assertFalse('rebase' in kwargs)
 161
 162     def test_remote_args_push_tags(self):
 163         # Push, swap local and remote
 164         (args, kwargs) = main.remote_args(
 165             self.context,
 166             self.remote,
 167             tags=True,
 168             local_branch=self.remote_branch,
 169             remote_branch=self.local_branch,
 170         )
 171
 172         self.assertEqual(args, [self.remote, 'local:remote'])
 173         self.assertTrue(kwargs['verbose'])
 174         self.assertTrue(kwargs['tags'])
 175         self.assertFalse('rebase' in kwargs)
 176
 177     def test_remote_args_push_same_remote_and_local(self):
 178         (args, kwargs) = main.remote_args(
 179             self.context,
 180             self.remote,
 181             tags=True,
 182             local_branch=self.local_branch,
 183             remote_branch=self.local_branch,
 184             push=True,
 185         )
 186
 187         self.assertEqual(args, [self.remote, 'local'])
 188         self.assertTrue(kwargs['verbose'])
 189         self.assertTrue(kwargs['tags'])
 190         self.assertFalse('rebase' in kwargs)
 191
 192     def test_remote_args_push_set_upstream(self):
 193         (args, kwargs) = main.remote_args(
 194             self.context,
 195             self.remote,
 196             tags=True,
 197             local_branch=self.local_branch,
 198             remote_branch=self.local_branch,
 199             push=True,
 200             set_upstream=True,
 201         )
 202
 203         self.assertEqual(args, [self.remote, 'local'])
 204         self.assertTrue(kwargs['verbose'])
 205         self.assertTrue(kwargs['tags'])
 206         self.assertTrue(kwargs['set_upstream'])
 207         self.assertFalse('rebase' in kwargs)
 208
 209     def test_remote_args_rebase_only(self):
 210         (_, kwargs) = main.remote_args(
 211             self.context, self.remote, pull=True, rebase=True, ff_only=True
 212         )
 213         self.assertTrue(kwargs['rebase'])
 214         self.assertFalse('ff_only' in kwargs)
 215
 216     def test_run_remote_action(self):
 217         def passthrough(*args, **kwargs):
 218             return (args, kwargs)
 219
 220         (args, kwargs) = main.run_remote_action(
 221             self.context,
 222             passthrough,
 223             self.remote,
 224             local_branch=self.local_branch,
 225             remote_branch=self.remote_branch,
 226         )
 227
 228         self.assertEqual(args, (self.remote, 'remote:local'))
 229         self.assertTrue(kwargs['verbose'])
 230         self.assertFalse('tags' in kwargs)
 231         self.assertFalse('rebase' in kwargs)
 232
 233
 234 if __name__ == '__main__':
 235     unittest.main()