Mocking

Clase 30 de 45 • Curso de GraphQL 2016

Contenido del curso

Conceptos Generales de GraphQL

Construyendo Esquemas a través de Tipos

Las Herramientas de GraphQL

Proyecto

Conclusiones

43
¿Cuándo usar GraphQL?
03:43 min

Contenido Bonus

Tomar examen

Comentarios

Anahi Zentella Aguirre

company_admin•

Excelente! luego me liaba para los datos de ejemplo en las pruebas

Julio Hurtado

student•

preserveResolvers: true nos permite dar preferencia a los datos de los resolvers

Julio J Yépez

student•

Cuando se solicitan en la consulta (query) valores que no se han definido aún en la clave mocks … no se generará un error, sino que todos los campos tendrán por defecto el valor “Hello world” … los campos que no se hayan definido explícitamente claro.

Julio J Yépez

student•

Juan Sebastián Contreras

student•

const server = new ApolloServer({
  typeDefs,
  resolvers,
  mocks,
  mockEntireSchema: false
});

David Daniel Castillo Nava

student•

Mi archivos pero necesito ayuda no logro hacer que funcione con los resolvers agregados. Me funciona me crean los datos aleatorios pero tengo que devolver vació los resolvers. Si alguien tiene una idea.

schema.js

const { gql, MockList } = require('apollo-server-express');
const casual = require('casual');

const typeDefs = gql`

  # Esto es un curso en nuestro sistema
  type Curso {
    id: ID!,
    titulo: String!
    description: String!
    profesor: Profesor
    rating: Float @deprecated(reason: "No queremos")
    comentarios: [Comentario]
  }
  
  type Profesor {
  	id: ID!
  	nombre: String!
  	nacionalidad: String!
  	genero: Genero
  	cursos: [Curso]
  }

  enum Genero {
  	MASCULINO
  	FEMENINO
  }

  type Comentario {
  	id: ID!
  	nombre: String!
	  cuerpo: String!
  }
  type Query {
    cursos: [Curso]
    profesores: [Profesor]
    curso(id: Int): Curso
    profesor(id: Int): Profesor
  }
`
const resolvers = {
  Query: {
    cursos: () => {
    	// return [
    	// 	{
	    // 		id:1,
	    // 		titulo: 'Curso de Graphql',
	    // 		description: 'Aprendiendo sobre resolvers'
	    // 	},
	    // 	{
	    // 		id:2,
	    // 		titulo: 'Curso de React',
	    // 		description: 'Aprendiendo sobre reactivo'
	    // 	},
     //    {
     //      id:3,
     //      titulo: 'Curso de Angular',
     //      description: 'Aprendiendo sobre angulando'
     //    }
    	// ]
    }
  },
  Curso: {
  	profesor: () => {
  		return {
  			// nombre: "Pablo"
  		}
  	}
  }
}

const mocks = {
  Query: () =>({
    cursos: () => new MockList([5, 5]),
  }),
  Curso: () => {
    return {
      id: casual.uuid,
      titulo: casual.sentence,
      description: casual.sentences(2)
    }
  },
  Profesor: () => {
    return {
      nombre: casual.name,
      nacionalidad: casual.country
    }
  }
}

module.exports = { typeDefs, resolvers, mocks }

index.js

const express = require('express');
const { ApolloServer } = require('apollo-server-express');
const { typeDefs, resolvers, mocks } = require('./schema')

const server = new ApolloServer({ typeDefs, resolvers, mocks, mockEntireSchema:true });

const app = express();
server.applyMiddleware({ app });

const PORT = 5678

app.listen(PORT, () => {
	console.log(`🚀 Server ready at http://localhost:${PORT}${server.graphqlPath}`)
});

Diego Forero

Team Platzi•

Qué error te da si el contenido del resolver no esta comentado?

David Daniel Castillo Nava

student•

@gollum23 así como esta funciona perfecto me muestra valores aleatorios gracias a casual y mockList pero tengo que devolverle objeto vacío los resolver si descontento el resolver no toma el mock toma los que tengo en resolver

Luis Val

student•

Que punto para mas interesante

Carlos Erices

student•

addMockFunctionToSchema => addMocksToSchema "cambio el nombre del modulo para los que les da error" año: 2020

Julio J Yépez

student•

¡Super útil esta librería casual!

