test/main_model_test.py

   1 import os
   2
   3 import pytest
   4
   5 from cola import core
   6 from cola import git
   7 from cola.models import main
   8 from cola.models.main import FETCH, PULL, PUSH
   9
  10 from . import helper
  11 from .helper import app_context
  12 from .helper import Mock
  13
  14
  15 # prevent unused imports lint errors.
  16 assert app_context is not None
  17
  18 REMOTE = 'server'
  19 LOCAL_BRANCH = 'local'
  20 REMOTE_BRANCH = 'remote'
  21
  22
  23 @pytest.fixture
  24 def mock_context():
  25     """Return a Mock context for testing"""
  26     context = Mock()
  27     context.git = git.create()
  28     return context
  29
  30
  31 def test_project(app_context):
  32     """Test the 'project' attribute."""
  33     project = os.path.basename(core.getcwd())
  34     app_context.model.set_worktree(core.getcwd())
  35     assert app_context.model.project == project
  36
  37
  38 def test_local_branches(app_context):
  39     """Test the 'local_branches' attribute."""
  40     helper.commit_files()
  41     app_context.model.update_status()
  42     assert app_context.model.local_branches == ['main']
  43
  44
  45 def test_remote_branches(app_context):
  46     """Test the 'remote_branches' attribute."""
  47     app_context.model.update_status()
  48     assert app_context.model.remote_branches == []
  49     helper.commit_files()
  50     helper.run_git('remote', 'add', 'origin', '.')
  51     helper.run_git('fetch', 'origin')
  52     app_context.model.update_status()
  53     assert app_context.model.remote_branches == ['origin/main']
  54
  55
  56 def test_modified(app_context):
  57     """Test the 'modified' attribute."""
  58     helper.write_file('A', 'change')
  59     app_context.model.update_status()
  60     assert app_context.model.modified == ['A']
  61
  62
  63 def test_unstaged(app_context):
  64     """Test the 'unstaged' attribute."""
  65     helper.write_file('A', 'change')
  66     helper.write_file('C', 'C')
  67     app_context.model.update_status()
  68     assert app_context.model.unstaged == ['A', 'C']
  69
  70
  71 def test_untracked(app_context):
  72     """Test the 'untracked' attribute."""
  73     helper.write_file('C', 'C')
  74     app_context.model.update_status()
  75     assert app_context.model.untracked == ['C']
  76
  77
  78 def test_stageable(app_context):
  79     """Test the 'stageable' attribute."""
  80     assert not app_context.model.is_stageable()
  81
  82
  83 def test_remotes(app_context):
  84     """Test the 'remote' attribute."""
  85     helper.run_git('remote', 'add', 'origin', '.')
  86     app_context.model.update_status()
  87     assert app_context.model.remotes == ['origin']
  88
  89
  90 def test_currentbranch(app_context):
  91     """Test the 'currentbranch' attribute."""
  92     helper.run_git('checkout', '-b', 'test')
  93     app_context.model.update_status()
  94     assert app_context.model.currentbranch == 'test'
  95
  96
  97 def test_tags(app_context):
  98     """Test the 'tags' attribute."""
  99     helper.commit_files()
 100     helper.run_git('tag', 'test')
 101     app_context.model.update_status()
 102     assert app_context.model.tags == ['test']
 103
 104
 105 def test_remote_args_fetch(mock_context):
 106     """FETCH swaps arguments vs. PUSH and PULL"""
 107     (args, kwargs) = main.remote_args(
 108         mock_context,
 109         REMOTE,
 110         FETCH,
 111         local_branch=LOCAL_BRANCH,
 112         remote_branch=REMOTE_BRANCH,
 113     )
 114     assert args == [REMOTE, 'remote:local']
 115     assert kwargs['verbose']
 116     assert 'tags' not in kwargs
 117     assert 'rebase' not in kwargs
 118
 119
 120 def test_remote_args_fetch_tags(mock_context):
 121     # Fetch tags
 122     (args, kwargs) = main.remote_args(
 123         mock_context,
 124         REMOTE,
 125         FETCH,
 126         tags=True,
 127         local_branch=LOCAL_BRANCH,
 128         remote_branch=REMOTE_BRANCH,
 129     )
 130     assert args == [REMOTE, 'remote:local']
 131     assert kwargs['verbose']
 132     assert kwargs['tags']
 133     assert 'rebase' not in kwargs
 134
 135
 136 def test_remote_args_fetch_into_tracking_branch(mock_context):
 137     (args, kwargs) = main.remote_args(
 138         mock_context,
 139         REMOTE,
 140         FETCH,
 141         remote_branch=REMOTE_BRANCH,
 142     )
 143     assert args == [REMOTE, 'remote:refs/remotes/server/remote']
 144
 145
 146 def test_remote_args_pull(mock_context):
 147     # Pull
 148     (args, kwargs) = main.remote_args(
 149         mock_context,
 150         REMOTE,
 151         PULL,
 152         local_branch='',
 153         remote_branch=REMOTE_BRANCH,
 154     )
 155     assert args == [REMOTE, 'remote']
 156     assert kwargs['verbose']
 157     assert 'rebase' not in kwargs
 158     assert 'tags' not in kwargs
 159
 160
 161 def test_remote_args_pull_rebase(mock_context):
 162     # Rebasing pull
 163     (args, kwargs) = main.remote_args(
 164         mock_context,
 165         REMOTE,
 166         PULL,
 167         rebase=True,
 168         local_branch='',
 169         remote_branch=REMOTE_BRANCH,
 170     )
 171     assert args == [REMOTE, 'remote']
 172     assert kwargs['verbose']
 173     assert kwargs['rebase']
 174     assert 'tags' not in kwargs
 175
 176
 177 def test_remote_args_push(mock_context):
 178     """PUSH swaps local and remote branches"""
 179     (args, kwargs) = main.remote_args(
 180         mock_context,
 181         REMOTE,
 182         PUSH,
 183         local_branch=LOCAL_BRANCH,
 184         remote_branch=REMOTE_BRANCH,
 185     )
 186     assert args == [REMOTE, 'local:remote']
 187     assert kwargs['verbose']
 188     assert 'tags' not in kwargs
 189     assert 'rebase' not in kwargs
 190
 191
 192 def test_remote_args_push_tags(mock_context):
 193     """Pushing tags uses --tags"""
 194     (args, kwargs) = main.remote_args(
 195         mock_context,
 196         REMOTE,
 197         PUSH,
 198         tags=True,
 199         local_branch=LOCAL_BRANCH,
 200         remote_branch=REMOTE_BRANCH,
 201     )
 202     assert args == [REMOTE, 'local:remote']
 203     assert kwargs['verbose']
 204     assert kwargs['tags']
 205     assert 'rebase' not in kwargs
 206
 207
 208 def test_remote_args_push_same_remote_and_local(mock_context):
 209     (args, kwargs) = main.remote_args(
 210         mock_context,
 211         REMOTE,
 212         PUSH,
 213         tags=True,
 214         local_branch=LOCAL_BRANCH,
 215         remote_branch=LOCAL_BRANCH,
 216     )
 217     assert args == [REMOTE, 'local']
 218     assert kwargs['verbose']
 219     assert kwargs['tags']
 220     assert 'rebase' not in kwargs
 221
 222
 223 def test_remote_args_push_set_upstream(mock_context):
 224     (args, kwargs) = main.remote_args(
 225         mock_context,
 226         REMOTE,
 227         PUSH,
 228         tags=True,
 229         local_branch=LOCAL_BRANCH,
 230         remote_branch=LOCAL_BRANCH,
 231         set_upstream=True,
 232     )
 233     assert args == [REMOTE, 'local']
 234     assert kwargs['verbose']
 235     assert kwargs['tags']
 236     assert kwargs['set_upstream']
 237     assert 'rebase' not in kwargs
 238
 239
 240 def test_remote_args_rebase_only(mock_context):
 241     (_, kwargs) = main.remote_args(
 242         mock_context, REMOTE, PULL, rebase=True, ff_only=True
 243     )
 244     assert kwargs['rebase']
 245     assert 'ff_only' not in kwargs
 246
 247
 248 def test_run_remote_action(mock_context):
 249     """Test running a remote action"""
 250     (args, kwargs) = main.run_remote_action(
 251         mock_context,
 252         lambda *args, **kwargs: (args, kwargs),
 253         REMOTE,
 254         FETCH,
 255         local_branch=LOCAL_BRANCH,
 256         remote_branch=REMOTE_BRANCH,
 257     )
 258     assert args == (REMOTE, 'remote:local')
 259     assert kwargs['verbose']
 260     assert 'tags' not in kwargs
 261     assert 'rebase' not in kwargs