Clase 3: Creación y procesamiento de Jsons

Práctico

 

Ejercicio 1

Dado el siguiente Json, procesar todos los datos de un Libro

Ejercicio 2

Crear un Json con los datos de estudiante: 

Nombre: Juan, Apellido: Lopez, DNI : 123123, Colegio: St. Albans

{“nombre”:“Juan”,“apellido” : “Lopez”,“DNI” : 1233, “Colegio”: “St. Albans” };

Ejercicio 3

Crear un Json con los datos 3 estudiantes: 

Nombre: Juan, Apellido: Lopez, DNI : 123123, Curso: Informatica

Nombre: Maria, Apellido: Rodriguez, DNI : 22222, Curso: Administración

Nombre: Juan, Apellido: Cowen, DNI : 123123, Curso: Finanzas

Se debe imprimir todos los datos del Json en pantalla.

Ejercicio 4:

Crear una clase libro con los datos de un libro: categoría (String), autor (String), titulo (String), precio (int). Crear un constructor que reciba los datos de un libro por parámetro.

Crear una lista de libros y almacenarlos en la lista.

Convertir la lista en una lista de Json (debe quedar almacenada en una variable de tipo String)

Agregar un identificador (en formato Json) al String que contiene al Json.

Mostrar la cantidad de elementos que tiene el Json creado (debería coincidir con la cantidad de libros que se crearon inicialmente)

Recorrer la lista de elementos del Json y mostrar el título y el precio en pantalla de cada libro. 

Calcular el precio total si comprase los 3 libros.

@Test

public void librosTest(){
  Libro l1 = new Libro(“Terror”, “J.W. Tolking”, “Arboleda”, 300);
  Libro l2 = new Libro(“Drama”, “J.W. Tolking”, “Titulo 2”, 500);
  Libro l3 = new Libro(“Humor”, “J.W. Tolking”, “Titulo 3”, 1000);

  List listaLibros = new ArrayList<>();
  listaLibros.add(l1);
  listaLibros.add(l2);
  listaLibros.add(l3);

  String json = new Gson().toJson(listaLibros);
   System.out.println(json);

   json = “{\”libros\”:” + json +”}”;

   //Array libros
  // [  categoria: terror  precio: 300]
  // [  categoria: drama   precio: 500]
   // [ cateogoria: humor   precio: 1000]

   JsonPath js = new JsonPath(json);
  int cantidadCursos = js.getInt(“libros.size()”);
   System.out.println(cantidadCursos);

  int total = 0;
  for (int i = 0; i < cantidadCursos; i++) {
      String titulo = js.get(“libros[” + i + “].titulo”);
      int precio = js.get(“libros[” + i + “].precio”);
       System.out.println(titulo + ” Precio: $” + precio);
      total += precio;
  }
   System.out.println(“Precio de todos los libros” + total);
}

Ejercicio 5

El siguiente Json contiene información de libros.

 Crear una clase de Test llamada LibrosTest

a) Crear un test que imprima todos los datos de los libros (su título y su precio) en pantalla y el precio total de los libros.

b) Crear un método de test llamado calcularPrecioTotal, que calcule el total que se recaudaría si se venden todos los libros. Luego validar ese dato con el valor que se encuentra dentro del Json en el campo total (1510). Utilizar un assert.

c) Crear un método de test llamado imprimirCopiasCucumber que imprima unicamente la cantidad de copias del libro de Cucumber

Sugerencia 1: crear una clase llamada Payload que contenga un método estático que retorne un String conteniendo todo el Json en formato String.

Sugerencia 2: Utilizar la clase Payload para convertir la información en un objeto JsonPath

 

