Edge.debug = true;

describe('Edge', function() {

  describe('#connect()', function() {
    after(() => {
      Edge.disconnect();
    });

    it('should open the connection', function() {
      return Edge.connect()
        .then(() => {
          chai.assert.isNotNull(Edge._conn);
        });
    });
  });

  describe('#disconnect()', function() {
    it('should close the connection', function() {
      Edge.disconnect();
      chai.assert.isNull(Edge._conn);
    });
  });

  describe('#send()', function() {
    this.timeout(5000);
    
    before(() => {
      return Edge.connect();
    });

    after(() => {
      Edge.disconnect();
    });

    it('should send a message to the server and echo back', function(done) {
      const now = new Date();
      const handler = evt => {
        chai.assert.equal(evt.detail.now, now.toJSON());
        Edge.removeEventListener('message', handler);
        done();
      }

      // Server should echo back message
      Edge.addEventListener('message', handler);

      // Send message to server
      Edge.send({ now });
    });
  });
  
});

describe('Remote Procedure Call', function() {

  before(() => {
    return Edge.connect();
  });

  after(() => {
    Edge.disconnect();
  });

  it('should call the remote echo() method and resolve the returned value', function() {
    const foo = "bar";

    return Edge.rpc('echo', { foo })
      .then(result => {
        chai.assert.equal(result.foo, foo);
      });
  });

  it('should call the remote throwError() method and reject with an error', function() {
    return Edge.rpc('throwError')
      .catch(err => {
        // Assert that it's an "internal" error
        // See https://www.jsonrpc.org/specification#error_object
        chai.assert.equal(err.code, -32603);
      });
  });

  it('should call an unregistered method and reject with an error', function() {
    return Edge.rpc('unregisteredMethod')
      .catch(err => {
        // Assert that it's an "method not found" error
        // See https://www.jsonrpc.org/specification#error_object
        chai.assert.equal(err.code, -32601);
      });
  });


  it('should call the add() method repetitively and keep count of the sent values', function() {
    this.timeout(10000);

    const values = [];
    for(let i = 0; i <= 1000; i++) {
      values.push((Math.random() * 1000 | 0));
    }
    return Edge.rpc('reset')
      .then(() => {
        return Promise.all(values.map(v =>  Edge.rpc("add", {value: v})));
      })
      .then(() => Edge.rpc('total'))
      .then(remoteTotal => {
        const localTotal = values.reduce((t, v) => t+v);
        console.log("Remote total:", remoteTotal, "Local total:", localTotal);
        chai.assert.equal(remoteTotal, localTotal)
      })
  });

});

describe('File Module', function() {

  before(() => {
    return Edge.connect();
  });

  after(() => {
    Edge.disconnect();
  });

  it('should upload then download a blob', function() {
    const content = JSON.stringify({"date": new Date()});
    const blob = new Blob([content], {type: "application/json"});

    return Edge.upload(blob)
      .then(upload => upload.result())
      .then(result => {

        chai.assert.isNotEmpty(result.blobId);
        chai.assert.isNotEmpty(result.bucket);
        
        const blobUrl = Edge.blobUrl(result.bucket, result.blobId);
        chai.assert.isNotEmpty(blobUrl);

        return fetch(blobUrl)
          .then(res => res.text())
          .then(blobContent => {
            chai.assert.equal(content, blobContent);
          });
      })
      .catch(err => {
        chai.assert.fail(err);
      })
  });

});