New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

er_memcached_data_server

Package Overview
Dependencies
Maintainers
1
Versions
10
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

er_memcached_data_server - npm Package Compare versions

Comparing version 1.0.1 to 1.1.0

tests/fixture/rate_limits.json

2

index.js

@@ -7,2 +7,2 @@ 'use strict';

module.exports = MemcachedDataServer;
module.exports = MemcachedDataServer;

2

package.json
{
"name": "er_memcached_data_server",
"version": "1.0.1",
"version": "1.1.0",
"description": "Plugin for event_request that implements a memcached data server",

@@ -5,0 +5,0 @@ "main": "index.js",

3

src/memcached_data_server_plugin.js

@@ -7,3 +7,4 @@ 'use strict';

module.exports = ( dataServerOptions )=>{
return new DataServerPlugin( 'er_data_server', { dataServer : DataServer, dataServerOptions } );
const dataServer = new DataServer( dataServerOptions );
return new DataServerPlugin( 'er_data_server', { dataServer } );
};

6

src/memcached_data_server.js

@@ -24,3 +24,3 @@ 'use strict';

? options[OPTIONS_SERVER_OPTIONS]
: {};
: { poolSize: 100 };

@@ -33,3 +33,3 @@ this.defaultTtl = typeof options['ttl'] === 'number'

this.server = new Memcached( serverLocations, serverOptions );
this.server = new Memcached( serverLocations, serverOptions );
}

@@ -42,3 +42,3 @@

{
this.server.end();
this.server.end(()=>{});
}

@@ -45,0 +45,0 @@

772

tests/memcached_data_server_test.js
'use strict';
const { Server } = require( 'event_request' );
const { test, assert, runAllTests } = require( 'event_request' ).Testing;
const { request } = require( 'http' );
const RateLimitsPlugin = require( 'event_request/server/plugins/available_plugins/rate_limits_plugin' );
const Session = require( 'event_request/server/components/session/session' );
const path = require( 'path' );
const DataServer = require( '../src/memcached_data_server' );
const path = require( 'path' );
const fs = require( 'fs' );
const MemcachedDataServer = require( '../src/memcached_data_server' );
const getPlugin = require( '../src/memcached_data_server_plugin' );
const PROJECT_ROOT = path.parse( require.main.filename ).dir;
const DEFAULT_PERSIST_FILE = path.join( PROJECT_ROOT, 'cache' );
const app = new Server.class();
const dataServer = new MemcachedDataServer();
app.apply( getPlugin() );
/**
* @brief Sends a request to the server and returns a Promise
*
* @param String path
* @param String method
* @param Number statusCode
* @param mixed data
* @param Number port
* @param String expectedBody
*
* @return Promise
*/
function sendServerRequest( path, method = 'GET', statusCode = 200, data = '', headers = {}, port = 3333, expectedBody = null )
{
return new Promise(( resolve,reject )=>{
const predefinedHeaders = {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': Buffer.byteLength( data )
};
headers = { ...predefinedHeaders, ...headers };
const options = {
hostname : 'localhost',
port,
path,
method,
headers
};
const req = request( options, ( res ) =>{
const bodyParts = [];
res.on( 'data',( chunk )=>{
bodyParts.push( chunk );
} );
res.on( 'end',()=>{
res.body = Buffer.concat( bodyParts );
if ( res.statusCode !== statusCode )
{
return reject( `Expected StatusCode: ${statusCode} but got ${res.statusCode} with body: ${res.body}`)
}
if ( expectedBody !== null )
{
assert.equal( res.body.toString(), expectedBody );
}
return resolve( res );
});
});
req.on('error', ( e ) => {
reject( e );
});
req.write( data );
req.end();
});
};
/**
* @brief Removes the cache file

@@ -24,7 +92,7 @@ */

