Socket
Socket
Sign inDemoInstall

oriskami

Package Overview
Dependencies
Maintainers
1
Versions
13
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

oriskami - npm Package Compare versions

Comparing version 1.17.0 to 1.18.0

test/L.js

24

lib/index.js

@@ -18,14 +18,14 @@ /* Oriskami API client factory

resources = resources || [
{"name": "Router" , "path": "router"}
, {"name": "RouterParameter" , "path": "router_parameters"}
, {"name": "RouterData" , "path": "router_data"}
, {"name": "RouterDataGeocoding" , "path": "router_data_geocoding"}
, {"name": "RouterDataBin" , "path": "router_data_bin"}
, {"name": "RouterDataGeoip" , "path": "router_data_geoip"}
, {"name": "RouterDataBlacklist" , "path": "router_data_blacklists"}
, {"name": "RouterDataPhone" , "path": "router_data_phone"}
, {"name": "RouterDataFeature" , "path": "router_data_features"}
, {"name": "RouterFlow" , "path": "router_flows"}
, {"name": "RouterBackup" , "path": "router_backups"}
, {"name": "RouterTest" , "path": "router_tests"}
{"name": "Router" , "path": "router"}
, {"name": "RouterParameter" , "path": "router_parameters"}
, {"name": "RouterData" , "path": "router_data"}
, {"name": "RouterDataGeocoding" , "path": "router_data_geocoding"}
, {"name": "RouterDataBin" , "path": "router_data_bin"}
, {"name": "RouterDataGeoip" , "path": "router_data_geoip"}
, {"name": "RouterDataBlacklist" , "path": "router_data_blacklists"}
, {"name": "RouterDataPhone" , "path": "router_data_phone"}
, {"name": "RouterDataFeature" , "path": "router_data_features"}
, {"name": "RouterFlow" , "path": "router_flows"}
, {"name": "RouterBackup" , "path": "router_backups"}
, {"name": "RouterTest" , "path": "router_tests"}

@@ -32,0 +32,0 @@ , {"name": "Event" , "path": "events"}

63

lib/Oriskami/index.js
var Resource = require("../Resource")
, jwt = require("jsonwebtoken")
, bindingName = "Oriskami/v1 NodeBindings/"

@@ -17,3 +18,2 @@ , httpTimeout = 120000

, "resources" : resources
, "api_host" : "api.oriskami.com"
, "revokedCerts" : ""

@@ -30,5 +30,5 @@ , "headers" : {

}
this._api.request.host = this._api.api_host
this.set("auth", token)
this.set("host", "api.oriskami.com")
}

@@ -48,4 +48,8 @@

Oriskami.prototype.set = function(key, value){
if(key === "timeout") value = value || httpTimeout
this._api[key] = value
if(key === "host") {
this._api.request.host = value
} else {
value = key === "timeout" ? value || httpTimeout : value
this._api[key] = value
}
}

@@ -61,2 +65,53 @@

/*
* Webhook validation middleware
* @params [Object] Parameters determining how the validator behaves
* + validate [Boolean] Whether the webhook should be validated
*/
Oriskami.prototype.webhook = function(params){
var shouldValidate= params && params.validate
, publicKey = this._api.public_key
if(!publicKey){
console.log("Public key missing—tip: call oriskami.getPublicKey(next)")
return new Error("err_missing_public_key")
}
return function(req, res, next) {
var token = req.body ? req.body.token : null
if(!token) return res.status(400).send({"success": "false", "err": "err_missing_token"})
jwt.verify(token, publicKey, function(err, json){
if(err) next(err)
req.json = json
next()
})
}
}
/*
* Retrieve Oriskami's public key
* @next [Function] Callback
*/
Oriskami.prototype.getPublicKey = function(next){
var self = this
, https = require("https")
, opts = {"path": "/public-key", "method": "GET"}
opts.headers = oriskami.get("headers")
var req = https.request(opts, function(res){
var publicKey = ""
res.setEncoding("utf8")
res.on("data", function(chunk){ publicKey += chunk })
res.on("end" , function(){
self._api.public_key = publicKey
next(null, true)
})
})
req.on("error", function(err){ next(err) })
req.end()
}
module.exports = Oriskami

6

lib/Resource/request/index.js

