from unittest.mock import patch

from utils import GitRepo

from utils import vcs_checkout

from utils import vcs_update

import os

import pytest

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_submodule(mkgitrepo, src, caplog, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in itith"""

submodule_name = "submodule_a"

submodule_a = mkgitrepo(submodule_name)

submodule_a.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule_a, submodule_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

# CmdCheckout(develop)(develop.parser.parse_args(["co", "egg"]))

vcs_checkout(sources, ["egg"], verbose=True)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert (

log.method_calls

== log.method_calls

== [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

]

)

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_two_submodules(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a'

and a submodule 'submodule_b' in it.

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule_b_name = "submodule_b"

submodule_b = mkgitrepo(submodule_b_name)

submodule.add_file("foo")

submodule_b.add_file("foo_b")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

egg.add_submodule(submodule_b, submodule_b_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

"submodule_b",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert set(os.listdir(src / "egg" / submodule_b_name)) == {

".git",

"foo_b",

}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_b_name}' with git.",),

{},

),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_two_submodules_recursive(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a'

and a submodule 'submodule_b' in it.

but this time we test it with the "recursive" option

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule_b_name = "submodule_b"

submodule_b = mkgitrepo(submodule_b_name)

submodule.add_file("foo")

submodule_b.add_file("foo_b")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

egg.add_submodule(submodule_b, submodule_b_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False, update_git_submodules="recursive")

assert set(os.listdir(src / "egg")) == {

"submodule_a",

"submodule_b",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert set(os.listdir(src / "egg" / submodule_b_name)) == {

".git",

"foo_b",

}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_update_with_submodule(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it.

Add a new 'submodule_b' to 'egg' and check it succesfully initializes.

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

]

submodule_b_name = "submodule_b"

submodule_b = mkgitrepo(submodule_b_name)

submodule_b.add_file("foo_b")

egg.add_submodule(submodule_b, submodule_b_name)

with patch("mxdev.vcs.git.logger") as log:

vcs_update(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

"submodule_b",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_b_name)) == {

".git",

"foo_b",

}

assert log.method_calls == [

("info", ("Updated 'egg' with git.",), {}),

("info", ("Switching to branch 'master'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_b_name}' with git.",),

{},

),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_update_with_submodule_recursive(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it.

Add a new 'submodule_b' to 'egg' and check it succesfully initializes.

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False, update_git_submodules="recursive")

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

]

submodule_b_name = "submodule_b"

submodule_b = mkgitrepo(submodule_b_name)

submodule_b.add_file("foo_b")

egg.add_submodule(submodule_b, submodule_b_name)

with patch("mxdev.vcs.git.logger") as log:

vcs_update(sources, ["egg"], verbose=False, update_git_submodules="recursive")

assert set(os.listdir(src / "egg")) == {

"submodule_a",

"submodule_b",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_b_name)) == {

".git",

"foo_b",

}

assert log.method_calls == [

("info", ("Updated 'egg' with git.",)),

("info", ("Switching to branch 'master'.",)),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_b_name}' with git.",),

),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_submodules_option_never(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it

without initializing the submodule, restricted by global 'never'

"""

submodule_name = "submodule_a"

submodule_a = mkgitrepo(submodule_name)

submodule_a.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule_a, submodule_name)

# develop.update_git_submodules = "never"

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False, update_git_submodules="never")

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == set()

assert log.method_calls == [("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {})]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_submodules_option_never_source_always(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it

and a module 'egg2' with the same submodule, initializing only the submodule

on egg that has the 'always' option

"""

submodule_name = "submodule_a"

submodule_a = mkgitrepo(submodule_name)

submodule_a.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule_a, submodule_name)

egg2 = mkgitrepo("egg2")

egg2.add_file("bar")

egg2.add_submodule(submodule_a, submodule_name)

sources = {

"egg": dict(

vcs="git",

name="egg",

url=egg.url,

path=src / "egg",

submodules="always",

),

"egg2": dict(vcs="git", name="egg2", url=egg2.url, path=src / "egg2"),

}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg", "egg2"], verbose=False, update_git_submodules="never")

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {"foo", ".git"}

assert set(os.listdir(src / "egg2")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg2" / submodule_name)) == set()

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

("info", (f"Cloned 'egg2' with git from '{egg2.url}'.",), {}),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_checkout_with_submodules_option_always_source_never(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it

and a module 'egg2' with the same submodule, not initializing the submodule

on egg2 that has the 'never' option

"""

submodule_name = "submodule_a"

submodule_a = mkgitrepo(submodule_name)

submodule_a.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule_a, submodule_name)

egg2 = mkgitrepo("egg2")

egg2.add_file("bar")

egg2.add_submodule(submodule_a, submodule_name)

sources = {

"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg"),

"egg2": dict(

vcs="git",

name="egg2",

url=egg2.url,

path=src / "egg2",

submodules="never",

),

}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg", "egg2"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {"foo", ".git"}

assert set(os.listdir(src / "egg2")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg2" / submodule_name)) == set()

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

("info", (f"Cloned 'egg2' with git from '{egg2.url}'.",), {}),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_update_with_submodule_checkout(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it.

Add a new 'submodule_b' to 'egg' and check it doesn't get initialized.

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

sources = {

"egg": dict(

vcs="git",

name="egg",

url=egg.url,

path=src / "egg",

submodules="checkout",

)

}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

]

submodule_b_name = "submodule_b"

submodule_b = mkgitrepo(submodule_b_name)

submodule_b.add_file("foo_b")

egg.add_submodule(submodule_b, submodule_b_name)

with patch("mxdev.vcs.git.logger") as log:

vcs_update(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

"submodule_b",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_b_name)) == set()

assert log.method_calls == [

("info", ("Updated 'egg' with git.",), {}),

("info", ("Switching to branch 'master'.",), {}),

]

@pytest.mark.skipif(condition=os.name == "nt", reason="submodules seem not to work on windows")

def test_update_with_submodule_dont_update_previous_submodules(mkgitrepo, src, git_allow_file_protocol):

"""Tests the checkout of a module 'egg' with a submodule 'submodule_a' in it.

Commits changes in the detached submodule, and checks update didn't break

the changes.

"""

submodule_name = "submodule_a"

submodule = mkgitrepo(submodule_name)

submodule.add_file("foo")

egg = mkgitrepo("egg")

egg.add_file("bar")

egg.add_submodule(submodule, submodule_name)

sources = {"egg": dict(vcs="git", name="egg", url=egg.url, path=src / "egg")}

with patch("mxdev.vcs.git.logger") as log:

vcs_checkout(sources, ["egg"], verbose=False)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {".git", "foo"}

assert log.method_calls == [

("info", (f"Cloned 'egg' with git from '{egg.url}'.",), {}),

(

"info",

(f"Initialized 'egg' submodule at '{submodule_name}' with git.",),

{},

),

]

repo = GitRepo(src / "egg" / submodule_name)

repo.setup_user()

repo.add_file("newfile")

with patch("mxdev.vcs.git.logger") as log:

vcs_update(sources, ["egg"], verbose=False, force=True)

assert set(os.listdir(src / "egg")) == {

"submodule_a",

".git",

"bar",

".gitmodules",

}

assert set(os.listdir(src / "egg" / submodule_name)) == {

".git",

"foo",

"newfile",

}

assert log.method_calls == [

("info", ("Updated 'egg' with git.",), {}),

("info", ("Switching to branch 'master'.",), {}),

]