test({
message : 'DataServer.set sets data',
message : 'MemcachedDataServer.set sets data',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer();
const dataServer = new MemcachedDataServer();
const key = `key${Math.random()}`

@@ -56,7 +124,7 @@ const value = 'value';

test({
message : 'DataServer.set sets data without options',
message : 'MemcachedDataServer.set sets data without options',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async()=>{
const dataServer = new DataServer();
const dataServer = new MemcachedDataServer();
const key = `key${Math.random()}`

@@ -80,7 +148,7 @@ const value = 'value';

test({
message : 'DataServer.set with ttl === -1',
message : 'MemcachedDataServer.set with ttl === -1',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const key = `key${Math.random()}`

@@ -104,3 +172,3 @@ const value = 'value';

test({
message : 'DataServer.set fails on handleError',
message : 'MemcachedDataServer.set fails on handleError',
dataProvider : [

@@ -119,3 +187,3 @@ ['key', 'value', 10, 123],

setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );

@@ -132,3 +200,3 @@ assert.equal( await dataServer.set( key, value, ttl, options ), null );

test({
message : 'DataServer.get gets data',
message : 'MemcachedDataServer.get gets data',
test : ( done )=>{

@@ -138,3 +206,3 @@ removeCache();

setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const key = `key${Math.random()}`

@@ -164,3 +232,3 @@ const value = 'value';

test({
message : 'DataServer.get with invalid data',
message : 'MemcachedDataServer.get with invalid data',
dataProvider : [

@@ -179,3 +247,3 @@ ['key', 123],

setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );

@@ -191,7 +259,7 @@ assert.equal( await dataServer.get( key, options ), null );

test({
message : 'DataServer.get prunes ( when expired it will be null )',
message : 'MemcachedDataServer.get prunes ( when expired it will be null )',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const key = `key${Math.random()}`

@@ -215,7 +283,7 @@ const value = 'value';

test({
message : 'DataServer.touch updates expirationDate',
message : 'MemcachedDataServer.touch updates expirationDate',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const key = `key${Math.random()}`;

@@ -249,3 +317,3 @@ const value = 'value';

test({
message : 'DataServer.touch with invalid data',
message : 'MemcachedDataServer.touch with invalid data',
dataProvider : [

@@ -269,3 +337,3 @@ ['key', '123', {}],

setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
await dataServer.set( key, '123' );

@@ -282,3 +350,3 @@

test({
message : 'DataServer.delete removes key and returns true but returns false if it does not exist or not string',
message : 'MemcachedDataServer.delete removes key and returns true but returns false if it does not exist or not string',
test : ( done )=>{

@@ -289,3 +357,3 @@ removeCache();

setTimeout( async ()=>{
const dataServer = new DataServer({ persist: false });
const dataServer = new MemcachedDataServer({ persist: false });
const key = `key${Math.random()}`

@@ -314,3 +382,3 @@ const value = { test: 'value' };

test({
message : 'DataServer.increment increments data',
message : 'MemcachedDataServer.increment increments data',
dataProvider : [

@@ -331,3 +399,3 @@ [100, 100, 200],

const dataServer = new DataServer({ persist: false });
const dataServer = new MemcachedDataServer({ persist: false });
const key = `key${Math.random()}`;

@@ -364,3 +432,3 @@ let called = 0;

test({
message : 'DataServer.decrement decrement data',
message : 'MemcachedDataServer.decrement decrement data',
dataProvider : [

@@ -383,3 +451,3 @@ [100, 100, 0],

const dataServer = new DataServer({ persist: false });
const dataServer = new MemcachedDataServer({ persist: false });
const key = `key${Math.random()}`

@@ -416,3 +484,3 @@ let called = 0;

test({
message : 'DataServer.set does not set if invalid data',
message : 'MemcachedDataServer.set does not set if invalid data',
dataProvider : [

@@ -434,3 +502,3 @@ [null, 'value', 100, true],

setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );

@@ -446,7 +514,7 @@ assert.equal( await dataServer.set( key, value, ttl, persist ), null );

test({
message : 'DataServer.lock locks data correctly',
message : 'MemcachedDataServer.lock locks data correctly',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
let called = 0;

@@ -475,7 +543,7 @@

test({
message : 'DataServer.lock locks data correctly with double unlock',
message : 'MemcachedDataServer.lock locks data correctly with double unlock',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );

@@ -499,7 +567,7 @@ await dataServer.unlock( 'key' );

test({
message : 'DataServer.unlock always returns true',
message : 'MemcachedDataServer.unlock always returns true',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
let called = 0;

@@ -525,7 +593,7 @@

test({
message : 'DataServer.lock acquires only one lock',
message : 'MemcachedDataServer.lock acquires only one lock',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const promises = [];

@@ -555,7 +623,7 @@

test({
message : 'DataServer.lockBurst acquires another lock with burst of locks',
message : 'MemcachedDataServer.lockBurst acquires another lock with burst of locks',
test : ( done )=>{
// Wait in case the file has not been deleted from the FS
setTimeout( async ()=>{
const dataServer = new DataServer( { persist: false } );
const dataServer = new MemcachedDataServer( { persist: false } );
const promises = [];

@@ -590,2 +658,622 @@ const key = `key${Math.random()}lockBurst`;

runAllTests();
test({
message : 'MemcachedDataServer.testWithServerAttachesSuccessfully',
test : ( done )=>{
const app = new Server.class();
const name = '/testWithServerAttachesSuccessfully';
const key = `${name}${Math.random()}`;
const value = 'test';
app.apply( getPlugin() );
app.get( name, async ( event )=>{
assert.equal( event.cachingServer instanceof MemcachedDataServer, true );
await event.cachingServer.set( key, value );
event.send( name );
});
app.get( `${name}GET`, async ( event )=>{
assert.equal( event.cachingServer instanceof MemcachedDataServer, true );
assert.equal( await event.cachingServer.get( key ), value );
event.send( `${name}GET` );
});
app.listen( 3334, ()=>{
sendServerRequest( name, 'GET', 200, '', {}, 3334 ).then(( response )=>{
assert.equal( response.body.toString(), name );
return sendServerRequest( `${name}GET`, 'GET', 200, '', {}, 3334 );
}).then(( response )=>{
assert.equal( response.body.toString(), `${name}GET` );
done();
}).catch( done );
});
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimits',
test : ( done )=>{
const dataStore = new MemcachedDataServer();
const appOne = new Server.class();
const appTwo = new Server.class();
const name = 'testErRateLimitsBucketWorksCrossApps';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
appOne.apply( new RateLimitsPlugin( 'rate_limits' ), { fileLocation, dataStore } );
appTwo.apply( new RateLimitsPlugin( 'rate_limits' ), { fileLocation, dataStore } );
appOne.get( `/${name}`, ( event )=>{
event.send( name );
} );
appTwo.get( `/${name}`, ( event )=>{
event.send( name );
} );
appOne.listen( 3360 );
appTwo.listen( 3361 );
setTimeout(()=>{
sendServerRequest( `/${name}`, 'GET', 200, '', {}, 3360 ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429, '', {}, 3361 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}, 100 );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsPermissive',
test : ( done )=>{
const name = 'testErRateLimitsWithPermissiveLimiting';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
let called = 0;
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
called ++;
if ( called > 1 )
{
assert.equal( event.rateLimited, true );
}
else
{
assert.equal( event.rateLimited, false );
}
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}` );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsPermissiveRefills',
test : ( done )=>{
const name = 'testErRateLimitsWithPermissiveLimitingRefills';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
assert.equal( event.rateLimited, false );
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
setTimeout(()=>{
sendServerRequest( `/${name}` ).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done )
}, 1000 );
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsConnectionDelay',
test : ( done )=>{
const name = 'testErRateLimitsWithConnectionDelayPolicy';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
const now = Math.floor( new Date().getTime() / 1000 );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}` );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
assert.equal( ( Math.floor( new Date().getTime() / 1000 ) - now ) >= 2, true );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrict',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicy';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrictSTRESS',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicyStress';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
const promises = [];
for ( let i = 0; i < 100; i ++ )
{
promises.push( sendServerRequest( `/${name}` ) );
}
setTimeout(()=>{
for ( let i = 0; i < 50; i ++ )
{
promises.push( sendServerRequest( `/${name}` ) );
}
Promise.all( promises).then(()=>{
done();
}).catch( done );
}, 2100 );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrictSpecifiedMethodMatches',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicyWithSpecifiedMethods';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrictSpecifiedMultipleMethodsMatch',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicyWithMultipleSpecifiedMethods';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrictSpecifiedMethodDoesNotMatch',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicyWithSpecifiedMethodsThatDoNotMatch';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}` );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStopPropagation',
test : ( done )=>{
const name = 'testErRateLimitsWithPropagation';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
let called = 0;
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
called ++;
if ( called > 1 )
{
assert.equal( event.rateLimited, true );
}
else
{
assert.equal( event.rateLimited, false );
}
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 200 );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsMultipleRules',
test : ( done )=>{
const name = 'testErRateLimitsWithMultipleRules';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsStrictOverridesConenctionDelay',
test : ( done )=>{
const name = 'testErRateLimitsStrictOverridesConnectionDelayPolicy';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsConnectionOverridesPermissive',
test : ( done )=>{
const name = 'testErRateLimitsConnectionDelayOverridesPermissivePolicy';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}` );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsConnectionReturns429IfNoMoreRetries',
test : ( done )=>{
const name = 'testErRateLimitsConnectionDelayReturns429IfNoMoreRetries';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
event.send( name );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerRateLimitsIpLimit',
test : ( done )=>{
const name = 'testErRateLimitsWithStrictPolicyWithIpLimit';
const fileLocation = path.join( __dirname, './fixture/rate_limits.json' );
if ( ! app.hasPlugin( app.er_rate_limits ) )
app.apply( app.er_rate_limits, { fileLocation } );
app.get( `/${name}`, ( event )=>{
try
{
assert.notEqual( Object.keys( event.rules[4].buckets )[0], `/${name}` );
}
catch ( e )
{
return done( 'er_rate_limits with ip limit did not return as expected' );
}
event.send( name );
} );
setTimeout(()=>{
sendServerRequest( `/${name}` ).then(( response )=>{
return sendServerRequest( `/${name}`, 'GET', 429 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'Too many requests' } ) );
done();
}).catch( done );
}, 50 );
}
});
test({
message : 'MemcachedDataServer.testWithServerResponseCache',
test : ( done )=>{
const name = 'testErResponseCacheCaches';
let i = 0;
if ( ! app.hasPlugin( app.er_response_cache ) )
{
app.apply( app.er_data_server, { dataServer } );
app.apply( app.er_response_cache );
}
app.get( `/${name}`, ( event )=>{
if ( i === 0 )
{
i ++;
return event.send( name );
}
event.sendError( 'ERROR', 501 );
}, 'cache.request' );
sendServerRequest( `/${name}` ).then(( response )=>{
assert.equal( response.body.toString(), name );
return sendServerRequest( `/${name}` );
}).then(( response )=>{
assert.equal( response.body.toString(), name );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerCacheDoesNotCacheIfNotNeeded',
test : ( done )=>{
const name = 'testErResponseCacheDoesNotCacheEverything';
let i = 0;
if ( ! app.hasPlugin( app.er_response_cache ) )
{
app.apply( app.er_data_server, { dataServer } );
app.apply( app.er_response_cache );
}
app.get( `/${name}`, ( event )=>{
if ( i === 0 )
{
i ++;
return event.send( name );
}
event.sendError( 'ERROR', 501 );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
assert.equal( response.body.toString(), name );
return sendServerRequest( `/${name}`, 'GET', 501 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'ERROR' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerCacheDoesNotCacheRaw',
test : ( done )=>{
const name = 'testErResponseCacheDoesNotCacheRaw';
let i = 0;
if ( ! app.hasPlugin( app.er_response_cache ) )
{
app.apply( app.er_data_server, { dataServer } );
app.apply( app.er_response_cache );
}
app.get( `/${name}`, ( event )=>{
if ( i === 0 )
{
i ++;
return event.send( name, 200, true );
}
event.sendError( 'ERROR', 501 );
} );
sendServerRequest( `/${name}` ).then(( response )=>{
assert.equal( response.body.toString(), name );
return sendServerRequest( `/${name}`, 'GET', 501 );
}).then(( response )=>{
assert.equal( response.body.toString(), JSON.stringify( { error: 'ERROR' } ) );
done();
}).catch( done );
}
});
test({
message : 'MemcachedDataServer.testWithServerSession',
test : ( done )=>{
const name = 'testErSession';
const appTwo = new Server.class();
assert.throws(()=>{
const appOne = new Server.class();
appOne.apply( appOne.er_session );
});
appTwo.apply( appTwo.er_data_server, { dataServer } );
appTwo.apply( appTwo.er_session );
appTwo.get( `/${name}`, ( event )=>{
event.initSession( event.next ).catch( event.next );
} );
appTwo.get( `/${name}`, async ( event )=>{
assert.equal( event.session instanceof Session, true );
const session = event.session;
if ( session.has( 'authenticated' ) === false )
{
assert.throws(()=>{
session.get( 'authenticated' );
});
session.add( 'authenticated', true );
}
else
{
assert.equal( session.get( 'authenticated' ), true );
event.setHeader( 'authenticated', 1 );
}
event.send( name );
} );
appTwo.listen( 3390, ()=>{
sendServerRequest( `/${name}`, 'GET', 200, '', {}, 3390 ).then(( response )=>{
assert.equal( response.body.toString(), name );
assert.equal( typeof response.headers['set-cookie'] !== 'undefined', true );
const cookies = {},
rc = response.headers['set-cookie'][0];
rc && rc.split( ';' ).forEach( function( cookie ) {
const parts = cookie.split( '=' );
cookies[parts.shift().trim()] = decodeURI( parts.join( '=' ) );
});
assert.equal( typeof cookies.sid === 'string', true );
const headers = { cookie: `sid=${cookies.sid}`};
setTimeout(()=>{
sendServerRequest( `/${name}`, 'GET', 200, '', headers, 3390 ).then(( response )=>{
assert.equal( response.body.toString(), name );
assert.equal( typeof response.headers.authenticated !== 'undefined', true );
// assert.equal( response.headers.authenticated, 1 );
const headers = { cookie: `sid=wrong`};
return sendServerRequest( `/${name}`, 'GET', 200, '', headers, 3390 );
}).then(( response )=>{
// assert.equal( response.body.toString(), name );
// assert.equal( typeof response.headers.authenticated === 'undefined', true );
done();
}).catch( done );
}, 1000 );
}).catch( done );
});
}
});
app.listen( 3333, async()=>{
runAllTests();
});

5

UPDATELOG.md

@@ -0,1 +1,6 @@

1.1.0
- Fixed the stop
- Added more tests
- Fixed the getPlugin
1.0.1

@@ -2,0 +7,0 @@ - Typo fix

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc