Pruebas en el servidor: Probando el método GET y Reto con FindByID

Esta es mi solucion.

   // Get 200 FindById
    it("200 and findById pin", done => {
      const data = { id: 1 };
      /* Dentro del Objeto Pins queremos espiar el metodo findById y ejecutamos nuestro propio metodo */
      spyOn(Pins, "findById").and.callFake((id, callBack) => {
        data.param = id;
        callBack(false, data);
      });
  
      request.get("http://localhost:3000/api/21312", (error, response, body) => {
        expect(response.statusCode).toBe(200);
        expect(error).toBe(null);
        expect(JSON.parse(response.body)).toEqual({ id: 1, param: "21312" });
        expect(JSON.parse(response.body).id).toEqual(1);
        expect(JSON.parse(body).param).toEqual("21312");
        done();
      });
    });

    //GET 500 FindById
    it("500", done => {
      const data = [{ id: 1 }];
      /* Dentro del Objeto Pins queremos espiar el metodo find y ejecutamos nuestro propio metodo */
      spyOn(Pins, "findById").and.callFake((id, callBack) => {
        callBack(true, data);
      });

      request.get("http://localhost:3000/api/21312", (error, response, body) => {
        expect(response.statusCode).toBe(500);
        done();
      });
    });

Acá la solución del reto

  describe('GET custom pin', () => {
    // GET 200
    const data = [{id: 1}];
    const elementId = '2132';

    it('should response with 200 and Get custom pin', (done) => {
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        // callback = function(err, post)
        expect(elementId).toEqual(id);
        callBack(false, data); // error = false
      });
      request.get('http://localhost:3000/api/'+elementId, (error, response, body) => {
        expect(response.statusCode).toBe(200);
        expect(JSON.parse(response.body)).toEqual([{id: 1}]);
        done();
      });
    });


    // GET 500
    it('Should return 500 when error', (done) =>{
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        // callback = function(err, post)
        callBack(true, data); // error = true
      });
      request.get('http://localhost:3000/api/'+elementId, (error, response, body) => {
        expect(response.statusCode).toBe(500);
        done();
      });
    });
  });

Yo lo hice de esta forma.

it('200 and find pin by Id', (done) => {
			spyOn(Pins, 'findById').and.callFake((id, callBack) => {
				callBack(false, id);
			});

			request.get('http://localhost:3000/api/1', (error, response, body) => {
				expect(response.statusCode).toBe(200);
				expect(error).toBe(null);
				expect(JSON.parse(response.body)).toEqual('1');
				done();
			});
		});```


Me encanta el curso por cierto.

// GET
    it("200 single ping by id", (done) => {
      const data = { id: 1 };
      const id = 1;
      spyOn(Pins, "findById").and.callFake((id, callback) => {
        callback(false, data);
      });
      request.get(
        `http://localhost:3000/api/${id}`,
        (error, response, body) => {
          expect(response.statusCode).toBe(200);
          expect(JSON.parse(response.body)).toEqual({ id: 1 });
          done();
        }
      );
    });

    // GET 500
    it("500", (done) => {
      const data = { id: 1 };
      const id = 1;
      spyOn(Pins, "findById").and.callFake((id, callback) => {
        callback(true, data);
      });
      request.get(
        `http://localhost:3000/api/${id}`,
        (error, response, body) => {
          expect(response.statusCode).toBe(500);
          done();
        }
      );
    });

it('200 and find by id', done => {
      const id = 1
      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        callBack(false)
      })

      request.get(`http://localhost:3000/api/${id}`, (error, response) => {
        expect(response.statusCode).toBe(200);
        expect(id).toEqual(1)
        done()
      })
    })

Como hago para validar el parametro que me llega por la url??

describe("GET SINGLE PIN BY ID", () => {
    // GET 200
    it("should return 200 and find pin by id", done => {
      const data = [{ _id: 1 }];
      spyOn(pinsModel, "findById").and.callFake((id, callback) => {
        callback(false, data);
      });
      request.get("http://localhost:3000/api/pin_id", (error, res, body) => {
        expect(pinsModel.findById).toHaveBeenCalledWith('pin_id', jasmine.any(Function))
        expect(res.statusCode).toBe(200);
        expect(JSON.parse(res.body)).toEqual([{ _id: 1 }]);
        done();
      });
    });

    // GET 500
    it("should return 500", done => {
      spyOn(pinsModel, "findById").and.callFake((id, callback) => {
        callback(true, null);
      });
      request.get("http://localhost:3000/api/pin_id", (error, res, body) => {
        expect(res.statusCode).toBe(500);
        done();
      });
    });
  });```

De dónde viene este callback?

Qué está llamando?

      spyOn(Pins, 'find').and.callFake((callBack) => {
        callBack(true, data);
      });

<code>
it("200 and pinById", (done) => {
    const data = [{ id: 1 }];
    const id = 1;

    spyOn(Pins, "findById").and.callFake((id, callBack) => {
      callBack(undefined, data);
    });

    request.get("http://localhost:3000/api/1", (error, response, body) => {
      expect(response.statusCode).toBe(200);
      expect(JSON.parse(body)).toEqual([{ id: 1 }]);
      done();
    });
  });
</code>

it('200 get by ID', (done) => {
      const idTest = '232'
      const data = {id: idTest}

      spyOn(Pins, 'findById').and.callFake((id, callBack) => {
        callBack(false, data)
      })

      request.get(`http://localhost:3000/api/${idTest}`, (error, response, body) => {
        expect(response.statusCode).toBe(200)        
        expect(JSON.parse(response.body)).toEqual(data)
        expect(JSON.parse(response.body).id).toEqual(idTest)
        done()
      })
    })

Aquí mi solución

it('should get the pin with the id indicated', (done) => {
                const pin = {id: 22};
                spyOn(Pins, 'findById').and.callFake((id, callBack) => {
                    callBack(false, pin);
                });
                request.get(`${apiUrl}/${pin.id}`, (error, response, body) => {
                    const bodyResponse = JSON.parse(response.body);
                    expect(error).toBeNull();
                    expect(response.statusCode).toBe(200);
                    expect(bodyResponse).toEqual(pin);
                    done();
                })
            });
            it('should get an error - get a pin', (done) => {
                const pin = {id: 22};
                spyOn(Pins, 'findById').and.callFake((id, callBack) => {
                    callBack(true, null);
                });
                request.get(`${apiUrl}/${pin.id}`, (error, response, body) => {
                    expect(response.statusCode).toBe(500);
                    done();
                });
            });
```

Aunque la verdad no se si realmente este bien
// GET BY ID
it(“200 and find pin”, (done) => {
const data = [{ id: 1234 }];
spyOn(Pins, “findById”).and.callFake((id, callBack) => {
callBack(false, data);
});

  request.get("https://localhost:3000/api/1234", (error, response, body) => {
    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.id)).toEqual([{ id: 1234 }]);
    done();
  });
});