init the awkward code

static/js/libarchive.js/test/archive_content/test/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+.idea

static/js/libarchive.js/test/archive_content/test/README.md

@@ -0,0 +1 @@
+# Adjaranet plugin for Kodi

static/js/libarchive.js/test/archive_content/test/addon/addon.py

@@ -0,0 +1,120 @@
+import simplejson as json
+from httplib2 import Http
+import re
+import urllib2
+import sys
+import urllib
+import urlparse
+import xbmc
+import xbmcgui
+import xbmcplugin
+
+API_BASE = 'http://net.adjara.com/'
+STATIC_FILES = 'http://staticnet.adjara.com/'
+CATEGORY_MAP = {
+    'new_release': 'Search/SearchResults?ajax=1&display=15&startYear=1900&endYear=2018&offset=0&orderBy=date&order%5Border%5D=data&order%5Bdata%5D=premiere&order%5Bmeta%5D=desc',
+    'top_movies': 'Search/SearchResults?ajax=1&display=15&startYear=1900&endYear=2018&offset=15&orderBy=date&order%5Border%5D=data&order%5Bdata%5D=views&order%5Bmeta%5D=views-week'
+}
+
+base_url = sys.argv[0]
+addon_handle = int(sys.argv[1])
+args = urlparse.parse_qs(sys.argv[2][1:])
+find_var_regex = re.compile(r"""movieUrlEmpty\s*=\s*[\'\"](.+)[\'\"]""")
+
+xbmcplugin.setContent(addon_handle, 'movies')
+
+def get_icon(movie_id):
+    movie_id = str(movie_id)
+    return STATIC_FILES + 'moviecontent/%s/covers/157x236-%s.jpg' % (movie_id,movie_id)
+def get_cover(movie_id):
+    movie_id = str(movie_id)
+    return STATIC_FILES + 'moviecontent/%s/covers/1920x1080-%s.jpg' % (movie_id,movie_id)
+
+def build_url(query):
+    return base_url + '?' + urllib.urlencode(query)
+
+def add_category(label,category,iconImage = 'DefaultFolder.png', url = None):
+    if url is None:
+        url = build_url({'mode': 'category', 'category': category})
+    li = xbmcgui.ListItem(label, iconImage=iconImage)
+    xbmcplugin.addDirectoryItem(handle=addon_handle, url=url,
+                                listitem=li, isFolder=True)
+
+def main_screen():
+    add_category('Search',None,'DefaultAddonsSearch.png',build_url({'mode': 'search'}))
+    add_category('New Releases','new_release')
+    add_category('Top Movies','top_movies')
+    xbmcplugin.endOfDirectory(addon_handle)
+
+def load_category(category):
+    cat_url = API_BASE + CATEGORY_MAP[category]
+    try:
+        (rsp_headers, json_data) = Http().request(cat_url)
+        data  = json.loads(json_data)
+        for item in data['data']:
+            url = build_url({'mode': 'movie', 'id': item['id']})
+            li = xbmcgui.ListItem(item['title_en'], iconImage=item['poster'])
+            li.setProperty('IsPlayable', 'true')
+            xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=False)
+
+    except Exception, e:
+        xbmc.log('adjaranet: got http error fetching %s \n %s' % (cat_url, str(e)), xbmc.LOGWARNING)
+    finally:
+        xbmcplugin.endOfDirectory(addon_handle)
+
+def search():
+    kb = xbmc.Keyboard('', 'Search for movie')
+    kb.doModal()
+    if (kb.isConfirmed()):
+        search_term = kb.getText()
+    else:
+        return
+
+    search_url = API_BASE + 'Home/quick_search?ajax=1&search=' + search_term
+    try:
+        (rsp_headers, json_data) = Http().request(search_url)
+        data  = json.loads(json_data)
+        for item in data['movies']['data']:
+            url = build_url({'mode': 'movie', 'id': item['id']})
+            li = xbmcgui.ListItem(item['title_en'])
+            li.setArt({
+                'icon': get_icon(item['id']),
+                'landscape': get_cover(item['id'])
+            })
+            li.setProperty('IsPlayable', 'true')
+            xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=False)
+    except Exception, e:
+        xbmc.log('adjaranet: got http error fetching %s \n %s' % (search_url, str(e)), xbmc.LOGWARNING)
+    finally:
+        xbmcplugin.endOfDirectory(addon_handle)
+
+
+def load_movie(movie_id):
+    script_url = API_BASE + 'Movie/main?id='+ movie_id +'&js=1'
+    try:
+        (rsp_headers, html_data) = Http().request(script_url)
+        match = re.search(find_var_regex,html_data)
+        if not match:
+            xbmc.log('can not find url at %s' % (script_url), xbmc.LOGWARNING)
+            raise Exception('url not found')
+        
+        url = match.group(1).replace('{lang}','English').replace('{quality}','1500')
+        xbmc.log(url, xbmc.LOGWARNING)
+        
+        play_item = xbmcgui.ListItem(path=url)
+        xbmcplugin.setResolvedUrl(addon_handle, True, listitem=play_item)
+    except Exception, e:
+        xbmc.log('adjaranet: got http error fetching %s \n %s' % (script_url, str(e)), xbmc.LOGWARNING)
+
+mode = args.get('mode', None)
+
+if mode is None:
+    main_screen()
+elif mode[0] == 'category':
+    category = args.get('category','new_release')
+    load_category(category[0])
+elif mode[0] == 'search':
+    search()
+elif mode[0] == 'movie':
+    movie_id = args.get('id', None)
+    load_movie(movie_id[0])

