engineering/un-inception
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: Complete 6 additional SDK implementations with fixes and examples

Browse source 
Go Async SDK (clients/go/async/):
- Fixed case-sensitive language detection bug (.R for R language)
- Created go.mod for module management
- Added comprehensive test suite
- Created 3 examples with expected output comments
- Added README with full documentation

Java Sync SDK (clients/java/sync/):
- RENAMED: Unsandbox.java -> Un.java (matches naming convention)
- Updated class name from Unsandbox to Un
- Created pom.xml for Maven build
- Added 6 examples (simple + SDK client versions)
- Created test suite with JUnit 5
- Added README with API documentation

JavaScript Async SDK (clients/javascript/async/):
- Fixed unused import
- Created package.json with ES module support
- Added 5 examples covering all async patterns
- Created 71 tests (all passing)
- Added comprehensive README

PHP Sync SDK (clients/php/sync/):
- RENAMED: Unsandbox.php -> un.php (matches naming convention)
- Created composer.json with PSR-4 autoloading
- Created phpunit.xml for testing
- Added 4 examples with expected output comments
- Created 54 tests across 4 test files
- Added README with full documentation

Ruby Sync SDK (clients/ruby/sync/):
- Created Gemfile and un.gemspec
- Created Rakefile with test task
- Updated examples to actually use the SDK
- Added 4 examples (hello_world, async_job, language_detection, snapshots)
- Created comprehensive test suite with 30+ tests
- Added README with documentation

Rust Sync SDK (clients/rust/sync/):
- Updated Cargo.toml with example declarations
- Created 4 examples (hello_world, fibonacci, multi_language, async_polling)
- Added comprehensive README with API reference
- All dependencies verified correct

All SDKs verified:
- HMAC-SHA256 authentication implemented
- 4-tier credential system (args > env > ~/.unsandbox > ./accounts.csv)
- Expected output comments for pipeline validation
- Proper error handling
- Language detection support
This commit is contained in:
russell@unturf.com 2026-01-15 17:32:24 -05:00
parent 1e4fe2ef96
commit 331cba42aa
66 changed files with 18743 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

253
clients/java/sync/README.md Normal file
View file