{
"informacion": {
"total": 1510,
"website": "selenium"
},
"libros": [
{
"titulo": "Selenium con Java",
"precio": 50,
"copias": 6
},
{
"titulo": "Rest Apis",
"precio": 40,
"copias": 4
},
{
"titulo": "Cucumber",
"precio": 45,
"copias": 10
}
]
}
public class Payload {


public static String informacionDeLibros(){
return "{\n" +
" \"informacion\": {\n" +
" \"total\": 910,\n" +
" \"website\": \"selenium\"\n" +
" },\n" +
" \"libros\": [\n" +
" {\n" +
" \"titulo\": \"Selenium con Java\",\n" +
" \"precio\": 150,\n" +
" \"copias\": 6\n" +
" },\n" +
" {\n" +
" \"titulo\": \"Rest Apis\",\n" +
" \"precio\": 40,\n" +
" \"copias\": 4\n" +
" },\n" +
" {\n" +
" \"titulo\": \"Cucumber\",\n" +
" \"precio\": 45,\n" +
" \"copias\": 10\n" +
" }\n" +
" ]\n" +
"}";
}

public class LibrosTest {

@Test
public void testInformacionLibros(){
JsonPath js = new JsonPath(payload.informacionDeLibros());

int cantidadLibros = js.getInt("libros.size()");
System.out.println(cantidadLibros);

System.out.println("**** TODOS LOS LIBROS *****");
int total = 0;
for (int i = 0; i < cantidadLibros; i++) {
String titulo = js.get("libros[" + i + "].titulo");
int precio = js.get("libros[" + i + "].precio");

System.out.println(titulo + " Precio: $" + precio);
total += precio;
}
System.out.println("El precio final es de " + total);
}


@Test
public void calcularPrecioTotal()
{
int sum = 0;

JsonPath js=new JsonPath(payload.informacionDeLibros());
int count= js.getInt("libros.size()");
for(int i=0;i<count;i++)
{
int price=js.getInt("libros["+i+"].precio");
int copies=js.getInt("libros["+i+"].copias");
int amount = price * copies;
System.out.println(amount);
sum = sum + amount;
}
System.out.println(sum);
int purchaseAmount = js.getInt("informacion.total");
Assert.assertEquals(sum, purchaseAmount);
}

@Test
public void imprimirCopiasCucumber() {
JsonPath js = new JsonPath(payload.informacionDeLibros());

int cantidadLibros = js.getInt("libros.size()");
System.out.println("La cantidad de libros es: " + cantidadLibros);

//imprimir la cantidad de copias de el libro de Cucumber
for (int i = 0; i < cantidadLibros; i++) {
String titulo = js.get("libros[" + i + "].titulo");
if (titulo.equalsIgnoreCase("Cucumber")){
int copias = js.get("libros[" + i + "].copias");
System.out.println("La cantidad de copias es " + copias);
break;
}
}
}

Ejercicio 6

Crear un método que reciba un String con un Json y un parámetro, y retorne el valor de ese parámetro en forma de String

public static String rawToJason(String response, String param){
   JsonPath jsonPath = new JsonPath(response);
   String parameter = jsonPath.get(param);
   return parameter;
}
 

Ejercicio 7:

Dado el siguiente Json, imprimir cada uno de los campos en pantalla. Sugerencia: Almacenar el JSON en un String y utilizar la clase JsonPath

{
    "access_token": "00D1N000001Rznq!AQYAQGGqJYk6Jqt3g8oVNzy2m6QKXGN_utdsdli5xUiwW9O1LROsoQEDmTGI8PO4V17pPC2tJCjlW0b5txdsbOsSL8CG8rW5",
    "instance_url": "https://emilianognocchi-dev-ed.my.salesforce.com",
    "id": "https://login.salesforce.com/id/00D1N000001RznqUAC/0051N000005TNbMQAW",
    "token_type": "Bearer",
    "issued_at": "1624384798213",
    "signature": "BSowPjEKEdR55Z8EX/7ym3TDSu/g8EC8SekYP7xBwYs="
}
public static void main(String args[]) {

String response = "{\n" +
" \"access_token\": \"00D1N000001Rznq!AQYAQGGqJYk6Jqt3g8oVNzy2m6QKXGN_utdsdli5xUiwW9O1LROsoQEDmTGI8PO4V17pPC2tJCjlW0b5txdsbOsSL8CG8rW5\",\n" +
" \"instance_url\": \"https://emilianognocchi-dev-ed.my.salesforce.com\",\n" +
" \"id\": \"https://login.salesforce.com/id/00D1N000001RznqUAC/0051N000005TNbMQAW\",\n" +
" \"token_type\": \"Bearer\",\n" +
" \"issued_at\": \"1624384798213\",\n" +
" \"signature\": \"BSowPjEKEdR55Z8EX/7ym3TDSu/g8EC8SekYP7xBwYs=\"\n" +
"}";

JsonPath jsonPath = new JsonPath(response);
String accessToken = jsonPath.get("access_token");
String instanceUrl = jsonPath.get("instance_url");
String id = jsonPath.get("id");
String signature = jsonPath.get("signature");


System.out.println("Access token --> " + accessToken);
System.out.println("Instance Url --> " + instanceUrl);
System.out.println("Instance Id --> " + id);
System.out.println("Signature --> " + signature);
//clave - valor
HashMap<String, String> mapaValores = new HashMap<>();
mapaValores.put("access_token", accessToken);
mapaValores.put("instance_url", instanceUrl);
mapaValores.put("id", id);
mapaValores.put("signature", signature);

System.out.println("El access token es " + mapaValores.get("access_token"));
System.out.println("La url de instancia es " + mapaValores.get("instance_url"));
System.out.println("El id es " + mapaValores.get("id"));
System.out.println("La signature es " + mapaValores.get("signature"));

}

 

Ejercicio 8

Crear un método reutilizable que dado un parámetro y un String con una respuesta retorne el valor de ese parámetro en la respuesta:

public static String rawToJason(String response, String param){
  JsonPath jsonPath = new JsonPath(response);
  String parameter = jsonPath.get(param);
  return parameter;
}

Ejercicio 9

Crear una clase específica para ello llamada ReUsableMethods. Los métodos de esta clase deben ser estáticos. Agregar métodos que se utilicen en varios tests e invocarlos.

public class ReUsableMethods {

  public static String rawToJason(String response, String param){
      JsonPath jsonPath = new JsonPath(response);
      String parameter = jsonPath.get(param);
      return parameter;
  }
}