static/js/libarchive.js/test/archive_content/test/addon/addon.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<addon id="plugin.addon.adjaranet.client" name="adjaranet client" version="0.0.1" provider-name="You">
+  <requires>
+    <import addon="xbmc.python" version="2.1.0"/>
+    <import addon="script.module.simplejson" />
+    <import addon="script.module.httplib2" />
+  </requires>
+  <extension point="xbmc.python.pluginsource" library="addon.py">
+    <provides>video</provides>
+  </extension>
+  <extension point="xbmc.addon.metadata">
+    <summary lang="en_GB">Adjaranet.com client</summary>
+    <description lang="en_GB">enable adjaranet inside kodi</description>
+    <disclaimer lang="en_GB"></disclaimer>
+    <language></language>
+    <platform>all</platform>
+    <license></license>
+    <forum></forum>
+    <website></website>
+    <email></email>
+    <source></source>
+    <news></news>
+    <assets>
+        <icon></icon>
+        <fanart></fanart>
+        <banner></banner>
+        <clearlogo></clearlogo>
+        <screenshot></screenshot>
+    </assets>
+  </extension>
+</addon>

static/js/libarchive.js/test/checksum.js

@@ -0,0 +1,9 @@
+
+module.exports.checksum = {
+    '.gitignore':'d1e8d4fa856e17b2ad54a216aae527a880873df76cc30a85d6ba6b32d2ee23cc',
+    'addon':{
+        'addon.py':'e0ab20fe5fd7ab5c2b38511d81d93b9cb6246e300d0893face50e8a5b9485b90',
+        'addon.xml':'d26a8bdf02e7ab2eaeadf2ab603a1d11b2a5bfe57a6ac672d1a1c4940958eba8'
+    },
+    'README.md':'b4555fd8dd6e81599625c1232e58d5e09fc36f3f6614bf792a6978b30cfe65bb'
+};

static/js/libarchive.js/test/files/encryption.html