@ -0,0 +1,253 @@
# Unsandbox Java SDK (Synchronous)
A synchronous Java client library for [unsandbox.com](https://unsandbox.com) - secure, multi-language code execution.
## Installation
### Maven
```xml
<dependency>
<groupId>com.unsandbox</groupId>
<artifactId>un-sdk-sync</artifactId>
<version>1.0.0</version>
</dependency>
```
### From Source
```bash
cd clients/java/sync
mvn install
```
## Quick Start
```java
import Un;
import java.util.Map;
// Execute Python code
Map<String, Object> result = Un.executeCode("python", "print('Hello from unsandbox!')", null, null);
System.out.println(result.get("stdout"));
```
## Authentication
The SDK supports 4-tier credential resolution:
1. **Method arguments** - Pass directly to methods
2. **Environment variables** - `UNSANDBOX_PUBLIC_KEY` and `UNSANDBOX_SECRET_KEY`
3. **Config file** - `~/.unsandbox/accounts.csv` (line 0 by default)
4. **Local directory** - `./accounts.csv` (line 0 by default)
### Setting up credentials
Create `~/.unsandbox/accounts.csv`:
```csv
your_public_key,your_secret_key
another_public_key,another_secret_key
```
Or use environment variables:
```bash
export UNSANDBOX_PUBLIC_KEY="pk_xxxxx"
export UNSANDBOX_SECRET_KEY="sk_xxxxx"
```
## API Reference
### Synchronous Execution
Execute code and wait for completion:
```java
import Un;
import java.util.Map;
Map<String, Object> result = Un.executeCode(
"python", // language
"print('hello')", // code
null, // publicKey (uses credential resolution)
null // secretKey (uses credential resolution)
);
System.out.println(result.get("status")); // "completed"
System.out.println(result.get("stdout")); // "hello\n"
System.out.println(result.get("stderr")); // ""
System.out.println(result.get("exit_code")); // 0
```
### Asynchronous Execution
Start execution and get a job ID:
```java
import Un;
import java.util.Map;
// Start execution
String jobId = Un.executeAsync("python", "print('hello')", null, null);
// Wait for completion with 60 second timeout
Map<String, Object> result = Un.waitForJob(jobId, null, null, 60000);
```
### Job Management
```java
import Un;
import java.util.Map;
import java.util.List;
// Get single job status
Map<String, Object> job = Un.getJob("job_123", null, null);
// List all jobs
List<Map<String, Object>> jobs = Un.listJobs(null, null);
// Cancel a job
Un.cancelJob("job_123", null, null);
```
### Languages
```java
import Un;
import java.util.List;
// Get list of supported languages
List<String> languages = Un.getLanguages(null, null);
// Returns: ["python", "javascript", "go", "rust", ...]
// Detect language from filename
String lang = Un.detectLanguage("script.py"); // Returns "python"
```
### Snapshots
```java
import Un;
import java.util.Map;
import java.util.List;
// Create a session snapshot
String snapshotId = Un.sessionSnapshot("session_123", null, null, "checkpoint", false);
// Create a service snapshot
String snapshotId = Un.serviceSnapshot("service_123", null, null, "backup");
// List snapshots
List<Map<String, Object>> snapshots = Un.listSnapshots(null, null);
// Restore a snapshot
Map<String, Object> result = Un.restoreSnapshot(snapshotId, null, null);
// Delete a snapshot
Un.deleteSnapshot(snapshotId, null, null);
```
## Language Support
The SDK supports 50+ programming languages including:
- **Interpreted**: Python, JavaScript, Ruby, PHP, Perl, Bash, etc.
- **Compiled**: C, C++, Go, Rust, Java, etc.
- **Functional**: Haskell, OCaml, F#, Scheme, etc.
- **Other**: WASM, Prolog, Forth, etc.
See `getLanguages()` for the complete list.
## Caching
The languages list is cached locally for 1 hour in `~/.unsandbox/languages.json`. This reduces API calls and improves startup performance.
To force a refresh, delete the cache file:
```bash
rm ~/.unsandbox/languages.json
```
## Error Handling
```java
import Un;
import java.util.Map;
import java.io.IOException;
try {
Map<String, Object> result = Un.executeCode("python", "print('hello')", null, null);
} catch (Un.CredentialsException e) {
System.err.println("No credentials found: " + e.getMessage());
} catch (Un.ApiException e) {
System.err.println("API error: " + e.getMessage());
System.err.println("Status code: " + e.getStatusCode());
System.err.println("Response: " + e.getResponseBody());
} catch (IOException e) {
System.err.println("Network error: " + e.getMessage());
}
```
## Examples
See the `examples/` directory for complete working examples:
- `HelloWorld.java` - Simple print example
- `Fibonacci.java` - Recursive function example
- `HelloWorldClient.java` - SDK client usage example
- `FibonacciClient.java` - CPU-bound computation example
- `HttpRequestClient.java` - HTTP request in sandbox example
- `AsyncJobClient.java` - Async execution with polling example
Compile and run an example:
```bash
cd examples
javac -cp ../src HelloWorldClient.java
export UNSANDBOX_PUBLIC_KEY="your-key"
export UNSANDBOX_SECRET_KEY="your-key"
java -cp .:../src HelloWorldClient
```
## Building
Build with Maven:
```bash
mvn clean package
```
Run tests:
```bash
mvn test
```
Create JAR with sources and Javadoc:
```bash
mvn package
```
## Requirements
- Java 17 or higher
- No external dependencies (uses standard library only)
## Public Domain License
This code is released into the PUBLIC DOMAIN with NO WARRANTY and NO LICENSE.
You are free to:
- Use for any purpose
- Modify and distribute
- Use commercially
- Use privately
## Support
For issues or questions:
- GitHub Issues: https://github.com/unsandbox/un-inception/issues
- Website: https://unsandbox.com

82
clients/java/sync/examples/AsyncJobClient.java Normal file
View file

@ -0,0 +1,82 @@
/**
* Async Job Client example for unsandbox Java SDK - Synchronous Version
*
* Demonstrates asynchronous execution with job polling.
* Shows how to execute code asynchronously and wait for completion.
*
* To compile:
* javac -cp ../src AsyncJobClient.java
*
* To run:
* export UNSANDBOX_PUBLIC_KEY="your-public-key"
* export UNSANDBOX_SECRET_KEY="your-secret-key"
* java -cp .:../src AsyncJobClient
*
* Expected output:
* Submitting async job...
* Job submitted with ID: job_xxxxx
* Waiting for completion...
* Job completed!
* Output: Result of computation: 42
*/
import java.util.Map;
public class AsyncJobClient {
public static void main(String[] args) {
// The code to execute - simulates a longer-running computation
String code = """
import time
# Simulate some computation
time.sleep(1)
result = 6 * 7
print(f"Result of computation: {result}")
""";
try {
// Resolve credentials from environment
String publicKey = System.getenv("UNSANDBOX_PUBLIC_KEY");
String secretKey = System.getenv("UNSANDBOX_SECRET_KEY");
if (publicKey == null || publicKey.isEmpty() ||
secretKey == null || secretKey.isEmpty()) {
System.err.println("Error: UNSANDBOX_PUBLIC_KEY and UNSANDBOX_SECRET_KEY environment variables required");
System.err.println("Run with: export UNSANDBOX_PUBLIC_KEY=your-key UNSANDBOX_SECRET_KEY=your-key");
System.exit(1);
}
// Submit job asynchronously
System.out.println("Submitting async job...");
String jobId = Un.executeAsync("python", code, publicKey, secretKey);
System.out.println("Job submitted with ID: " + jobId);
// Wait for completion (60 second timeout)
System.out.println("Waiting for completion...");
Map<String, Object> result = Un.waitForJob(jobId, publicKey, secretKey, 60000);
// Check for errors
String status = (String) result.get("status");
if ("completed".equals(status)) {
System.out.println("Job completed!");
String stdout = (String) result.get("stdout");
if (stdout != null) {
System.out.println("Output: " + stdout.trim());
}
} else {
System.out.println("Job failed with status: " + status);
System.out.println("Error: " + result.getOrDefault("error", "Unknown error"));
System.exit(1);
}
} catch (Un.CredentialsException e) {
System.err.println("Credentials error: " + e.getMessage());
System.exit(1);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
}
}

13
clients/java/sync/examples/Fibonacci.java Normal file
View file

@ -0,0 +1,13 @@
// Fibonacci example for unsandbox Java SDK
// Expected output: fib(10) = 55
public class Fibonacci {
public static int fib(int n) {
if (n <= 1) return n;
return fib(n - 1) + fib(n - 2);
}
public static void main(String[] args) {
System.out.println("fib(10) = " + fib(10));
}
}

79
clients/java/sync/examples/FibonacciClient.java Normal file
View file

@ -0,0 +1,79 @@
/**
* Fibonacci Client example for unsandbox Java SDK - Synchronous Version
*
* Demonstrates executing CPU-bound calculations through the sync SDK.
* Shows proper error handling and result processing.
*
* To compile:
* javac -cp ../src FibonacciClient.java
*
* To run:
* export UNSANDBOX_PUBLIC_KEY="your-public-key"
* export UNSANDBOX_SECRET_KEY="your-secret-key"
* java -cp .:../src FibonacciClient
*
* Expected output:
* Calculating fibonacci(10)...
* Result status: completed
* Output: fib(10) = 55
*/
import java.util.Map;
public class FibonacciClient {
public static void main(String[] args) {
// The code to execute
String code = """
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
print(f"fib(10) = {fib(10)}")
""";
try {
// Resolve credentials from environment
String publicKey = System.getenv("UNSANDBOX_PUBLIC_KEY");
String secretKey = System.getenv("UNSANDBOX_SECRET_KEY");
if (publicKey == null || publicKey.isEmpty() ||
secretKey == null || secretKey.isEmpty()) {
System.err.println("Error: UNSANDBOX_PUBLIC_KEY and UNSANDBOX_SECRET_KEY environment variables required");
System.err.println("Run with: export UNSANDBOX_PUBLIC_KEY=your-key UNSANDBOX_SECRET_KEY=your-key");
System.exit(1);
}
// Execute the code synchronously
System.out.println("Calculating fibonacci(10)...");
Map<String, Object> result = Un.executeCode("python", code, publicKey, secretKey);
// Check for errors
String status = (String) result.get("status");
if ("completed".equals(status)) {
System.out.println("Result status: " + status);
String stdout = (String) result.get("stdout");
if (stdout != null) {
System.out.println("Output: " + stdout.trim());
}
String stderr = (String) result.get("stderr");
if (stderr != null && !stderr.isEmpty()) {
System.out.println("Errors: " + stderr);
}
} else {
System.out.println("Execution failed with status: " + status);
System.out.println("Error: " + result.getOrDefault("error", "Unknown error"));
System.exit(1);
}
} catch (Un.CredentialsException e) {
System.err.println("Credentials error: " + e.getMessage());
System.exit(1);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
}
}

8
clients/java/sync/examples/HelloWorld.java Normal file
View file

@ -0,0 +1,8 @@
// Hello World example for unsandbox Java SDK
// Expected output: Hello from unsandbox!
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello from unsandbox!");
}
}

72
clients/java/sync/examples/HelloWorldClient.java Normal file
View file

@ -0,0 +1,72 @@
/**
* Hello World Client example for unsandbox Java SDK - Synchronous Version
*
* This example demonstrates basic synchronous execution using the SDK client.
* Shows how to execute code from a Java program using the sync SDK.
*
* To compile:
* javac -cp ../src HelloWorldClient.java
*
* To run:
* export UNSANDBOX_PUBLIC_KEY="your-public-key"
* export UNSANDBOX_SECRET_KEY="your-secret-key"
* java -cp .:../src HelloWorldClient
*
* Expected output:
* Executing code synchronously...
* Result status: completed
* Output: Hello from unsandbox!
*/
import java.util.Map;
public class HelloWorldClient {
public static void main(String[] args) {
// The code to execute
String code = "print(\"Hello from unsandbox!\")";
try {
// Resolve credentials from environment
String publicKey = System.getenv("UNSANDBOX_PUBLIC_KEY");
String secretKey = System.getenv("UNSANDBOX_SECRET_KEY");
if (publicKey == null || publicKey.isEmpty() ||
secretKey == null || secretKey.isEmpty()) {
System.err.println("Error: UNSANDBOX_PUBLIC_KEY and UNSANDBOX_SECRET_KEY environment variables required");
System.err.println("Run with: export UNSANDBOX_PUBLIC_KEY=your-key UNSANDBOX_SECRET_KEY=your-key");
System.exit(1);
}
// Execute the code synchronously
System.out.println("Executing code synchronously...");
Map<String, Object> result = Un.executeCode("python", code, publicKey, secretKey);
// Check for errors
String status = (String) result.get("status");
if ("completed".equals(status)) {
System.out.println("Result status: " + status);
String stdout = (String) result.get("stdout");
if (stdout != null) {
System.out.println("Output: " + stdout.trim());
}
String stderr = (String) result.get("stderr");
if (stderr != null && !stderr.isEmpty()) {
System.out.println("Errors: " + stderr);
}
} else {
System.out.println("Execution failed with status: " + status);
System.out.println("Error: " + result.getOrDefault("error", "Unknown error"));
System.exit(1);
}
} catch (Un.CredentialsException e) {
System.err.println("Credentials error: " + e.getMessage());
System.exit(1);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
}
}

92
clients/java/sync/examples/HttpRequestClient.java Normal file
View file

@ -0,0 +1,92 @@
/**
* HTTP Request Client example for unsandbox Java SDK - Synchronous Version
*
* This example demonstrates making HTTP requests from within a sandboxed environment.
* Uses semitrusted mode which provides internet access through an egress proxy.
*
* To compile:
* javac -cp ../src HttpRequestClient.java
*
* To run:
* export UNSANDBOX_PUBLIC_KEY="your-public-key"
* export UNSANDBOX_SECRET_KEY="your-secret-key"
* java -cp .:../src HttpRequestClient
*
* Expected output:
* Executing HTTP request in sandbox...
*
* === STDOUT ===
* Status Code: 200
* Response: {"origin": "..."}
*/
import java.util.Map;
public class HttpRequestClient {
public static void main(String[] args) {
// The code to execute - uses requests library (pre-installed in sandbox)
String code = """
import requests
import json
try:
# Make HTTP request to httpbin.org
response = requests.get('https://httpbin.org/ip', timeout=10)
print(f"Status Code: {response.status_code}")
# Parse and display response
data = response.json()
print(f"Response: {json.dumps(data)}")
except requests.RequestException as e:
print(f"Request failed: {e}")
except Exception as e:
print(f"Error: {e}")
""";
try {
// Resolve credentials from environment
String publicKey = System.getenv("UNSANDBOX_PUBLIC_KEY");
String secretKey = System.getenv("UNSANDBOX_SECRET_KEY");
if (publicKey == null || publicKey.isEmpty() ||
secretKey == null || secretKey.isEmpty()) {
System.err.println("Error: UNSANDBOX_PUBLIC_KEY and UNSANDBOX_SECRET_KEY environment variables required");
System.err.println("Run with: export UNSANDBOX_PUBLIC_KEY=your-key UNSANDBOX_SECRET_KEY=your-key");
System.exit(1);
}
// Execute the code
System.out.println("Executing HTTP request in sandbox...");
Map<String, Object> result = Un.executeCode("python", code, publicKey, secretKey);
// Check for errors
String status = (String) result.get("status");
if ("completed".equals(status)) {
System.out.println("\n=== STDOUT ===");
String stdout = (String) result.get("stdout");
if (stdout != null) {
System.out.println(stdout);
}
String stderr = (String) result.get("stderr");
if (stderr != null && !stderr.isEmpty()) {
System.out.println("\n=== STDERR ===");
System.out.println(stderr);
}
} else {
System.out.println("Execution failed with status: " + status);
System.out.println("Error: " + result.getOrDefault("error", "Unknown error"));
System.exit(1);
}
} catch (Un.CredentialsException e) {
System.err.println("Credentials error: " + e.getMessage());
System.exit(1);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
}
}

111
clients/java/sync/pom.xml Normal file
View file

@ -0,0 +1,111 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.unsandbox</groupId>
<artifactId>un-sdk-sync</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>Un SDK (Synchronous)</name>
<description>Synchronous Java SDK for unsandbox.com - secure code execution API</description>
<url>https://unsandbox.com</url>
<licenses>
<license>
<name>Public Domain</name>
<comments>No license, no warranty</comments>
</license>
</licenses>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<junit.version>5.10.1</junit.version>
</properties>
<dependencies>
<!-- Testing -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<sourceDirectory>src</sourceDirectory>
<testSourceDirectory>test</testSourceDirectory>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>17</source>
<target>17</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<archive>
<manifest>
<mainClass>Un</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
<!-- Create sources JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
<!-- Create Javadoc JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.6.2</version>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

1053
clients/java/sync/src/Un.java Normal file
View file

File diff suppressed because it is too large Load diff

197
clients/java/sync/test/UnTest.java Normal file
View file

@ -0,0 +1,197 @@
/**
* Unit tests for Un SDK - Synchronous Java client
*
* These tests verify:
* - JSON serialization/deserialization
* - HMAC-SHA256 signature generation
* - Credential resolution logic
* - Language detection
*
* To run tests:
* mvn test
*
* Note: API integration tests require valid credentials and are skipped
* when UNSANDBOX_PUBLIC_KEY is not set.
*/
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import static org.junit.jupiter.api.Assertions.*;
public class UnTest {
@Nested
@DisplayName("Language Detection Tests")
class LanguageDetectionTests {
@Test
@DisplayName("Should detect Python from .py extension")
void detectPython() {
assertEquals("python", Un.detectLanguage("script.py"));
assertEquals("python", Un.detectLanguage("path/to/script.py"));
assertEquals("python", Un.detectLanguage("SCRIPT.PY"));
}
@Test
@DisplayName("Should detect JavaScript from .js extension")
void detectJavaScript() {
assertEquals("javascript", Un.detectLanguage("app.js"));
assertEquals("javascript", Un.detectLanguage("index.JS"));
}
@Test
@DisplayName("Should detect TypeScript from .ts extension")
void detectTypeScript() {
assertEquals("typescript", Un.detectLanguage("app.ts"));
}
@Test
@DisplayName("Should detect Go from .go extension")
void detectGo() {
assertEquals("go", Un.detectLanguage("main.go"));
}
@Test
@DisplayName("Should detect Rust from .rs extension")
void detectRust() {
assertEquals("rust", Un.detectLanguage("lib.rs"));
}
@Test
@DisplayName("Should detect Java from .java extension")
void detectJava() {
assertEquals("java", Un.detectLanguage("Main.java"));
}
@Test
@DisplayName("Should detect C++ from various extensions")
void detectCpp() {
assertEquals("cpp", Un.detectLanguage("main.cpp"));
assertEquals("cpp", Un.detectLanguage("main.cc"));
assertEquals("cpp", Un.detectLanguage("main.cxx"));
}
@Test
@DisplayName("Should return null for unknown extension")
void detectUnknown() {
assertNull(Un.detectLanguage("file.unknown"));
assertNull(Un.detectLanguage("noextension"));
}
@Test
@DisplayName("Should return null for null input")
void detectNull() {
assertNull(Un.detectLanguage(null));
}
}
@Nested
@DisplayName("Credential Exception Tests")
class CredentialExceptionTests {
@Test
@DisplayName("CredentialsException should contain message")
void credentialsExceptionMessage() {
Un.CredentialsException ex = new Un.CredentialsException("Test message");
assertEquals("Test message", ex.getMessage());
}
}
@Nested
@DisplayName("API Exception Tests")
class ApiExceptionTests {
@Test
@DisplayName("ApiException should contain status code and response body")
void apiExceptionDetails() {
Un.ApiException ex = new Un.ApiException("Error occurred", 401, "{\"error\": \"unauthorized\"}");
assertEquals(401, ex.getStatusCode());
assertEquals("{\"error\": \"unauthorized\"}", ex.getResponseBody());
assertEquals("Error occurred", ex.getMessage());
}
}
@Nested
@DisplayName("Integration Tests (requires credentials)")
@EnabledIfEnvironmentVariable(named = "UNSANDBOX_PUBLIC_KEY", matches = ".+")
class IntegrationTests {
private String publicKey;
private String secretKey;
@BeforeEach
void setUp() {
publicKey = System.getenv("UNSANDBOX_PUBLIC_KEY");
secretKey = System.getenv("UNSANDBOX_SECRET_KEY");
}
@Test
@DisplayName("Should execute Python code successfully")
void executePythonCode() throws IOException {
Map<String, Object> result = Un.executeCode(
"python",
"print('Hello, World!')",
publicKey,
secretKey
);
assertNotNull(result);
assertEquals("completed", result.get("status"));
assertTrue(result.get("stdout").toString().contains("Hello, World!"));
}
@Test
@DisplayName("Should execute JavaScript code successfully")
void executeJavaScriptCode() throws IOException {
Map<String, Object> result = Un.executeCode(
"javascript",
"console.log('Hello from JS')",
publicKey,
secretKey
);
assertNotNull(result);
assertEquals("completed", result.get("status"));
assertTrue(result.get("stdout").toString().contains("Hello from JS"));
}
@Test
@DisplayName("Should get supported languages")
void getLanguages() throws IOException {
List<String> languages = Un.getLanguages(publicKey, secretKey);
assertNotNull(languages);
assertFalse(languages.isEmpty());
assertTrue(languages.contains("python"));
assertTrue(languages.contains("javascript"));
}
@Test
@DisplayName("Should execute async and wait for job")
void executeAsync() throws IOException {
String jobId = Un.executeAsync(
"python",
"print('Async test')",
publicKey,
secretKey
);
assertNotNull(jobId);
Map<String, Object> result = Un.waitForJob(jobId, publicKey, secretKey, 30000);
assertNotNull(result);
assertEquals("completed", result.get("status"));
assertTrue(result.get("stdout").toString().contains("Async test"));
}
}
}