@@ -26,5 +26,5 @@ /*

req.on("response" , self.response( req, next))
req.on("socket" , self.socket(content, req, next))
req.on("error" , self.error( req, next))
req.on("response", self.response( req, next))
req.on("socket" , self.socket(content, req, next))
req.on("error" , self.error( req, next))
}

50

lib/Resource/response/index.js

@@ -11,35 +11,26 @@ /*

return function(res) {
var json = ""
var body = ""
res.setEncoding("utf8")
res.on("data", function(chunk) {
json += chunk
})
res.on("end", function() {
var err = null
res.on("data", function(chunk) { body += chunk })
res.on("end" , function() {
var err, json = {"success": "false", "data": null, "err": "err_internal"}, code = parseInt(res.statusCode)
if(code === 500) err = new Error.OriskamiInternalServerError(json)
else if(code === 502) err = new Error.OriskamiBadGatewayError(json)
else if(code > 500) err = new Error.OriskamiAPIError(json)
try { // to parse the json
json = JSON.parse(json)
var code = parseInt(res.statusCode)
, isOk = code >= 200 && code <= 204
if(code === 401){ err = new Error.OriskamiUnauthorizedError(json)
} else if(code === 402){ err = new Error.OriskamiPaymentRequiredError(json)
} else if(code === 405){ err = new Error.OriskamiMethodNotAllowedError(json)
} else if(code === 429){ err = new Error.OriskamiTooManyRequestsError(json)
} else if(code === 500){ err = new Error.OriskamiInternalServerError(json)
} else if(code === 502){ err = new Error.OriskamiBadGatewayError(json)
} else if(code > 500){ err = new Error.OriskamiAPIError(json)
} else if(!isOk ){ err = new Error.OriskamiError.generate(json)
}
json = JSON.parse(body)
if(code === 401 ) err = new Error.OriskamiUnauthorizedError(json)
if(code === 402 ) err = new Error.OriskamiPaymentRequiredError(json)
if(code === 405 ) err = new Error.OriskamiMethodNotAllowedError(json)
if(code === 429 ) err = new Error.OriskamiTooManyRequestsError(json)
if(code < 200 ) err = new Error.OriskamiError.generate(json)
if(code >= 300 && code < 400) err = new Error.OriskamiError.generate(json)
} catch (e) { // failed to parse the json
err = new Error.OriskamiAPIError({
"message" : "Invalid JSON received from the Oriskami API"
, "json" : json
, "exception" : e
})
json.err= e.message
err = new Error.OriskamiAPIError(json)
}
json.status_code = code
next(err, json)

@@ -49,8 +40,3 @@ })

res.on("error", function(err){
err = new Error.OriskamiAPIError({
"message" : "Error processing the response from Oriskami."
, "json" : json
, "exception" : err
})
err = new Error.OriskamiAPIError({"success": "false", "data": null, "err": err.message})
next(err, json)

@@ -57,0 +43,0 @@ })

8

package.json
{
"name": "oriskami",
"version": "1.17.0",
"version": "1.18.0",
"description": "API wrapper to Oriskami",

@@ -26,7 +26,9 @@ "main": "lib/index.js",

"mocha": "^2.1.0",
"lodash": "^3.3.1"
"lodash": "^3.3.1",
"async": "^2.6.1"
},
"dependencies": {
"all": "0.0.0"
"all": "0.0.0",
"jsonwebtoken": "^8.3.0"
}
}

2

README.md

@@ -35,3 +35,3 @@ # Oriskami node.js bindings

```js
oriskami.EventsPast.create({
oriskami.EventPast.create({
"parameters" :{

@@ -38,0 +38,0 @@ "id": 16646

6

test/oriskami.js

@@ -5,8 +5,2 @@ var fs = require("fs")

// _________________________________________________________________________
// 2018-06-05: routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failure
// https://github.com/nodejs/node/issues/16196
require("tls").DEFAULT_ECDH_CURVE = "auto"
// _________________________________________________________________________
module.exports = require("../lib")(process.env["ORISKAMI_TEST_TOKEN_NODEJS_1"], apiVersion)

240

test/Resources/Event/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, L = require("../../L")
, oriskami = require("../../oriskami")

@@ -7,21 +9,10 @@ , examples = require("../../data/Event")

, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["create", "retrieve", "update", "del", "list"]
, resourceName = "Event"
describe("Event", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["Event"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["Event"]["oriskami"]).to.exist
})
it("Should have CRUD(L) methods", function() {
_.each(methods, function(method){
expect(oriskami["Event"][method]).to.exist
})
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
it("Should have CRUD(L) methods" , function() { _.each(methods, function(method){ expect(oriskami[resourceName][method]).to.exist }) })
})

@@ -32,179 +23,108 @@

var defaultId = 0
oriskami["RouterData"].update(defaultId, {"is_active": "true"}, function(err, res){
if(err){ console.log(err, res) ; done(new Error("Did not update")) }
done()
})
oriskami["RouterData"].update(defaultId, {"is_active": "true"}, L.logError(done))
})
var json = jsons[0]
, idResource
it("Should create and return a resource", function(done){
oriskami["Event"].create(json, function(err, res){
if(err){
console.log(err, res)
done(err)
} else if(!!res.data && !!res.data[0] && !!res.data[0].id){
idResource = res.data[0].id
done()
} else {
console.log(err, res)
done(new Error("Did not return an id"))
}
})
})
it("Should create, retrieve, and delete resource", function(done){
var idResource
async.waterfall([
function( next){ oriskami[resourceName].create(json, next) }
, function(res, next){
var isOk = !!res.data && !!res.data[0]
idResource = isOk && ("" + res.data[0].id)
isOk ? next(null, res) : next(new Error("err_creating_resource"))
},function(res, next){ oriskami[resourceName].retrieve(idResource, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length === 1 && (""+res.data[0].id) === idResource
isOk ? next(null, true) : next(new Error("err_retrieving_resource"))
}, function(res, next){ oriskami[resourceName].del(idResource, next)}
], L.logError(done))
}).timeout(20000)
it("Should retrieve via its id the created resource", function(done){
oriskami["Event"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(err){
console.log(err, res)
done(err)
} else if(res.data.length === 1 && res.data[0].id === idResource){
done()
} else {
console.log("Expected ", idResource, " Returned ", res.data[0].id)
done((new Error("Did not return the resource with id = "+idResource)))
}
})
})
it("Should update the created resource", function(done){
var newEmail = "abc@gmail.com"
oriskami["Event"].update(idResource, {
"id" : jsons[1].id
, "parameters": {"email": newEmail}
}, function(err, res){
if(err){
console.log(err, res)
done(err)
} else if(res.data.length === 1){
if(res.data[0].parameters.email !== newEmail){
done(new Error("Updated resource is not equal to submitted resource"))
console.log(err, sentData, newData)
}
done()
} else if(res.data.length !== 1){
console.log("Data:", res.data)
done(new Error("Data length !== 1 when updating"))
}
})
, idResource= jsons[1].id
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, { "id": idResource, "parameters": {"email": newEmail}},next) }
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].parameters.email === newEmail
isOk ? next(null, true) : next(new Error("err_resource_is_different"))
}], L.logError(done))
})
it("Should delete the created resource", function(done){
oriskami["Event"].del(idResource, function(err, res){
if(!err && res.data.length === 1){
oriskami["Event"].retrieve(idResource, function(err, res){
if(err || res.data.length > 0){
console.log(err, res)
done((new Error("Should have deleted resource id = "+idResource)))
}
done()
})
} else {
console.log(err, res)
done((new Error("Did not return the deleted resource with id = "+idResource)))
}
})
})
})
describe("Pagination", function(){
oriskami.set("timeout", 20000)
before(function(done){
oriskami["Event"].create(jsons[0], function(err, res){
if(err) return done(err)
oriskami["Event"].create(jsons[1], function(err, res){
if(err) return done(err)
oriskami["Event"].create(jsons[2], function(err, res){
done(err)
})
})
})
async.waterfall([
function( next){ oriskami[resourceName].create(jsons[0], next)}
, function(res, next){ oriskami[resourceName].create(jsons[1], next)}
, function(res, next){ oriskami[resourceName].create(jsons[2], next)}
], done)
})
it("Should limit retrieved resources to N=1", function(done){
var nLimit = 1
oriskami["Event"].list({"limit": nLimit}, function(err, res){
if(err) {
console.log(err, res)
done(err)
} else if(res.data.length === nLimit) {
done()
} else {
console.log(res)
done(new Error("Should 'limit' list to N="+nLimit+" resources"))
}
})
it("Should limit retrieved resources to N=1 and N=2", function(done){
async.waterfall([
function( next){ oriskami[resourceName].list({"limit": 1}, next) }
, function(res, next){
var isOk = res.data.length === 1
isOk ? next(null, true): next(new Error("err_limit_list_1"))
},function(res, next){ oriskami[resourceName].list({"limit": 2}, next) }
, function(res, next){
var isOk = res.data.length === 2
isOk ? next(null, true): next(new Error("err_limit_list_2"))
}], L.logError(done))
})
it("Should limit retrieved resources to N=2", function(done){
var nLimit = 2
oriskami["Event"].list({limit:nLimit}, function(err, res){
if(err) {
console.log(err)
done(err)
} else if(res.data.length === nLimit) {
done()
} else {
console.log(res)
done(new Error("Should 'limit' list to N="+nLimit+" resources"))
}
})
})
it("Should list ids greater than (gt) a given id", function(done){
var nLimit = 2
, object = {"id":{"gt":ids[0]}, "limit":nLimit}
oriskami["Event"].list(object, function(err, res){
if(err) return done(err)
if(res.data.length !== nLimit) return done(new Error("Should return N="+nLimit))
async.waterfall([
function(next){ oriskami[resourceName].list(object, next) }
, function(res, next){
if(res.data.length !== nLimit) next(new Error("err_invalid_number_of_returned_results"))
var returnedIds = _.pluck(res.data, "id")
if(_.contains(returnedIds, ids[1]) && _.contains(returnedIds, ids[2])){
return done()
}
return done(new Error("Should contain the right ids"))
})
, isOk = _.contains(returnedIds, ids[1]) && _.contains(returnedIds, ids[2])
isOk ? next(null, true) : next(new Error("err_invalid_returned_ids"))
}], L.logError(done))
})
it("Should list and order DESC the ids that are less than (lt) an id", function(done){
var nLimit = 2
oriskami["Event"].list({"id":{"lt":ids[2]}, "order":"-id", "limit":nLimit}, function(err, res){
if(err) return done(err)
if(res.data.length !== nLimit) return done(new Error("Should return N="+nLimit))
var nLimit = 2
, object = {"id":{"lt":ids[2]}, "order":"-id", "limit":nLimit}
async.waterfall([
function(next){ oriskami[resourceName].list(object, next) }
, function(res, next){
if(res.data.length !== nLimit) next(new Error("err_invalid_number_of_returned_results"))
var returnedIds = _.pluck(res.data, "id")
if(_.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && !_.contains(returnedIds,ids[2])){
return done()
}
return done(new Error("Should contain the right ids"))
})
, isOk = _.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && !_.contains(returnedIds,ids[2])
isOk ? next(null, true) : next(new Error("err_invalid_returned_ids"))
}], L.logError(done))
})
it("Should list ids greater than or equal (gte) to a given id", function(done){
var nLimit = 3
oriskami["Event"].list({"id":{"gte":ids[0]}, "limit":nLimit}, function(err, res){
if(err) return done(err)
if(res.data.length !== nLimit) return done(new Error("Should return N="+nLimit))
var nLimit = 3
, object = {"id":{"gte":ids[0]}, "limit":nLimit}
async.waterfall([
function( next){ oriskami[resourceName].list(object, next) }
, function(res, next){
if(res.data.length !== nLimit) next(new Error("err_invalid_number_of_returned_results"))
var returnedIds = _.pluck(res.data, "id")
if(_.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && _.contains(returnedIds, ids[2])){
return done()
}
return done(new Error("Should contain the right ids"))
})
, isOk = _.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && _.contains(returnedIds,ids[2])
isOk ? next(null, true) : next(new Error("err_invalid_returned_ids"))
}], L.logError(done))
})
it("Should list and order DESC the ids that are less than or equal (lte) an id", function(done){
var nLimit = 3
oriskami["Event"].list({"id":{"lte":ids[2]}, "order":"-id", "limit":nLimit}, function(err, res){
if(err) return done(err)
if(res.data.length !== nLimit) return done(new Error("Should return N="+nLimit))
var nLimit = 3
, object = {"id":{"lte":ids[2]}, "order":"-id", "limit":nLimit}
async.waterfall([
function(next){ oriskami[resourceName].list(object, next) }
, function(res, next){
if(res.data.length !== nLimit) next(new Error("err_invalid_number_of_returned_results"))
var returnedIds = _.pluck(res.data, "id")
if(_.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && _.contains(returnedIds,ids[2])){
return done()
}
return done(new Error("Should contain the right ids"))
})
, isOk = _.contains(returnedIds, ids[0]) && _.contains(returnedIds, ids[1]) && _.contains(returnedIds,ids[2])
isOk ? next(null, true) : next(new Error("err_invalid_returned_ids"))
}], L.logError(done))
})
})
})

105

test/Resources/EventLabel/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "EventLabel"
describe("EventLabel", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventLabel"]["path"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventLabel"]["oriskami"]).to.exist
})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["EventLabel"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
if(!hasMethod) done(new Error("err_missing_method_" + method ))
else done()
})

@@ -37,62 +30,46 @@ })

it("Should retrieve", function(done){
oriskami["EventLabel"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(!err && res.data.length >= 0){
done()
} else {
console.log(err, res)
done((new Error("Did not retrieve")))
}
})
async.waterfall([
function(next){ oriskami[resourceName].retrieve(idResource, next)}
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length
isOk ? next(null, true) : next(new Error("err_retrieving"))
}], L.logError(done))
})
it("Should update to 'false'", function(done){
oriskami["EventLabel"].update(idResource
, {"id": idResource, "label": "is_loss", "value": "false"}
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].labels.is_loss === "false"){
done()
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"id": idResource, "label": "is_loss", "value": "false"}, next)}
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].labels.is_loss === "false"
isOk ? next(null, true) : next(new Error("err_updating"))
}], L.logError(done))
})
it("Should update to 'true'", function(done){
oriskami["EventLabel"].update(idResource
, {"id": idResource, "label": "is_loss", "value": "true"}
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].labels.is_loss === "true"){
done()
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"id": idResource, "label": "is_loss", "value": "true"}, next) }
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].labels.is_loss === "true"
isOk ? next(null, true) : next(new Error("err_updating"))
}], L.logError(done))
})
it("Should delete", function(done){
oriskami["EventLabel"].del(idResource
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].labels.is_loss === undefined){
done()
} else {
console.log(err, res)
done((new Error("Did not delete")))
}
})
async.waterfall([
function( next){ oriskami[resourceName].del(idResource, next) }
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].labels.is_loss === undefined
isOk ? next(null, true) : next(new Error("err_deleting"))
}], L.logError(done))
})
it("Should list", function(done){
oriskami["EventLabel"].list(function(err, res){
if(!err && res.data.length === 3 && _.contains(_.keys(res.data[0]), "labels")) {
done()
} else {
console.log(res)
done(new Error("Should have only one returned element"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].list(next) }
, function(res, next){
var isOk = res.data.length === 3 && _.contains(_.keys(res.data[0]), "labels")
isOk ? next(null, true) : next(new Error("err_listing"))
}], L.logError(done))
})
})
})

52

test/Resources/EventLastId/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["list"]
, resourceName = "EventLastId"
describe("EventLastId", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventLastId"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventLastId"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function(){ expect(oriskami[resourceName]["path"] ).to.exist })
it("Should link to parent (oriskami)" , function(){ expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["EventLastId"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
if(!hasMethod) done(new Error("err_missing_method_"+ method))
else done()
})

@@ -34,19 +24,11 @@ })

describe("Methods", function(){
var json = jsons[0]
, idResource
it("Should list the last id", function(done){
oriskami["EventLastId"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else if(res.data.length === 1 && res.data[0].id === "3") {
done()
} else {
console.log(res)
done(new Error("Should have only one returned element"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].list(next) }
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].id === "3"
isOk ? next(null, true) : next(new Error("err_invalid_number_of_rows"))
}], L.logError(done))
})
})
})

57

test/Resources/EventNotification/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "list"]
, resourceName = "EventNotification"
describe("EventNotification", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventNotification"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventNotification"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function(){ expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function(){ expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["EventNotification"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new Error("err_missing_method_" + method))
})

@@ -37,24 +27,19 @@ })

it("Should retrieve", function(done){
oriskami["EventNotification"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(!err && res.data.length >= 0){
done()
} else {
console.log(err, res)
done((new Error("Did not retrieve")))
}
})
async.waterfall([
function( next){ oriskami[resourceName].retrieve(idResource, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length >= 0
isOk ? next(null, true) : next(new Error("err_retrieving"))
}], L.logError(done))
})
it("Should list", function(done){
oriskami["EventNotification"].list(function(err, res){
if(!err && res.data.length === 3 && _.contains(_.keys(res.data[0]), "notifications")) {
done()
} else {
console.log(res)
done(new Error("Should have only one returned element"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].list(next)}
, function(res, next){
var isOk = res.data.length === 3 && _.contains(_.keys(res.data[0]), "notifications")
isOk ? next(null, true) : next(new Error("err_list"))
}], L.logError(done))
})
})
})

113

test/Resources/EventPast/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, methods = ["create"]
, methods = ["create", "retrieve", "update", "del", "list"]
, resourceName = "EventPast"
describe("EventPast", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventPast"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventPast"]["oriskami"]).to.exist
})
it("Should have CRUD(L) methods", function() {
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
it("Should have CRUD(L) methods" , function() {
_.each(methods, function(method){
expect(oriskami["EventPast"][method]).to.exist
})
expect(oriskami[resourceName][method]).to.exist
})
})

@@ -28,73 +24,26 @@ })

var json = jsons[0]
, newEmail = "abc@gmail.com"
, idResource
it("Should create and return a single resource", function(done){
oriskami["EventPast"].create(json, function(err, res){
if(err){
console.log(err, res)
done(err)
} else if(!!res.data && !!res.data[0] && !!res.data[0].id){
idResource = res.data[0].id
done()
} else {
console.log(res)
done(new Error("Did not return an id"))
}
})
it("Should create, retrieve, update, and delete a resource", function(done){
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){
var isOk = !!res.data && !!res.data[0] && !!res.data[0].id
idResource = res.data[0].id
isOk ? oriskami[resourceName].retrieve(idResource, next) : next(new Error("err_creating"))
}, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length === 1 && res.data[0].id === idResource
isOk ? next(null, true) : next(new Error("err_retrieving"))
}, function(res, next){ oriskami[resourceName].update(idResource, {"id": jsons[1].id, "parameters": {"email": newEmail}}, next)}
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].parameters.email === newEmail
isOk ? next(null, true) : next(new Error("err_updating"))
},function(res, next){ oriskami[resourceName].del(idResource, next)}
, function(res, next){ oriskami[resourceName].retrieve(idResource, next)}
, function(res, next){
var isOk = res.data.length === 0
isOk ? next(null, true) : next(new Error("err_retrieving"))
}], L.logError(done))
})
it("Should retrieve via its id the created resource", function(done){
oriskami["EventPast"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(err){
console.log(err, res)
done(err)
} else if(res.data.length === 1 && res.data[0].id === idResource){
done()
} else {
console.log("Expected ", idResource, " Returned ", res.data[0].id)
done((new Error("Did not return the resource with id = "+idResource)))
}
})
})
it("Should update the created resource", function(done){
var newEmail = "abc@gmail.com"
oriskami["EventPast"].update(idResource, {
"id" : jsons[1].id
, "parameters": {"email": newEmail}
}, function(err, res){
if(err){
console.log(err, res)
done(err)
} else if(res.data.length === 1){
if(res.data[0].parameters.email !== newEmail){
done(new Error("Updated resource is not equal to submitted resource"))
console.log(err, sentData, newData)
}
done()
} else if(res.data.length !== 1){
console.log("Data:", res.data)
done(new Error("Data length !== 1 when updating"))
}
})
})
it("Should delete the created resource", function(done){
oriskami["EventPast"].del(idResource, function(err, res){
if(!err && res.data.length === 1){
oriskami["EventPast"].retrieve(idResource, function(err, res){
if(err || res.data.length > 0){
console.log(err, res)
done((new Error("Should have deleted resource id = "+idResource)))
}
done()
})
} else {
console.log(err, res)
done((new Error("Did not return the deleted resource with id = "+idResource)))
}
})
})
})
})

141

test/Resources/EventQueue/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "EventQueue"
describe("EventQueue", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventQueue"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventQueue"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["EventQueue"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new Error("err_missing_method_" + method))
})

@@ -37,91 +27,52 @@ })

before(function(done){
oriskami["Event"].create(jsons[0], function(err, res){
if(err) return done(err)
oriskami["Event"].create(jsons[1], function(err, res){
if(err) return done(err)
oriskami["Event"].create(jsons[2], function(err, res){
done(err)
})
})
})
async.waterfall([
function( next){ oriskami["Event"].create(jsons[0], next)}
, function(res, next){ oriskami["Event"].create(jsons[1], next)}
, function(res, next){ oriskami["Event"].create(jsons[2], next)}
], done)
})
it("Should retrieve", function(done){
oriskami["EventQueue"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(!err && res.data.length >= 0){
done()
} else {
console.log(err, res)
done((new Error("Did not retrieve")))
}
})
async.waterfall([
function( next){ oriskami[resourceName].retrieve(idResource, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length >= 0
isOk ? next(null, true) : next(new Error("err_retrieving"))
}], L.logError(done))
})
it("Should update to 'false'", function(done){
oriskami["EventQueue"].update(idResource
, {"id": idResource, "active": "rules_custom"}
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].queues.active === "rules_custom"){
done()
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
it("Should update", function(done){
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"id": idResource, "active": "rules_custom"}, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length == 1 && res.data[0].queues.active === "rules_custom"
isOk ? next(null, true) : next(new Error("err_updating"))
},function(res, next){ oriskami[resourceName].update(idResource, {"id": idResource, "active": "rules_base"}, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length == 1 && res.data[0].queues.active === "rules_base"
isOk ? next(null, true) : next(new Error("err_updating"))
}], L.logError(done))
})
it("Should update to 'true'", function(done){
oriskami["EventQueue"].update(idResource
, {"id": idResource, "active": "rules_base"}
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].queues.active === "rules_base"){
done()
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami["EventQueue"].del(idResource
, function(err, res){
if(!err && res.data.length === 1 && res.data[0].queues.active === undefined){
done()
} else {
console.log(err, res)
done((new Error("Did not delete")))
}
})
async.waterfall([
function( next){ oriskami[resourceName].del(idResource, next) }
, function(res, next){
var isOk = res.data.length === 1 && res.data[0].queues.active === undefined
isOk ? next(null, true) : next(new Error("err_deleting"))
}], L.logError(done))
})
it("Should create one and list", function(done){
oriskami["EventQueue"].update(idResource
, {"id": idResource, "active": "rules_base"}
, function(err, res){
if(err) {
console.log(err, res)
done(new Error("Did not update"))
}
oriskami["EventQueue"].list(function(err, res){
if(err){
console.log(err, res)
done(new Error("Should have no error"))
} else if(res.data.length !== 1){
console.log(res)
done(new Error("Should return only one element for this dataset"))
} else if(!_.contains(_.keys(res.data[0]), "queue")){
console.log(res)
done(new Error("Should have an attribute named 'queue' in 'data'"))
} else if(!_.contains(_.keys(res), "summary")){
console.log(res)
done(new Error("Should have an attribute named 'summary'"))
} else {
done()
}
})
})
it("Should create one, list, and have the {queue, summary, active} attributes", function(done){
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"id": idResource, "active": "rules_base"}, next) }
, function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
if(res.data.length !== 1) return next(new Error("err_list_more_than_one_returned_row"))
if(!res.data[0].queue ) return next(new Error("err_no_queue_attribute"))
if(!res.summary ) return next(new Error("err_no_summary"))
next(null, true)
}], L.logError(done))
})
})
})

182

test/Resources/EventReview/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "EventReview"
describe("EventReview", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["EventReview"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["EventReview"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["EventReview"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new Error("err_missing_method_" + method))
})

@@ -37,11 +27,8 @@ })

it("Should retrieve", function(done){
oriskami["EventReview"].retrieve(idResource, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(!err && res.data.length >= 0){
done()
} else {
console.log(err, res)
done((new Error("Did not retrieve")))
}
})
async.waterfall([
function( next){ oriskami[resourceName].retrieve(idResource, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length >= 0
isOk ? next(null, true) : next(new Error("err_retrieving"))
}], L.logError(done))
})

@@ -51,23 +38,12 @@

var now = (new Date()).toISOString().slice(0,16)
oriskami["EventReview"].update(idResource
, {"message": now, "reviewer_id": "123"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not create (err)"))
} else if(res.data.length <= 0){
console.log(res)
done(new Error("Did not create (empty result)"))
} else {
var reviews = res.data.reverse()
if(reviews[0].message !== now){
console.log(res.data)
console.log(reviews[0].message)
console.log(now)
done(new Error("Did not create (now !=)"))
} else {
done()
}
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"message": now, "reviewer_id": "123"}, next) }
, function(res, next){
var isOk = res.status_code >= 200 && res.status_code <= 204 && res.data.length >= 0
isOk ? next(null, res) : next(new Error("err_creating"))
},function(res, next){
var reviews = res.data.reverse()
, isOk = reviews[0].message == now
isOk ? next(null, true) : next(new Error("err_creating_invalid_values"))
}], L.logError(done))
})

@@ -77,58 +53,25 @@

var reviewId = 0
, reviewerId= "124"
oriskami["EventReview"].update(idResource
, {"review_id": reviewId, "reviewer_id": reviewerId}
, function(err, res){
var reviews = res.data
if(err){
console.log(err)
done(new Error("Error updating"))
} else if(reviews[reviewId].reviewer.id === reviewerId){
done()
} else {
console.log(reviews)
console.log(reviews[reviewId])
console.log("reviewer_id", reviewerId)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"review_id": reviewId, "reviewer_id": "124"}, next) }
, function(res, next){
var isOk = res.data[reviewId].reviewer.id === "124"
isOk ? next(null, true) : next(new Error("err_updating_1"))
}, function(res, next){ oriskami[resourceName].update(idResource, {"review_id": reviewId, "reviewer_id": "123"}, next)}
, function(res, next){
var isOk = res.data[reviewId].reviewer.id === "123"
isOk ? next(null, true) : next(new Error("err_updating_2"))
}], L.logError(done))
})
it("Should update", function(done){
var reviewId = 0
, reviewerId= "123"
oriskami["EventReview"].update(idResource
, {"review_id": reviewId, "reviewer_id": reviewerId}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not create"))
}
var review = res.data[reviewId]
if(review.reviewer.id === reviewerId){
done()
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami["EventReview"].retrieve(idResource, function(err, res){
var nReviews = res.data.length
oriskami["EventReview"].del(idResource
, {"review_id": 0}
, function(err, res){
if(err){
console.log(err, res)
return done(new Error("Did not delete"))
} else if(res.data.length === nReviews - 1){
return done()
} else {
console.log(res.data.length, nReviews)
done(new Error("Did not delete"))
}
})
})
var nReviews
async.waterfall([
function( next){ oriskami[resourceName].retrieve(idResource, next) }
, function(res, next){
nReviews = res.data.length
oriskami[resourceName].del(idResource, {"review_id": 0}, next)
}, function(res, next){
var isOk = res.data.length === nReviews - 1
isOk ? next(null, true) : next(new Error("err_deleting"))
}], L.logError(done))
})

@@ -139,27 +82,18 @@

, reviewerId= "124"
oriskami.set("timeout", 20000)
oriskami["EventReview"].update(idResource
, {"review_id": reviewId, "reviewer_id": reviewerId}
, function(err, res){
if(err){
console.log(res)
return done(new Error("Should have only one returned element"))
}
oriskami["EventReview"].list(function(err, res){
if(!err && res.data.length > 0 && _.contains(_.keys(res.data[0]), "message")) {
// cleanup
_.each(res.data, function(eventReview){
if(eventReview.id === idResource){
var nReviews = res.data.length
oriskami["EventReview"].del(idResource, {"review_id": nReviews - 1}, done)
}
})
} else {
console.log(res)
done(new Error("Should have only one returned element"))
async.waterfall([
function( next){ oriskami[resourceName].update(idResource, {"review_id": reviewId, "reviewer_id": reviewerId}, next) }
, function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
var isOk = res.data.length > 0 && _.contains(_.keys(res.data[0]), "message")
isOk ? next(null, res) : next(new Error("err_listing"))
}, function(res, next){
async.map(res.data, function(eventReview){
if(eventReview.id === idResource){
var nReviews = res.data.length
oriskami[resourceName].del(idResource, {"review_id": nReviews - 1}, next)
}
})
})
}, next)
}], L.logError(done))
})
})
})

71

test/Resources/Filter/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["update"]
, resourceName = "Filter"
describe("Filter", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["Filter"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["Filter"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["Filter"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -27,41 +21,16 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["Filter"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done))})
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["Filter"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data[ruleId]
if(rule.is_active === "true"){
// roll back
oriskami["Filter"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.is_active === "true"
isOk ? next(null, true) : next(new Error("err_updating_1"))
}, function(res, next){ oriskami[resourceName].update(ruleId, {"is_active": "false"} , next)
}], L.logError(done))
}).timeout(20000)
})
})

58

test/Resources/FilterBlacklist/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "FilterBlacklist"
describe("FilterBlacklist", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterBlacklist"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterBlacklist"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterBlacklist"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -33,26 +23,14 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["FilterBlacklist"].list(done)
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
var blacklistId = "0"
oriskami["FilterBlacklist"].update(blacklistId
, {"is_active": "true"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
var blacklist = res.data[blacklistId]
if(blacklist.is_active === "true"){
// roll back
oriskami["FilterBlacklist"].update(blacklistId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(blacklistId, {"is_active": "true"}, next) }
, function(res, next){
var isOk = res.data[blacklistId] && res.data[blacklistId].is_active === "true"
isOk ? next(null, true) : next(new Error("err_updating_1"))
}, function(res, next){ oriskami[resourceName].update(blacklistId, {"is_active": "false"}, next) }
], L.logError(done))
})
})
})

59

test/Resources/FilterRulesAI/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "FilterRulesAI"
describe("FilterRulesAI", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterRulesAI"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterRulesAI"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)", function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterRulesAI"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -33,27 +23,14 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["FilterRulesAI"].list(done)
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
var ruleId = "0"
oriskami["FilterRulesAI"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data[ruleId]
if(rule.is_active === "true"){
// roll back
oriskami["FilterRulesAI"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId , {"is_active": "true"}, next) }
, function(res, next){
var isOk = res.data[ruleId] && res.data[ruleId].is_active == "true"
isOk ? next(null, true) : next(new Error("err_updating_1"))
}, function(res, next){ oriskami[resourceName].update(ruleId , {"is_active": "false"}, next) }
], L.logError(done))
})
})
})

58

test/Resources/FilterRulesBase/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, L = require("../../L")
, methods = ["retrieve", "update", "list"]
, resourceName = "FilterRulesBase"
describe("FilterRulesBase", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterRulesBase"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterRulesBase"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterRulesBase"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method])? done() : done(new error("err_missing_" + method))
})

@@ -32,28 +21,15 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["FilterRulesBase"].list(done)
})
it("Should list" , function(done){oriskami[resourceName].list(done) })
it("Should update", function(done){
var ruleId = "0"
oriskami["FilterRulesBase"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var rule = res.data[ruleId]
if(rule.is_active === "true"){
// roll back
oriskami["FilterRulesBase"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
rule && rule.is_active == "true" ? next(null, ruleId) : next(new Error("err_updating_1"))
}, function(res, next){ oriskami[resourceName].update(ruleId, {"is_active": "false"}, next)}
], L.logError(done))
})
})
})

97

test/Resources/FilterRulesCustom/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, L = require("../../L")
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "FilterRulesCustom"
, json = {

@@ -17,19 +16,9 @@ "value" : "New Value"

describe("FilterRulesCustom", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterRulesCustom"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterRulesCustom"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterRulesCustom"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new error("err_missing_notifier_email_method_" + method))
})

@@ -41,15 +30,9 @@ })

it("Should create", function(done){
oriskami["FilterRulesCustom"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){
var rule = res.data.reverse()[0]
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
isEqual ? next(null, true) : next(new Error("err_creating_filter_rules_custom"))
}], L.logError(done))
})

@@ -59,33 +42,25 @@

var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["FilterRulesCustom"].update(ruleId
, {"value": "yahoo.com"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"value": "yahoo.com"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.value === "yahoo.com"
isOk ? oriskami[resourceName].update(ruleId, {"value": "gmail.com"}, next) : next(new Error("err_invalid_notifier_email_value"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.value === "yahoo.com"){
// roll back
oriskami["FilterRulesCustom"].update(ruleId
, {"value": "gmail.com"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
it("Should create, list, and delete", function(done){
var nRules0
async.waterfall([
function( next){ oriskami[resourceName].create(json, next) }
, function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
nRules0 = res.data.length
oriskami[resourceName].del(nRules0 - 1, next)
}, function(res, next){
var isOk = res.data.length === nRules0 - 1
isOk ? next(null, isOk) : next(new Error("err_filter_rules_custom"))
}], L.logError(done))
})
it("Should delete", function(done){
oriskami.set("timeout", 20000)
oriskami["FilterRulesCustom"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var ruleId = res.data.length - 1
oriskami["FilterRulesCustom"].del(ruleId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
})
})
})

111

test/Resources/FilterScoringsDedicated/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, methods = ["create", "retrieve", "update", "del", "list"]
, resourceName = "FilterScoringsDedicated"
describe("FilterScoringsDedicated", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterScoringsDedicated"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterScoringsDedicated"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterScoringsDedicated"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_filter_scorings_dedicated_method_" + method))
})

@@ -28,72 +22,37 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["FilterScoringsDedicated"].list(function(err, res){
if(err){
console.log(err)
return done(new Error("Failed to list filter scorings dedicated"))
}
done()
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should create", function(done){
oriskami["FilterScoringsDedicated"].create({
oriskami[resourceName].create({
"query_target" : "sample:100"
, "query_base" : "fr"
, "features" : "all"
}, function(err, res) {
if(err) {
console.log(err)
return done(new Error("Failed to create scoring"))
}
done()
})
}, L.logError(done))
})
it("Should retrieve", function(done){
oriskami["FilterScoringsDedicated"].create({
"query_target" : "sample:100"
, "query_base" : "fr"
, "features" : "all"
}, function(err, res0) {
if(err){
console.log(err)
return done(new Error("Failed to create / retrieve score"))
}
var expectedScoreId = res0.model_id
oriskami["FilterScoringsDedicated"].retrieve(res0.model_id, function(err, res1) {
if(err){
console.log(err)
console.log("Expected score id", expectedScoreId)
return done(new Error("Failed to retrieve the created score"))
}
done()
})
})
it("Should create and retrieve", function(done){
var expectedScoreId
async.waterfall([
function(next){ oriskami[resourceName].create({
"query_target" : "sample:100"
, "query_base" : "fr"
, "features" : "all"
}, next)
}, function(res, next) {
expectedScoreId = res.model_id
oriskami[resourceName].retrieve(expectedScoreId, next)
}], L.logError(done))
})
xit("Should update status", function(done){
oriskami["FilterScoringsDedicated"].create({
"is_active": "false"
}, function(err, res){
if(!err && res.data && res.data.is_active === "false"){
oriskami["FilterScoringsDedicated"].create({
"is_active": "true"
}, function(err, res){
if(!err && res.data && res.data.is_active === "true"){
done()
} else if(!err){
done(new Error("Failed to roll back 'is_active'"))
} else {
done(err)
}
})
} else if(!err){
done(new Error("Failed to set 'is_active'"))
} else {
done(err)
}
})
xit("Should update status [TODO]", function(done){
async.waterfall([
function( next){ oriskami[resourceName].create({"is_active": "false"}, next)}
, function(res, next){
var isOk = res.data.is_active === "false"
isOk ? oriskami[resourceName].update({"is_active": "true"}, next) : next(new Error("err_creating_filter_scorings_dedicated"))
}, function(res, next){
var isOk = res.data.is_active === "true"
isOk ? next() : next(new Error("err_updating"))
}], L.logError(done))
})
})
})

90

test/Resources/FilterWhitelist/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "FilterWhitelist"
, json = {

@@ -17,19 +16,10 @@ "value" : "New Value"

describe("FilterWhitelist", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["FilterWhitelist"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["FilterWhitelist"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["FilterWhitelist"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -40,49 +30,29 @@ })

describe("Methods", function(){
it("Should create", function(done){
oriskami["FilterWhitelist"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
it("Should create, list, and delete", function(done){
var nWhitelists0
async.waterfall([
function( next){ oriskami[resourceName].create(json, next) }
, function(res, next){
var whitelist = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === whitelist[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
})
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === whitelist[k] }, true)
isEqual ? next(null, true) : next(new Error("err_creating"))
},function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
nWhitelists0 = res.data.length
oriskami[resourceName].del(nWhitelists0 - 1, next)
}, function(res, next){ res.data.length == nWhitelists0 - 1 ? next(null, true) : next(new Error("err_deleting")) }
], L.logError(done))
}).timeout(20000)
it("Should update", function(done){
var whitelistId = "0"
oriskami["FilterWhitelist"].update(whitelistId
, {"value": "yahoo.com"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){oriskami[resourceName].update(whitelistId, {"value": "yahoo.com"}, next)}
, function(res, next){
var whitelist = res.data[whitelistId]
if(whitelist.value === "yahoo.com"){
// roll back
oriskami["FilterWhitelist"].update(whitelistId
, {"value": "gmail.com"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
whitelist.value === "yahoo.com" ? next(null, true) : next(new Error("err_updating"))
}, function(res, next){ oriskami[resourceName].update(whitelistId, {"value": "gmail.com"}, next)
}], L.logError(done))
})
it("Should delete", function(done){
oriskami["FilterWhitelist"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var whitelistId = res.data.length - 1
oriskami["FilterWhitelist"].del(whitelistId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
})
})
})

63

test/Resources/Notifier/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, methods = ["update"]

@@ -8,17 +10,8 @@

describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["Notifier"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["Notifier"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami["Notifier"]["path"]).to.exist})
it("Should link to parent (oriskami)", function() { expect(oriskami["Notifier"]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["Notifier"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami["Notifier"][method])
hasMethod ? done() : done(new Error("err_missing_notifier_email_method_" + method))
})

@@ -28,37 +21,15 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["Notifier"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami["Notifier"].list(L.logError(done))})
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["Notifier"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){ done(new Error("Did not update")) }
var rule = res.data[ruleId]
if(rule.is_active === "true"){
// roll back
oriskami["Notifier"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
async.waterfall([
function( next){ oriskami["Notifier"].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.is_active === "true"
isOk ? oriskami["Notifier"].update(ruleId, {"is_active": "false"}, next) : next(new Error("err_invalid_notifier_is_active"))
}], L.logError(done))
}).timeout(20000)
})
})

58

test/Resources/NotifierECommerce/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, L = require("../../L")
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "NotifierECommerce"
describe("NotifierECommerce", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["NotifierECommerce"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["NotifierECommerce"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() {expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["NotifierECommerce"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_notifier_email_method_" + method))
})

@@ -35,23 +25,13 @@ })

var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["NotifierECommerce"].update(ruleId
, {"is_active": "false"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "false"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.is_active === "false"
isOk ? oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) : next(new Error("err_invalid_notifier_ecommerce_value"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.is_active === "false"){
// roll back
oriskami["NotifierECommerce"].update(ruleId, {"value": "true"}, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should list", function(done){
oriskami["NotifierECommerce"].list(done)
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done))})
})
})

94

test/Resources/NotifierEmail/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "NotifierEmail"
, json = {

@@ -16,19 +15,9 @@ "value" : "abc@gmail.com"

describe("NotifierEmail", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["NotifierEmail"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["NotifierEmail"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)", function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["NotifierEmail"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new error("err_missing_method_" + method))
})

@@ -40,15 +29,9 @@ })

it("Should create", function(done){
oriskami["NotifierEmail"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){
var rule = res.data.reverse()[0]
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
isEqual ? next(null, true) : next(new Error("err_creating"))
}], L.logError(done))
})

@@ -58,33 +41,24 @@

var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["NotifierEmail"].update(ruleId
, {"value": "yahoo.com"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"value": "yahoo.com"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.value === "yahoo.com"
isOk ? oriskami[resourceName].update(ruleId, {"value": "gmail.com"}, next) : next(new Error("err_updating"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.value === "yahoo.com"){
// roll back
oriskami["NotifierEmail"].update(ruleId
, {"value": "gmail.com"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami.set("timeout", 20000)
oriskami["NotifierEmail"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var ruleId = res.data.length - 1
oriskami["NotifierEmail"].del(ruleId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
var nRules0
async.waterfall([
function( next){ oriskami[resourceName].list(next) }
, function(res, next){
nRules0 = res.data.length
oriskami[resourceName].del(nRules0 - 1, next)
}, function(res, next){
var isOk = res.data.length === nRules0 - 1
isOk ? next(null, isOk) : next(new Error("err_deleting"))
}], L.logError(done))
})
})
})

93

test/Resources/NotifierSlack/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, L = require("../../L")
, oriskami = require("../../oriskami")
, methods = ["retrieve", "update", "del", "list"]
, resourceName = "NotifierSlack"
, json = {

@@ -11,19 +14,10 @@ "value" : "https://some-url"

describe("NotifierSlack", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["NotifierSlack"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["NotifierSlack"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["NotifierSlack"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+method+" methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_notifier_slack_method_" + method))
})

@@ -35,15 +29,9 @@ })

it("Should create", function(done){
oriskami["NotifierSlack"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){
var rule = res.data.reverse()[0]
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
isEqual ? next(null, true) : next(new Error("err_creating"))
}], L.logError(done))
})

@@ -53,33 +41,24 @@

var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["NotifierSlack"].update(ruleId
, {"value": "https://another-url"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"value": "https://another-url"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isOk = rule.value === "https://another-url"
isOk ? oriskami[resourceName].update(ruleId, {"value": "https://some-url"}, next) : next(new Error("err_updating"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.value === "https://another-url"){
// roll back
oriskami["NotifierSlack"].update(ruleId
, {"value": "https://some-url"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami.set("timeout", 20000)
oriskami["NotifierSlack"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var ruleId = res.data.length - 1
oriskami["NotifierSlack"].del(ruleId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
})
var nRules0
async.waterfall([
function( next){ oriskami[resourceName].list(next) }
, function(res, next){
nRules0 = res.data.length
oriskami[resourceName].del(nRules0 - 1, next)
}, function(res, next){
var isOk = res.data.length === nRules0 - 1
isOk ? next(null, isOk) : next(new Error("err_deleting"))
}], L.logError(done))
}).timeout(20000)
})
})

96

test/Resources/NotifierSms/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, oriskami = require("../../oriskami")
, L = require("../../L")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, resourceName = "NotifierSms"
, methods = ["retrieve", "update", "del", "list"]

@@ -16,19 +15,10 @@ , json = {

describe("NotifierSms", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["NotifierSms"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["NotifierSms"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["NotifierSms"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_notifier_sms_method_" + method))
})

@@ -40,50 +30,32 @@ })

it("Should create", function(done){
oriskami["NotifierSms"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].create(json, next) }
, function(res, next){
var rule = res.data.reverse()[0]
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
isEqual ? next(null, isEqual) : next(new Error("err_creating"))
}], L.logError(done))
})
it("Should update", function(done){
var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["NotifierSms"].update(ruleId
, {"value": "+1 987 654 321"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
var ruleId = "0"
, value1 = "+1 987 654 321"
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"value": value1}, next) }
, function(res, next){
var isOk = res.data[ruleId].value === value1
isOk ? oriskami[resourceName].update(ruleId, {"value": json.value}, next) : next(new Error("err_updating"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.value === "+1 987 654 321"){
// roll back
oriskami["NotifierSms"].update(ruleId
, {"value": "+1 123 456 789"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami.set("timeout", 20000)
oriskami["NotifierSms"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var ruleId = res.data.length - 1
oriskami["NotifierSms"].del(ruleId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
})
var nNotifiers0
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){ oriskami[resourceName].list(next)}
, function(res, next){ nNotifiers0 = res.data.length; oriskami[resourceName].del(nNotifiers0 - 1, next)}
, function(res, next){ res.data.length == nNotifiers0 - 1 ? next(null, true) : next(new Error("err_deleting")) }
], L.logError(done))
}).timeout(20000)
})
})

95

test/Resources/NotifierWebhook/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, L = require("../../L")
, oriskami = require("../../oriskami")
, examples = require("../../data/Event")
, jsons = _.map(examples, function(x){return {"id": x.id, "parameters": x}})
, ids = _.map(examples, function(x){return x.id})
, rootProps = ["log","_api"]
, subProps = ["auth","protocol","timeout","resources","revokedCerts","headers","request"]
, resourceName = "NotifierWebhook"
, methods = ["retrieve", "update", "del", "list"]

@@ -16,19 +15,10 @@ , json = {

describe("NotifierWebhook", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["NotifierWebhook"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["NotifierWebhook"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["NotifierWebhook"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_notifier_webhook_method_" + method))
})

@@ -39,51 +29,26 @@ })

describe("Methods", function(){
it("Should create", function(done){
oriskami["NotifierWebhook"].create(json
, function(err, res){
if(err){ done(new Error("Did not create")) }
it("Should create, list, and delete", function(done){
var nWebhooks0
async.waterfall([
function( next){ oriskami[resourceName].create(json, next)}
, function(res, next){
var rule = res.data.reverse()[0]
, isEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
isEqual ? next(null, isEqual) : next(new Error("err_creating_notifier_webhook_not_equal"))
},function(res, next){ oriskami[resourceName].list(next)}
, function(res, next){ nWebhooks0 = res.data.length ; oriskami[resourceName].del(nWebhooks0 - 1, next)}
, function(res, next){ res.data.length === nWebhooks0 - 1? next(null, true) : next(new Error("err_deleting"))}
], L.logError(done))
}).timeout(20000)
var rule = res.data.reverse()[0]
, deepEqual = _.reduce(_.keys(json), function(memo, k){ return memo && json[k] === rule[k] }, true)
if(deepEqual){
done()
} else {
console.log(err, res)
done(new Error("Did not create"))
}
})
})
it("Should update", function(done){
var ruleId = "0"
oriskami.set("timeout", 20000)
oriskami["NotifierWebhook"].update(ruleId
, {"value": "https://another-url"}
, function(err, res){
if(err){ done(new Error("Did not create")) }
var rule = res.data[ruleId]
if(rule.value === "https://another-url"){
// roll back
oriskami["NotifierWebhook"].update(ruleId
, {"value": "https://some-url"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should delete", function(done){
oriskami.set("timeout", 20000)
oriskami["NotifierWebhook"].list(function(err, res){
if(err){ done(new Error("Did not list"))}
var ruleId = res.data.length - 1
oriskami["NotifierWebhook"].del(ruleId, function(err, res){
if(!err && res.data.length === 2){ return done() }
done(err)
})
})
})
async.waterfall([
function( next) { oriskami[resourceName].update(ruleId, {"value": "https://another-url"}, next) }
, function(res, next) {
var isValid = res.data[ruleId].value === "https://another-url"
isValid ? oriskami[resourceName].update(ruleId, {"value": "https://some-url"}, next) : next(new Error("err_updating"))
}], L.logError(done))
}).timeout(20000)
})
})

37

test/Resources/Router/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["retrieve", "list"]
, resourceName = "Router"
describe("Router", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["Router"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["Router"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["Router"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() :done("err_missing_router_method_" + method)
})

@@ -29,9 +23,6 @@ })

it("Should retrieve", function(done){
oriskami["Router"].retrieve(0, function(err, res){
var isStatusOk = res.statusCode >= 200 && res.statusCode <= 204
if(!err && res.data.length >= 0){
done()
} else {
done(new Error("Did not retrieve"))
}
oriskami[resourceName].retrieve(0, function(err, res){
var isStatusOk = !err && res.status_code >= 200 && res.status_code <= 204
if(err) return done(err)
else return isStatusOk ? done() : done(new Error("err_retrieving"))
})

@@ -38,0 +29,0 @@ })

128

test/Resources/RouterBackup/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["create","retrieve","del","list"]
, resourceName = "RouterBackup"
describe("RouterBackup", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterBackup"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterBackup"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterBackup"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("Should have "+METHOD+" methods"))
})

@@ -30,76 +24,40 @@ })

var now = (new Date()).toISOString()
oriskami["RouterBackup"].create({"name": now}, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not create"))
}
, backupId
async.waterfall([
function( next){ oriskami[resourceName].create({"name": now}, next)}
, function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
var isBackedUp= _.reduce(_.keys(res.data), function(isBackedup, k){
var backup = res.data[k]
if(backup.name === now){ backupId = backup.id }
return backup.name === now
}, false)
isBackedUp ? next(null, backupId) : next(new Error("err_router_backup_missing"))
}, function(res, next){oriskami[resourceName].del(backupId, next)
}], L.logError(done))
}).timeout(20000)
oriskami["RouterBackup"].list(function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not list"))
}
var backups = res.data
, backupId
, isBackedup= _.reduce(_.keys(backups), function(isBackedup, k){
var backup = backups[k]
if(backup.name === now){ backupId = backup.id }
return backup.name === now
}, false)
if(!isBackedup){ done(new Error("Did not find the created RouterBackup")) }
oriskami["RouterBackup"].del(backupId, function(err, res){
if(err){
console.log(err, res)
return done(new Error("Did not delete"))
}
done()
})
})
})
}).timeout(10000)
it("Should retrieve (restore) a flow backup", function(done){
var now = (new Date()).toISOString()
oriskami["FilterWhitelist"].create({"description": now}, function(err, res){
if(err){ return done(new Error("Did not update the flow")) }
oriskami["RouterBackup"].create({"name": now}, function(err, res){
if(err){ return done(new Error("Did not create")) }
var now2 = (new Date()).toISOString()
oriskami["FilterWhitelist"].create({"description": now2}, function(err, res){
if(err){ return done(new Error("Did not update the flow")) }
oriskami["RouterBackup"].list(function(err, res){
if(err){ return done(new Error("Did not list the flow")) }
var backups = res.data
, backupId
_.each(backups, function(backup){ if(backup.name === now){ backupId = backup.id }})
if(backupId === undefined){ return done(new Error("Did not find the created RouterBackup")) }
oriskami["RouterBackup"].retrieve(backupId, function(err, res){
if(err){ return done(new Error("Did not retrieve RouterBackup")) }
oriskami["FilterWhitelist"].list(function(err, res){
if(err){ return done(new Error("Did not retrieve FilterWhitelist")) }
var whitelists = res.data
, returned = _.reduce(whitelists, function(memo, w){ return memo || w.description === now}, false)
if(!returned){ return done(new Error("Did not restore"))}
oriskami["RouterBackup"].del(backupId, function(err, res){ done(err) })
})
})
})
})
})
})
}).timeout(10000)
, now2= now + "_ABC"
, backupId
async.waterfall([
function( next){ oriskami["FilterWhitelist"].create({"description": now}, next) }
, function(res, next){ oriskami[resourceName].create({"name": now}, next) }
, function(res, next){ oriskami["FilterWhitelist"].create({"description": now2}, next) }
, function(res, next){ oriskami[resourceName].list(next) }
, function(res, next){
backupId = _.reduce(res.data, function(memo, backup){ return backup.name === now ? backup.id : memo}, -1)
backupId >= 0 ? next(null, backupId) : next(new Error("err_retrieving_backup_id_in_backups"))
}, function(backupId, next){ oriskami[resourceName].retrieve(backupId, next)}
, function(res, next){ oriskami["FilterWhitelist"].list(next) }
, function(res, next){
var hasWhitelist = _.reduce(res.data, function(memo, w){ return memo || w.description === now}, false)
hasWhitelist ? next(null, hasWhitelist) : next(new Error("err_retrieving_modified_rule_in_restored_backup"))
}, function(res, next){ oriskami[resourceName].del(backupId, next) }
], L.logError(done))
}).timeout(20000)
it("Should list", function(done){
oriskami["RouterBackup"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done))})
})
})

68

test/Resources/RouterData/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, resourceName = "RouterData"
, methods = ["update"]
describe("RouterData", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterData"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterData"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function(){ expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function(){ expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterData"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_method_" + method))
})

@@ -27,41 +21,15 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterData"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterData"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next)}
, function(res, next){
var isActive = res.data[ruleId].is_active
isActive ? oriskami[resourceName].update(ruleId, {"is_active": "false"}, next) : next(new Error("err_router_data_inactive"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data[ruleId]
if(rule.is_active === "true"){
// roll back
oriskami["RouterData"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done))})
})
})

64

test/Resources/RouterDataBin/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list", "update"]
, resourceName = "RouterDataBin"
describe("RouterDataBin", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataBin"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataBin"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)", function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataBin"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+method+" methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_bin_method_" + method))
})

@@ -28,37 +22,13 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataBin"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list", function(done){oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterDataBin"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data
if(rule.is_active === "true"){
// roll back
oriskami["RouterDataBin"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, rule)
done(new Error("Did not update"))
}
})
})
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var isActive = res.data.is_active === "true"
oriskami[resourceName].update(ruleId, {"is_active": "false"}, done)
}], L.logError(done))
}).timeout(20000)
})
})

66

test/Resources/RouterDataBlacklist/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list", "update"]
, resourceName = "RouterDataBlacklist"
describe("RouterDataBlacklist", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataBlacklist"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataBlacklist"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataBlacklist"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_blacklist_method_" + method))
})

@@ -28,37 +22,13 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataBlacklist"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterDataBlacklist"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data
if(rule.is_active === "true"){
// roll back
oriskami["RouterDataBlacklist"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var isActive = res.data.is_active === "true"
isActive ? oriskami[resourceName].update(ruleId, {"is_active": "false"}, next) : next(new Error("err_updating"))
}], L.logError(done))
}).timeout(20000)
})
})

38

test/Resources/RouterDataFeature/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list"]
, resourceName = "RouterDataFeature"
describe("RouterDataFeature", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataFeature"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataFeature"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist })
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataFeature"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+method+" methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_feature_method_" + method))
})

@@ -27,15 +21,5 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataFeature"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done)) })
})
})

63

test/Resources/RouterDataGeocoding/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list", "update"]
, resourceName = "RouterDataGeocoding"
describe("RouterDataGeocoding", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataGeocoding"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataGeocoding"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataGeocoding"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done(): done(new Error("err_missing_router_data_geocoding_method_" + method))
})

@@ -28,37 +23,13 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataGeocoding"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterDataGeocoding"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data
if(rule.is_active === "true"){
// roll back
oriskami["RouterDataGeocoding"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
async.waterfall([
function(next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next)}
, function(res, next){
var isActive = res.data.is_active === "true"
isActive ? oriskami[resourceName].update(ruleId, {"is_active":"false"}, next) : next(new Error("err_updating_1"))
}], L.logError(done))
}).timeout(20000)
})
})

63

test/Resources/RouterDataGeoip/spec.js
var _ = require("lodash")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, async = require("async")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list", "update"]
, resourceName = "RouterDataGeoip"
describe("RouterDataGeoip", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataGeoip"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataGeoip"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)", function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataGeoip"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+method+" methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_geoip_method_" + method))
})

@@ -28,37 +22,14 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataGeoip"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done)) })
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterDataGeoip"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data
if(rule.is_active === "true"){
// roll back
oriskami["RouterDataGeoip"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var isActive = res.data.is_active === "true"
isActive ? oriskami[resourceName].update(ruleId, {"is_active": "false"}, done) : next(new Error("err_updating_1"))
}], L.logError(done))
})
})
})

65

test/Resources/RouterDataPhone/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["list", "update"]
, resourceName = "RouterDataPhone"
describe("RouterDataPhone", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterDataPhone"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterDataPhone"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterDataPhone"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+method+" methods", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_router_data_phone_method_" + method))
})

@@ -28,37 +22,14 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterDataPhone"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterDataPhone"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var isActive = res.data.is_active === "true"
isActive ? oriskami[resourceName].update(ruleId, {"is_active": "false"}, next) : next(new Error("err_router_data_phone_inactive"))
}], L.logError(done))
}).timeout(20000)
var rule = res.data
if(rule.is_active === "true"){
// roll back
oriskami["RouterDataPhone"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done))})
})
})

98

test/Resources/RouterFlow/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["create","update","del","list"]
, resourceName = "RouterFlow"
describe("RouterFlow", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterFlow"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterFlow"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterFlow"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -27,61 +22,32 @@ })

describe("Methods", function(){
it("Should create and delete RouterFlow", function(done){
oriskami["RouterFlow"].list(function(err, res){
if(err){ return done(new Error("Did not list")) }
var nRouterFlows0 = res.data.length
oriskami["RouterFlow"].create({}, function(err, res){
if(err){ return done(new Error("Did not create")) }
var nRouterFlows1 = res.data.length
if(nRouterFlows1 <= nRouterFlows0){return done(new Error("Did not expand the set of RouterFlows"))}
oriskami["RouterFlow"].del(nRouterFlows1 - 1, function(err, res){
if(err){ return done(new Error("Did not delete")) }
var nRouterFlows2 = res.data.length
if(nRouterFlows2 !== nRouterFlows0){return done(new Error("Did not delete the created flow"))}
done()
})
})
it("Should create and delete", function(done){
var nRouterFlows0
, nRouterFlows1
async.waterfall([
function( next){ oriskami[resourceName].list(next)}
, function(res, next){ nRouterFlows0 = res.data.length; oriskami[resourceName].create({}, next) }
, function(res, next){ nRouterFlows1 = res.data.length; oriskami[resourceName].del(nRouterFlows1 - 1, next) }
], function(err, res) {
var nRouterFlows2 = !err && res.data && res.data.length
err && console.log(err)
if(nRouterFlows1 <= nRouterFlows0) return done(new Error("err_creating_router_flow"))
if(nRouterFlows2 !== nRouterFlows0) return done(new Error("err_deleting_created_flow"))
done(err)
})
}).timeout(10000)
}).timeout(20000)
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterFlow"].update(ruleId
, {"is_active": "true"}
, function(err, res){
if(err){
return done(new Error("Did not update"))
}
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"is_active": "true"}, next) }
, function(res, next){
var isActive = res.data.is_active === "true"
if(isActive) return oriskami[resourceName].update(ruleId, {"is_active": "false"}, next)
else return next(new Error("err_updating_router_flow"))
}], L.logError(done))
}).timeout(20000)
var flow = res.data
if(flow.is_active === "true"){
// roll back
oriskami["RouterFlow"].update(ruleId
, {"is_active": "false"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
it("Should list", function(done){
oriskami["RouterFlow"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list", function(done){ oriskami[resourceName].list(L.logError(done))})
})
})

72

test/Resources/RouterParameter/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, oriskami = require("../../oriskami")
, L = require("../../L")
, methods = ["update","list"]
, resourceName = "RouterParameter"
describe("RouterParameter", function(){
describe(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterParameter"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterParameter"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function() { expect(oriskami[resourceName]["path"]).to.exist})
it("Should link to parent (oriskami)" , function() { expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterParameter"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have "+ method +" method", function(done) {
var hasMethod = _.isFunction(oriskami[resourceName][method])
hasMethod ? done() : done(new Error("err_missing_method_" + method))
})

@@ -27,41 +21,15 @@ })

describe("Methods", function(){
it("Should list", function(done){
oriskami["RouterParameter"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done))})
it("Should update", function(done){
oriskami.set("timeout", 20000)
var ruleId = "0"
oriskami["RouterParameter"].update(ruleId
, {"f_cogs": "0.25"}
, function(err, res){
if(err){
console.log(err, res)
done(new Error("Did not update"))
}
var rule = res.data[ruleId]
if(rule.f_cogs === "0.25"){
// roll back
oriskami["RouterParameter"].update(ruleId
, {"f_cogs": "0.50"}
, done)
} else {
console.log(err, res)
done(new Error("Did not update"))
}
})
})
var ruleId = "0"
async.waterfall([
function( next){ oriskami[resourceName].update(ruleId, {"f_cogs": "0.25"}, next) }
, function(res, next){
var rule = res.data[ruleId]
, isValueOk = rule.f_cogs === "0.25"
isValueOk ? oriskami[resourceName].update(ruleId, {"f_cogs": "0.50"}, next) : next(new Error("err_invalid_router_parameter_value"))
}], L.logError(done))
}).timeout(20000)
})
})

52

test/Resources/RouterTest/spec.js
var _ = require("lodash")
, async = require("async")
, expect = require("chai").expect
, oriskami = require("../../oriskami")
, L = require("../../L")
, oriskami = require("../../oriskami")
, methods = ["retrieve", "list"]
, resourceName = "RouterTest"
describe.skip("RouterTest", function(){
describe.skip(resourceName, function(){
describe("Properties", function(){
it("Should have a name and path attribute", function() {
expect(oriskami["RouterTest"]["path"]).to.exist
})
it("Should link to parent (oriskami)", function() {
expect(oriskami["RouterTest"]["oriskami"]).to.exist
})
it("Should have a name and path attribute", function(){ expect(oriskami[resourceName]["path"]).to.exist })
it("Should link to parent (oriskami)" , function(){ expect(oriskami[resourceName]["oriskami"]).to.exist})
_.each(methods, function(method){
var METHOD = method.toUpperCase()
it("Should have "+METHOD+" methods", function(done) {
if(!_.isFunction(oriskami["RouterTest"][method])){
return done(new Error("Should have "+METHOD+" methods"))
}
done()
it("Should have " + method + " methods", function(done) {
_.isFunction(oriskami[resourceName][method]) ? done() : done(new Error("err_missing_method_" + method))
})

@@ -28,2 +21,3 @@ })

describe("Methods", function(){
it("Should create", function(done){ oriskami[resourceName].create({}, L.logError(done)) })
it("Should update", function(done){

@@ -33,3 +27,3 @@ var now1 = (new Date()).toISOString().slice(0,16) + "_abc"

, ssize = parseInt(Math.random() * 1000)
oriskami["RouterTest"].update(0, {
oriskami[resourceName].update(0, {
"query_target": now1

@@ -56,26 +50,4 @@ , "query_base" : now2

})
it("Should create", function(done){
var disregarded = {}
oriskami["RouterTest"].create(disregarded, function(err, res){
if(err){
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list", function(done){
oriskami["RouterTest"].list(function(err, res){
if(err) {
console.log(err, res)
done(err)
} else {
done()
}
})
})
it("Should list" , function(done){ oriskami[resourceName].list(L.logError(done))})
})
})
package-lock.json
yarn.lock
.npmignore

Sorry, the diff of this file is not supported yet

CHANGELOG

Sorry, the diff of this file is not supported yet

test/mocha.opts

Sorry, the diff of this file is not supported yet

VERSION

Sorry, the diff of this file is not supported yet

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