@@ -0,0 +1,80 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>test webworker</title>
+    </head>
+    <body>
+        <input type="file" id="file" />
+        <script type="module" >
+
+            function hex(buffer) {
+                const hexCodes = [];
+                const view = new DataView(buffer);
+                for (let i = 0; i < view.byteLength; i += 4) {
+                    const value = view.getUint32(i)
+                    const stringValue = value.toString(16)
+                    const padding = '00000000'
+                    const paddedValue = (padding + stringValue).slice(-padding.length)
+                    hexCodes.push(paddedValue);
+                }
+                return hexCodes.join("");
+            }
+
+            function getChecksum(file){
+                return new Promise((resolve,reject) => {
+                    try{
+                        const reader = new FileReader();
+                        reader.onload = function() {
+                            crypto.subtle.digest("SHA-256", reader.result).then(function (hash) {
+                                resolve(hex(hash));
+                            });
+                        }
+                        reader.readAsArrayBuffer(file);
+                    }catch(err){
+                        reject(err);
+                    }
+                });
+            }
+
+            function finish(){
+                const d = document.createElement('div');
+                d.setAttribute('id','done');
+                d.textContent = 'Done.';
+                document.body.appendChild(d);
+            }
+
+            async function fileChecksums(obj){
+                for( const [key,val] of Object.entries(obj) ){
+                    obj[key] = val instanceof File ? 
+                        await getChecksum(val) : await fileChecksums(val);
+                }
+                return obj;
+            }
+
+            import {Archive} from '../../src/libarchive.js';
+
+            Archive.init({
+                workerUrl: '../../dist/worker-bundle.js'
+            });
+
+            window.Archive = Archive;
+
+            document.getElementById('file').addEventListener('change', async (e) => {
+                let obj = null, encEntries = false;
+                try{
+                    const file = e.currentTarget.files[0];
+                    const archive = await Archive.open(file);
+                    encEntries = await archive.hasEncryptedData();
+                    await archive.usePassword("nika");
+                    obj = await archive.extractFiles();
+                    obj = await fileChecksums(obj);
+                }catch(err){
+                    console.error(err);
+                }finally{
+                    window.obj = {files: obj, encrypted: encEntries};
+                    finish();
+                }
+            });
+        </script>
+    </body>
+</html>

static/js/libarchive.js/test/files/index.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>test webworker</title>
+    </head>
+    <body>
+        <input type="file" id="file" />
+        <script type="module" >
+
+            function hex(buffer) {
+                const hexCodes = [];
+                const view = new DataView(buffer);
+                for (let i = 0; i < view.byteLength; i += 4) {
+                    const value = view.getUint32(i)
+                    const stringValue = value.toString(16)
+                    const padding = '00000000'
+                    const paddedValue = (padding + stringValue).slice(-padding.length)
+                    hexCodes.push(paddedValue);
+                }
+                return hexCodes.join("");
+            }
+
+            function getChecksum(file){
+                return new Promise((resolve,reject) => {
+                    try{
+                        const reader = new FileReader();
+                        reader.onload = function() {
+                            crypto.subtle.digest("SHA-256", reader.result).then(function (hash) {
+                                resolve(hex(hash));
+                            });
+                        }
+                        reader.readAsArrayBuffer(file);
+                    }catch(err){
+                        reject(err);
+                    }
+                });
+            }
+
+            function finish(){
+                const d = document.createElement('div');
+                d.setAttribute('id','done');
+                d.textContent = 'Done.';
+                document.body.appendChild(d);
+            }
+
+            async function fileChecksums(obj){
+                for( const [key,val] of Object.entries(obj) ){
+                    obj[key] = val instanceof File ? 
+                        await getChecksum(val) : await fileChecksums(val);
+                }
+                return obj;
+            }
+
+            import {Archive} from '../../src/libarchive.js';
+
+            Archive.init({
+                workerUrl: '../../dist/worker-bundle.js'
+            });
+
+            window.Archive = Archive;
+
+            document.getElementById('file').addEventListener('change', async (e) => {
+                let obj = null;
+                try{
+                    const file = e.currentTarget.files[0];
+                    const archive = await Archive.open(file);
+                    //console.log( await archive.getFilesObject() );
+                    //console.log( await archive.getFilesArray() );
+                    obj = await archive.extractFiles();
+                    //console.log( await archive.getFilesObject() );
+                    //console.log( await archive.getFilesArray() );
+                    obj = await fileChecksums(obj);
+                }catch(err){
+                    console.error(err);
+                }finally{
+                    window.obj = obj;
+                    finish();
+                }
+            });
+        </script>
+    </body>
+</html>

static/js/libarchive.js/test/files/test-single.html

