infinispan 0.11.0 → 0.13.0

package/spec/infinispan_ssl_spec.js

@@ -1,441 +0,0 @@
-var _ = require('underscore');
-
-var util = require('util');
-
-var t = require('./utils/testing'); // Testing dependency
-
-describe('Infinispan TLS/SSL client', function() {
-
-  it('can operate on data via trusted encrypted transport',
-     testSsl('trust', t.ssl, sslTrust())
-  );
-
-  it('can operate on data via crypto store trusted encrypted transport',
-     testSsl('trust-cryptostore', t.ssl, sslTrustCryptoStore())
-  );
-
-  it('can operate on data via authenticated encrypted transport',
-     testSsl('auth', t.ssl, sslAuth())
-  );
-
-  it('can operate on data via SNI trusted encrypted transport',
-     testSsl('sni-trusted', t.ssl, sslSniTrusted())
-  );
-
-  it('can operate on data via SNI trusted encrypted transport while having multiple identities',
-      testSsl('sni-trusted', t.ssl, sslSniTrustedInCaseOfMultipleTrustedSni())
-  );
-
-  it('fails to operate if default server name (SNI) does not match default server realm',
-     testError(expectContainsError("self signed certificate in certificate chain"),
-               sslSniDefault())
-  );
-
-  it('fails to operate if server name (SNI) and trusted certificate are incorrect',
-     testError(
-       expectAnyExactErrors(
-         ['CERT_SIGNATURE_FAILURE'
-           , 'certificate signature failure'
-           , 'self signed certificate in certificate chain'
-         ])
-       , sslSniUntrusted()
-     )
-  );
-
-  it('fails to operate if no passphrase provided for crypto store',
-     testError(expectAnyExactErrors(['No passphrase defined for crypto store']),
-               sslStoreNoPassphrase())
-  );
-
-  it('fails to operate if no path provided for crypto store',
-     testError(expectAnyExactErrors(['No path defined for crypto store']),
-               sslStoreNoPath())
-  );
-
-  it('fails to operate if no encrypted transport is provided',
-      testError(expectAnyExactErrors(['self signed certificate in certificate chain']),
-                sslStoreNoCryptoStore())
-  );
-
-  // it('fails to operate if key for authenticated encrypted transport is missing',
-  //     testError(expectAnyExactErrors(['CERT_SIGNATURE_FAILURE', 'self signed certificate']),
-  //               sslAuthWithMissingKey())
-  // );
-  //
-  // it('fails to operate if passphrase for authenticated encrypted transport is missing',
-  //     testError(expectAnyExactErrors(['CERT_SIGNATURE_FAILURE', 'self signed certificate']),
-  //               sslAuthWithMissingPassphrase())
-  // );
-
-  // it('fails to operate if cert path for authenticated encrypted transport is missing',
-  //     testError(expectAnyExactErrors(['CERT_SIGNATURE_FAILURE', 'self signed certificate']),
-  //               sslAuthWithMissingCert())
-  // );
-
-  // it('fails to operate if authenticated encrypted transport is missing',
-  //     testError(expectAnyExactErrors(['CERT_SIGNATURE_FAILURE', 'self signed certificate']),
-  //               sslAuthWithMissingInfo())
-  // );
-
-  it('fails to operate if trusted certificate is missing for authenticated encrypted transport',
-      testError(expectAnyExactErrors(['self signed certificate in certificate chain']),
-                sslAuthWithMissingTrustCertificate())
-  );
-
-  function testSsl(infix, addr, sslOpts) {
-    var k = util.format('ssl-%s-key', infix);
-    var v = util.format('ssl-%s-value', infix);
-    return function(done) {
-      t.client(addr, sslOpts)
-        .then(t.assert(t.put(k, v)))
-        .then(t.assert(t.get(k), t.toBe(v)))
-        .then(t.disconnect())
-        .catch(t.failed(done))
-        .finally(done);
-    }
-  }
-
-  function sslTrust() {
-    return {
-      ssl: {
-        enabled: true,
-        secureProtocol: 'TLS_client_method',
-        trustCerts: ['out/ssl/ca/ca.pem']
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslTrustCryptoStore() {
-    return {
-      ssl: {
-        enabled: true,
-        secureProtocol: 'TLS_client_method',
-        cryptoStore: {
-          path: 'out/ssl/client/client.p12',
-          passphrase: 'secret'
-        }
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslAuth() {
-    return {
-        ssl: {
-          enabled: true,
-          trustCerts: ['out/ssl/ca/ca.pem'],
-          clientAuth: {
-            key: 'out/ssl/client/client.pk',
-            passphrase: 'secret',
-            cert: 'out/ssl/client/client.pem'
-          }
-        },
-        authentication: {
-          enabled: true,
-          saslMechanism: 'PLAIN',
-          userName: 'admin',
-          password: 'pass'
-        }
-    }
-  }
-
-  function sslSniTrusted() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-        sniHostName: 'localhost'
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslSniTrustedInCaseOfMultipleTrustedSni() {
-    return {
-        ssl: {
-          enabled: true,
-          trustCerts: ['out/ssl/ca/ca.pem'],
-          sniHostName: 'localhost'
-        },
-        authentication: {
-          enabled: true,
-          saslMechanism: 'PLAIN',
-          userName: 'admin',
-          password: 'pass'
-        }
-    }
-  }
-
-  function sslSniDefault() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/untrust-ca/untrust-ca.pem'],
-        sniHostName: 'trustfail'
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslSniDefaultWithTrustedCertificate() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslSniUntrusted() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/untrust-ca/untrust-ca.pem'],
-        sniHostName: "untrust"
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function testError(errF, sslOpts) {
-    return function(done) {
-      t.client(t.ssl, sslOpts)
-        .then(shouldFail())
-        .catch(errF(done))
-        .finally(done);
-    }
-  }
-
-  function shouldFail() {
-    return function(client) {
-      var disconnect = client.disconnect();
-      return disconnect.finally(function() {
-        throw Error('Expected operation to fail');
-      });
-    }
-  }
-
-  function expectError(msg) {
-    return function(err) {
-      expect(err.message).toBe(msg);
-    }
-  }
-
-  function expectContainsError(msg) {
-    return function(done) {
-      return function(err) {
-        toContainAnyOf([msg], err, done);
-      }
-    }
-  }
-
-  function expectAnyExactErrors(msgs) {
-    return function(done) {
-      return function(err) {
-        toBeAnyOf(msgs, err, done);
-      }
-    }
-  }
-
-  function sslStoreNoPassphrase() {
-    return {
-      ssl: {
-        enabled: true,
-        cryptoStore: {
-          path: 'out/ssl/client/client.p12'
-        }
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslStoreNoPath() {
-    return {
-      ssl: {
-        enabled: true,
-        cryptoStore: {}
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslStoreNoCryptoStore() {
-    return {
-      ssl: {
-        enabled: true
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslSniWithNoCert() {
-    return {
-      ssl: {
-        enabled: true,
-        sniHostName: "untrust"
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslAuthWithMissingKey() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-        clientAuth: {
-          passphrase: 'secret',
-          cert: 'out/ssl/client/client.pem'
-        },
-        authentication: {
-          enabled: true,
-          saslMechanism: 'PLAIN',
-          userName: 'admin',
-          password: 'pass'
-        }
-      }
-    }
-  }
-
-  function sslAuthWithMissingPassphrase() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-        clientAuth: {
-          key: 'out/ssl/client/client.pk',
-          cert: 'out/ssl/client/client.pem'
-        },
-        authentication: {
-          enabled: true,
-          saslMechanism: 'PLAIN',
-          userName: 'admin',
-          password: 'pass'
-        }
-      }
-    }
-  }
-
-  function sslAuthWithMissingCert() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-        clientAuth: {
-          key: 'out/ssl/client/client.pk',
-          passphrase: 'secret'
-        }
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslAuthWithMissingInfo() {
-    return {
-      ssl: {
-        enabled: true,
-        trustCerts: ['out/ssl/ca/ca.pem'],
-        clientAuth: {}
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function sslAuthWithMissingTrustCertificate() {
-    return {
-      ssl: {
-        enabled: true,
-        clientAuth: {
-          key: 'out/ssl/client/client.pk',
-          passphrase: 'secret',
-          cert: 'out/ssl/client/client.pem'
-        }
-      },
-      authentication: {
-        enabled: true,
-        saslMechanism: 'PLAIN',
-        userName: 'admin',
-        password: 'pass'
-      }
-    }
-  }
-
-  function toBeAnyOf(expecteds, actual, done) {
-    for (var i = 0, l = expecteds.length; i < l; i++) {
-      if (_.isEqual(actual.message, expecteds[i]))
-        return;
-    }
-    done(new Error('[' + actual.message + '] is not any of: [' + expecteds + ']'));
-  }
-
-  function toContainAnyOf(expecteds, actual, done) {
-    for (var i = 0, l = expecteds.length; i < l; i++) {
-      if (actual.message.includes(expecteds[i]))
-        return;
-    }
-    done(new Error('[' + actual.message + '] does not contain any of: [' + expecteds + ']'));
-  }
-
-});

package/spec/infinispan_stress_spec.js

@@ -1,32 +0,0 @@
-var _ = require('underscore');
-
-var t = require('./utils/testing'); // Testing dependency
-
-describe('Infinispan local client under stress load', function() {
-  var client = t.client(t.local, t.authOpts);
-
-  beforeEach(function(done) { client
-    .then(t.assert(t.clear()))
-    .catch(t.failed(done)).finally(done);
-  });
-
-  it('can do multiple puts continuously and only wait at the end', function(done) {
-    client.then(function(cl) {
-      var puts = _.map(_.range(1000), function(i) {
-        return cl.put(i + '', i + '');
-      });
-
-      return Promise.all(puts)
-        .catch(t.failed(done))
-        .finally(done);
-    })
-  });
-
-  // Since Jasmine 1.3 does not have afterAll callback, this disconnect test must be last
-  it('disconnects client', function(done) { client
-    .then(t.disconnect())
-    .catch(t.failed(done))
-    .finally(done);
-  });
-
-});

package/spec/infinispan_xsite_spec.js

@@ -1,99 +0,0 @@
-var _ = require('underscore');
-
-var t = require('./utils/testing'); // Testing dependency
-var u = require('../lib/utils');
-
-var logger = u.logger('xsite-test');
-
-describe('Infinispan xsite cluster client', function() {
-
-  // Since Jasmine 1.3 does not have beforeAll callback, execute
-  // any cleanup as first test so that it only gets executed once.
-  it('start sites', function(done) {
-      logger.debugf("Starting servers for xsite replication tests.");
-      t.launchClusterNodeAndWaitView('server-earth', t.earth1Config, t.earth1['port'], t.earth1MCastAddr, 1, t.client)
-          .then(function(client) {return t.launchClusterNodeAndWaitView('server-moon', t.moon1Config, t.moon1['port'], t.moon1MCastAddr, 1, client);})
-          .then(function () {
-            logger.debugf("Both moon and earth servers started");
-          }).catch(t.failed(done)).finally(done);
-  }, 15000);
-
-  it('can manually switch and fail over sites', function(done) {
-    siteClients().then(function(cs) {
-      expect(cs[0].getTopologyInfo().getMembers()).toEqual([t.earth1]);
-      expect(cs[1].getTopologyInfo().getMembers()).toEqual([t.moon1]);
-      return cs[0].getTopologyInfo().switchToCluster('server-moon')
-        .then(function() {
-          expect(cs[0].getTopologyInfo().getMembers()).toEqual([t.moon1]);
-          return cs[0].getTopologyInfo().switchToDefaultCluster();
-        })
-        .then(function() {
-          expect(cs[0].getTopologyInfo().getMembers()).toEqual([t.earth1]);
-          return cs[0].put('xsite-key', 'xsite-value');
-        })
-        .then(assertGet('xsite-key', 'xsite-value', cs[0]))
-        .then(assertGet('xsite-key', 'xsite-value', cs[1]))
-        .then(t.stopClusterNode(t.earth1['port'], true))
-        // Client connected to surviving site should find data
-        .then(assertGet('xsite-key', 'xsite-value', cs[1]))
-        // Client connected to crashed site should failover
-        .then(assertGet('xsite-key', 'xsite-value', cs[0]))
-        .then(function() {
-          expect(cs[0].getTopologyInfo().getMembers()).toEqual([t.moon1]);
-          expect(cs[1].getTopologyInfo().getMembers()).toEqual([t.moon1]);
-        })
-        // Re-launch site stopped site and stop alive site
-        .then(assertGet('xsite-key', 'xsite-value', cs[0]))
-        .then(function(client) { return t.launchClusterNodeAndWaitView('server-earth', t.earth1Config, t.earth1['port'], t.earth1MCastAddr, 1, client); })
-        .then(t.stopClusterNode(t.moon1['port'], true))
-        // Client connected to failed over site should come back to original site
-        .then(assertGet('xsite-key', undefined, cs[0]))
-        .then(function() {
-          expect(cs[0].getTopologyInfo().getMembers()).toEqual([t.earth1]);
-        })
-        .then(function() {
-          return cs[0].put('xsite-key-2', 'xsite-value-2');
-        })
-        .then(assertGet('xsite-key-2', 'xsite-value-2', cs[0]))
-          //Stopping the rest of the servers to finish the test
-        .then(t.stopClusterNode(t.earth1['port'], true))
-        .finally(function() {
-          return Promise.all(_.map(cs, function(c) { return c.disconnect(); }));
-        });
-    })
-    .catch(t.failed(done)).finally(done);
-  }, 15000);
-
-});
-
-function assertGet(k, expected, client) {
-  return function() {
-    return client.get(k)
-      .then(function(v) {
-        expect(v).toBe(expected);
-      })
-  }
-}
-
-function clusterSiteMoon() {
-  return {
-    cacheName: t.xsiteCacheName,
-    authentication: t.authOpts.authentication,
-    clusters: [
-      {
-        name: 'server-moon',
-        servers: [t.moon1]
-      }
-    ]
-  };
-}
-
-function siteClients() {
-  return Promise.all([
-    t.client(t.earth1, clusterSiteMoon()),
-    t.client(t.moon1, {cacheName:
-      t.xsiteCacheName,
-      authentication: t.authOpts.authentication
-    })
-  ]);
-}

package/spec/protocols_spec.js

@@ -1,82 +0,0 @@
-'use strict';
-
-var _ = require('underscore');
-var f = require('../lib/functional');
-var codec = require('../lib/codec');
-
-var t = require('./utils/testing'); // Testing dependency
-
-var singleExpiryDecode = f.actions([codec.decodeUByte(), codec.decodeVLong()], codec.allDecoded(2));
-var constantExpiryDecode = f.actions([codec.decodeUByte()], codec.allDecoded(1));
-
-function lifespan(unit) { return unit << 4 | 0x07; }
-function maxIdle(unit) { return 0x70 | unit; }
-
-function object(name) {
-  return function(value) {
-    return _.object([name], [value]);
-  }
-}
-
-describe('Protocols', function() {
-  var p = t.protocol25();
-
-  it('can encode/decode lifespan', function() {
-    encodeDecodeUnits('lifespan', lifespan);
-  });
-  it('can encode/decode max idle', function() {
-    encodeDecodeUnits('maxIdle', maxIdle);
-  });
-  it('connects with undefined HotRod Protocol', function (done) {
-    t.expectToThrow(function () {
-      t.client(t.local_notsecured, {version: '1.1'});
-    }, 'Unknown protocol version: 1.1', done);
-  });
-  it('can handle different protocols at the same time', function() {
-    var p1 = t.protocol29({
-      dataFormat : {
-        keyType: 'text/plain',
-        valueType: 'text/plain'
-      }
-    });
-    var p2 = t.protocol29({
-      dataFormat : {
-        keyType: 'application/json',
-        valueType: 'application/json'
-      }
-    });
-
-    expect(p1.clientOpts.dataFormat.keyType).toEqual('text/plain');
-    expect(p1.getKeyMediaType()).toEqual('text/plain');
-    expect(p1.getValueMediaType()).toEqual('text/plain');
-
-    expect(p2.clientOpts.dataFormat.keyType).toEqual('application/json');
-    expect(p2.getKeyMediaType()).toEqual('application/json');
-    expect(p2.getValueMediaType()).toEqual('application/json');
-  });
-
-  function encodeDecodeUnits(name, converter) {
-    var exp = object(name);
-    encodeDecodeSingleNumericExpiry(exp('777777777d'), 777777777, converter(0x06));
-    encodeDecodeSingleNumericExpiry(exp('66666666h'), 66666666, converter(0x05));
-    encodeDecodeSingleNumericExpiry(exp('5555555m'), 5555555, converter(0x04));
-    encodeDecodeSingleNumericExpiry(exp('444444s'), 444444, converter(0x00));
-    encodeDecodeSingleNumericExpiry(exp('33333ms'), 33333, converter(0x01));
-    encodeDecodeSingleNumericExpiry(exp('2222μs'), 2222, converter(0x03));
-    encodeDecodeSingleNumericExpiry(exp('111ns'), 111, converter(0x02));
-    encodeDecodeSingleConstantExpiry(exp(0), converter(0x07));
-    encodeDecodeSingleConstantExpiry(exp(-1), converter(0x08));
-  }
-
-  function encodeDecodeSingleNumericExpiry(expiry, duration, unit) {
-    var encoder = f.actions(p.encodeExpiry(expiry), codec.bytesEncoded);
-    var bytebuf = t.assertEncode(t.newByteBuf(), encoder, t.vNumSize(duration) + 1);
-    expect(singleExpiryDecode({buf: bytebuf.buf, offset: 0})).toEqual([unit, duration]);
-  }
-
-  function encodeDecodeSingleConstantExpiry(expiry, unit) {
-    var encoder = f.actions(p.encodeExpiry(expiry), codec.bytesEncoded);
-    var bytebuf = t.assertEncode(t.newByteBuf(), encoder, 1);
-    expect(constantExpiryDecode({buf: bytebuf.buf, offset: 0})).toEqual([unit]);
-  }
-});