How to use msValidator method in Appium Base Driver

1import _ from 'lodash';
2
3
4function isNumber (o) {
5  return _.isNumber(o) || !_.isNaN(parseInt(o)) || !_.isNaN(parseFloat(o));
6}
7
8function msValidator (ms) {
9  if (!_.isNumber(ms) || ms < 0) {
10    throw new Error('Wait ms must be a number equal to 0 or greater');
11  }
12}
13
14const validators = {
15  setUrl: (url) => {
16    // either an `xyz://` or `about:` scheme is allowed
17    if (!url || !url.match(/^([a-zA-Z0-9_-]+:\/\/)|(about:)/)) {
18      throw new Error('Url or Uri must start with <scheme>://');
19    }
20  },
21  implicitWait: (ms) => {
22    msValidator(ms);
23  },
24  asyncScriptTimeout: (ms) => {
25    msValidator(ms);
26  },
27  timeouts: (type, ms) => {
28    msValidator(ms);
29    if (!_.contains(['script', 'implicit', 'page load', 'command'], type)) {
30      throw new Error(`'${type}' is not a valid timeout type`);
31    }
32  },
33  clickCurrent: (button) => {
34    if (!(isNumber(button) || _.isUndefined(button)) || (button < 0 || button > 2)) {
35      throw new Error('Click button must be 0, 1, or 2');
36    }
37  },
38  setNetworkConnection: (type) => {
39    if (!isNumber(type) || [0, 1, 2, 4, 6].indexOf(type) === -1) {
40      throw new Error('Network type must be one of 0, 1, 2, 4, 6');
41    }
42  }
43};
44
45export { validators };
46

Source: validators.js

import _ from 'lodash';


function isNumber (o) {
  return _.isNumber(o) || !_.isNaN(parseInt(o)) || !_.isNaN(parseFloat(o));
}

function msValidator (ms) {
  if (!_.isNumber(ms) || ms < 0) {
    throw new Error('Wait ms must be a number equal to 0 or greater');
  }
}

const validators = {
  setUrl: (url) => {
    // either an `xyz://` or `about:` scheme is allowed
    if (!url || !url.match(/^([a-zA-Z0-9_-]+:\/\/)|(about:)/)) {
      throw new Error('Url or Uri must start with <scheme>://');
    }
  },
  implicitWait: (ms) => {
    msValidator(ms);
  },
  asyncScriptTimeout: (ms) => {
    msValidator(ms);
  },
  timeouts: (type, ms) => {
    msValidator(ms);
    if (!_.contains(['script', 'implicit', 'page load', 'command'], type)) {
      throw new Error(`'${type}' is not a valid timeout type`);
    }
  },
  clickCurrent: (button) => {
    if (!(isNumber(button) || _.isUndefined(button)) || (button < 0 || button > 2)) {
      throw new Error('Click button must be 0, 1, or 2');
    }
  },
  setNetworkConnection: (type) => {
    if (!isNumber(type) || [0, 1, 2, 4, 6].indexOf(type) === -1) {
      throw new Error('Network type must be one of 0, 1, 2, 4, 6');
    }
  }
};

export { validators };