@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>test webworker</title>
+    </head>
+    <body>
+        <input type="file" id="file" />
+        <script type="module" >
+
+            function hex(buffer) {
+                const hexCodes = [];
+                const view = new DataView(buffer);
+                for (let i = 0; i < view.byteLength; i += 4) {
+                    const value = view.getUint32(i)
+                    const stringValue = value.toString(16)
+                    const padding = '00000000'
+                    const paddedValue = (padding + stringValue).slice(-padding.length)
+                    hexCodes.push(paddedValue);
+                }
+                return hexCodes.join("");
+            }
+
+            function getChecksum(file){
+                return new Promise((resolve,reject) => {
+                    try{
+                        const reader = new FileReader();
+                        reader.onload = function() {
+                            crypto.subtle.digest("SHA-256", reader.result).then(function (hash) {
+                                resolve(hex(hash));
+                            });
+                        }
+                        reader.readAsArrayBuffer(file);
+                    }catch(err){
+                        reject(err);
+                    }
+                });
+            }
+
+            function finish(){
+                const d = document.createElement('div');
+                d.setAttribute('id','done');
+                d.textContent = 'Done.';
+                document.body.appendChild(d);
+            }
+
+            async function fileChecksums(obj){
+                for( const [key,val] of Object.entries(obj) ){
+                    obj[key] = val instanceof File ? 
+                        await getChecksum(val) : await fileChecksums(val);
+                }
+                return obj;
+            }
+
+            import {Archive} from '../../src/libarchive.js';
+
+            Archive.init({
+                workerUrl: '../../dist/worker-bundle.js'
+            });
+
+            window.Archive = Archive;
+
+            document.getElementById('file').addEventListener('change', async (e) => {
+                let objAfter,objBefore,fileObj;
+                try{
+                    const file = e.currentTarget.files[0];
+                    const archive = await Archive.open(file);
+                    const files =  await archive.getFilesArray();
+                    fileObj = await files[0].file.extract();
+                }catch(err){
+                    console.error(err);
+                }finally{
+                    window.obj = await getChecksum(fileObj);
+                    finish();
+                }
+            });
+        </script>
+    </body>
+</html>

static/js/libarchive.js/test/formats/7z.test.js

