1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
|
# ===--- SchemeMock.py ----------------------------------------------------===#
#
# This source file is part of the Swift.org open source project
#
# Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
# Licensed under Apache License v2.0 with Runtime Library Exception
#
# See https:#swift.org/LICENSE.txt for license information
# See https:#swift.org/CONTRIBUTORS.txt for the list of Swift project authors
#
# ===----------------------------------------------------------------------===#
"""This file defines objects for mocking an update-checkout scheme. It creates
a json .config file and a series of .git repos with "fake commits".
"""
import json
import os
import subprocess
import unittest
# For now we only use a config with a single scheme. We should add support for
# handling multiple schemes.
MOCK_REMOTE = {
'repo1': [
# This is a series of changes to repo1. (File, NewContents)
('A.txt', 'A'),
('B.txt', 'B'),
('A.txt', 'a'),
],
'repo2': [
# This is a series of changes to repo2. (File, NewContents)
('X.txt', 'X'),
('Y.txt', 'Y'),
('X.txt', 'z'),
],
}
MOCK_CONFIG = {
# This is here just b/c we expect it. We should consider consolidating
# clone-patterns into a dictionary where we map protocols (i.e. ['ssh,
# 'https'] to patterns). Then we can define this issue.
'ssh-clone-pattern': 'DO_NOT_USE',
# We reset this value with our remote path when we process
'https-clone-pattern': '',
'repos': {
'repo1': {
'remote': {'id': 'repo1'},
},
'repo2': {
'remote': {'id': 'repo2'},
},
},
'default-branch-scheme': 'main',
'branch-schemes': {
'main': {
'aliases': ['main'],
'repos': {
'repo1': 'main',
'repo2': 'main',
}
}
}
}
class CallQuietlyException(Exception):
def __init__(self, command, returncode, output):
self.command = command
self.returncode = returncode
self.output = output
def __str__(self):
return f"Command returned a non-zero exit status {self.returncode}:\n"\
f"Command: {' '.join(self.command)}\n" \
f"Output: {self.output.decode('utf-8')}"
def call_quietly(*args, **kwargs):
kwargs['stderr'] = subprocess.STDOUT
try:
subprocess.check_output(*args, **kwargs)
except subprocess.CalledProcessError as e:
raise CallQuietlyException(command=e.cmd, returncode=e.returncode,
output=e.stdout) from e
def create_dir(d):
if not os.path.isdir(d):
os.makedirs(d)
def teardown_mock_remote(base_dir):
call_quietly(['rm', '-rf', base_dir])
def get_config_path(base_dir):
return os.path.join(base_dir, 'test-config.json')
def setup_mock_remote(base_dir, base_config):
create_dir(base_dir)
# We use local as a workspace for creating commits.
LOCAL_PATH = os.path.join(base_dir, 'local')
# We use remote as a directory that simulates our remote unchecked out
# repo.
REMOTE_PATH = os.path.join(base_dir, 'remote')
create_dir(REMOTE_PATH)
create_dir(LOCAL_PATH)
for (k, v) in MOCK_REMOTE.items():
local_repo_path = os.path.join(LOCAL_PATH, k)
remote_repo_path = os.path.join(REMOTE_PATH, k)
create_dir(remote_repo_path)
create_dir(local_repo_path)
call_quietly(['git', 'init', '--bare', remote_repo_path])
call_quietly(['git', 'symbolic-ref', 'HEAD', 'refs/heads/main'],
cwd=remote_repo_path)
call_quietly(['git', 'clone', '-l', remote_repo_path, local_repo_path])
call_quietly(['git', 'config', 'user.name', 'swift_test'],
cwd=local_repo_path)
call_quietly(['git', 'config', 'user.email', 'no-reply@swift.org'],
cwd=local_repo_path)
call_quietly(['git', 'symbolic-ref', 'HEAD', 'refs/heads/main'],
cwd=local_repo_path)
for (i, (filename, contents)) in enumerate(v):
filename_path = os.path.join(local_repo_path, filename)
with open(filename_path, 'w') as f:
f.write(contents)
call_quietly(['git', 'add', filename], cwd=local_repo_path)
call_quietly(['git', 'commit', '-m', 'Commit %d' % i],
cwd=local_repo_path)
call_quietly(['git', 'push', 'origin', 'main'],
cwd=local_repo_path)
https_clone_pattern = os.path.join('file://%s' % REMOTE_PATH, '%s')
base_config['https-clone-pattern'] = https_clone_pattern
with open(get_config_path(base_dir), 'w') as f:
json.dump(base_config, f)
return (LOCAL_PATH, REMOTE_PATH)
BASEDIR_ENV_VAR = 'UPDATECHECKOUT_TEST_WORKSPACE_DIR'
CURRENT_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
UPDATE_CHECKOUT_PATH = os.path.abspath(os.path.join(CURRENT_FILE_DIR,
os.path.pardir,
os.path.pardir,
'update-checkout'))
class SchemeMockTestCase(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(SchemeMockTestCase, self).__init__(*args, **kwargs)
self.config = MOCK_CONFIG.copy()
self.workspace = os.getenv(BASEDIR_ENV_VAR)
if self.workspace is None:
raise RuntimeError('Misconfigured test suite! Environment '
'variable %s must be set!' % BASEDIR_ENV_VAR)
self.config_path = get_config_path(self.workspace)
self.update_checkout_path = UPDATE_CHECKOUT_PATH
if not os.access(self.update_checkout_path, os.X_OK):
raise RuntimeError('Error! Could not find executable '
'update-checkout at path: %s'
% self.update_checkout_path)
self.source_root = os.path.join(self.workspace, 'source_root')
def setUp(self):
create_dir(self.source_root)
(self.local_path, self.remote_path) = setup_mock_remote(
self.workspace, self.config
)
def tearDown(self):
teardown_mock_remote(self.workspace)
def call(self, *args, **kwargs):
kwargs['cwd'] = self.source_root
call_quietly(*args, **kwargs)
def get_all_repos(self):
return list(self.config["repos"].keys())
def add_branch_scheme(self, name, scheme):
self.config["branch-schemes"][name] = scheme
|