UNIVERSIDAD TECNOLÓGICA DE PANAMÁ

FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES

DEPARTAMENTO DE INGENIERÍA DE SOFTWARE
GUÍA DE LABORATORIO N° 3

Facilitadora: Ing. Belén B. Bonilla M. Asignatura: Calidad de Software

Fecha de asignación: 11 de mayo de 2021 Grupo: 1SF131/1SF132
Fecha de entrega: 12 de mayo de 2021

A. TÍTULO DE LA EXPERIENCIA: Uso del software de control de versiones Git como parte de la
administración del cambio en el aseguramiento de la calidad del software (Parte III)

B. TEMAS:
● Fusión de ramas en Git
● Trabajar con repositorios remotos

C. OBJETIVO(S):
Conocer los principios y funcionalidades básicas de Git para realizar control de versiones de
archivos a fin de apoyar la administración del cambio en los productos de trabajo dentro de un
proyecto de desarrollo de software.

D. METODOLOGÍA:
1. Trabajar de manera individual.
2. Desarrollar el laboratorio siguiendo los pasos indicados en esta guía y por la profesora.
3. Entregar sus resultados en el espacio de tarea indicado en el Teams.

E. PROCEDIMIENTO O ENUNCIADO DE LA EXPERIENCIA:

Fusión de ramas en Git

1. Vamos a revisar el estado de nuestro trabajo hasta el momento (Laboratorio 1 y 2). Nos
vamos a ubicar en cada rama (master, backend y frontend) y vamos a consultar los commits a los
que apunta cada rama.
git checkout [nombre de la rama]
git log

Tome una captura de pantalla por rama y colóquela aquí:

2. Fusión de ramas. En Git dos ramas se pueden fusionar a través del comando
git merge [nombre de la rama]
Para ello debemos ubicarnos en la rama donde deseamos realizar la fusión y ejecutar el comando.
Supongamos que deseamos fusionar el trabajo que hemos realizado en backend con nuestra rama
master. Para ellos nos movemos a la rama master y ejecutamos la instrucción:
git merge backend

Tome una captura de pantalla tras ejecutar la instrucción y colóquela aquí:

Atienda a la explicación docente. Ejecute la instrucción git log e indique lo que ha sucedido:
Fusionamos la rama backend con la rama master colocandonos en la rama master primero.
3. Saltemos a la rama frontend y creemos un nuevo archivo dentro de la carpeta css llamado
home.css. Preparamos el archivo y lo confirmamos.
Consultamos el log de las confirmaciones.
Tome una captura de pantalla tras inspeccionar el log y colóquela aquí:

4. Ahora vamos a fusionar frontend con master. Deseamos realizar esta fusión en master por lo
cual nos movemos a esta rama. Estando allí, ejecutamos la instrucción:
git merge frontend
Atienda la explicación docente.
Tome una captura de pantalla de la interfaz que se despliega:

Agregue el siguiente comentario a través de la interfaz que se despliega: “Fusión de la rama

master, que trae el nuevo commit en backend, con la rama frontend que tiene un nuevo commit”

Tome una captura de pantalla del resultado que se muestra en consola tras cerrar la interfaz de
edición abierta:
 Explique con sus propias palabras lo que ha sucedido: Fusionamos la rama frontend con la rama
master colocandonos en la rama master primero.

Trabajo con repositorios remotos

5. Lo primero que haremos es crear una cuenta en GitHub (si ya posee una, puede usarla).
Acceda a través de https://github.com/
Podemos clonar repositorios remotos y publicar nuestros propios repositorios.

6. Vamos a publicar nuestro repositorio, creado de manera local, en GitHub. Para ello, vamos a
iniciar sesión en nuestra cuenta de GitHub y vamos a crear un repositorio con el mismo nombre
que lo hemos creado de manera local.
Siga las indicaciones de la docente.

7. Una vez creado el repositorio remoto, volvemos a nuestra consola, nos cercioramos de estar
ubicados en master (quien tiene actualmente toda la actualización de nuestro proyecto) y
procedemos a añadir el repositorio remoto creado para poder acceder desde nuestra consola
(computadora, local) a ese repositorio.
Primero vamos a consultar si existe ya registrado algún repositorio remoto para nuestro repositorio.
Podemos consultar los repositorios remotos que tenemos agregados con la instrucción:
git remote
Hasta este momento no debemos tener ningún repositorio remoto asociado. Procedemos
entonces, a añadir el repositorio remoto creado en GitHub. Empleamos para ello la instrucción:
git remote add [nombre-remoto] [url]
Volvemos a consultar los repositorios remotos que tenemos agregados con la instrucción:
git remote
Si agregamos -v al final de la instrucción, se muestra las URLs que Git ha asociado al nombre y
que serán usadas al leer y escribir en ese remoto:
git remote -v

Tome una captura de la salida y colóquela aquí:

8. Para publicar nuestro trabajo local (en una rama determinada) en el repositorio remoto,
debemos enviar nuestros cambios al servidor, es decir, todos nuestros commits. Para ello
empleamos el comando:
git push [nombre-remoto] [nombre-rama]

Tome una captura de pantalla de la salida obtenida y colóquela aquí:

 Revisemos nuestro repositorio en GitHub, ¿Aparecen nuestros commits?

9. Consultemos las ramas que tenemos disponibles. Esta vez emplearemos el comando git
branch pero con la opciones -a (lista todas las ramas tanto locales como remotas) y -v
(muestra el commit al que apunta cada rama):
git branch -a -v
Tome una captura de pantalla de la salida obtenida y colóquela aquí:

10. Supongamos ahora que un compañero de trabajo hizo un push al remoto con un nuevo
commit (Siga indicación docente en este punto). Por supuesto, de manera local nosotros no hemos
actualizado y por consiguiente no vemos reflejado este commit. Para traer la información que está
en el repositorio remoto, pero no en nuestro local, utilizamos la instrucción:
git fetch [nombre-remoto][nombre-rama]
Tome una captura de pantalla de la salida obtenida y colóquela aquí:

Es importante destacar que el comando git fetch solo trae el trabajo que se encuentra en el

remoto/rama y que no tenemos de manera local y lo coloca en la rama que hace referencia a la
 rama (en este caso, master) en nuestro remoto - ni lo combina automáticamente con nuestro
trabajo ni modifica el trabajo que llevamos hecho.
11. Para combinarlo debemos hacer un merge de manera manual (debemos estar colocados en
la rama donde queremos tener los nuevos cambios; en este caso, master). Para ello empleamos:
git merge [nombre-remoto]/[nombre-rama]
Tome una captura de pantalla de la salida obtenida y colóquela aquí:

12. Volvemos a consultar las ramas que tenemos disponibles y los commit a los que apuntan:
git branch -a -v
Tome una captura de pantalla de la salida obtenida y colóquela aquí:

13. Supongamos nuevamente que un compañero de trabajo hizo un push al remoto con un nuevo
commit. Podemos hacer un fetch y merge directo a través de la instrucción:
git pull [nombre del remoto] [nombre de la rama en el
remoto]
Tome una captura de pantalla de la salida obtenida y colóquela aquí:

14. Volvemos a consultar las ramas que tenemos disponibles y los commit a los que apuntan:
git branch -a -v
Tome una captura de pantalla de la salida obtenida y colóquela aquí:
 Cree la estructura de árbol que hasta el momento mantenemos:

F. RECURSOS:
Internet, computadora, software Git para el sistema operativo usado