1const fs = require('fs');
2const path = require('path');
3const uuidv4 = require('uuid');
4const appDir = path.dirname(require.main.filename);
5
6const SITE_JSON_PATH = appDir + '/data/siteinfo.json';
7const AUTH_JSON_PATH = appDir + '/data/auth.json';
8
9class CMS {
10  constructor(data = {}) {
11    data = Object.assign({}, CMS.defaults(), data);
12    this.id = data.id;
13    this.sitename = data.sitename;
14    this.frontendurl = data.frontendurl;
15    this.apiurl = data.apiurl;
16    this.haswww = data.haswww;
17    this.isHttps = data.isHttps;
18    this.authkey = data.authkey;
19
20    this.googleAdClient = data.googleAdClient;
21    this.googleAnalytics = data.googleAnalytics;
22    this.msValidator = data.msValidator;
23    this.defMetaDesc = data.defMetaDesc;
24    this.defMetaKey = data.defMetaKey;
25    this.lang = data.lang;
26  }
27
28  validate() {
29    if (!this.sitename || !this.frontendurl || !this.apiurl) {
30      return false;
31    }
32    return true;
33  }
34
35  /**
36   * Returns new object with current data.
37   * @param {{needAuthKey:boolean;}} data Optional, has props like authkey flag
38   */
39  toJSON(data = {}) {
40    if (data.needAuthKey == void 0) { data.needAuthKey = false; }
41    const json = {};
42    json.id = this.id;
43    json.sitename = this.sitename;
44    json.frontendurl = this.frontendurl;
45    json.apiurl = this.apiurl;
46    json.haswww = this.haswww;
47    json.isHttps = this.isHttps;
48
49    if (data.needAuthKey) {
50      json.authkey = this.authkey;
51    }
52
53    json.googleAdClient = this.googleAdClient;
54    json.googleAnalytics = this.googleAnalytics;
55    json.msValidator = this.msValidator;
56    json.defMetaDesc = this.defMetaDesc;
57    json.defMetaKey = this.defMetaKey;
58    json.lang = this.lang;
59    return json;
60  }
61
62  clean() {
63    for (let key in this) {
64      if (this.hasOwnProperty(key)) {
65        delete this[key];
66      }
67    }
68  }
69
70  set(data) {
71    this.clean();
72    Object.assign(this, {}, data);
73  }
74
75  getFrontendURL() {
76    let www = '';
77    if (this.haswww) {
78      www = 'www.';
79    }
80
81    let https = 'http://';
82    if (this.isHttps) {
83      https = 'https://';
84    }
85
86    return https + www + this.frontendurl;
87  }
88
89  getAPIURL() {
90    let https = 'http://';
91    if (this.isHttps) {
92      https = 'https://';
93    }
94
95    return https + this.apiurl;
96  }
97}
98
99CMS.SCHEMA = {
100  properties: [{
101    name: 'id',
102    isPrimaryKey: true,
103    type: 'uuid'
104  }, {
105    name: 'sitename',
106    type: 'string'
107  }, {
108    name: 'frontendurl',
109    type: 'string'
110  }, {
111    name: 'apiurl',
112    type: 'uuid'
113  }, {
114    name: 'haswww',
115    type: 'boolean'
116  }, {
117    name: 'isHttps',
118    type: 'boolean'
119  }, {
120    name: 'authkey',
121    type: 'string'
122  }, {
123    name: 'googleAdClient',
124    type: 'string'
125  }, {
126    name: 'googleAnalytics',
127    type: 'string'
128  }, {
129    name: 'msValidator',
130    type: 'string'
131  }, {
132    name: 'defMetaDesc',
133    type: 'string'
134  }, {
135    name: 'defMetaKey',
136    type: 'string'
137  }, {
138    name: 'lang',
139    type: 'string'
140  }]
141};
142
143CMS.defaults = () => {
144  return {
145    id: uuidv4.v4(),
146    haswww: true,
147    isHttps: false,
148    googleAdClient: '',
149    googleAnalytics: '',
150    msValidator: '',
151    defMetaDesc: '',
152    defMetaKey: '',
153    lang: ''
154  };
155};
156
157CMS.isConfigured = false;
158
159/**
160 * Returns promise containing JSON object.
161 * @param {string} path path of the json to read from
162 */
163CMS.readJSON = (path) => {
164  return new Promise((res, rej) => {
165    fs.readFile(path, 'utf8', (err, data) => {
166      if (err) {
167        rej(err);
168      } else {
169        res(JSON.parse(data));
170      }
171    });
172  });
173};
174
175/**
176 * Writes json by stringifying it
177 * Returns promise containing JSON object.
178 * @param {string} path path of the json to write to
179 * @param {Object} json JSON object to write
180 */
181CMS.writeJSON = (path, json) => {
182  return new Promise((res, rej) => {
183    fs.writeFile(path, JSON.stringify(json), (err) => {
184      if (err) {
185        rej(err);
186      } else {
187        res(json);
188      }
189    });
190  });
191};
192
193CMS.readConfigJSONFIle = () => CMS.readJSON(SITE_JSON_PATH);
194
195/**
196 * Automatically configures site incase of memory failure.
197 */
198CMS.autoConfigure = () => {
199  return new Promise((res, rej) => {
200    CMS.readConfigJSONFIle().then((data) => {
201      CMS._instance.set(data);
202      CMS.isConfigured = true;
203      res({ message: 'configured', siteinfo: CMS._instance.toJSON() });
204      return data;
205    }, (err) => {
206      if (err.code == 'ENOENT') {
207        res({ message: 'jsonfilenotpresent' });
208        CMS.isConfigured = false;
209        console.log('Site is not configured yet, needs to be configured');
210      } else {
211        CMS.isConfigured = false;
212        rej(err);
213      }
214    });
215  });
216};
217
218CMS._instance = new CMS();
219
220CMS.getInstance = () => CMS._instance;
221
222module.exports = { CMS };

Source: main.js

const fs = require('fs');
const path = require('path');
const uuidv4 = require('uuid');
const appDir = path.dirname(require.main.filename);

const SITE_JSON_PATH = appDir + '/data/siteinfo.json';
const AUTH_JSON_PATH = appDir + '/data/auth.json';

