Skip to content

GitLab

Merged
Created by Dan Jones@danjonOwner

Resolve "Sort out linting config"

Viewing commit b9dfcc49
36 files
+ 687
- 675
Show latest version
di‎st‎
adapter‎.esm.js‎ +44 -38
adapt‎er.js‎ +44 -38
protoco‎l.esm.js‎ +52 -55
proto‎col.js‎ +52 -55
s‎rc‎
ada‎pter‎
inde‎x.js‎ +44 -38
prot‎ocol‎
example-‎client.js‎ +25 -26
inde‎x.js‎ +54 -57
te‎st‎
cucu‎mber‎
ada‎pter‎
auth.s‎teps.js‎ +9 -7
before.‎steps.js‎ +36 -26
broadcast‎.steps.js‎ +21 -20
common.‎steps.js‎ +41 -30
get-authorizatio‎n-header.steps.js‎ +12 -9
poll.s‎teps.js‎ +43 -34
publish.‎steps.js‎ +21 -20
token-vali‎d.steps.js‎ +8 -8
validate‎.steps.js‎ +5 -6
prot‎ocol‎
common.‎steps.js‎ +2 -2
decode.‎steps.js‎ +2 -2
encode.‎steps.js‎ +2 -2
get-type‎.steps.js‎ +8 -5
validate‎.steps.js‎ +4 -4
sch‎ema‎
validate‎.steps.js‎ +6 -6
fixt‎ures‎
serv‎er.js‎ +6 -4
mo‎ck‎
mess‎ages‎
Message_Vehic‎leMission.json‎ +1 -1
Message_Vehic‎leStatus.json‎ +1 -1
swagge‎r.json‎ +21 -4
.eslin‎trc.js‎ +6 -11
.pretti‎erignore‎ +8 -62
.pret‎tierrc‎ +0 -10
.pretti‎errc.js‎ +10 -0
LICEN‎CE.md‎ +1 -1
READ‎ME.md‎ +46 -46
cucum‎ber.js‎ +3 -3
jest.co‎nfig.js‎ +1 -2
packag‎e.json‎ +3 -3
yarn‎.lock‎ +45 -39
dist/adapter.esm.js
+ 44
- 38
Show all unchanged lines Show 20 lines
/**
/**
* Test parsing the message based on the provided protocol schema
* Test parsing the message based on the provided protocol schema
*
*
* The message must be successfully json decoded into an object
* The message must be successfully json decoded into an object
* prior to validation
* prior to validation
*
*
* At present this returns the validation result which is an
* At present this returns the validation result which is an
* object containing a boolean valid field as well as details
* object containing a boolean valid field as well as details
* of any errors.
* of any errors.
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Call the GET /receive endpoint and process the messages with decode
* Call the GET /receive endpoint and process the messages with decode
*
*
* Returns the response
* Returns the response
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns {object}
* @returns {object}
*/
*/
poll(is_retry=false) {
poll(is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Publish a message to the backbone with the specified topic
* Publish a message to the backbone with the specified topic
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} topic
* @param {string} topic
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
publish(topic, body, is_retry=false) {
publish(topic, body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Broadcast the message on the backbone
* Broadcast the message on the backbone
*
*
* Broadcast messages bypass the normal publisher queues
* Broadcast messages bypass the normal publisher queues
* this means they can be used to deliver messages more
* this means they can be used to deliver messages more
* quickly in an emergency scenario.
* quickly in an emergency scenario.
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
broadcast(body, is_retry=false) {
broadcast(body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines
dist/adapter.js
+ 44
- 38
Show all unchanged lines Show 20 lines
/**
/**
* Test parsing the message based on the provided protocol schema
* Test parsing the message based on the provided protocol schema
*
*
* The message must be successfully json decoded into an object
* The message must be successfully json decoded into an object
* prior to validation
* prior to validation
*
*
* At present this returns the validation result which is an
* At present this returns the validation result which is an
* object containing a boolean valid field as well as details
* object containing a boolean valid field as well as details
* of any errors.
* of any errors.
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Call the GET /receive endpoint and process the messages with decode
* Call the GET /receive endpoint and process the messages with decode
*
*
* Returns the response
* Returns the response
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns {object}
* @returns {object}
*/
*/
poll(is_retry=false) {
poll(is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Publish a message to the backbone with the specified topic
* Publish a message to the backbone with the specified topic
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} topic
* @param {string} topic
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
publish(topic, body, is_retry=false) {
publish(topic, body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Broadcast the message on the backbone
* Broadcast the message on the backbone
*
*
* Broadcast messages bypass the normal publisher queues
* Broadcast messages bypass the normal publisher queues
* this means they can be used to deliver messages more
* this means they can be used to deliver messages more
* quickly in an emergency scenario.
* quickly in an emergency scenario.
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
broadcast(body, is_retry=false) {
broadcast(body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines
dist/protocol.esm.js
+ 52
- 55
Show all unchanged lines Show 20 lines
/**
/**
* GenericProtocol defines a simple passthru handler for messages
* GenericProtocol defines a simple passthru handler for messages
* This can be extended to handle different schemas
* This can be extended to handle different schemas
*
*
* The assumption is that all messages conform to a single
* The assumption is that all messages conform to a single
* wrapper schema definition. Different payloads are handled
* wrapper schema definition. Different payloads are handled
* by a oneOf definitions within the schema determined by a
* by a oneOf definitions within the schema determined by a
* field value.
* field value.
*
*
* This class can be extended and overridden to handle
* This class can be extended and overridden to handle
* different schemas and to implement the client specific
* different schemas and to implement the client specific
* logic related to be executed when invoked for a given
* logic related to be executed when invoked for a given
* message type.
* message type.
*
*
* By default encode and decode are just passthru stubs
* By default encode and decode are just passthru stubs
*
*
* decode is invoked when receiving a message from the backbone
* decode is invoked when receiving a message from the backbone
* encode is invoked before delivering a message to the backbone
* encode is invoked before delivering a message to the backbone
*
*
* The intention is that these allow you to transform the message
* The intention is that these allow you to transform the message
* and call invoke internal functions and services as required
* and call invoke internal functions and services as required
*/
*/
class GenericProtocol {
class GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
* @param {object} schema
* @param {object} schema
* @returns {Validator}
* @returns {Validator}
*/
*/
createValidator(schema) {
createValidator(schema) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Identify the payload type from the message content
* Identify the payload type from the message content
* @param {object} message
* @param {object} message
* @returns {string}
* @returns {string}
*/
*/
getType(message) {
getType(message) {
try {
try {
return message.payload.message_type;
return message.payload.message_type;
} catch(error) {
} catch (error) {
return null;
return null;
}
}
}
}
/**
/**
* Invoked on receiving a message from the backbone
* Invoked on receiving a message from the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the decode method
* be needed by sub-classes overriding the decode method
* @param {string} type
* @param {string} type
* @param {object} message
* @param {object} message
* @returns {*}
* @returns {*}
*/
*/
decode(type, message) {
decode(type, message) {
return message;
return message;
}
}
/**
/**
* Invoked on receiving an invalid message from the backbone
* Invoked on receiving an invalid message from the backbone
*
*
* @param {object} message
* @param {object} message
* @param {object} validation
* @param {object} validation
* @returns {*}
* @returns {*}
*/
*/
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Optionally invoked before delivering a message to the backbone
* Optionally invoked before delivering a message to the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the encode method
* be needed by sub-classes overriding the encode method
* @param {string} type
* @param {string} type
* @param {*} message
* @param {*} message
* @returns {object}
* @returns {object}
*/
*/
encode(type, message) {
encode(type, message) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
}
}
/**
/**
* GenericSoarProtocol defines a simple passthru handler for messages
* GenericSoarProtocol defines a simple passthru handler for messages
*
*
* This provides the same as above but loads a version of the
* This provides the same as above but loads a version of the
* SoAR message protocol
* SoAR message protocol
*/
*/
class GenericSoarProtocol extends GenericProtocol {
class GenericSoarProtocol extends GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
*
*
* If schema is a string build a URL and retrieve the
* If schema is a string build a URL and retrieve the
* schema from gitlab
* schema from gitlab
* @param {string|object} schema
* @param {string|object} schema
* @returns {object}
* @returns {object}
*/
*/
createValidator(schema) {
createValidator(schema) {
if (typeof schema === 'string' && schema.match(/^[\w\.]+$/)) {
if (typeof schema === 'string' && schema.match(/^[\w.]+$/)) {
this.loadSchema(schema)
this.loadSchema(schema).then((schema) => {
.then((schema) => {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
});
});
} else {
} else {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
}
}
}
}
/**
/**
* Load schema from gitlab by tag/branch/commitref
* Load schema from gitlab by tag/branch/commitref
* @param {string} version
* @param {string} version
* @returns {object}
* @returns {object}
*/
*/
loadSchema(version) {
loadSchema(version) {
this.axios = axios;
this.axios = axios;
let repository = "https://git.noc.ac.uk/communications-backbone-system/backbone-message-format";
let repository =
 
'https://git.noc.ac.uk/communications-backbone-system/backbone-message-format';
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
return this.axios.get(url)
return this.axios.get(url).then((response) => {
.then((response) => {
this.schema = response.data;
this.schema = response.data;
return response.data;
return response.data;
});
});
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines
dist/protocol.js
+ 52
- 55
Show all unchanged lines Show 20 lines
/**
/**
* GenericProtocol defines a simple passthru handler for messages
* GenericProtocol defines a simple passthru handler for messages
* This can be extended to handle different schemas
* This can be extended to handle different schemas
*
*
* The assumption is that all messages conform to a single
* The assumption is that all messages conform to a single
* wrapper schema definition. Different payloads are handled
* wrapper schema definition. Different payloads are handled
* by a oneOf definitions within the schema determined by a
* by a oneOf definitions within the schema determined by a
* field value.
* field value.
*
*
* This class can be extended and overridden to handle
* This class can be extended and overridden to handle
* different schemas and to implement the client specific
* different schemas and to implement the client specific
* logic related to be executed when invoked for a given
* logic related to be executed when invoked for a given
* message type.
* message type.
*
*
* By default encode and decode are just passthru stubs
* By default encode and decode are just passthru stubs
*
*
* decode is invoked when receiving a message from the backbone
* decode is invoked when receiving a message from the backbone
* encode is invoked before delivering a message to the backbone
* encode is invoked before delivering a message to the backbone
*
*
* The intention is that these allow you to transform the message
* The intention is that these allow you to transform the message
* and call invoke internal functions and services as required
* and call invoke internal functions and services as required
*/
*/
class GenericProtocol {
class GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
* @param {object} schema
* @param {object} schema
* @returns {Validator}
* @returns {Validator}
*/
*/
createValidator(schema) {
createValidator(schema) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Identify the payload type from the message content
* Identify the payload type from the message content
* @param {object} message
* @param {object} message
* @returns {string}
* @returns {string}
*/
*/
getType(message) {
getType(message) {
try {
try {
return message.payload.message_type;
return message.payload.message_type;
} catch(error) {
} catch (error) {
return null;
return null;
}
}
}
}
/**
/**
* Invoked on receiving a message from the backbone
* Invoked on receiving a message from the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the decode method
* be needed by sub-classes overriding the decode method
* @param {string} type
* @param {string} type
* @param {object} message
* @param {object} message
* @returns {*}
* @returns {*}
*/
*/
decode(type, message) {
decode(type, message) {
return message;
return message;
}
}
/**
/**
* Invoked on receiving an invalid message from the backbone
* Invoked on receiving an invalid message from the backbone
*
*
* @param {object} message
* @param {object} message
* @param {object} validation
* @param {object} validation
* @returns {*}
* @returns {*}
*/
*/
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Optionally invoked before delivering a message to the backbone
* Optionally invoked before delivering a message to the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the encode method
* be needed by sub-classes overriding the encode method
* @param {string} type
* @param {string} type
* @param {*} message
* @param {*} message
* @returns {object}
* @returns {object}
*/
*/
encode(type, message) {
encode(type, message) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
}
}
/**
/**
* GenericSoarProtocol defines a simple passthru handler for messages
* GenericSoarProtocol defines a simple passthru handler for messages
*
*
* This provides the same as above but loads a version of the
* This provides the same as above but loads a version of the
* SoAR message protocol
* SoAR message protocol
*/
*/
class GenericSoarProtocol extends GenericProtocol {
class GenericSoarProtocol extends GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
*
*
* If schema is a string build a URL and retrieve the
* If schema is a string build a URL and retrieve the
* schema from gitlab
* schema from gitlab
* @param {string|object} schema
* @param {string|object} schema
* @returns {object}
* @returns {object}
*/
*/
createValidator(schema) {
createValidator(schema) {
if (typeof schema === 'string' && schema.match(/^[\w\.]+$/)) {
if (typeof schema === 'string' && schema.match(/^[\w.]+$/)) {
this.loadSchema(schema)
this.loadSchema(schema).then((schema) => {
.then((schema) => {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
});
});
} else {
} else {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
}
}
}
}
/**
/**
* Load schema from gitlab by tag/branch/commitref
* Load schema from gitlab by tag/branch/commitref
* @param {string} version
* @param {string} version
* @returns {object}
* @returns {object}
*/
*/
loadSchema(version) {
loadSchema(version) {
this.axios = axios;
this.axios = axios;
let repository = "https://git.noc.ac.uk/communications-backbone-system/backbone-message-format";
let repository =
 
'https://git.noc.ac.uk/communications-backbone-system/backbone-message-format';
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
return this.axios.get(url)
return this.axios.get(url).then((response) => {
.then((response) => {
this.schema = response.data;
this.schema = response.data;
return response.data;
return response.data;
});
});
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines
src/adapter/index.js
+ 44
- 38
Show all unchanged lines Show 20 lines
/**
/**
* Test parsing the message based on the provided protocol schema
* Test parsing the message based on the provided protocol schema
*
*
* The message must be successfully json decoded into an object
* The message must be successfully json decoded into an object
* prior to validation
* prior to validation
*
*
* At present this returns the validation result which is an
* At present this returns the validation result which is an
* object containing a boolean valid field as well as details
* object containing a boolean valid field as well as details
* of any errors.
* of any errors.
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Call the GET /receive endpoint and process the messages with decode
* Call the GET /receive endpoint and process the messages with decode
*
*
* Returns the response
* Returns the response
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns {object}
* @returns {object}
*/
*/
poll(is_retry=false) {
poll(is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Publish a message to the backbone with the specified topic
* Publish a message to the backbone with the specified topic
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} topic
* @param {string} topic
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
publish(topic, body, is_retry=false) {
publish(topic, body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Broadcast the message on the backbone
* Broadcast the message on the backbone
*
*
* Broadcast messages bypass the normal publisher queues
* Broadcast messages bypass the normal publisher queues
* this means they can be used to deliver messages more
* this means they can be used to deliver messages more
* quickly in an emergency scenario.
* quickly in an emergency scenario.
*
*
* Messages should be passed through encode before sending
* Messages should be passed through encode before sending
* @param {string} body
* @param {string} body
* @param {boolean} is_retry
* @param {boolean} is_retry
* @returns
* @returns
*/
*/
broadcast(body, is_retry=false) {
broadcast(body, is_retry = false) {
let adapterConfig = this.config;
let adapterConfig = this.config;
return this.getAuthorizationHeader()
return this.getAuthorizationHeader()
.then((headers) => {
.then((headers) => {
Show 20 lines Show all unchanged lines Show 20 lines
})
})
.catch((error) => {
.catch((error) => {
let retry = false;
let retry = false;
switch(error.response.status) {
switch (error.response.status) {
case 403: {
case 403:
this.credentials = null;
{
retry = true;
this.credentials = null;
} break;
retry = true;
 
}
 
break;
case 503: {
case 503: {
retry = true;
retry = true;
}
}
Show 20 lines Show all unchanged lines
src/protocol/example-client.js
+ 25
- 26
import { GenericProtocol } from '~/modules/comms-adapter/protocol';
import { GenericProtocol } from '~/modules/comms-adapter/protocol';
/**
/**
*
*
*/
*/
export class ExampleClientProtocol extends GenericProtocol {
export class ExampleClientProtocol extends GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
super(schema, services);
super(schema, services);
// bootstrap any injected services
// bootstrap any injected services
}
}
/**
/**
* Process a message received from the backbone
* Process a message received from the backbone
*
*
* This method is overridden to take appropriate
* This method is overridden to take appropriate
* action for each message type.
* action for each message type.
*
*
* Further methods can then be defined to handle
* Further methods can then be defined to handle
* each message type.
* each message type.
*
*
* You can use this to take action directly or
* You can use this to take action directly or
* transform that data to invoke an existing process.
* transform that data to invoke an existing process.
* @param {string} type
* @param {string} type
* @param {object} message
* @param {object} message
* @returns
* @returns
*/
*/
decode(type, message) {
decode(type, message) {
switch (type) {
switch (type) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Transform local data into a message conforming to the protocol schema
* Transform local data into a message conforming to the protocol schema
*
*
* When a client event occurs the local data is passed through
* When a client event occurs the local data is passed through
* encode to handle the translation from the native client format
* encode to handle the translation from the native client format
* into a message conforming to the protocol schema.
* into a message conforming to the protocol schema.
* @param {string} type
* @param {string} type
* @param {object} message
* @param {object} message
* @returns
* @returns
*/
*/
encode(type, message) {
encode(type, message) {
return message;
return message;
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Act upon a received VehicleStatus message
* Act upon a received VehicleStatus message
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
decodeVehicleStatus(message) {
decodeVehicleStatus(message) {
const battery = message.battery_percentage;
const battery = message.battery_percentage;
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Act upon a received VehicleMission message
* Act upon a received VehicleMission message
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
decodeVehicleMission(message) {
decodeVehicleMission(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Transform local data into a VehicleStatus message
* Transform local data into a VehicleStatus message
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
encodeVehicleStatus(message) {
encodeVehicleStatus(message) {
Show 20 lines Show all unchanged lines
src/protocol/index.js
+ 54
- 57
Show all unchanged lines Show 20 lines
/**
/**
* GenericProtocol defines a simple passthru handler for messages
* GenericProtocol defines a simple passthru handler for messages
* This can be extended to handle different schemas
* This can be extended to handle different schemas
*
*
* The assumption is that all messages conform to a single
* The assumption is that all messages conform to a single
* wrapper schema definition. Different payloads are handled
* wrapper schema definition. Different payloads are handled
* by a oneOf definitions within the schema determined by a
* by a oneOf definitions within the schema determined by a
* field value.
* field value.
*
*
* This class can be extended and overridden to handle
* This class can be extended and overridden to handle
* different schemas and to implement the client specific
* different schemas and to implement the client specific
* logic related to be executed when invoked for a given
* logic related to be executed when invoked for a given
* message type.
* message type.
*
*
* By default encode and decode are just passthru stubs
* By default encode and decode are just passthru stubs
*
*
* decode is invoked when receiving a message from the backbone
* decode is invoked when receiving a message from the backbone
* encode is invoked before delivering a message to the backbone
* encode is invoked before delivering a message to the backbone
*
*
* The intention is that these allow you to transform the message
* The intention is that these allow you to transform the message
* and call invoke internal functions and services as required
* and call invoke internal functions and services as required
*/
*/
export class GenericProtocol {
export class GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
* @param {object} schema
* @param {object} schema
* @returns {Validator}
* @returns {Validator}
*/
*/
createValidator(schema) {
createValidator(schema) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Identify the payload type from the message content
* Identify the payload type from the message content
* @param {object} message
* @param {object} message
* @returns {string}
* @returns {string}
*/
*/
getType(message) {
getType(message) {
try {
try {
return message.payload.message_type;
return message.payload.message_type;
} catch(error) {
} catch (error) {
return null;
return null;
}
}
}
}
/**
/**
* Invoked on receiving a message from the backbone
* Invoked on receiving a message from the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the decode method
* be needed by sub-classes overriding the decode method
* @param {string} type
* @param {string} type
* @param {object} message
* @param {object} message
* @returns {*}
* @returns {*}
*/
*/
decode(type, message) {
decode(type, message) {
return message;
return message;
}
}
/**
/**
* Invoked on receiving an invalid message from the backbone
* Invoked on receiving an invalid message from the backbone
*
*
* @param {object} message
* @param {object} message
* @param {object} validation
* @param {object} validation
* @returns {*}
* @returns {*}
*/
*/
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Optionally invoked before delivering a message to the backbone
* Optionally invoked before delivering a message to the backbone
*
*
* Whilst type isn't used in the generic stub it will
* Whilst type isn't used in the generic stub it will
* be needed by sub-classes overriding the encode method
* be needed by sub-classes overriding the encode method
* @param {string} type
* @param {string} type
* @param {*} message
* @param {*} message
* @returns {object}
* @returns {object}
*/
*/
encode(type, message) {
encode(type, message) {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
}
}
/**
/**
* GenericSoarProtocol defines a simple passthru handler for messages
* GenericSoarProtocol defines a simple passthru handler for messages
*
*
* This provides the same as above but loads a version of the
* This provides the same as above but loads a version of the
* SoAR message protocol
* SoAR message protocol
*/
*/
export class GenericSoarProtocol extends GenericProtocol {
export class GenericSoarProtocol extends GenericProtocol {
constructor(schema, services) {
constructor(schema, services) {
Show 20 lines Show all unchanged lines Show 20 lines
/**
/**
* Create a Validator from the provided JSONSchema
* Create a Validator from the provided JSONSchema
*
*
* If schema is a string build a URL and retrieve the
* If schema is a string build a URL and retrieve the
* schema from gitlab
* schema from gitlab
* @param {string|object} schema
* @param {string|object} schema
* @returns {object}
* @returns {object}
*/
*/
createValidator(schema) {
createValidator(schema) {
if (typeof schema === 'string' && schema.match(/^[\w\.]+$/)) {
if (typeof schema === 'string' && schema.match(/^[\w.]+$/)) {
this.loadSchema(schema)
this.loadSchema(schema).then((schema) => {
.then((schema) => {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
});
});
} else {
} else {
this.validator = new Validator(schema);
this.validator = new Validator(schema);
}
}
}
}
/**
/**
* Load schema from gitlab by tag/branch/commitref
* Load schema from gitlab by tag/branch/commitref
* @param {string} version
* @param {string} version
* @returns {object}
* @returns {object}
*/
*/
loadSchema(version) {
loadSchema(version) {
this.axios = axios;
this.axios = axios;
let repository = "https://git.noc.ac.uk/communications-backbone-system/backbone-message-format";
let repository =
 
'https://git.noc.ac.uk/communications-backbone-system/backbone-message-format';
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
let url = `${repository}/-/raw/${version}/project/soar/swagger.json`;
return this.axios.get(url)
return this.axios.get(url).then((response) => {
.then((response) => {
this.schema = response.data;
this.schema = response.data
return response.data;
return response.data;
});
});
}
}
/**
/**
* Validate that a message meets the reqiured schema
* Validate that a message meets the reqiured schema
* @param {object} message
* @param {object} message
* @returns {object}
* @returns {object}
*/
*/
validate(message) {
validate(message) {
Show 20 lines Show all unchanged lines Show 20 lines
false
false
);
);
}
}
}
}
\ No newline at end of file
test/cucumber/adapter/auth.steps.js
+ 9
- 7
Show all unchanged lines Show 20 lines
const { fixtures } = require('../../fixtures/server');
const { fixtures } = require('../../fixtures/server');
When('the auth method is called', async function() {
When('the auth method is called', async function () {
await this.adapter.auth();
await this.adapter.auth();
});
});
Then('the adapter credentials are populated', function() {
Then('the adapter credentials are populated', function () {
assert.equal(this.adapter.credentials.token, fixtures.get('response-valid-token').token);
assert.equal(
 
this.adapter.credentials.token,
 
fixtures.get('response-valid-token').token
 
);
});
});
Then('the adapter auth fails', function() {
Then('the adapter auth fails', function () {
this.adapter.auth()
this.adapter.auth().catch((error) => {
.catch((error) => {
assert.equal(error.response.status, 403);
assert.equal(error.response.status, 403);
});
});
});
});
\ No newline at end of file
test/cucumber/adapter/before.steps.js
+ 36
- 26
const assert = require('assert');
const assert = require('assert');
const { Before } = require('@cucumber/cucumber');
const { Before } = require('@cucumber/cucumber');
const axios = require("axios");
const axios = require('axios');
const MockAdapter = require("axios-mock-adapter");
const MockAdapter = require('axios-mock-adapter');
// This sets the mock adapter on the default instance
// This sets the mock adapter on the default instance
const mockAxios = new MockAdapter(axios);
const mockAxios = new MockAdapter(axios);
Show 20 lines Show all unchanged lines Show 20 lines
const { Adapter } = require('../../../dist/adapter');
const { Adapter } = require('../../../dist/adapter');
/**
/**
* Use assert.CallTracker to track internal method calls
* Use assert.CallTracker to track internal method calls
* Instead of adding trackers to each method, create a
* Instead of adding trackers to each method, create a
* single tracked stub function and then use the parameters
* single tracked stub function and then use the parameters
* to record what is being tracked.
* to record what is being tracked.
*/
*/
const tracker = new assert.CallTracker();
const tracker = new assert.CallTracker();
const trackedFunction = function(method, params) {
const trackedFunction = function (method, params) {
// do nothing;
// do nothing;
};
};
const recorder = tracker.calls(trackedFunction);
const recorder = tracker.calls(trackedFunction);
Show 20 lines Show all unchanged lines Show 20 lines
}
}
getTrackedCalls(method) {
getTrackedCalls(method) {
let calls = this.tracker.getCalls(this.recorder);
let calls = this.tracker.getCalls(this.recorder);
let methodCalls = calls.filter(call => call.arguments[0] === method);
let methodCalls = calls.filter((call) => call.arguments[0] === method);
return methodCalls;
return methodCalls;
}
}
resetTracker() {
resetTracker() {
Show 20 lines Show all unchanged lines Show 20 lines
this.tracker = tracker;
this.tracker = tracker;
}
}
encode(type, message) {
encode(type, message) {
this.recorder('encode', {type, message});
this.recorder('encode', { type, message });
return super.encode(type, message)
return super.encode(type, message);
}
}
decode(type, message) {
decode(type, message) {
this.recorder('decode', {type, message});
this.recorder('decode', { type, message });
return super.decode(type, message)
return super.decode(type, message);
}
}
validate(message) {
validate(message) {
this.recorder('validate', {message});
this.recorder('validate', { message });
return super.validate(message);
return super.validate(message);
}
}
getTrackedCalls(method) {
getTrackedCalls(method) {
let calls = this.tracker.getCalls(this.recorder);
let calls = this.tracker.getCalls(this.recorder);
let methodCalls = calls.filter(call => call.arguments[0] === method);
let methodCalls = calls.filter((call) => call.arguments[0] === method);
return methodCalls;
return methodCalls;
}
}
resetTracker() {
resetTracker() {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
}
}
Before(function() {
Before(function () {
this.api = mockValidConfig.api;
this.api = mockValidConfig.api;
this.schema = mockSchema;
this.schema = mockSchema;
this.tracker = tracker;
this.tracker = tracker;
this.recorder = recorder;
this.recorder = recorder;
let services = {
let services = {
recorder,
recorder,
tracker
tracker,
};
};
this.classes = {
this.classes = {
TrackedAdapter,
TrackedAdapter,
TrackedGenericProtocol,
TrackedGenericProtocol,
};
};
this.callCounts = {};
this.callCounts = {};
this.protocol = new this.classes.TrackedGenericProtocol(this.schema, services);
this.protocol = new this.classes.TrackedGenericProtocol(
 
this.schema,
 
services
 
);
this.protocol.setupCallTracking(this.recorder, this.tracker);
this.protocol.setupCallTracking(this.recorder, this.tracker);
this.protocol.resetTracker();
this.protocol.resetTracker();
this.mockAxios = mockAxios;
this.mockAxios = mockAxios;
this.mockAxios.reset();
this.mockAxios.reset();
this.mockAxios.resetHistory();
this.mockAxios.resetHistory();
this.mockAxios.onGet(
this.mockAxios
`${mockValidConfig.api}/token`,
.onGet(`${mockValidConfig.api}/token`, {
{ params: { client_id: mockValidConfig.client_id, secret: mockValidConfig.secret } }
params: {
).reply(200, fixtures.get('response-valid-token'));
client_id: mockValidConfig.client_id,
 
secret: mockValidConfig.secret,
 
},
 
})
 
.reply(200, fixtures.get('response-valid-token'));
this.mockAxios.onGet(
this.mockAxios
`${mockInvalidConfig.api}/token`,
.onGet(`${mockInvalidConfig.api}/token`, {
{ params: { client_id: mockInvalidConfig.client_id, secret: mockInvalidConfig.secret } }
params: {
).reply(403, fixtures.get('response-denied-token'));
client_id: mockInvalidConfig.client_id,
secret: mockInvalidConfig.secret,
});
},
\ No newline at end of file
})
 
.reply(403, fixtures.get('response-denied-token'));
 
});
test/cucumber/adapter/broadcast.steps.js
+ 21
- 20
Show all unchanged lines Show 20 lines
const mockValidConfig = fixtures.get('config-valid');
const mockValidConfig = fixtures.get('config-valid');
When('a mock notify API response is configured to return success', function() {
When('a mock notify API response is configured to return success', function () {
const response = {};
const response = {};
this.mockAxios.onPost(
this.mockAxios.onPost(`${mockValidConfig.api}/notify`).reply(200, response);
`${mockValidConfig.api}/notify`,
).reply(200, response);
});
});
When('a mock notify API response is configured to return a {int} error', function(statusCode) {
When(
const statusMessages = {
'a mock notify API response is configured to return a {int} error',
403: 'Token expired',
function (statusCode) {
503: 'Service unavailable'
const statusMessages = {
};
403: 'Token expired',
this.mockAxios.onPost(
503: 'Service unavailable',
`${mockValidConfig.api}/notify`,
};
).reply(statusCode, { message: statusMessages[statusCode] })
this.mockAxios
});
.onPost(`${mockValidConfig.api}/notify`)
.reply(statusCode, { message: statusMessages[statusCode] });
When('the broadcast method is called', function() {
}
 
);
 
 
When('the broadcast method is called', function () {
const message = fixtures.get('message-vehicle-status');
const message = fixtures.get('message-vehicle-status');
this.message = message;
this.message = message;
const body = JSON.stringify(message);
const body = JSON.stringify(message);
Show 20 lines Show all unchanged lines Show 20 lines
this.callCounts.broadcast = this.adapter.getTrackedCalls('broadcast').length;
this.callCounts.broadcast = this.adapter.getTrackedCalls('broadcast').length;
});
});
When('the broadcast method is called with is_retry on', function() {
When('the broadcast method is called with is_retry on', function () {
const message = fixtures.get('message-vehicle-status');
const message = fixtures.get('message-vehicle-status');
this.message = message;
this.message = message;
const body = JSON.stringify(message);
const body = JSON.stringify(message);
Show 20 lines Show all unchanged lines Show 20 lines
this.callCounts.broadcast = this.adapter.getTrackedCalls('broadcast').length;
this.callCounts.broadcast = this.adapter.getTrackedCalls('broadcast').length;
});
});
Then('the broadcast method was called with is_retry on', function() {
Then('the broadcast method was called with is_retry on', function () {
let broadcastCalls = this.adapter.getTrackedCalls('broadcast');
let broadcastCalls = this.adapter.getTrackedCalls('broadcast');
let lastCall = broadcastCalls[broadcastCalls.length-1];
let lastCall = broadcastCalls[broadcastCalls.length - 1];
assert.ok(lastCall.arguments[1].is_retry);
assert.ok(lastCall.arguments[1].is_retry);
});
});
Then('the broadcast method is not called again', function() {
Then('the broadcast method is not called again', function () {
let newBroadcastCallCount = this.adapter.getTrackedCalls('broadcast').length;
let newBroadcastCallCount = this.adapter.getTrackedCalls('broadcast').length;
assert.equal(this.callCounts.broadcast, newBroadcastCallCount);
assert.equal(this.callCounts.broadcast, newBroadcastCallCount);
});
});
\ No newline at end of file
test/cucumber/adapter/common.steps.js
+ 41
- 30
Show all unchanged lines Show 20 lines
const mockSchema = require('../../mock/swagger.json');
const mockSchema = require('../../mock/swagger.json');
// const { Adapter } = require('../../../dist/adapter');
// const { Adapter } = require('../../../dist/adapter');
Given('valid config', function() {
Given('valid config', function () {
this.config = mockValidConfig
this.config = mockValidConfig;
});
});
Given('invalid config', function() {
Given('invalid config', function () {
this.schema = mockSchema;
this.schema = mockSchema;
this.config = mockInvalidConfig;
this.config = mockInvalidConfig;
});
});
When('the adapter instance is created', function() {
When('the adapter instance is created', function () {
this.adapter = new this.classes.TrackedAdapter(this.protocol, this.config);
this.adapter = new this.classes.TrackedAdapter(this.protocol, this.config);
this.adapter.setupCallTracking(this.recorder, this.tracker);
this.adapter.setupCallTracking(this.recorder, this.tracker);
});
});
Then('a successful response is returned with status {int}', function(expectedStatus) {
Then(
this.call
'a successful response is returned with status {int}',
.then(response => {
function (expectedStatus) {
assert.equal(response.status, expectedStatus);
this.call.then((response) => {
});
assert.equal(response.status, expectedStatus);
});
});
 
}
 
);
Then('an error response is returned with status {int}', function(expectedStatus) {
Then(
this.call
'an error response is returned with status {int}',
.catch((error) => {
function (expectedStatus) {
assert.equal(error.response.status, expectedStatus);
this.call.catch((error) => {
});
assert.equal(error.response.status, expectedStatus);
});
});
 
}
 
);
Then('the credentials are deleted', function() {
Then('the credentials are deleted', function () {
assert.equal(this.adapter.credentials, null);
assert.equal(this.adapter.credentials, null);
});
});
Then('the credentials are not deleted', function() {
Then('the credentials are not deleted', function () {
assert.notEqual(this.adapter.credentials, null);
assert.notEqual(this.adapter.credentials, null);
});
});
When('the {string} method call counts are checked', function(method) {
When('the {string} method call counts are checked', function (method) {
let newCallCount = this.adapter.getTrackedCalls(method).length;
let newCallCount = this.adapter.getTrackedCalls(method).length;
this.callCounts[method] = newCallCount;
this.callCounts[method] = newCallCount;
});
});
Then('the {string} method is not called again', function(method) {
Then('the {string} method is not called again', function (method) {
let newCallCount = this.adapter.getTrackedCalls(method).length;
let newCallCount = this.adapter.getTrackedCalls(method).length;
assert.equal(this.callCounts[method], newCallCount);
assert.equal(this.callCounts[method], newCallCount);
});
});
Then('the total number of calls to {string} was {int}', function(method, expectedCallCount) {
Then(
let callCount = this.adapter.getTrackedCalls(method).length;
'the total number of calls to {string} was {int}',
assert.equal(callCount, expectedCallCount);
function (method, expectedCallCount) {
});
let callCount = this.adapter.getTrackedCalls(method).length;
assert.equal(callCount, expectedCallCount);
Then('the total number of {string} requests to {string} was {int}', function(method, endpoint, expectedCallCount) {
}
let url = `${this.api}${endpoint}`;
);
let requestHistory = this.mockAxios.history[method.toLowerCase()].filter((request) => request.url === url);
assert.equal(requestHistory.length, expectedCallCount);
});
 
Then(
 
'the total number of {string} requests to {string} was {int}',
 
function (method, endpoint, expectedCallCount) {
 
let url = `${this.api}${endpoint}`;
 
let requestHistory = this.mockAxios.history[method.toLowerCase()].filter(
 
(request) => request.url === url
 
);
 
assert.equal(requestHistory.length, expectedCallCount);
 
}
 
);
test/cucumber/adapter/get-authorization-header.steps.js
+ 12
- 9
const assert = require('assert');
const assert = require('assert');
const { When, Then } = require('@cucumber/cucumber');
const { When, Then } = require('@cucumber/cucumber');
When('the getAuthorizationHeader method is called', function() {
When('the getAuthorizationHeader method is called', function () {
this.call = this.adapter.getAuthorizationHeader();
this.call = this.adapter.getAuthorizationHeader();
let callCount = this.adapter.getTrackedCalls('getAuthorizationHeader').length;
let callCount = this.adapter.getTrackedCalls('getAuthorizationHeader').length;
this.callCounts.getAuthorizationHeader = callCount;
this.callCounts.getAuthorizationHeader = callCount;
});
});
Then('a headers object is returned containing a bearer token authorization header', function() {
Then(
this.call.then(headers => {
'a headers object is returned containing a bearer token authorization header',
assert.ok('Authorization' in headers);
function () {
const authHeaderWords = headers.Authorization.split(" ");
this.call.then((headers) => {
assert.ok(authHeaderWords[0] === 'Bearer');
assert.ok('Authorization' in headers);
assert.ok(authHeaderWords[1] === this.adapter.credentials.token);
const authHeaderWords = headers.Authorization.split(' ');
});
assert.ok(authHeaderWords[0] === 'Bearer');
});
assert.ok(authHeaderWords[1] === this.adapter.credentials.token);
 
});
 
}
 
);
test/cucumber/adapter/poll.steps.js
+ 43
- 34
Show all unchanged lines Show 20 lines
const mockValidConfig = fixtures.get('config-valid');
const mockValidConfig = fixtures.get('config-valid');
const xMessageResponse = function(xMessages) {
const xMessageResponse = function (xMessages) {
const message = fixtures.get('message-vehicle-status');
const message = fixtures.get('message-vehicle-status');
let response = [];
let response = [];
for (let i=0; i<xMessages; i++) {
for (let i = 0; i < xMessages; i++) {
response.push({
response.push({
topic: "broadcast",
topic: 'broadcast',
message: JSON.stringify(message)
message: JSON.stringify(message),
});
});
}
}
return response;
return response;
};
};
When('a mock receive API response is configured to return {int} messages', function(xMessages) {
When(
const response = xMessageResponse(xMessages);
'a mock receive API response is configured to return {int} messages',
this.mockAxios.onGet(
function (xMessages) {
`${mockValidConfig.api}/receive`,
const response = xMessageResponse(xMessages);
).reply(200, response);
this.mockAxios.onGet(`${mockValidConfig.api}/receive`).reply(200, response);
});
}
 
);
When('a mock receive API response is configured to return a {int} error', function(statusCode) {
When(
const statusMessages = {
'a mock receive API response is configured to return a {int} error',
403: 'Token expired',
function (statusCode) {
503: 'Service unavailable'
const statusMessages = {
};
403: 'Token expired',
this.mockAxios.onGet(
503: 'Service unavailable',
`${mockValidConfig.api}/receive`,
};
).reply(statusCode, { message: statusMessages[statusCode] })
this.mockAxios
});
.onGet(`${mockValidConfig.api}/receive`)
 
.reply(statusCode, { message: statusMessages[statusCode] });
 
}
 
);
When('the poll method is called', function() {
When('the poll method is called', function () {
this.call = this.adapter.poll();
this.call = this.adapter.poll();
this.callCounts.poll = this.adapter.getTrackedCalls('poll').length;
this.callCounts.poll = this.adapter.getTrackedCalls('poll').length;
});
});
Then('a successful response is returned with {int} messages', function(xMessages) {
Then(
this.call
'a successful response is returned with {int} messages',
.then(response => {
function (xMessages) {
assert.equal(response.data.length, xMessages);
this.call.then((response) => {
});
assert.equal(response.data.length, xMessages);
});
});
 
}
 
);
Then('the protocol {string} method is called {int} times', function(method, xInvokes) {
Then(
const decodes = this.protocol.getTrackedCalls(method);
'the protocol {string} method is called {int} times',
assert.equal(decodes.length, xInvokes);
function (method, xInvokes) {
});
const decodes = this.protocol.getTrackedCalls(method);
 
assert.equal(decodes.length, xInvokes);
 
}
 
);
When('the poll method is called with is_retry on', function() {
When('the poll method is called with is_retry on', function () {
this.call = this.adapter.poll(true);
this.call = this.adapter.poll(true);
this.callCounts.poll = this.adapter.getTrackedCalls('poll').length;
this.callCounts.poll = this.adapter.getTrackedCalls('poll').length;
});
});
Then('the poll method was called with is_retry on', function() {
Then('the poll method was called with is_retry on', function () {
let pollCalls = this.adapter.getTrackedCalls('poll');
let pollCalls = this.adapter.getTrackedCalls('poll');
let lastCall = pollCalls[pollCalls.length-1];
let lastCall = pollCalls[pollCalls.length - 1];
assert.ok(lastCall.arguments[1].is_retry);
assert.ok(lastCall.arguments[1].is_retry);
});
});
Then('the poll method is not called again', function() {
Then('the poll method is not called again', function () {
let newPollCallCount = this.adapter.getTrackedCalls('poll').length;
let newPollCallCount = this.adapter.getTrackedCalls('poll').length;
assert.equal(this.callCounts.poll, newPollCallCount);
assert.equal(this.callCounts.poll, newPollCallCount);
});
});
test/cucumber/adapter/publish.steps.js
+ 21
- 20
Show all unchanged lines Show 20 lines
const mockValidConfig = fixtures.get('config-valid');
const mockValidConfig = fixtures.get('config-valid');
When('a mock send API response is configured to return success', function() {
When('a mock send API response is configured to return success', function () {
const response = {};
const response = {};
this.mockAxios.onPost(
this.mockAxios.onPost(`${mockValidConfig.api}/send`).reply(200, response);
`${mockValidConfig.api}/send`,
).reply(200, response);
});
});
When('a mock send API response is configured to return a {int} error', function(statusCode) {
When(
const statusMessages = {
'a mock send API response is configured to return a {int} error',
403: 'Token expired',
function (statusCode) {
503: 'Service unavailable'
const statusMessages = {
};
403: 'Token expired',
this.mockAxios.onPost(
503: 'Service unavailable',
`${mockValidConfig.api}/send`,
};
).reply(statusCode, { message: statusMessages[statusCode] })
this.mockAxios
});
.onPost(`${mockValidConfig.api}/send`)
.reply(statusCode, { message: statusMessages[statusCode] });
When('the publish method is called', function() {
}
 
);
 
 
When('the publish method is called', function () {
const message = fixtures.get('message-vehicle-status');
const message = fixtures.get('message-vehicle-status');
this.message = message;
this.message = message;
const topic = message.metadata.destination;
const topic = message.metadata.destination;
Show 20 lines Show all unchanged lines Show 20 lines
this.callCounts.publish = this.adapter.getTrackedCalls('publish').length;
this.callCounts.publish = this.adapter.getTrackedCalls('publish').length;
});
});
When('the publish method is called with is_retry on', function() {
When('the publish method is called with is_retry on', function () {
const message = fixtures.get('message-vehicle-status');
const message = fixtures.get('message-vehicle-status');
this.message = message;
this.message = message;
const topic = message.metadata.destination;
const topic = message.metadata.destination;
Show 20 lines Show all unchanged lines Show 20 lines
this.callCounts.publish = this.adapter.getTrackedCalls('publish').length;
this.callCounts.publish = this.adapter.getTrackedCalls('publish').length;
});
});
Then('the publish method was called with is_retry on', function() {
Then('the publish method was called with is_retry on', function () {
let publishCalls = this.adapter.getTrackedCalls('publish');
let publishCalls = this.adapter.getTrackedCalls('publish');
let lastCall = publishCalls[publishCalls.length-1];
let lastCall = publishCalls[publishCalls.length - 1];
assert.ok(lastCall.arguments[1].is_retry);
assert.ok(lastCall.arguments[1].is_retry);
});
});
Then('the publish method is not called again', function() {
Then('the publish method is not called again', function () {
let newPublishCallCount = this.adapter.getTrackedCalls('publish').length;
let newPublishCallCount = this.adapter.getTrackedCalls('publish').length;
assert.equal(this.callCounts.publish, newPublishCallCount);
assert.equal(this.callCounts.publish, newPublishCallCount);
});
});
\ No newline at end of file
test/cucumber/adapter/token-valid.steps.js
+ 8
- 8
const assert = require('assert');
const assert = require('assert');
const { When, Then } = require('@cucumber/cucumber');
const { When, Then } = require('@cucumber/cucumber');
When('the token expiry is in the future', function() {
When('the token expiry is in the future', function () {
const expiry = new Date();
const expiry = new Date();
expiry.setHours(expiry.getHours()+1);
expiry.setHours(expiry.getHours() + 1);
this.adapter.credentials.expiry = expiry.toISOString();
this.adapter.credentials.expiry = expiry.toISOString();
});
});
When('the token expiry is in the past', function() {
When('the token expiry is in the past', function () {
const expiry = new Date();
const expiry = new Date();
expiry.setHours(expiry.getHours()-1);
expiry.setHours(expiry.getHours() - 1);
this.adapter.credentials.expiry = expiry.toISOString();
this.adapter.credentials.expiry = expiry.toISOString();
});
});
// Boolean parameters are not supported
// Boolean parameters are not supported
// and returns "true" would be misleading
// and returns "true" would be misleading
Then('tokenValid returns true', function() {
Then('tokenValid returns true', function () {
const isValid = this.adapter.tokenValid();
const isValid = this.adapter.tokenValid();
assert.ok(isValid);
assert.ok(isValid);
});
});
Then('tokenValid returns false', function() {
Then('tokenValid returns false', function () {
const isValid = this.adapter.tokenValid();
const isValid = this.adapter.tokenValid();
assert.ok(!isValid);
assert.ok(!isValid);
});
});
\ No newline at end of file
test/cucumber/adapter/validate.steps.js
+ 5
- 6
const assert = require('assert');
const { Given, When } = require('@cucumber/cucumber');
const { Given, When, Then } = require('@cucumber/cucumber');
const { fixtures } = require('../../fixtures/server');
const { fixtures } = require('../../fixtures/server');
Given('a valid message', function() {
Given('a valid message', function () {
this.message = fixtures.get('message-vehicle-status');
this.message = fixtures.get('message-vehicle-status');
});
});
Given('an invalid message', function() {
Given('an invalid message', function () {
this.message = fixtures.get('message-vehicle-status-invalid');
this.message = fixtures.get('message-vehicle-status-invalid');
});
});
When('the validate method is called', function() {
When('the validate method is called', function () {
this.validation = this.adapter.validate(this.message);
this.validation = this.adapter.validate(this.message);
});
});
\ No newline at end of file
test/cucumber/protocol/common.steps.js
+ 2
- 2
const assert = require('assert');
const assert = require('assert');
const { Then } = require('@cucumber/cucumber');
const { Then } = require('@cucumber/cucumber');
Then('the message is returned unaltered', function() {
Then('the message is returned unaltered', function () {
assert.equal(this.message, this.response);
assert.equal(this.message, this.response);
});
});
\ No newline at end of file
test/cucumber/protocol/decode.steps.js
+ 2
- 2
const { When } = require('@cucumber/cucumber');
const { When } = require('@cucumber/cucumber');
When('the protocol.decode method is called', function() {
When('the protocol.decode method is called', function () {
const type = this.protocol.getType(this.message);
const type = this.protocol.getType(this.message);
this.response = this.protocol.decode(type, this.message);
this.response = this.protocol.decode(type, this.message);
});
});
\ No newline at end of file
test/cucumber/protocol/encode.steps.js
+ 2
- 2
const { When } = require('@cucumber/cucumber');
const { When } = require('@cucumber/cucumber');
When('the protocol.encode method is called', function() {
When('the protocol.encode method is called', function () {
const type = this.protocol.getType(this.message);
const type = this.protocol.getType(this.message);
this.response = this.protocol.encode(type, this.message);
this.response = this.protocol.encode(type, this.message);
});
});
\ No newline at end of file
test/cucumber/protocol/get-type.steps.js
+ 8
- 5
const assert = require('assert');
const assert = require('assert');
const { When, Then } = require('@cucumber/cucumber');
const { When, Then } = require('@cucumber/cucumber');
When('protocol getType is called', function() {
When('protocol getType is called', function () {
this.type = this.protocol.getType(this.message);
this.type = this.protocol.getType(this.message);
});
});
Then('getType returns message.payload.message_type if present', function() {
Then('getType returns message.payload.message_type if present', function () {
assert.equal(this.type, this.message.payload.message_type);
assert.equal(this.type, this.message.payload.message_type);
});
});
Then('getType returns null if message.payload.message_type is not present', function() {
Then(
assert.equal(this.type, null);
'getType returns null if message.payload.message_type is not present',
});
function () {
\ No newline at end of file
assert.equal(this.type, null);
 
}
 
);
test/cucumber/protocol/validate.steps.js
+ 4
- 4
const assert = require('assert');
const assert = require('assert');
const { When, Then } = require('@cucumber/cucumber');
const { When, Then } = require('@cucumber/cucumber');
When('the protocol.validate method is called', function() {
When('the protocol.validate method is called', function () {
this.validation = this.protocol.validate(this.message);
this.validation = this.protocol.validate(this.message);
});
});
Then('the message is validated successfully', function() {
Then('the message is validated successfully', function () {
assert.equal(this.validation.valid, true);
assert.equal(this.validation.valid, true);
assert.equal(this.validation.errorCount, 0);
assert.equal(this.validation.errorCount, 0);
});
});
Then('the message fails to validate', function() {
Then('the message fails to validate', function () {
assert.equal(this.validation.valid, false);
assert.equal(this.validation.valid, false);
assert.notEqual(this.validation.errorCount, 0);
assert.notEqual(this.validation.errorCount, 0);
});
});
\ No newline at end of file
test/cucumber/schema/validate.steps.js
+ 6
- 6
Show all unchanged lines Show 20 lines
const schemaLocation = './test/mock/swagger.json';
const schemaLocation = './test/mock/swagger.json';
Given('the test schema', function() {
Given('the test schema', function () {
this.schema = JSON.parse(fs.readFileSync(schemaLocation));
this.schema = JSON.parse(fs.readFileSync(schemaLocation));
});
});
When('it is validated', function() {
When('it is validated', function () {
const validator = new OpenAPISchemaValidator({ version: 3 });
const validator = new OpenAPISchemaValidator({ version: 3 });
this.validation = validator.validate(this.schema);
this.validation = validator.validate(this.schema);
});
});
Then('it matches the OpenAPI specification', function() {
Then('it matches the OpenAPI specification', function () {
// According to the docs this should return a valid:boolean
// According to the docs this should return a valid:boolean
// but if you look at the code it just returns a list of errors
// but if you look at the code it just returns a list of errors
// which is empty for a valid result
// which is empty for a valid result
assert.equal(this.validation.errors.length, 0);
assert.equal(this.validation.errors.length, 0);
});
});
\ No newline at end of file
test/fixtures/server.js
+ 6
- 4
Show all unchanged lines Show 20 lines
exports.fixtures = {
exports.fixtures = {
get: function (fixtureName) {
get: function (fixtureName) {
try {
try {
let fixtureContent = fs.readFileSync(path.join(__dirname, `${fixtureName}.json`));
let fixtureContent = fs.readFileSync(
 
path.join(__dirname, `${fixtureName}.json`)
 
);
let fixture = JSON.parse(fixtureContent);
let fixture = JSON.parse(fixtureContent);
return fixture;
return fixture;
} catch(e) {
} catch (e) {
console.error('Fixture not found', fixtureName);
console.error('Fixture not found', fixtureName);
return null;
return null;
}
}
}
},
}
};
\ No newline at end of file
test/mock/messages/Message_VehicleMission.json
+ 1
- 1
Show all unchanged lines Show 20 lines
"longitude": -10.432,
"longitude": -10.432,
"depth": 50,
"depth": 50,
"projection": 4326
"projection": 4326
},
},
"actions": []
"actions": []
}
}
}
}
test/mock/messages/Message_VehicleStatus.json
+ 1
- 1
Show all unchanged lines Show 20 lines
},
},
"battery_percentage": 64
"battery_percentage": 64
}
}
}
}
\ No newline at end of file
test/mock/swagger.json
+ 21
- 4
Show all unchanged lines Show 20 lines
"example": "VehicleStatus"
"example": "VehicleStatus"
}
}
},
},
"required": ["source","destination","message_id"],
"required": ["source", "destination", "message_id"],
"type": "object"
"type": "object"
},
},
"Coordinates": {
"Coordinates": {
Show 20 lines Show all unchanged lines Show 20 lines
"example": 64
"example": 64
}
}
},
},
"required": ["message_type", "operator_id", "vehicle_id", "coordinates", "battery_percentage"],
"required": [
 
"message_type",
 
"operator_id",
 
"vehicle_id",
 
"coordinates",
 
"battery_percentage"
 
],
"type": "object"
"type": "object"
},
},
"VehicleMission": {
"VehicleMission": {
Show 20 lines Show all unchanged lines Show 20 lines
}
}
}
}
},
},
"required": ["message_type", "operator_id", "vehicle_id", "coordinates", "actions"],
"required": [
 
"message_type",
 
"operator_id",
 
"vehicle_id",
 
"coordinates",
 
"actions"
 
],
"type": "object"
"type": "object"
},
},
"AreaOfInterest": {
"AreaOfInterest": {
Show 20 lines Show all unchanged lines Show 20 lines
"$ref": "#/components/schemas/Coordinates"
"$ref": "#/components/schemas/Coordinates"
}
}
},
},
"required": ["message_type", "operator_id", "vehicle_id", "coordinates"],
"required": [
 
"message_type",
 
"operator_id",
 
"vehicle_id",
 
"coordinates"
 
],
"type": "object"
"type": "object"
},
},
"GoToWaypoint": {
"GoToWaypoint": {
Show 20 lines Show all unchanged lines
.eslintrc.js
+ 6
- 11
Show all unchanged lines Show 20 lines
env: {
env: {
browser: true,
browser: true,
node: true,
node: true,
'jest/globals': true,
es6: true,
},
},
parserOptions: {
parserOptions: {
parser: '@babel/eslint-parser',
parser: '@babel/eslint-parser',
// Fix "No Babel config file detected for [file]" error
sourceType: 'module',
// https://github.com/babel/babel/issues/11975#issuecomment-786803214
requireConfigFile: false,
requireConfigFile: false,
 
ecmaVersion: 'latest',
},
},
extends: [
extends: ['eslint:recommended', 'plugin:prettier/recommended'],
'eslint:recommended',
ignorePatterns: ['**/dist/'],
'prettier',
],
// required to lint *.vue files
plugins: ['vue', 'jest', 'prettier'],
// add your custom rules here
// add your custom rules here
rules: {
rules: {
'no-console': ['warn', { allow: ['warn', 'error'] }],
'no-console': ['error', { allow: ['warn', 'error'] }],
'no-debugger': 'warn',
'no-unused-vars': ['error', { args: 'none' }],
'no-unused-vars': ['error', { args: 'none' }],
},
},
};
};
.prettierignore
+ 8
- 62
###
# Ignore artifacts:
# Place your Prettier ignore content here
**/dist/
**/*.esm.js
###
**/*.ssr.js
# .gitignore content is duplicated here due to https://github.com/prettier/prettier/issues/8506
**/*.min.js
**/.nyc-output/
# Created by .ignore support plugin (hsz.mobi)
**/.nuxt/
### Node template
**/.turbo/
# Logs
\ No newline at end of file
/logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
# nyc test coverage
.nyc_output
# Dependency directories
node_modules/
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variables file
.env
# parcel-bundler cache (https://parceljs.org/)
.cache
# IDE / Editor
.idea
# macOS
.DS_Store
# Vim swap files
*.swp
.prettierrc deleted
+ 0
- 10
{
"trailingComma": "es5",
"tabWidth": 2,
"useTabs": false,
"semi": true,
"singleQuote": true,
"bracketSameLine": false,
"arrowParens": "always",
"endOfLine": "lf"
}
.prettierrc.js
+ 10
- 0
 
module.exports = {
 
trailingComma: 'es5',
 
tabWidth: 2,
 
useTabs: false,
 
semi: true,
 
singleQuote: true,
 
bracketSameLine: false,
 
arrowParens: 'always',
 
endOfLine: 'lf',
 
};
LICENCE.md
+ 1
- 1
Show all unchanged lines Show 20 lines
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
README.md
+ 46
- 46
# backbone-adapter-javascript
# backbone-adapter-javascript
Generic adapter for the communications-backbone.
Generic adapter for the communications-backbone.
Implements:
Implements:
- client credentials grant
- client credentials grant
- http send/receive/notify to backbone
- http send/receive/notify to backbone
- websockets send and receive
- websockets send and receive
- validation of messages against a specified OpenAPI schema
- validation of messages against a specified OpenAPI schema
- decode/encode stubs
- decode/encode stubs
## Setup
## Setup
```
```
yarn install
yarn install
Show 20 lines Show all unchanged lines Show 20 lines
yarn copytests
yarn copytests
```
```
## Test
## Test
The tests are written in [cucumber](https://cucumber.io/docs/installation/javascript/)
The tests are written in [cucumber](https://cucumber.io/docs/installation/javascript/)
This means we can have a common suite of [gherkin](https://github.com/cucumber/gherkin)
This means we can have a common suite of [gherkin](https://github.com/cucumber/gherkin)
tests across adapter ports written in multiple languages.
tests across adapter ports written in multiple languages.
```
```
yarn test
yarn test
```
```
## Installing in your project
## Installing in your project
We may publish this to a public registry but for now you need to install the package
We may publish this to a public registry but for now you need to install the package
from git.
from git.
### Requirements
### Requirements
An `axios` library. Axios is included as a dev dependency to run the tests.
An `axios` library. Axios is included as a dev dependency to run the tests.
I've not installed it as a runtime dependency because in nuxt you need to
I've not installed it as a runtime dependency because in nuxt you need to
use `@nuxtjs/axios` instead.
use `@nuxtjs/axios` instead.
**TODO fix this in rollup config**
**TODO fix this in rollup config**
Show 20 lines Show all unchanged lines Show 20 lines
npm install git+https://git.noc.ac.uk/communications-backbone-system/backbone-adapter-javascript.git
npm install git+https://git.noc.ac.uk/communications-backbone-system/backbone-adapter-javascript.git
```
```
## Schema
## Schema
The example code uses a mock schema with some example messages. The intention is the message
The example code uses a mock schema with some example messages. The intention is the message
protocol schema is retreived from an external source.
protocol schema is retreived from an external source.
## Config
## Config
To run the adapter you need a credentials file called `soar-config.json`.
To run the adapter you need a credentials file called `soar-config.json`.
This will be provided by the backbone operator or requested via the API.
This will be provided by the backbone operator or requested via the API.
```json
```json
{
{
Show 20 lines Show all unchanged lines Show 20 lines
}
}
```
```
### Topics
### Topics
When sending messages you should publish them using a topic matching [this definition](https://git.noc.ac.uk/communications-backbone-system/backbone-message-format#topics).
When sending messages you should publish them using a topic matching [this definition](https://git.noc.ac.uk/communications-backbone-system/backbone-message-format#topics).
## Encoding and decoding
## Encoding and decoding
### Decoding
### Decoding
Decoding refers to translation from the backbone message protocol into a
Decoding refers to translation from the backbone message protocol into a
native format for the client app to process.
native format for the client app to process.
All messages received from the backbone are parsed and validated against the
All messages received from the backbone are parsed and validated against the
protocol schema and then passed to the protocol decode function.
protocol schema and then passed to the protocol decode function.
By overriding the decode function the client can define local actions to be
By overriding the decode function the client can define local actions to be
executed when a message of a given type is received.
executed when a message of a given type is received.
### Encoding
### Encoding
Encoding refers to translation from the client app's native format into a
Encoding refers to translation from the client app's native format into a
message conforming to the backbone message protocol.
message conforming to the backbone message protocol.
The equivalent encode method allows the client to define translations per
The equivalent encode method allows the client to define translations per
message type to transform local data into a message conforming to the
message type to transform local data into a message conforming to the
protocol schema for transmission.
protocol schema for transmission.
Messages passed to the publish and broadcast methods should have been
Messages passed to the publish and broadcast methods should have been
encoded and validated against the protocol schema.
encoded and validated against the protocol schema.
## Publish vs Broadcast
## Publish vs Broadcast
It is intended that all normal-operation messages will be published on
It is intended that all normal-operation messages will be published on
a given topic allowing clients to choose which message topics to
a given topic allowing clients to choose which message topics to
subscribe to.
subscribe to.
Broadcast is provided for contingency scenarios. The intention is that
Broadcast is provided for contingency scenarios. The intention is that
in the case of a failure/abort a message can be sent to all parties
in the case of a failure/abort a message can be sent to all parties
which bypasses any existing messages in the publish queue.
which bypasses any existing messages in the publish queue.
The client implementation can chose to take no-action on decoding one of
The client implementation can chose to take no-action on decoding one of
these messages but they will be made available to all clients.
these messages but they will be made available to all clients.
cucumber.js
+ 3
- 3
module.exports = {
module.exports = {
default: {
default: {
formatOptions: {
formatOptions: {
snippetInterface: "synchronous"
snippetInterface: 'synchronous',
},
},
paths: [ 'test/features/**/*.feature' ],
paths: ['test/features/**/*.feature'],
require: [ 'test/cucumber/**/*.steps.js' ],
require: ['test/cucumber/**/*.steps.js'],
},
},
};
};
jest.config.js
+ 1
- 2
Show all unchanged lines Show 20 lines
'^.+\\.js$': 'babel-jest',
'^.+\\.js$': 'babel-jest',
},
},
collectCoverage: true,
collectCoverage: true,
collectCoverageFrom: [
collectCoverageFrom: [],
],
testEnvironment: 'jsdom',
testEnvironment: 'jsdom',
};
};
package.json
+ 3
- 3
Show all unchanged lines Show 20 lines
"copytest:features": "npx recursive-copy -w node_modules/backbone-adapter-testsuite/features test/features",
"copytest:features": "npx recursive-copy -w node_modules/backbone-adapter-testsuite/features test/features",
"copytest:fixtures": "npx recursive-copy -w node_modules/backbone-adapter-testsuite/fixtures test/fixtures",
"copytest:fixtures": "npx recursive-copy -w node_modules/backbone-adapter-testsuite/fixtures test/fixtures",
"copytests": "npm run copytest:features && npm run copytest:fixtures",
"copytests": "npm run copytest:features && npm run copytest:fixtures",
"lint:js": "eslint --ext \".js\" --ignore-path .gitignore .",
"lint:js": "eslint -c .eslintrc.js --ext .js --ignore-path .gitignore .",
"lint:prettier": "prettier --check .",
"lint:prettier": "prettier --check .",
"lint": "yarn lint:js && yarn lint:prettier",
"lint": "yarn lint:js && yarn lint:prettier",
"lintfix": "prettier --write --list-different . && yarn lint:js --fix",
"lintfix": "prettier --write --list-different . && yarn lint:js --fix",
Show 20 lines Show all unchanged lines Show 20 lines
"babel-jest": "^27.4.4",
"babel-jest": "^27.4.4",
"backbone-adapter-testsuite": "git+https://git.noc.ac.uk/communications-backbone-system/backbone-adapter-testsuite.git#dev",
"backbone-adapter-testsuite": "git+https://git.noc.ac.uk/communications-backbone-system/backbone-adapter-testsuite.git#dev",
"cross-env": "^7.0.3",
"cross-env": "^7.0.3",
"eslint": "^8.4.1",
"eslint": "^8.36.0",
"eslint-config-prettier": "^8.3.0",
"eslint-config-prettier": "^8.3.0",
"eslint-plugin-prettier": "^4.2.1",
"eslint-plugin-prettier": "^4.2.1",
"husky": "^7.0.4",
"husky": "^7.0.4",
"jest": "^27.4.4",
"jest": "^27.4.4",
"lint-staged": "^12.1.2",
"lint-staged": "^12.1.2",
"openapi-schema-validator": "^12.1.0",
"openapi-schema-validator": "^12.1.0",
"prettier": "^2.5.1",
"prettier": "^2.8.4",
"recursive-copy-cli": "^1.0.20",
"recursive-copy-cli": "^1.0.20",
"rollup": "^3.9.1"
"rollup": "^3.9.1"
}
}
Show 20 lines Show all unchanged lines
yarn.lock
+ 45
- 39
Show all unchanged lines Show 20 lines
ts-node "^9"
ts-node "^9"
tslib "^2"
tslib "^2"
"@eslint/eslintrc@^1.4.1":
"@eslint-community/eslint-utils@^4.2.0":
version "1.4.1"
version "4.3.0"
resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.4.1.tgz#af58772019a2d271b7e2d4c23ff4ddcba3ccfb3e"
resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.3.0.tgz#a556790523a351b4e47e9d385f47265eaaf9780a"
integrity sha512-XXrH9Uarn0stsyldqDYq8r++mROmWRI1xKMXa640Bb//SY1+ECYX6VzT6Lcx5frD0V30XieqJ0oX9I2Xj5aoMA==
integrity sha512-v3oplH6FYCULtFuCeqyuTd9D2WKO937Dxdq+GmHOLL72TTRriLxz2VLlNfkZRsvj6PKnOPAtuT6dwrs/pA5DvA==
 
dependencies:
 
eslint-visitor-keys "^3.3.0"
 
 
"@eslint-community/regexpp@^4.4.0":
 
version "4.4.0"
 
resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.4.0.tgz#3e61c564fcd6b921cb789838631c5ee44df09403"
 
integrity sha512-A9983Q0LnDGdLPjxyXQ00sbV+K+O+ko2Dr+CZigbHWtX9pNfxlaBkMR8X1CztI73zuEyEBXTVjx7CE+/VSwDiQ==
 
 
"@eslint/eslintrc@^2.0.1":
 
version "2.0.1"
 
resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.0.1.tgz#7888fe7ec8f21bc26d646dbd2c11cd776e21192d"
 
integrity sha512-eFRmABvW2E5Ho6f5fHLqgena46rOj7r7OKHYfLElqcBfGFHHpjBhivyi5+jOEQuSpdc/1phIZJlbC2te+tZNIw==
dependencies:
dependencies:
ajv "^6.12.4"
ajv "^6.12.4"
debug "^4.3.2"
debug "^4.3.2"
espree "^9.4.0"
espree "^9.5.0"
globals "^13.19.0"
globals "^13.19.0"
ignore "^5.2.0"
ignore "^5.2.0"
import-fresh "^3.2.1"
import-fresh "^3.2.1"
Show 20 lines Show all unchanged lines Show 20 lines
minimatch "^3.1.2"
minimatch "^3.1.2"
strip-json-comments "^3.1.1"
strip-json-comments "^3.1.1"
 
"@eslint/js@8.36.0":
 
version "8.36.0"
 
resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.36.0.tgz#9837f768c03a1e4a30bd304a64fb8844f0e72efe"
 
integrity sha512-lxJ9R5ygVm8ZWgYdUweoq5ownDlJ4upvoWmO4eLxBYHdMo+vZ/Rx0EN6MbKWDJOSUGrqJy2Gt+Dyv/VKml0fjg==
 
"@humanwhocodes/config-array@^0.11.8":
"@humanwhocodes/config-array@^0.11.8":
version "0.11.8"
version "0.11.8"
resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9"
resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9"
Show 20 lines Show all unchanged lines Show 20 lines
esrecurse "^4.3.0"
esrecurse "^4.3.0"
estraverse "^5.2.0"
estraverse "^5.2.0"
eslint-utils@^3.0.0:
eslint-visitor-keys@^2.1.0:
version "3.0.0"
resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672"
integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==
dependencies:
eslint-visitor-keys "^2.0.0"
eslint-visitor-keys@^2.0.0, eslint-visitor-keys@^2.1.0:
version "2.1.0"
version "2.1.0"
resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303"
resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303"
integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==
integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==
Show 20 lines Show all unchanged lines Show 20 lines
resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
eslint@^8.4.1:
eslint@^8.36.0:
version "8.31.0"
version "8.36.0"
resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.31.0.tgz#75028e77cbcff102a9feae1d718135931532d524"
resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.36.0.tgz#1bd72202200a5492f91803b113fb8a83b11285cf"
integrity sha512-0tQQEVdmPZ1UtUKXjX7EMm9BlgJ08G90IhWh0PKDCb3ZLsgAOHI8fYSIzYVZej92zsgq+ft0FGsxhJ3xo2tbuA==
integrity sha512-Y956lmS7vDqomxlaaQAHVmeb4tNMp2FWIvU/RnU5BD3IKMD/MJPr76xdyr68P8tV1iNMvN2mRK0yy3c+UjL+bw==
dependencies:
dependencies:
"@eslint/eslintrc" "^1.4.1"
"@eslint-community/eslint-utils" "^4.2.0"
 
"@eslint-community/regexpp" "^4.4.0"
 
"@eslint/eslintrc" "^2.0.1"
 
"@eslint/js" "8.36.0"
"@humanwhocodes/config-array" "^0.11.8"
"@humanwhocodes/config-array" "^0.11.8"
"@humanwhocodes/module-importer" "^1.0.1"
"@humanwhocodes/module-importer" "^1.0.1"
"@nodelib/fs.walk" "^1.2.8"
"@nodelib/fs.walk" "^1.2.8"
Show 20 lines Show all unchanged lines Show 20 lines
doctrine "^3.0.0"
doctrine "^3.0.0"
escape-string-regexp "^4.0.0"
escape-string-regexp "^4.0.0"
eslint-scope "^7.1.1"
eslint-scope "^7.1.1"
eslint-utils "^3.0.0"
eslint-visitor-keys "^3.3.0"
eslint-visitor-keys "^3.3.0"
espree "^9.4.0"
espree "^9.5.0"
esquery "^1.4.0"
esquery "^1.4.2"
esutils "^2.0.2"
esutils "^2.0.2"
fast-deep-equal "^3.1.3"
fast-deep-equal "^3.1.3"
file-entry-cache "^6.0.1"
file-entry-cache "^6.0.1"
Show 20 lines Show all unchanged lines Show 20 lines
minimatch "^3.1.2"
minimatch "^3.1.2"
natural-compare "^1.4.0"
natural-compare "^1.4.0"
optionator "^0.9.1"
optionator "^0.9.1"
regexpp "^3.2.0"
strip-ansi "^6.0.1"
strip-ansi "^6.0.1"
strip-json-comments "^3.1.0"
strip-json-comments "^3.1.0"
text-table "^0.2.0"
text-table "^0.2.0"
espree@^9.4.0:
espree@^9.5.0:
version "9.4.1"
version "9.5.0"
resolved "https://registry.yarnpkg.com/espree/-/espree-9.4.1.tgz#51d6092615567a2c2cff7833445e37c28c0065bd"
resolved "https://registry.yarnpkg.com/espree/-/espree-9.5.0.tgz#3646d4e3f58907464edba852fa047e6a27bdf113"
integrity sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==
integrity sha512-JPbJGhKc47++oo4JkEoTe2wjy4fmMwvFpgJT9cQzmfXKp22Dr6Hf1tdCteLz1h0P3t+mGvWZ+4Uankvh8+c6zw==
dependencies:
dependencies:
acorn "^8.8.0"
acorn "^8.8.0"
acorn-jsx "^5.3.2"
acorn-jsx "^5.3.2"
Show 20 lines Show all unchanged lines Show 20 lines
resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
esquery@^1.4.0:
esquery@^1.4.2:
version "1.4.0"
version "1.5.0"
resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5"
resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b"
integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==
integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
dependencies:
dependencies:
estraverse "^5.1.0"
estraverse "^5.1.0"
Show 20 lines Show all unchanged lines Show 20 lines
dependencies:
dependencies:
fast-diff "^1.1.2"
fast-diff "^1.1.2"
prettier@^2.5.1:
prettier@^2.8.4:
version "2.8.2"
version "2.8.4"
resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.2.tgz#c4ea1b5b454d7c4b59966db2e06ed7eec5dfd160"
resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.4.tgz#34dd2595629bfbb79d344ac4a91ff948694463c3"
integrity sha512-BtRV9BcncDyI2tsuS19zzhzoxD8Dh8LiCx7j7tHzrkz8GFXAexeWFdi22mjE1d16dftH2qNaytVxqiRTGlMfpw==
integrity sha512-vIS4Rlc2FNh0BySk3Wkd6xmwxB0FpOndW5fisM5H8hsZSxU2VWVB5CWIkIjWvrHjIhxk2g3bfMKM87zNTrZddw==
pretty-format@^27.5.1:
pretty-format@^27.5.1:
version "27.5.1"
version "27.5.1"
Show 20 lines Show all unchanged lines Show 20 lines
resolved "https://registry.yarnpkg.com/regexp-tree/-/regexp-tree-0.1.24.tgz#3d6fa238450a4d66e5bc9c4c14bb720e2196829d"
resolved "https://registry.yarnpkg.com/regexp-tree/-/regexp-tree-0.1.24.tgz#3d6fa238450a4d66e5bc9c4c14bb720e2196829d"
integrity sha512-s2aEVuLhvnVJW6s/iPgEGK6R+/xngd2jNQ+xy4bXNDKxZKJH6jpPHY6kVeVv1IeLCHgswRj+Kl3ELaDjG6V1iw==
integrity sha512-s2aEVuLhvnVJW6s/iPgEGK6R+/xngd2jNQ+xy4bXNDKxZKJH6jpPHY6kVeVv1IeLCHgswRj+Kl3ELaDjG6V1iw==
regexpp@^3.2.0:
version "3.2.0"
resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
repeat-string@^1.5.2, repeat-string@^1.6.1:
repeat-string@^1.5.2, repeat-string@^1.6.1:
version "1.6.1"
version "1.6.1"
resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
Show 20 lines Show all unchanged lines