@@ -0,0 +1,36 @@
+/* eslint-disable no-undef */
+const {checksum} = require('../checksum');
+const {navigate,inputFile,response,setup,cleanup} = require('../testutils');
+
+let browser,page;
+
+beforeAll(async () => {
+    let tmp = await setup();
+    browser = tmp.browser;
+    page = tmp.page;
+});
+
+describe("Extract 7Z files with various compressions", () => {
+    test("Extract 7Z with LZMA", async () => {
+        await navigate(page);
+        await inputFile('archives/7z/lzma.7z',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract 7Z with LZMA2", async () => {
+        await navigate(page);
+        await inputFile('archives/7z/lzma2.7z',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract 7Z with BZIP2", async () => {
+        await navigate(page);
+        await inputFile('archives/7z/bzip2.7z',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+});
+
+afterAll(() => {
+    cleanup(browser);
+});

static/js/libarchive.js/test/formats/rar.test.js

@@ -0,0 +1,30 @@
+/* eslint-disable no-undef */
+const {checksum} = require('../checksum');
+const {navigate,inputFile,response,setup,cleanup} = require('../testutils');
+
+let browser,page;
+
+beforeAll(async () => {
+    let tmp = await setup();
+    browser = tmp.browser;
+    page = tmp.page;
+});
+
+describe("Extract RAR files", () => {
+    test("Extract RAR v4", async () => {
+        await navigate(page);
+        await inputFile('archives/rar/test-v4.rar',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract RAR v5", async () => {
+        await navigate(page);
+        await inputFile('archives/rar/test-v5.rar',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+});
+
+afterAll(() => {
+    cleanup(browser);
+});

static/js/libarchive.js/test/formats/tar.test.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-undef */
+const {checksum} = require('../checksum');
+const {navigate,inputFile,response,setup,cleanup} = require('../testutils');
+
+let browser,page;
+
+beforeAll(async () => {
+    let tmp = await setup();
+    browser = tmp.browser;
+    page = tmp.page;
+});
+
+describe("Extract TAR files with various compressions", () => {
+    test("Extract TAR without compression", async () => {
+        await navigate(page);
+        await inputFile('archives/tar/test.tar',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract TAR BZIP2", async () => {
+        await navigate(page);
+        await inputFile('archives/tar/test.tar.bz2',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract TAR GZIP", async () => {
+        await navigate(page);
+        await inputFile('archives/tar/test.tar.gz',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract TAR LZMA2", async () => {
+        await navigate(page);
+        await inputFile('archives/tar/test.tar.xz',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+});
+
+afterAll(() => {
+    cleanup(browser);
+});

static/js/libarchive.js/test/formats/zip.test.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-undef */
+const {checksum} = require('../checksum');
+const {navigate,inputFile,response,setup,cleanup} = require('../testutils');
+
+let browser,page;
+
+beforeAll(async () => {
+    let tmp = await setup();
+    browser = tmp.browser;
+    page = tmp.page;
+});
+
+describe("Extract ZIP files with various compressions", () => {
+    test("Extract ZIP deflate", async () => {
+        await navigate(page);
+        await inputFile('archives/zip/deflate.zip',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    /* test("Extract ZIP deflate64", async () => { // not support
+        await navigate(page);
+        await inputFile('archives/zip/deflate64.zip',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000); */
+    test("Extract ZIP bzip2", async () => {
+        await navigate(page);
+        await inputFile('archives/zip/bzip2.zip',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+    test("Extract ZIP lzma", async () => {
+        await navigate(page);
+        await inputFile('archives/zip/lzma.zip',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+});
+
+afterAll(() => {
+    cleanup(browser);
+});

static/js/libarchive.js/test/main.test.js

@@ -0,0 +1,39 @@
+/* eslint-disable no-undef */
+const {checksum} = require('./checksum');
+const {navigate,inputFile,response,setup,cleanup} = require('./testutils');
+
+let browser,page;
+
+beforeAll(async () => {
+    let tmp = await setup();
+    browser = tmp.browser;
+    page = tmp.page;
+});
+
+describe("extract various compression types", () => {
+    test("extract 7z file", async () => {
+        await navigate(page);
+        await inputFile('archives/test.7z',page);
+        const files = await response(page);
+        expect(files).toEqual(checksum);
+    }, 16000);
+
+    test("extract single file from zip", async () => {
+        await navigate(page,'test-single.html');
+        await inputFile('archives/test.zip',page);
+        const file = await response(page);
+        expect(file).toEqual(checksum['.gitignore']);
+    }, 16000);
+    
+    test("extract encrypted zip", async () => {
+        await navigate(page,'encryption.html');
+        await inputFile('archives/encrypted.zip',page);
+        const {files,encrypted} = await response(page);
+        expect(encrypted).toEqual(true);
+        expect(files).toEqual(checksum);
+    }, 16000);
+});
+
+afterAll(() => {
+    cleanup(browser);
+});

static/js/libarchive.js/test/testutils.js

@@ -0,0 +1,46 @@
+const StaticServer = require('static-server');
+const puppeteer = require('puppeteer');
+const port = 8787;
+const width = 800;
+const height = 600;
+const server = new StaticServer({
+    rootPath: '.',
+    port: port,
+    cors: '*',
+});
+
+const startServer = () => new Promise((resolve) => {
+    server.start( () => {
+        console.log('Server listening to', port);
+        resolve();
+    });
+});
+
+module.exports = {
+    setup: async () => {
+        let browser = await puppeteer.launch();
+        let page = await browser.newPage();
+        await page.setViewport({ width, height });
+        await startServer();
+        page.on('console', msg => {
+            for (let i = 0; i < msg.args().length; ++i) console.log(`${i}: ${msg.args()[i]}`);
+        });
+        return {browser,page};
+    },
+    cleanup: (browser) => {
+        server.stop();
+        browser.close();
+    },
+    navigate: async function (page, path = 'index.html') {
+        await page.goto(`http://127.0.0.1:${port}/test/files/${path}`);
+    },
+    inputFile: async function (file,page){
+        const fileInp = await page.$('#file');
+        fileInp.uploadFile('test/files/'+file);
+    },
+    response: async function (page){
+        await page.waitForSelector('#done');
+        return await page.evaluate(`window.obj`);
+    }
+};
+