class CMS {
  constructor(data = {}) {
    data = Object.assign({}, CMS.defaults(), data);
    this.id = data.id;
    this.sitename = data.sitename;
    this.frontendurl = data.frontendurl;
    this.apiurl = data.apiurl;
    this.haswww = data.haswww;
    this.isHttps = data.isHttps;
    this.authkey = data.authkey;

    this.googleAdClient = data.googleAdClient;
    this.googleAnalytics = data.googleAnalytics;
    this.msValidator = data.msValidator;
    this.defMetaDesc = data.defMetaDesc;
    this.defMetaKey = data.defMetaKey;
    this.lang = data.lang;
  }

  validate() {
    if (!this.sitename || !this.frontendurl || !this.apiurl) {
      return false;
    }
    return true;
  }

  /**
   * Returns new object with current data.
   * @param {{needAuthKey:boolean;}} data Optional, has props like authkey flag
   */
  toJSON(data = {}) {
    if (data.needAuthKey == void 0) { data.needAuthKey = false; }
    const json = {};
    json.id = this.id;
    json.sitename = this.sitename;
    json.frontendurl = this.frontendurl;
    json.apiurl = this.apiurl;
    json.haswww = this.haswww;
    json.isHttps = this.isHttps;

    if (data.needAuthKey) {
      json.authkey = this.authkey;
    }

    json.googleAdClient = this.googleAdClient;
    json.googleAnalytics = this.googleAnalytics;
    json.msValidator = this.msValidator;
    json.defMetaDesc = this.defMetaDesc;
    json.defMetaKey = this.defMetaKey;
    json.lang = this.lang;
    return json;
  }

  clean() {
    for (let key in this) {
      if (this.hasOwnProperty(key)) {
        delete this[key];
      }
    }
  }

  set(data) {
    this.clean();
    Object.assign(this, {}, data);
  }

  getFrontendURL() {
    let www = '';
    if (this.haswww) {
      www = 'www.';
    }

    let https = 'http://';
    if (this.isHttps) {
      https = 'https://';
    }

    return https + www + this.frontendurl;
  }

  getAPIURL() {
    let https = 'http://';
    if (this.isHttps) {
      https = 'https://';
    }

    return https + this.apiurl;
  }
}

CMS.SCHEMA = {
  properties: [{
    name: 'id',
    isPrimaryKey: true,
    type: 'uuid'
  }, {
    name: 'sitename',
    type: 'string'
  }, {
    name: 'frontendurl',
    type: 'string'
  }, {
    name: 'apiurl',
    type: 'uuid'
  }, {
    name: 'haswww',
    type: 'boolean'
  }, {
    name: 'isHttps',
    type: 'boolean'
  }, {
    name: 'authkey',
    type: 'string'
  }, {
    name: 'googleAdClient',
    type: 'string'
  }, {
    name: 'googleAnalytics',
    type: 'string'
  }, {
    name: 'msValidator',
    type: 'string'
  }, {
    name: 'defMetaDesc',
    type: 'string'
  }, {
    name: 'defMetaKey',
    type: 'string'
  }, {
    name: 'lang',
    type: 'string'
  }]
};

CMS.defaults = () => {
  return {
    id: uuidv4.v4(),
    haswww: true,
    isHttps: false,
    googleAdClient: '',
    googleAnalytics: '',
    msValidator: '',
    defMetaDesc: '',
    defMetaKey: '',
    lang: ''
  };
};

CMS.isConfigured = false;

/**
 * Returns promise containing JSON object.
 * @param {string} path path of the json to read from
 */
CMS.readJSON = (path) => {
  return new Promise((res, rej) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) {
        rej(err);
      } else {
        res(JSON.parse(data));
      }
    });
  });
};

/**
 * Writes json by stringifying it
 * Returns promise containing JSON object.
 * @param {string} path path of the json to write to
 * @param {Object} json JSON object to write
 */
CMS.writeJSON = (path, json) => {
  return new Promise((res, rej) => {
    fs.writeFile(path, JSON.stringify(json), (err) => {
      if (err) {
        rej(err);
      } else {
        res(json);
      }
    });
  });
};

CMS.readConfigJSONFIle = () => CMS.readJSON(SITE_JSON_PATH);

/**
 * Automatically configures site incase of memory failure.
 */
CMS.autoConfigure = () => {
  return new Promise((res, rej) => {
    CMS.readConfigJSONFIle().then((data) => {
      CMS._instance.set(data);
      CMS.isConfigured = true;
      res({ message: 'configured', siteinfo: CMS._instance.toJSON() });
      return data;
    }, (err) => {
      if (err.code == 'ENOENT') {
        res({ message: 'jsonfilenotpresent' });
        CMS.isConfigured = false;
        console.log('Site is not configured yet, needs to be configured');
      } else {
        CMS.isConfigured = false;
        rej(err);
      }
    });
  });
};

CMS._instance = new CMS();

CMS.getInstance = () => CMS._instance;

module.exports = { CMS };