Creación de un fixture para test de petición de imágenes

Clase 13 de 61 • Curso Profesional de Node.js y JavaScript 2016

Contenido del curso

Crea el backend de tu aplicación

Módulo de base de datos con RethinkDB

Módulo del API de nuestra aplicación

Módulo de Client de nuestra aplicación

Integración con nuestro Frontend

RealTime con Socket.io

Lleva tu proyecto a producción

Tomar examen

Miguel Angel Espeso Alvarez

student•

Hola, me esta arrojando el siguiente error el test de likes, y por mas vueltas que doy no consigo entender.
Tengo el codigo igual al de la clase, y corriendo rethinkdb.

ESte es el error en terminal:

  2 passed
  1 failed

  db-test › setup database  for like image

  /home/miguel/proyectos/proyectoMichaelgram/michaelgram-db/node_modules/rethinkdb/errors.js:23

  Rejected promise returned by test. Reason:

  ReqlOpFailedError {
    frames: [],
    message: `Database `michaelgram_7xgTlZQTMcrAsB8hbAuKqZ` already exists in:␊
    r.dbCreate("michaelgram_7xgTlZQTMcrAsB8hbAuKqZ")␊
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`,
    msg: 'Database `michaelgram_7xgTlZQTMcrAsB8hbAuKqZ` already exists.',
    name: 'ReqlOpFailedError',
  }

  ReqlOpFailedError.ReqlError [as constructor] (node_modules/rethinkdb/errors.js:23:13)
  ReqlOpFailedError.ReqlRuntimeError [as constructor] (node_modules/rethinkdb/errors.js:90:51)
  ReqlOpFailedError.ReqlAvailabilityError [as constructor] (node_modules/rethinkdb/errors.js:167:56)
  new ReqlOpFailedError (node_modules/rethinkdb/errors.js:178:52)
  mkErr (node_modules/rethinkdb/util.js:177:10)
  TcpConnection.Connection._processResponse (node_modules/rethinkdb/net.js:152:16)
  TcpConnection.Connection._data (node_modules/rethinkdb/net.js:122:12)
  Socket.<anonymous> (node_modules/rethinkdb/net.js:689:32)
npm ERR! Test failed.  See above for more details.

Gracias

codigo lib/db.js

'use strict'
 
 const co = require('co')
 const r = require('rethinkdb')
 const Promise = require('bluebird')
 const uuid = require('uuid-base62')
 const utils = require('./utils')
 
 const defaults = {
   host: 'localhost',
   port: 28015,
   db: 'platzigram'
 }
 
 class Db {
   constructor (options) {
     options = options || {}
     this.host = options.host || defaults.host
     this.port = options.port || defaults.port
     this.db = options.db || defaults.db
   }
 
   connect (callback) {
     this.connection = r.connect({
       host: this.host,
       port: this.port
     })
 
     this.connected = true
 
     let db = this.db
     let connection = this.connection
 
     let setup = co.wrap(function * () {
       let conn = yield connection
 
       let dbList = yield r.dbList().run(conn)
       if (dbList.indexOf(db) === -1) {
         yield r.dbCreate(db).run(conn)
       }
       let dbTables = yield r.db(db).tableList().run(conn)
       if (dbTables.indexOf('images') === -1) {
         yield r.db(db).tableCreate('images').run(conn)
       }
       if (dbTables.indexOf('users') === -1) {
         yield r.db(db).tableCreate('users').run(conn)
       }
 
       return conn
     })
 
     return Promise.resolve(setup()).asCallback(callback)
   }
 
   disconnect (callback) {
     if (!this.connected) {
       return Promise.reject(new Error('not connected')).assCallback(callback)
     }
 
     this.connected = false
     return Promise.resolve(this.connection)
     .then((conn) => conn.close())
   }
 
   saveImage (image, callback) {
     if (!this.connect) {
       return Promise.reject(new Error('not connected')).Callback(callback)
     }
 
     let connection = this.connection
     let db = this.db
 
     let tasks = co.wrap(function * () {
       let conn = yield connection
       image.createdAt = new Date()
       image.tags = utils.extractTags(image.description)
 
       let result = yield r.db(db).table('images').insert(image).run(conn)
 
       if (result.errors > 0) {
         return Promise.reject(new Error(result.first_error))
       }
 
       image.id = result.generated_keys[0]
 
       yield r.db(db).table('images').get(image.id).update({
         public_id: uuid.encode(image.id)
       }).run(conn)
 
       let created = yield r.db(db).table('images').get(image.id).run(conn)
 
       return Promise.resolve(created)
     })
 
     return Promise.resolve(tasks()).asCallback(callback)
   }

 likeImage (id, callback) {
   if (!this.connect) {
      return Promise.reject(new Error('not connected')).Callback(callback)
    }

    let connection = this.connection
    let db = this.db
    let imageId = uuid.decode(id)

    let tasks = co.wrap(function * () {
      let conn = yield connection
      let image = yield r.db(db).table('images').get(imageId).run(conn)
      yield r.db(db).table('images').get(imageId).update({
        liked: true,
       likes: image.likes + 1
     }).run(conn)
     let created = yield r.db(db).table('images').get(imageId).run(conn)
     return Promise.resolve(created)
  })
    return Promise.resolve(tasks()).asCallback(callback)
  }
 }
 
 module.exports = Db

