523 lines
15 KiB
TypeScript
523 lines
15 KiB
TypeScript
|
/**
|
||
|
|
* Native PyPI CLI Testing
|
||
|
|
* Tests the PyPI registry implementation using pip and twine CLI tools
|
||
|
|
*/
|
||
|
|
|
||
|
|
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||
|
|
import { tapNodeTools } from '@git.zone/tstest/tapbundle_serverside';
|
||
|
|
import { SmartRegistry } from '../ts/index.js';
|
||
|
|
import { createTestRegistry, createTestTokens, createPythonWheel, createPythonSdist } from './helpers/registry.js';
|
||
|
|
import type { IRequestContext, IResponse } from '../ts/core/interfaces.core.js';
|
||
|
|
import * as http from 'http';
|
||
|
|
import * as url from 'url';
|
||
|
|
import * as fs from 'fs';
|
||
|
|
import * as path from 'path';
|
||
|
|
|
||
|
|
// Test context
|
||
|
|
let registry: SmartRegistry;
|
||
|
|
let server: http.Server;
|
||
|
|
let registryUrl: string;
|
||
|
|
let registryPort: number;
|
||
|
|
let pypiToken: string;
|
||
|
|
let testDir: string;
|
||
|
|
let pipHome: string;
|
||
|
|
let hasPip = false;
|
||
|
|
let hasTwine = false;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create HTTP server wrapper around SmartRegistry
|
||
|
|
*/
|
||
|
|
async function createHttpServer(
|
||
|
|
registryInstance: SmartRegistry,
|
||
|
|
port: number
|
||
|
|
): Promise<{ server: http.Server; url: string }> {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
const httpServer = http.createServer(async (req, res) => {
|
||
|
|
try {
|
||
|
|
// Parse request
|
||
|
|
const parsedUrl = url.parse(req.url || '', true);
|
||
|
|
const pathname = parsedUrl.pathname || '/';
|
||
|
|
const query = parsedUrl.query;
|
||
|
|
|
||
|
|
// Read body
|
||
|
|
const chunks: Buffer[] = [];
|
||
|
|
for await (const chunk of req) {
|
||
|
|
chunks.push(chunk);
|
||
|
|
}
|
||
|
|
const bodyBuffer = Buffer.concat(chunks);
|
||
|
|
|
||
|
|
// Parse body based on content type
|
||
|
|
let body: any;
|
||
|
|
if (bodyBuffer.length > 0) {
|
||
|
|
const contentType = req.headers['content-type'] || '';
|
||
|
|
if (contentType.includes('application/json')) {
|
||
|
|
try {
|
||
|
|
body = JSON.parse(bodyBuffer.toString('utf-8'));
|
||
|
|
} catch (error) {
|
||
|
|
body = bodyBuffer;
|
||
|
|
}
|
||
|
|
} else if (contentType.includes('multipart/form-data')) {
|
||
|
|
// For multipart, pass raw buffer
|
||
|
|
body = bodyBuffer;
|
||
|
|
} else {
|
||
|
|
body = bodyBuffer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert to IRequestContext
|
||
|
|
const context: IRequestContext = {
|
||
|
|
method: req.method || 'GET',
|
||
|
|
path: pathname,
|
||
|
|
headers: req.headers as Record<string, string>,
|
||
|
|
query: query as Record<string, string>,
|
||
|
|
body: body,
|
||
|
|
rawBody: bodyBuffer,
|
||
|
|
};
|
||
|
|
|
||
|
|
// Handle request
|
||
|
|
const response: IResponse = await registryInstance.handleRequest(context);
|
||
|
|
|
||
|
|
// Convert IResponse to HTTP response
|
||
|
|
res.statusCode = response.status;
|
||
|
|
|
||
|
|
// Set headers
|
||
|
|
for (const [key, value] of Object.entries(response.headers || {})) {
|
||
|
|
res.setHeader(key, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Send body
|
||
|
|
if (response.body) {
|
||
|
|
if (Buffer.isBuffer(response.body)) {
|
||
|
|
res.end(response.body);
|
||
|
|
} else if (typeof response.body === 'string') {
|
||
|
|
res.end(response.body);
|
||
|
|
} else {
|
||
|
|
res.setHeader('Content-Type', 'application/json');
|
||
|
|
res.end(JSON.stringify(response.body));
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
res.end();
|
||
|
|
}
|
||
|
|
} catch (error) {
|
||
|
|
console.error('Server error:', error);
|
||
|
|
res.statusCode = 500;
|
||
|
|
res.setHeader('Content-Type', 'application/json');
|
||
|
|
res.end(JSON.stringify({ error: 'INTERNAL_ERROR', message: String(error) }));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
httpServer.listen(port, () => {
|
||
|
|
const serverUrl = `http://localhost:${port}`;
|
||
|
|
resolve({ server: httpServer, url: serverUrl });
|
||
|
|
});
|
||
|
|
|
||
|
|
httpServer.on('error', reject);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Setup .pypirc for twine authentication
|
||
|
|
*/
|
||
|
|
function setupPypirc(
|
||
|
|
token: string,
|
||
|
|
pipHomeArg: string,
|
||
|
|
serverUrl: string
|
||
|
|
): string {
|
||
|
|
fs.mkdirSync(pipHomeArg, { recursive: true });
|
||
|
|
|
||
|
|
const pypircContent = `[distutils]
|
||
|
|
index-servers = testpypi
|
||
|
|
|
||
|
|
[testpypi]
|
||
|
|
repository = ${serverUrl}/pypi
|
||
|
|
username = testuser
|
||
|
|
password = ${token}
|
||
|
|
`;
|
||
|
|
|
||
|
|
const pypircPath = path.join(pipHomeArg, '.pypirc');
|
||
|
|
fs.writeFileSync(pypircPath, pypircContent, 'utf-8');
|
||
|
|
|
||
|
|
// Set restrictive permissions
|
||
|
|
fs.chmodSync(pypircPath, 0o600);
|
||
|
|
|
||
|
|
return pypircPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Setup pip.conf for pip to use our registry
|
||
|
|
*/
|
||
|
|
function setupPipConf(
|
||
|
|
token: string,
|
||
|
|
pipHomeArg: string,
|
||
|
|
serverUrl: string,
|
||
|
|
port: number
|
||
|
|
): string {
|
||
|
|
fs.mkdirSync(pipHomeArg, { recursive: true });
|
||
|
|
|
||
|
|
// pip.conf with authentication
|
||
|
|
const pipConfContent = `[global]
|
||
|
|
index-url = ${serverUrl}/pypi/simple/
|
||
|
|
trusted-host = localhost
|
||
|
|
extra-index-url = https://pypi.org/simple/
|
||
|
|
`;
|
||
|
|
|
||
|
|
const pipDir = path.join(pipHomeArg, 'pip');
|
||
|
|
fs.mkdirSync(pipDir, { recursive: true });
|
||
|
|
|
||
|
|
const pipConfPath = path.join(pipDir, 'pip.conf');
|
||
|
|
fs.writeFileSync(pipConfPath, pipConfContent, 'utf-8');
|
||
|
|
|
||
|
|
return pipConfPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a test Python package wheel file
|
||
|
|
*/
|
||
|
|
async function createTestWheelFile(
|
||
|
|
packageName: string,
|
||
|
|
version: string,
|
||
|
|
targetDir: string
|
||
|
|
): Promise<string> {
|
||
|
|
const wheelData = await createPythonWheel(packageName, version);
|
||
|
|
const normalizedName = packageName.replace(/-/g, '_');
|
||
|
|
const wheelFilename = `${normalizedName}-${version}-py3-none-any.whl`;
|
||
|
|
const wheelPath = path.join(targetDir, wheelFilename);
|
||
|
|
|
||
|
|
fs.writeFileSync(wheelPath, wheelData);
|
||
|
|
|
||
|
|
return wheelPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a test Python package sdist file
|
||
|
|
*/
|
||
|
|
async function createTestSdistFile(
|
||
|
|
packageName: string,
|
||
|
|
version: string,
|
||
|
|
targetDir: string
|
||
|
|
): Promise<string> {
|
||
|
|
const sdistData = await createPythonSdist(packageName, version);
|
||
|
|
const sdistFilename = `${packageName}-${version}.tar.gz`;
|
||
|
|
const sdistPath = path.join(targetDir, sdistFilename);
|
||
|
|
|
||
|
|
fs.writeFileSync(sdistPath, sdistData);
|
||
|
|
|
||
|
|
return sdistPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Run pip command with custom config
|
||
|
|
*/
|
||
|
|
async function runPipCommand(
|
||
|
|
command: string,
|
||
|
|
cwd: string
|
||
|
|
): Promise<{ stdout: string; stderr: string; exitCode: number }> {
|
||
|
|
const pipConfDir = path.join(pipHome, 'pip');
|
||
|
|
const fullCommand = `cd "${cwd}" && PIP_CONFIG_FILE="${path.join(pipConfDir, 'pip.conf')}" pip ${command}`;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const result = await tapNodeTools.runCommand(fullCommand);
|
||
|
|
return {
|
||
|
|
stdout: result.stdout || '',
|
||
|
|
stderr: result.stderr || '',
|
||
|
|
exitCode: result.exitCode || 0,
|
||
|
|
};
|
||
|
|
} catch (error: any) {
|
||
|
|
return {
|
||
|
|
stdout: error.stdout || '',
|
||
|
|
stderr: error.stderr || String(error),
|
||
|
|
exitCode: error.exitCode || 1,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Run twine command with custom config
|
||
|
|
*/
|
||
|
|
async function runTwineCommand(
|
||
|
|
command: string,
|
||
|
|
cwd: string
|
||
|
|
): Promise<{ stdout: string; stderr: string; exitCode: number }> {
|
||
|
|
const pypircPath = path.join(pipHome, '.pypirc');
|
||
|
|
const fullCommand = `cd "${cwd}" && twine ${command} --config-file "${pypircPath}"`;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const result = await tapNodeTools.runCommand(fullCommand);
|
||
|
|
return {
|
||
|
|
stdout: result.stdout || '',
|
||
|
|
stderr: result.stderr || '',
|
||
|
|
exitCode: result.exitCode || 0,
|
||
|
|
};
|
||
|
|
} catch (error: any) {
|
||
|
|
return {
|
||
|
|
stdout: error.stdout || '',
|
||
|
|
stderr: error.stderr || String(error),
|
||
|
|
exitCode: error.exitCode || 1,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Cleanup test directory
|
||
|
|
*/
|
||
|
|
function cleanupTestDir(dir: string): void {
|
||
|
|
if (fs.existsSync(dir)) {
|
||
|
|
fs.rmSync(dir, { recursive: true, force: true });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ========================================================================
|
||
|
|
// TESTS
|
||
|
|
// ========================================================================
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should verify pip is installed', async () => {
|
||
|
|
try {
|
||
|
|
const result = await tapNodeTools.runCommand('pip --version');
|
||
|
|
console.log('pip version output:', result.stdout.substring(0, 200));
|
||
|
|
hasPip = result.exitCode === 0;
|
||
|
|
expect(result.exitCode).toEqual(0);
|
||
|
|
} catch (error) {
|
||
|
|
console.log('pip CLI not available');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should verify twine is installed', async () => {
|
||
|
|
try {
|
||
|
|
const result = await tapNodeTools.runCommand('twine --version');
|
||
|
|
console.log('twine version output:', result.stdout.substring(0, 200));
|
||
|
|
hasTwine = result.exitCode === 0;
|
||
|
|
expect(result.exitCode).toEqual(0);
|
||
|
|
} catch (error) {
|
||
|
|
console.log('twine CLI not available');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!hasPip && !hasTwine) {
|
||
|
|
console.log('Neither pip nor twine available, skipping native CLI tests');
|
||
|
|
tap.skip.test('PyPI CLI: remaining tests skipped - no CLI tools available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should setup registry and HTTP server', async () => {
|
||
|
|
// Create registry
|
||
|
|
registry = await createTestRegistry();
|
||
|
|
const tokens = await createTestTokens(registry);
|
||
|
|
pypiToken = tokens.pypiToken;
|
||
|
|
|
||
|
|
expect(registry).toBeInstanceOf(SmartRegistry);
|
||
|
|
expect(pypiToken).toBeTypeOf('string');
|
||
|
|
|
||
|
|
// Use port 39000 (avoids conflicts with other tests)
|
||
|
|
registryPort = 39000;
|
||
|
|
const serverSetup = await createHttpServer(registry, registryPort);
|
||
|
|
server = serverSetup.server;
|
||
|
|
registryUrl = serverSetup.url;
|
||
|
|
|
||
|
|
expect(server).toBeDefined();
|
||
|
|
expect(registryUrl).toEqual(`http://localhost:${registryPort}`);
|
||
|
|
|
||
|
|
// Setup test directory
|
||
|
|
testDir = path.join(process.cwd(), '.nogit', 'test-pypi-cli');
|
||
|
|
cleanupTestDir(testDir);
|
||
|
|
fs.mkdirSync(testDir, { recursive: true });
|
||
|
|
|
||
|
|
// Setup pip/pypi home directory
|
||
|
|
pipHome = path.join(testDir, '.pip');
|
||
|
|
fs.mkdirSync(pipHome, { recursive: true });
|
||
|
|
|
||
|
|
// Setup .pypirc for twine
|
||
|
|
const pypircPath = setupPypirc(pypiToken, pipHome, registryUrl);
|
||
|
|
expect(fs.existsSync(pypircPath)).toEqual(true);
|
||
|
|
|
||
|
|
// Setup pip.conf
|
||
|
|
const pipConfPath = setupPipConf(pypiToken, pipHome, registryUrl, registryPort);
|
||
|
|
expect(fs.existsSync(pipConfPath)).toEqual(true);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should verify server is responding', async () => {
|
||
|
|
// Check server is up by doing a direct HTTP request to simple index
|
||
|
|
const response = await fetch(`${registryUrl}/pypi/simple/`);
|
||
|
|
expect(response.status).toBeGreaterThanOrEqual(200);
|
||
|
|
expect(response.status).toBeLessThan(500);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should upload wheel with twine', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping twine test - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
const version = '1.0.0';
|
||
|
|
const wheelPath = await createTestWheelFile(packageName, version, testDir);
|
||
|
|
|
||
|
|
expect(fs.existsSync(wheelPath)).toEqual(true);
|
||
|
|
|
||
|
|
const result = await runTwineCommand(
|
||
|
|
`upload --repository testpypi "${wheelPath}"`,
|
||
|
|
testDir
|
||
|
|
);
|
||
|
|
console.log('twine upload output:', result.stdout);
|
||
|
|
console.log('twine upload stderr:', result.stderr);
|
||
|
|
|
||
|
|
expect(result.exitCode).toEqual(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should verify package in simple index', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
|
||
|
|
const response = await fetch(`${registryUrl}/pypi/simple/${packageName}/`);
|
||
|
|
expect(response.status).toEqual(200);
|
||
|
|
|
||
|
|
const html = await response.text();
|
||
|
|
expect(html).toContain('1.0.0');
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should upload sdist with twine', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping twine test - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
const version = '1.1.0';
|
||
|
|
const sdistPath = await createTestSdistFile(packageName, version, testDir);
|
||
|
|
|
||
|
|
expect(fs.existsSync(sdistPath)).toEqual(true);
|
||
|
|
|
||
|
|
const result = await runTwineCommand(
|
||
|
|
`upload --repository testpypi "${sdistPath}"`,
|
||
|
|
testDir
|
||
|
|
);
|
||
|
|
console.log('twine upload sdist output:', result.stdout);
|
||
|
|
console.log('twine upload sdist stderr:', result.stderr);
|
||
|
|
|
||
|
|
expect(result.exitCode).toEqual(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should list all versions in simple index', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
|
||
|
|
const response = await fetch(`${registryUrl}/pypi/simple/${packageName}/`);
|
||
|
|
expect(response.status).toEqual(200);
|
||
|
|
|
||
|
|
const html = await response.text();
|
||
|
|
expect(html).toContain('1.0.0');
|
||
|
|
expect(html).toContain('1.1.0');
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should get JSON metadata', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
|
||
|
|
const response = await fetch(`${registryUrl}/pypi/pypi/${packageName}/json`);
|
||
|
|
expect(response.status).toEqual(200);
|
||
|
|
|
||
|
|
const metadata = await response.json();
|
||
|
|
expect(metadata.info).toBeDefined();
|
||
|
|
expect(metadata.info.name).toEqual(packageName);
|
||
|
|
expect(metadata.releases).toBeDefined();
|
||
|
|
expect(metadata.releases['1.0.0']).toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should download package with pip', async () => {
|
||
|
|
if (!hasPip || !hasTwine) {
|
||
|
|
console.log('Skipping pip download test - pip or twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const downloadDir = path.join(testDir, 'downloads');
|
||
|
|
fs.mkdirSync(downloadDir, { recursive: true });
|
||
|
|
|
||
|
|
// Download (not install) the package
|
||
|
|
const result = await runPipCommand(
|
||
|
|
`download test-pypi-pkg==1.0.0 --dest "${downloadDir}" --no-deps`,
|
||
|
|
testDir
|
||
|
|
);
|
||
|
|
console.log('pip download output:', result.stdout);
|
||
|
|
console.log('pip download stderr:', result.stderr);
|
||
|
|
|
||
|
|
// pip download may fail if the package doesn't meet pip's requirements
|
||
|
|
// Just check it doesn't crash
|
||
|
|
expect(result.exitCode).toBeLessThanOrEqual(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should search for packages via API', async () => {
|
||
|
|
const packageName = 'test-pypi-pkg';
|
||
|
|
|
||
|
|
// Use the JSON API to search/list
|
||
|
|
const response = await fetch(`${registryUrl}/pypi/pypi/${packageName}/json`);
|
||
|
|
expect(response.status).toEqual(200);
|
||
|
|
|
||
|
|
const metadata = await response.json();
|
||
|
|
expect(metadata.info.name).toEqual(packageName);
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.test('PyPI CLI: should fail upload without auth', async () => {
|
||
|
|
if (!hasTwine) {
|
||
|
|
console.log('Skipping twine test - twine not available');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const packageName = 'unauth-pkg';
|
||
|
|
const version = '1.0.0';
|
||
|
|
const wheelPath = await createTestWheelFile(packageName, version, testDir);
|
||
|
|
|
||
|
|
// Create a pypirc without proper credentials
|
||
|
|
const badPypircPath = path.join(testDir, '.bad-pypirc');
|
||
|
|
fs.writeFileSync(badPypircPath, `[distutils]
|
||
|
|
index-servers = badpypi
|
||
|
|
|
||
|
|
[badpypi]
|
||
|
|
repository = ${registryUrl}/pypi
|
||
|
|
username = baduser
|
||
|
|
password = badtoken
|
||
|
|
`, 'utf-8');
|
||
|
|
|
||
|
|
const fullCommand = `cd "${testDir}" && twine upload --repository badpypi "${wheelPath}" --config-file "${badPypircPath}"`;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const result = await tapNodeTools.runCommand(fullCommand);
|
||
|
|
// Should fail
|
||
|
|
expect(result.exitCode).not.toEqual(0);
|
||
|
|
} catch (error: any) {
|
||
|
|
// Expected to fail
|
||
|
|
expect(error.exitCode || 1).not.toEqual(0);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
tap.postTask('cleanup pypi cli tests', async () => {
|
||
|
|
// Stop server
|
||
|
|
if (server) {
|
||
|
|
await new Promise<void>((resolve) => {
|
||
|
|
server.close(() => resolve());
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// Cleanup test directory
|
||
|
|
if (testDir) {
|
||
|
|
cleanupTestDir(testDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Destroy registry
|
||
|
|
if (registry) {
|
||
|
|
registry.destroy();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
export default tap.start();
|