Julio J Yépez

student•

Lo que veo también es que al usar esta función addMockFunctionsToSchema, se descartaran de plano los resolvers que se hayan definido.

Julio J Yépez

student•

XD … ¡muy bien! … la observación queda resuelta con el tercer parámetro: preserveResolvers

Juan Pareles

student•

muy util la lib de casual, no solo para graphql sino para generar dummy data en general

José Iván Sandoya

student•

Podemos decir que Mocking sustituye funcionalmente a los Resolvers tal como los aprendimos en clases pasadas?

const { gql, MockList } = require('apollo-server-express');
const casual = require('casual');

const typeDefs = gql`

  # Esto es un curso en nuestro sistema
  type Curso {
    id: ID!,
    titulo: String!
    description: String!
    profesor: Profesor
    rating: Float @deprecated(reason: "No queremos")
    comentarios: [Comentario]
  }
  
  type Profesor {
  	id: ID!
  	nombre: String!
  	nacionalidad: String!
  	genero: Genero
  	cursos: [Curso]
  }

  enum Genero {
  	MASCULINO
  	FEMENINO
  }

  type Comentario {
  	id: ID!
  	nombre: String!
	  cuerpo: String!
  }
  type Query {
    cursos: [Curso]
    profesores: [Profesor]
    curso(id: Int): Curso
    profesor(id: Int): Profesor
  }
`
const resolvers = {
  Query: {
    cursos: () => {
    	// return [
    	// 	{
	    // 		id:1,
	    // 		titulo: 'Curso de Graphql',
	    // 		description: 'Aprendiendo sobre resolvers'
	    // 	},
	    // 	{
	    // 		id:2,
	    // 		titulo: 'Curso de React',
	    // 		description: 'Aprendiendo sobre reactivo'
	    // 	},
     //    {
     //      id:3,
     //      titulo: 'Curso de Angular',
     //      description: 'Aprendiendo sobre angulando'
     //    }
    	// ]
    }
  },
  Curso: {
  	profesor: () => {
  		return {
  			// nombre: "Pablo"
  		}
  	}
  }
}

const mocks = {
  Query: () =>({
    cursos: () => new MockList([5, 5]),
  }),
  Curso: () => {
    return {
      id: casual.uuid,
      titulo: casual.sentence,
      description: casual.sentences(2)
    }
  },
  Profesor: () => {
    return {
      nombre: casual.name,
      nacionalidad: casual.country
    }
  }
}

module.exports = { typeDefs, resolvers, mocks }

const express = require('express');
const { ApolloServer } = require('apollo-server-express');
const { typeDefs, resolvers, mocks } = require('./schema')

const server = new ApolloServer({ typeDefs, resolvers, mocks, mockEntireSchema:true });

const app = express();
server.applyMiddleware({ app });

const PORT = 5678

app.listen(PORT, () => {
	console.log(`🚀 Server ready at http://localhost:${PORT}${server.graphqlPath}`)
});

Mocking

Conceptos Generales de GraphQL

Por qué aprender GraphQL

Orígenes de GraphQL

GraphQL vs REST

Construyendo Esquemas a través de Tipos

El Schema - Types

Scalars

Objects

Enum

Interface

Union

Modificadores de tipo

Root Type: Query

Root Type: Mutation

Las Herramientas de GraphQL

Aclaración antes de empezar éste modulo

La Interfaz de GraphiQL

Queries

Argumentos

Variables

Aliases

Fragments

Inline Fragments

Directives

Mutations

Input Types

Proyecto

Presentación del Proyecto

Inicialización del Proyecto

Creación del Esquema

Deprecación de Campos

Resolvers

Desafío: Terminar los Resolvers

Mocking

Implementación de Bases de Datos

Resolviendo a Base de Datos

Modularización del Esquema

Mutaciones: Creando Registros

Mutaciones: Editando Registros

Mutaciones: Eliminando Registros

Desafío: Terminar de Crear las Mutaciones

Implementando la Búsqueda

Manejo de Errores

Usando GraphQl fuera de GraphiQL

Los Clientes de GraphQL: Apollo vs Relay

Implementación de Apollo Client

Conclusiones

¿Cuándo usar GraphQL?

Contenido Bonus

Herramientas de la Comunidad

GraphQL Real Time con Subscriptions