test/db-test-js

'use strict'
 
 const test = require('ava')
 
 const uuid = require('uuid-base62')
 
 const r = require('rethinkdb')
 
 const Db = require('../')
 
 const dbName = `platzigram_${uuid.v4()}`
 
 const db = new Db({ db: dbName })
 
+const fixtures = require('./fixtures')
+
 test.before('setup database', async t => {
   await db.connect()
   t.true(db.connected, 'should be connected')
 })
 
 test.after('disconnect database', async t => {
   await db.disconnect()
   t.false(db.connected, 'should be disconnect')
 })
 
 test.after.always('cleanup database', async t => {
   let conn = await r.connect({})
   await r.dbDrop(dbName).run(conn)
 })
 
 test('save image', async t => {
   t.is(typeof db.saveImage, 'function', 'saveImage is function')
 
  let image = {
    description: 'an #awesome picture with #tags #platzi',
  url: `https://platzigram.test/${uuid.v4()}.jpg`,
   likes: 0,
   liked: false,
   user_id: uuid.uuid()
  }
  let image = fixtures.getImage()
 
   let created = await db.saveImage(image)
   t.is(created.description, image.description)
   t.is(created.url, image.url)
   t.is(created.likes, image.likes)
   t.is(created.liked, image.liked)
   t.deepEqual(created.tags, [ 'awesome', 'tags', 'platzi' ])
   t.is(created.user_id, image.user_id)
   t.is(typeof created.id, 'string')
   t.is(created.public_id, uuid.encode(created.id))
   t.truthy(created.createdAt)
 })

test('like image', async t => {
  t.is(typeof db.likeImage, 'function', 'likeImage is function')

  let image = fixtures.getImage()
  let created = await db.saveImage(image)
  let result = await db.likeImage(created.public_id)

  t.true(result.liked)
  t.is(result.likes, image.likes + 1)
})

Miguel Angel Espeso Alvarez

student•

Crei que era por como defino public_id , pero no es por eso.
La cosa es que corren los dos tr¡es, y cuando añado el de like imageme falla tambien el de save image
Vaya tela…

Diego Forero

Team Platzi•

Al parecer no esta limpiando la base de datos y por eso el error es que el mensaje ya existe, revisa que no tengas algún error de digitación al momento de hacer el cleanup de la base de datos.

Creación de un fixture para test de petición de imágenes

Crea el backend de tu aplicación

Introducción y arquitectura de nuestro proyecto

Cómo crear una cuenta de Amazon Web Services y configurar S3 ( Almacenamiento de Archivos )

Usando el SDK de Amazon Web Services

Cómo agregar Standard ( Linter ) a nuestro código en JavaScript

Testing en JavaScript usando AVA

Prueba unitaria para validar un array

Uso de expresiones regulares para nuestras pruebas unitarias

Módulo de base de datos con RethinkDB

Introduccion a RethinkDB

Accediendo a nuestra base de datos Rethinkdb desde Node.js

Creación de test para RethinkDB y almacenamiento de ruta de imágenes

Almacenamiento de rutas de imágenes en RethinkDB

Completando el test para nuestro objeto imagen