pygitgo 1.2.0__tar.gz → 1.2.1__tar.gz

{pygitgo-1.2.0/src/pygitgo.egg-info → pygitgo-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.0
+Version: 1.2.1
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later

{pygitgo-1.2.0 → pygitgo-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.2.0"
+version = "1.2.1"
 description = "GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management."
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/auth/ssh_utils.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error
+from pygitgo.utils.executor import run_command
 from pygitgo.utils import platform_utils
 from pathlib import Path
 import subprocess
@@ -35,11 +35,15 @@ def ensure_github_known_host():
 def check_connection():
     ensure_github_known_host()
     result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    if not hasattr(result, "stderr") or not result.stderr:
+        return False
     return "successfully authenticated" in result.stderr
 
 def get_github_username():
 
     result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    if not hasattr(result, "stderr") or not result.stderr:
+        return None
     output = result.stderr
     
     if "Hi " in output and "!" in output:

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/commands/git_operations.py

@@ -2,11 +2,18 @@ from pygitgo.auth.ssh_utils import convert_https_to_ssh, is_ssh_url, check_conne
 from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.utils.executor import run_command
 from pygitgo.utils.config import get_config
+from argparse import Namespace
 import subprocess
 import sys
 import os
 
 
+def get_status_content():
+    status = run_command(["git", "status", "--porcelain"], allow_fail=True)
+    if isinstance(status, subprocess.CalledProcessError) or not status.strip():
+        sys.exit(1)
+    return status
+
 def get_current_branch():
     branch = run_command(["git", "branch", "--show-current"]).strip()
     if not branch:
@@ -26,8 +33,17 @@ def is_branch_exist(branch):
 
 
 def git_new_branch(branch):
-    run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
-    success(f"\nBranch '{branch}' created.\n")
+    result = run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
+    if isinstance(result, subprocess.CalledProcessError):
+        error(f"Failed to create branch '{branch}'! It may already exist.")
+        choice = input("\nWould you like to jump to the existing branch instead? (y/n): ").strip().lower()
+        if choice == "y":
+            from pygitgo.commands.jump import jump_operation
+            jump_operation(Namespace(branch=branch))
+        else:
+            sys.exit(1)
+    else:
+        success(f"\nBranch '{branch}' created.\n")
 
     return branch
 
@@ -136,8 +152,16 @@ def git_push(branch):
             if ssh_url:
                 run_command(["git", "remote", "set-url", "origin", ssh_url], loading_msg="Converting remote from HTTPS to SSH for secure push...")
                 success(f"Remote updated to: {ssh_url}")
-    
-    run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+
+    try:    
+        run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+    except (subprocess.CalledProcessError, OSError) as e:
+        error("Failed to push to remote repository!")
+        warning("Please check your network connection, remote URL, and authentication.")
+        if "rebase in progress" in str(e):
+            handle_rebase()
+        else:
+            sys.exit(1)
 
 
 def handle_rebase():

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/commands/jump.py

@@ -1,9 +1,8 @@
 from pygitgo.commands.git_operations import (
     is_branch_exist, get_current_branch, git_new_branch, get_main_branch
 )
-from pygitgo.utils.executor import run_command
-from pygitgo.commands.state import *
 from pygitgo.utils.colors import warning, info, success, error
+from pygitgo.utils.executor import run_command
 import subprocess
 import sys
 

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/commands/state.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, highlight, error, warning, success
+from pygitgo.utils.executor import run_command
 import sys
 
 
@@ -59,20 +59,19 @@ def display_save_states():
 
 
 def is_number(value):
-    try:
-        float(value)
-        return True
-    except ValueError:
-        return False
+    val = str(value).strip()
+    if val.startswith('-'):
+        return val[1:].isdigit()
+    return val.isdigit()
     
 def validate_state_id(state_id, save_states):
     if not is_number(state_id):
         error("\nInvalid input. Please enter a valid state ID.\n")
         return False
-    elif (int(float(state_id)) - 1) < 0:
+    elif (int(state_id) - 1) < 0:
         error("\nState ID cannot be '0' or negative. Please enter a valid state ID.\n")
         return False
-    elif (int(float(state_id)) - 1) >= len(save_states):
+    elif (int(state_id) - 1) >= len(save_states):
         error("\nState ID out of range. Please enter a valid state ID.\n")
         return False
     return True
@@ -124,9 +123,13 @@ def save_state(state_name=None):
     if not state_name:
         state_name = "Auto-Save"
 
-    run_command(["git", "stash", "push", "-m", state_name])
-
-    success(f"\nState '{state_name}' saved successfully.\n")
+    output = run_command(["git", "stash", "push", "-m", state_name], allow_fail=True)
+    if isinstance(output, Exception):
+        error(f"\nFailed to save state '{state_name}'.\n")
+    elif "No local changes to save" in output:
+        warning("\nNo local changes to save.\n")
+    else:
+        success(f"\nState '{state_name}' saved successfully.\n")
 
 
 def delete_state(identifier=None):

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/main.py

@@ -1,18 +1,17 @@
-from pygitgo.auth.ssh_utils import ensure_github_known_host
 from pygitgo.commands.git_operations import (
     git_new_branch, git_commit, git_init, add_remote_origin,
-    confirm_remote_link, create_main_branch, check_and_sync_branch,
-    git_push, handle_rebase, get_current_branch, is_branch_exist
+    confirm_remote_link, git_push, get_current_branch, is_branch_exist
 )
-from pygitgo.utils.colors import info, success, warning, error, highlight
+from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.utils.config import get_config, config_operation
+from pygitgo.exceptions import GitCommandError, GitGoError
 from pygitgo.utils.setup import ensure_first_run_setup
 from pygitgo.commands.state import state_operations
 from pygitgo.commands.jump import jump_operation
 from pygitgo.utils.executor import run_command
 from pygitgo.auth.manager import login, logout
 from pygitgo.auth.account import get_user
-from pygitgo.exceptions import GitGoError
+from argparse import Namespace
 import subprocess
 import argparse
 import sys
@@ -109,11 +108,24 @@ def push_operation(args):
         if branch and not message and not is_branch_exist(branch):
             message = branch
             branch = get_current_branch()
+            info(f"No branch name provided. Using current branch: '{branch}'\n")
+            
+        elif branch and is_branch_exist(branch):
+            current_branch = get_current_branch()
+            if current_branch != branch:
+                warning(f"You are currently on branch '{current_branch}', not '{branch}'.")
+                user_choice = input(f"Do you want to switch to branch '{branch}'? (y/n): ").lower()
+                if user_choice != 'y':
+                    error("\nPush aborted to prevent committing to the wrong branch.\n")
+                    sys.exit(1)
+                jump_operation(Namespace(branch=branch))
+    
         elif not branch:
             branch = get_current_branch()
 
     if not message:
         message = get_config("default-message", "New Project Update")
+        info(f"No commit message provided. Using default: '{message}'\n")
 
     commit_made = git_commit(message)
     
@@ -129,7 +141,7 @@ def push_operation(args):
                 info("\nWorking tree is clean and everything is up to date.")
                 warning("Make some changes first before using GitGo to commit and push.")
                 return
-        except:
+        except (GitCommandError, Exception):
             warning("\nNo changes to commit. Cannot verify remote status.")
             warning("Make some changes first or check your git remote configuration.")
             return

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/utils/config.py

@@ -51,4 +51,6 @@ def config_operation(args):
         if current_value:
             info(f"\n{key} is currently set to: '{current_value}'\n")
         else:
-            warning(f"\n{key} is not currently set.\n")
+            warning(f"\n{key} is not currently set.\n")
+
+            

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/utils/executor.py

@@ -1,8 +1,8 @@
-import subprocess
-import sys
-import os
 from pygitgo.utils.colors import error, info, success, warning
 from pygitgo.exceptions import GitCommandError
+from yaspin import yaspin
+import subprocess
+import os
 
 
 def run_command(command, allow_fail=False, return_complete=False, loading_msg=None):
@@ -15,7 +15,6 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
     :param loading_msg: if provided, show a yaspin spinner with this message
     :raises GitCommandError: when the command fails and allow_fail is False
     """
-    from yaspin import yaspin
 
     spinner = yaspin(text=loading_msg, color="cyan") if loading_msg else None
 
@@ -34,11 +33,18 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
             spinner.ok("✔")
 
         return result if return_complete else result.stdout.strip()
-    except subprocess.CalledProcessError as e:
+    except (subprocess.CalledProcessError, OSError) as e:
         if spinner:
             spinner.fail("✖")
 
-        stderr = e.stderr.strip() if e.stderr else ""
+        stderr = ""
+        returncode = 1
+
+        if isinstance(e, subprocess.CalledProcessError):
+            stderr = e.stderr.strip() if e.stderr else ""
+            returncode = e.returncode
+        else:
+            stderr = f"Command not found or execution failed: {str(e)}"
         
         if "detected dubious ownership" in stderr:
             error(f"\nSECURITY ALERT: {stderr}")
@@ -68,4 +74,4 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
         if allow_fail:
             return e
         
-        raise GitCommandError(command, stderr=stderr, returncode=e.returncode)
+        raise GitCommandError(command, stderr=stderr, returncode=returncode)

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/utils/setup.py

@@ -19,7 +19,7 @@ def ensure_first_run_setup():
 
     is_initialized = get_config("initialized", fallback_value="false")
 
-    if not is_initialized:
+    if is_initialized == "false":
         info("\nInitializing GitGo network settings for the first time... please wait.")
         ensure_github_known_host()
 

{pygitgo-1.2.0 → pygitgo-1.2.1/src/pygitgo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.0
+Version: 1.2.1
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo.egg-info/SOURCES.txt

@@ -24,9 +24,11 @@ src/pygitgo/utils/config.py
 src/pygitgo/utils/executor.py
 src/pygitgo/utils/platform_utils.py
 src/pygitgo/utils/setup.py
+tests/test_config.py
 tests/test_git_operations.py
 tests/test_jump.py
 tests/test_main.py
 tests/test_platform.py
+tests/test_setup.py
 tests/test_state.py
 tests/test_url_validator.py

pygitgo-1.2.1/tests/test_config.py

@@ -0,0 +1,99 @@
+from pygitgo.utils.config import get_config, set_config, config_operation
+from conftest import capture_system_exit_code
+from argparse import Namespace
+import subprocess
+
+
+def test_get_config_fallback(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="")
+
+    fallback_value = "false"
+
+    result = get_config("default-key", fallback_value)
+    assert result == fallback_value
+
+def test_get_config_ok(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="true")
+
+    fallback_value = "false"
+
+    result = get_config("default-key", fallback_value)
+    assert result != fallback_value
+
+def test_set_config_fallback(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value=subprocess.CalledProcessError(1, 'git'))
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+
+    key = 'default-key'
+
+    result = set_config(key, 'true')
+    assert result == False
+
+    fake_error.assert_called_with(f"\nFailed to save configuration for '{key}'.")
+
+def test_set_config_ok(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value='ok')
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    fake_success = mocker.patch('pygitgo.utils.config.success')
+    
+    key = 'default-key'
+    value = 'true'
+
+    result = set_config(key, value)
+    assert result == True
+
+    fake_error.assert_not_called()
+    fake_success.assert_called_with(f"\nConfiguration saved: {key} = '{value}'")
+
+def test_config_operation_not_valid_keys(mocker):
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    fake_warning = mocker.patch('pygitgo.utils.config.warning')
+    
+
+    VALID_KEYS = ["default-branch", "default-message"]
+
+    key = "not-valid"
+    value = "true"
+    args = Namespace(key=key, action="set", value=value)
+
+    assert capture_system_exit_code(lambda: config_operation(args)) is None
+
+    fake_error.assert_called_with(f"\nInvalid configuration key: '{key}'")
+    fake_warning.assert_called_with(f"Valid keys are: {', '.join(VALID_KEYS)}\n")
+
+def test_get_config_strip(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="  true  \n")
+    result = get_config("default-key", "false")
+    assert result == "true"
+
+def test_get_config_error_handling(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value=subprocess.CalledProcessError(1, 'git'))
+    result = get_config("default-key", "fallback")
+    assert result == "fallback"
+
+def test_config_operation_set_no_value(mocker):
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    args = Namespace(key="default-branch", action="set") # value is missing
+    config_operation(args)
+    fake_error.assert_called_with("\nYou must provide a value to set!\n")
+
+def test_config_operation_set_ok(mocker):
+    fake_set = mocker.patch('pygitgo.utils.config.set_config')
+    args = Namespace(key="default-branch", action="set", value="main")
+    config_operation(args)
+    fake_set.assert_called_with("default-branch", "main")
+
+def test_config_operation_get_ok(mocker):
+    mocker.patch('pygitgo.utils.config.get_config', return_value="main")
+    fake_info = mocker.patch('pygitgo.utils.config.info')
+    args = Namespace(key="default-branch", action="get")
+    config_operation(args)
+    fake_info.assert_called_with("\ndefault-branch is currently set to: 'main'\n")
+
+def test_config_operation_get_none(mocker):
+    mocker.patch('pygitgo.utils.config.get_config', return_value=None)
+    fake_warning = mocker.patch('pygitgo.utils.config.warning')
+    args = Namespace(key="default-branch", action="get")
+    config_operation(args)
+    fake_warning.assert_called_with("\ndefault-branch is not currently set.\n")
+

{pygitgo-1.2.0 → pygitgo-1.2.1}/tests/test_git_operations.py

@@ -7,7 +7,7 @@ from pygitgo.commands.git_operations import (
 from unittest.mock import call
 import subprocess
 import pytest
-import os
+
 
 def test_git_branch_logic(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_operations.run_command")
@@ -21,6 +21,36 @@ def test_git_branch_logic(mocker):
         loading_msg="Creating branch 'hello-world'..."
     )
 
+def test_git_branch_exists_jump_yes(mocker):
+    fake_run = mocker.patch("pygitgo.commands.git_operations.run_command", return_value=subprocess.CalledProcessError(1, 'git'))
+    mocker.patch("builtins.input", return_value="y")
+    fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
+    fake_error = mocker.patch("pygitgo.commands.git_operations.error")
+
+    branch_name = "existing-branch"
+    result = git_new_branch(branch_name)
+    
+    assert result == "existing-branch"
+    fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'! It may already exist.")
+    
+    args = fake_jump.call_args[0][0]
+    assert args.branch == branch_name
+
+def test_git_branch_exists_jump_no(mocker):
+    fake_run = mocker.patch("pygitgo.commands.git_operations.run_command", return_value=subprocess.CalledProcessError(1, 'git'))
+    mocker.patch("builtins.input", return_value="n")
+    fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
+    fake_error = mocker.patch("pygitgo.commands.git_operations.error")
+
+    branch_name = "existing-branch"
+    
+    with pytest.raises(SystemExit) as exc_info:
+        git_new_branch(branch_name)
+    
+    assert exc_info.value.code == 1
+    fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'! It may already exist.")
+    fake_jump.assert_not_called()
+
 def test_git_commit(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_operations.run_command")\
     

{pygitgo-1.2.0 → pygitgo-1.2.1}/tests/test_jump.py

@@ -1,18 +1,13 @@
 from pygitgo.commands.jump import undo_jump_operation, jump_operation
+from conftest import capture_system_exit_code
 from argparse import Namespace
 import subprocess
 import pytest
 
+
 def make_args(branch):
-    """Helper to create an argparse-like Namespace for jump_operation."""
     return Namespace(branch=branch)
 
-def check_pytest_system_exit(function):
-    with pytest.raises(SystemExit) as exc_info:
-        function()
-
-    return exc_info.value.code
-
 def test_undo_jump_operation_no_stash(mocker):
     fake_run = mocker.patch('pygitgo.commands.jump.run_command', return_value="")
     
@@ -47,7 +42,7 @@ def test_jump_operation_same_branch(mocker):
     )
     fake_warning = mocker.patch('pygitgo.commands.jump.warning')
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(main_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(main_branch))) == 0
 
     fake_warning.assert_called_with(f"\nYou are already on branch '{main_branch}'.\n")
 
@@ -60,7 +55,7 @@ def test_jump_operation_not_valid_repo(mocker):
         return_value=subprocess.CalledProcessError(1, 'git')
     )
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 1
 
     fake_warning.assert_called_with("\nUnable to check for uncommitted changes. Please ensure you're in a valid git repository.")
 
@@ -77,7 +72,7 @@ def test_jump_operation_has_changes_exit(mocker):
         side_effect=['some-changes']
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 0
 
     fake_warning.assert_any_call("\nYou cannot switch branches with unsaved changes. Jump canceled.\n")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -94,7 +89,7 @@ def test_jump_operation_save_changes_error(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 1
 
     fake_warning.assert_called_with("\nFailed to save your changes. Please resolve any issues and try again.")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -115,7 +110,7 @@ def test_jump_operation_no_changes(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_success.assert_called_with(f"\nSuccess! You are now on '{target_branch}'.\n")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -143,7 +138,7 @@ def test_jump_operation_branch_not_exist_cancel_operation(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_info.assert_any_call('\nYour changes have been saved. Jumping to the new branch...')
     fake_info.assert_any_call("Exiting without jumping...\n")
@@ -175,7 +170,7 @@ def test_jump_operation_branch_not_exist_create_branch(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_info.assert_called_with('\nYour changes have been saved. Jumping to the new branch...')
     fake_success.assert_any_call(f"\nSuccess! You are now on '{target_branch}'.")
@@ -204,7 +199,7 @@ def test_jump_operation_sync_fail_cancel(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 1
 
     fake_warning.assert_any_call("\nFailed to pull updates from 'main'. Make sure you have internet or the remote branch exists.")
 
@@ -225,7 +220,7 @@ def test_jump_operation_sync_fail_stay(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_success.assert_any_call("\nOkay! You are on the new branch, but without the latest updates from 'main'.")
 
@@ -247,7 +242,7 @@ def test_jump_operation_merge_conflict_cancel(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_error.assert_any_call("\nSTOP! There is a 'Merge Conflict'.")
 
@@ -270,7 +265,7 @@ def test_jump_operation_merge_conflict_stay(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_success.assert_any_call("\nOkay! You are on the new branch with your code.")
     fake_warning.assert_any_call("Please open your code editor RIGHT NOW to fix the conflicts!")

{pygitgo-1.2.0 → pygitgo-1.2.1}/tests/test_main.py

@@ -1,5 +1,6 @@
-import pytest
 from pygitgo.main import validate_repo_url
+import pytest
+
 
 @pytest.mark.parametrize("url", [
     "https://github.com/Huerte/GitGo.git",

pygitgo-1.2.1/tests/test_setup.py

@@ -0,0 +1,55 @@
+from pygitgo.utils.setup import check_git_installed, ensure_first_run_setup
+from conftest import capture_system_exit_code
+
+
+def test_check_git_installed_no_exist(mocker):
+    mocker.patch("shutil.which", return_value=None)
+    fake_error = mocker.patch("pygitgo.utils.setup.error")
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    assert capture_system_exit_code(lambda: check_git_installed()) == 1
+
+    fake_error.assert_called_with("\nGit is not installed or not found on your PATH!")
+    fake_info.assert_any_call("Install Git from: https://git-scm.com/downloads")
+    fake_info.assert_any_call("After installing, restart your terminal and try again.\n")
+
+def test_check_git_installed_exist(mocker):
+    mocker.patch("shutil.which", return_value="ok")
+    fake_error = mocker.patch("pygitgo.utils.setup.error")
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    assert capture_system_exit_code(lambda: check_git_installed()) == None
+
+    fake_error.assert_not_called()
+    fake_info.assert_not_called()
+
+def test_ensure_first_run_setup_already_initialized(mocker):
+    mocker.patch('pygitgo.utils.setup.check_git_installed', return_value=None)
+    fake_get_config = mocker.patch('pygitgo.utils.setup.get_config', return_value="ok")
+    fake_github_function = mocker.patch('pygitgo.utils.setup.ensure_github_known_host', return_value=None)
+    fake_set_config = mocker.patch('pygitgo.utils.setup.set_config', return_value=True)
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    ensure_first_run_setup()
+
+    fake_info.assert_not_called()
+    fake_github_function.assert_not_called()
+    fake_set_config.assert_not_called()
+
+    fake_get_config.assert_called_with("initialized", fallback_value="false")
+
+def test_ensure_first_run_setup_not_initialized(mocker):
+    mocker.patch('pygitgo.utils.setup.check_git_installed', return_value=None)
+    fake_get_config = mocker.patch('pygitgo.utils.setup.get_config', return_value="false")
+    fake_github_function = mocker.patch('pygitgo.utils.setup.ensure_github_known_host', return_value=None)
+    fake_set_config = mocker.patch('pygitgo.utils.setup.set_config', return_value=True)
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    ensure_first_run_setup()
+
+    fake_info.assert_called_with("\nInitializing GitGo network settings for the first time... please wait.")
+    fake_github_function.assert_called_once()
+    fake_set_config.assert_called_with("initialized", "true")
+
+    fake_get_config.assert_called_with("initialized", fallback_value="false")
+

{pygitgo-1.2.0 → pygitgo-1.2.1}/tests/test_state.py

@@ -3,12 +3,11 @@ from pygitgo.commands.state import (
     all_save_state
 )
 from unittest.mock import call
-import subprocess
 import pytest
-import os
+
 
 @pytest.mark.parametrize('state_id',[
-    '1', '3', '11', '00002', '7.0'
+    '1', '3', '11', '00002'
 ])
 def test_validate_state_id(state_id, mocker):
     fake_error = mocker.patch('pygitgo.commands.state.error')
@@ -20,7 +19,7 @@ def test_validate_state_id(state_id, mocker):
     fake_error.assert_not_called()
 
 @pytest.mark.parametrize('state_id',[
-    '-1', '-3', '-11', '-00002', '-7.0'
+    '-1', '-3', '-11', '-00002'
 ])
 def test_validate_state_id_negative(state_id, mocker):
 
@@ -33,7 +32,7 @@ def test_validate_state_id_negative(state_id, mocker):
     fake_error.assert_called_with("\nState ID cannot be '0' or negative. Please enter a valid state ID.\n")
 
 @pytest.mark.parametrize('state_id',[
-    '4', '10', '15', '0000020', '00007.00000'
+    '4', '10', '15', '0000020'
 ])
 def test_validate_state_id_out_scope(state_id, mocker):
 
@@ -156,21 +155,21 @@ def test_load_state_no_args(mocker):
 
 
 def test_save_state_no_args(mocker):
-    fake_run = mocker.patch("pygitgo.commands.state.run_command")
+    fake_run = mocker.patch("pygitgo.commands.state.run_command", return_value="Saved working directory")
     fake_success = mocker.patch("pygitgo.commands.state.success")
 
     save_state()
 
-    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "Auto-Save"])
+    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "Auto-Save"], allow_fail=True)
     fake_success.assert_called_once_with("\nState 'Auto-Save' saved successfully.\n")
 
 def test_save_state_with_name(mocker):
-    fake_run = mocker.patch("pygitgo.commands.state.run_command")
+    fake_run = mocker.patch("pygitgo.commands.state.run_command", return_value="Saved working directory")
     fake_success = mocker.patch("pygitgo.commands.state.success")
 
     save_state("My-State")
 
-    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "My-State"])
+    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "My-State"], allow_fail=True)
     fake_success.assert_called_once_with("\nState 'My-State' saved successfully.\n")
 
 

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/auth/account.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error, BLUE, RESET
+from pygitgo.utils.executor import run_command
 import subprocess
 
 

{pygitgo-1.2.0 → pygitgo-1.2.1}/src/pygitgo/auth/manager.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error
+from pygitgo.utils.executor import run_command
 from . import ssh_utils
 import os