public async void InvokeFromStreamAsync_WithTypeParameter_WithModuleFactory_InvokesFromCacheIfModuleIsCached()
{
// Arrange
const string dummyArg = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
await testSubject.InvokeFromStreamAsync(memoryStream, DUMMY_CACHE_IDENTIFIER, "setString", new[] { dummyArg }).ConfigureAwait(false);
// Act
DummyResult result = await testSubject.
InvokeFromStreamAsync <DummyResult>(() => null, DUMMY_CACHE_IDENTIFIER, "getString").ConfigureAwait(false);
// Assert
Assert.Equal(dummyArg, result.Result);
}
public async void InvokeFromStreamAsync_WithoutTypeParameter_WithModuleFactory_IsThreadSafe()
{
// Arrange
HttpNodeJSService testSubject = CreateHttpNodeJSService();
// Act
const int numThreads = 5;
var threads = new List <Thread>();
for (int i = 0; i < numThreads; i++)
{
var thread = new Thread(() =>
{
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
testSubject.InvokeFromStreamAsync(memoryStream, DUMMY_CACHE_IDENTIFIER, "incrementNumber").GetAwaiter().GetResult();
});
threads.Add(thread);
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
// Assert
(bool success, int result) = await testSubject.TryInvokeFromCacheAsync <int>(DUMMY_CACHE_IDENTIFIER, "getNumber").ConfigureAwait(false);
Assert.True(success);
Assert.Equal(numThreads, result);
}
public async void InvokeFromStreamAsync_WithoutTypeParameter_WithModuleFactory_InvokesFromCacheIfModuleIsCached()
{
// Arrange
HttpNodeJSService testSubject = CreateHttpNodeJSService();
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
await testSubject.InvokeFromStreamAsync(memoryStream, DUMMY_CACHE_IDENTIFIER, "incrementNumber").ConfigureAwait(false);
// Act
await testSubject.
InvokeFromStreamAsync(() => null, DUMMY_CACHE_IDENTIFIER, "incrementNumber").ConfigureAwait(false);
// Assert
int result = await testSubject.InvokeFromStreamAsync <int>(memoryStream, DUMMY_CACHE_IDENTIFIER, "getNumber").ConfigureAwait(false);
Assert.Equal(2, result);
}
public async void InvokeFromStreamAsync_WithoutTypeParameter_WithRawStreamModule_InvokesFromStream()
{
// Arrange
const string dummyArg = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService(projectPath: _projectPath);
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
// Act
await testSubject.InvokeFromStreamAsync(memoryStream, DUMMY_CACHE_IDENTIFIER, "setString", new[] { dummyArg }).ConfigureAwait(false);
// Assert
DummyResult result = await testSubject.
InvokeFromStreamAsync <DummyResult>(memoryStream, DUMMY_CACHE_IDENTIFIER, "getString").ConfigureAwait(false);
Assert.Equal(dummyArg, result.Result);
}
public void InvokeFromStreamAsync_WithTypeParameter_WithRawStreamModule_IsThreadSafe()
{
// Arrange
const string dummyArg = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
// Act
var results = new ConcurrentQueue <DummyResult>();
const int numThreads = 5;
var threads = new List <Thread>();
for (int i = 0; i < numThreads; i++)
{
var thread = new Thread(() =>
{
MemoryStream memoryStream = CreateMemoryStream(_dummyReturnsArgModule);
results.Enqueue(testSubject.InvokeFromStreamAsync <DummyResult>(memoryStream, args: new[] { dummyArg }).GetAwaiter().GetResult());
});
threads.Add(thread);
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
// Assert
Assert.Equal(numThreads, results.Count);
foreach (DummyResult result in results)
{
Assert.Equal(dummyArg, result.Result);
}
}
public async void InvokeFromStreamAsync_WithTypeParameter_WithRawStreamModule_InvokesFromStream()
{
// Arrange
const string dummyArg = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
MemoryStream memoryStream = CreateMemoryStream(_dummyReturnsArgModule);
// Act
DummyResult result = await testSubject.InvokeFromStreamAsync <DummyResult>(memoryStream, args : new[] { dummyArg }).ConfigureAwait(false);
// Assert
Assert.Equal(dummyArg, result.Result);
}
public async void InvokeFromStreamAsync_WithoutTypeParameter_WithModuleFactory_InvokesFromStreamAndCachesModuleIfModuleIsNotCached()
{
// Arrange
HttpNodeJSService testSubject = CreateHttpNodeJSService();
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
// Act
await testSubject.
InvokeFromStreamAsync(() => memoryStream, DUMMY_CACHE_IDENTIFIER, "incrementNumber").ConfigureAwait(false);
// Assert
// Ensure module was cached
(bool success, int result) = await testSubject.TryInvokeFromCacheAsync <int>(DUMMY_CACHE_IDENTIFIER, "getNumber").ConfigureAwait(false);
Assert.True(success);
Assert.Equal(1, result);
}
public async void InvokeFromStreamAsync_WithTypeParameter_WithModuleFactory_InvokesFromStreamAndCachesModuleIfModuleIsNotCached()
{
// Arrange
const string dummyArg = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
MemoryStream memoryStream = CreateMemoryStream(_dummyReturnsArgModule);
// Act
// Module hasn't been cached, so if this returns the expected value, stream was sent over
DummyResult result1 = await testSubject.
InvokeFromStreamAsync <DummyResult>(() => memoryStream, DUMMY_CACHE_IDENTIFIER, args : new[] { dummyArg }).ConfigureAwait(false);
// Assert
// Ensure module was cached
(bool success, DummyResult result2) = await testSubject.
TryInvokeFromCacheAsync <DummyResult>(DUMMY_CACHE_IDENTIFIER, args : new[] { dummyArg }).ConfigureAwait(false);
Assert.Equal(dummyArg, result1.Result);
Assert.True(success);
Assert.Equal(dummyArg, result2.Result);
}
public void InvokeFromStreamAsync_IsThreadSafe()
{
// Arrange
const string dummyModule = "module.exports = (callback, resultString) => callback(null, {result: resultString});";
const string dummyResultString = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
// Act
var results = new ConcurrentQueue <DummyResult>();
const int numThreads = 5;
var threads = new List <Thread>();
for (int i = 0; i < numThreads; i++)
{
var thread = new Thread(() =>
{
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
streamWriter.Write(dummyModule);
streamWriter.Flush();
memoryStream.Position = 0;
results.Enqueue(testSubject.InvokeFromStreamAsync <DummyResult>(memoryStream, args: new[] { dummyResultString }).GetAwaiter().GetResult());
}
});
threads.Add(thread);
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
// Assert
Assert.Equal(numThreads, results.Count);
foreach (DummyResult result in results)
{
Assert.Equal(dummyResultString, result.Result);
}
}
public async void InvokeFromStreamAsync_InvokesJavascript()
{
// Arrange
const string dummyResultString = "success";
HttpNodeJSService testSubject = CreateHttpNodeJSService();
DummyResult result;
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
streamWriter.Write("module.exports = (callback, resultString) => callback(null, {result: resultString});");
streamWriter.Flush();
memoryStream.Position = 0;
// Act
result = await testSubject.InvokeFromStreamAsync <DummyResult>(memoryStream, args : new[] { dummyResultString }).ConfigureAwait(false);
}
// Assert
Assert.Equal(dummyResultString, result.Result);
}
public void InvokeFromStreamAsync_WithTypeParameter_WithModuleFactory_IsThreadSafe()
{
// Arrange
HttpNodeJSService testSubject = CreateHttpNodeJSService();
// Act
var results = new ConcurrentQueue <int>();
const int numThreads = 5;
var threads = new List <Thread>();
for (int i = 0; i < numThreads; i++)
{
var thread = new Thread(() =>
{
MemoryStream memoryStream = CreateMemoryStream(_dummyExportsMultipleFunctionsModule);
results.Enqueue(testSubject.InvokeFromStreamAsync <int>(() => memoryStream, DUMMY_CACHE_IDENTIFIER, "incrementAndGetNumber").GetAwaiter().GetResult());
});
threads.Add(thread);
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
// Assert
Assert.Equal(numThreads, results.Count);
// Module shouldn't get cached more than once, we should get exactly [1,2,3,4,5]
List <int> resultsList = results.ToList();
resultsList.Sort();
for (int i = 0; i < numThreads; i++)
{
Assert.Equal(resultsList[i], i + 1);
}
}