Spring Boot Testing - REST API Integration Testing using Testcontainers | Crash Course

hi welcome to the crash course titled spring boot application integration testing using test containers well in this course i'm going to show you how we can you know perform integration testing using test containers you know many organizations uses containerized platform for the deployment right and let's say if you set up the jenkins ci pipeline in your production then you can simply run your test cases in the jenkins ci pipeline and in java test containers java java library basically helps us to run the integration test cases in a jenkins you know a ci pipeline using docker containers all right well in this course i'm gonna show you how we can do the integration test using test containers so basically we're gonna deploy mysql database in a docker container using test containers and then we'll you know execute integration test cases with respect to the mysql database which is deployed in a docker container now let's take a look into what is integration testing well as names suggest integration tests focus on integrating different layers of the application that means no mocking is involved for example here you can see this is again a three-layer architecture all right controller layer service layer repository layer and repository layer will talk with the database and this is for employee management feature okay because we have our employee controller employee service and employee repository and basically integration testing means we are going to test the integration of these different layers we are not going to test a single or individual component we are going to test the integration of these layers okay this complete flow from employee controller to database okay and we are not going to mock any objects while integration testing so integration testing means basically we will test the integration of different layers all right consider one more example user management feature well while implementing user management feature we create a user controller user service user repository right and in order to do the integration testing for this feature we do the testing for all these layers okay we don't test only the single component like user controller we test the integration of all these components okay similarly login feature all right so just remember integration testing means testing the integration of different layers okay and in case of integration testing we don't have to use a mocking mechanism okay we don't have to use a market of framework or any other mocking frameworks well this video is sponsored by my vdm course we'll look at here testing spring boot application with jnet and mercuto well this is a brand new course i have published on video me and in this course you will learn how to do the unit testing integration testing for your spring boot application using junit marketo asset jham crust json path and test container so these are the well java frameworks for testing so in this course you will use all these popular frameworks for testing the springboot application and basically in this course you will learn how to unit test repository layer and service layer and you will learn how to you know unit test rest apis you will learn how to do the integration testing using mysql database you will learn how to do integration testing using test containers you will basically learn a lot of stuff about testing spring boot application in this course and this course has a very you know less cost or less you know price so you can go ahead and grab this course on udemy let's go and let's kick start this crash course by looking into what is test containers well test containers is a well-known java library that supports junit test cases okay and if you can consider this architecture diagram over here typically we write the integration test with respect to the local database in our case let's say mysql database okay so basically we write the integration test and we run with respect to mysql database which is installed in a local machine but the problem here is the integration test are tightly depends on the you know mysql database which is installed locally isn't it and every time we want to run the integration test cases then we have to you know install mysql database let's say if you are developing a big enterprise application then your enterprise application may depends on various external services for example let's say databases message queues readys okay rabbit mq kafka all right so before running integration test you need to install all these external services then only you can able to run the integration test cases right so this is uh you know common problem while executing test cases that is integration test cases and this is the basically a common problem right and test containers is a solution for this problem well basically test containers what it does it allows us to use a docker container in jna test cases only well if we use test containers with jna test cases then test container will basically deploy a docker image in a docker container for example let's say our integration test cases depends on the mysql database then these test containers will pull you know mysql docker image from the docker hub and then it will deploy in a docker container so that we can able to run our integration test cases with respect to mysql database this is awesome right we don't have to install mysql database in our local machine if we have a docker installed then we can simply use test containers to deploy the mysql docker image in a docker container and we can able to run our integration test cases let's see how we can do this step by step well before creating springboot project from scratch let's quickly take a look into what is test containers well test containers is a basically java library that supports junit test providing lightweight throwaway instances of common databases sell any web browsers or anything else that can run in the docker container well basically test containers is a java library and that allows us to use a docker container in jna test cases itself okay so we can simply you know give the docker image name to the test containers then test container will basically pull that docker image from the docker hub and then it will deploy in a docker container so that we can able to run our jna test cases with respect to database this is awesome right you don't have to install any external services for example mysql database or rabbitmq or any external services alright great well test containers make the following kinds of tests easier well you can use test containers with data access layer integration test application integration test acceptance test and much more because these test cases are depends on external services so you can use test containers to deploy these external services in a docker container alright let's take a look into the prerequisites well docker is a preview widget basically if you want to use test containers then you have to install docker in your machine let's say if you want to run your integration test cases in a jenkins ci pipeline in a production and it is common that most of the organization you know uses docker in a jenkins pipeline to deploy the applications right and yeah so docker is kind of a prerequisite for test containers and make sure that before using test containers you have to install docker in your machine or if you want to run your integration test cases on production then make sure that docker is available in a production next marvin dependencies well if you are using marvin project then you can go ahead and grab this test containers dependency if you are using gradle then we can go ahead and grab this gradle dependency for test containers all right and you can see here feature so if you want to learn more about test containers then you can go ahead and dive into these features of test containers and you can see the models well you can see there are a lot of models containers docker compose module azure google cloud okay local stack rabid mq well basically test container supports all these cloud and other modules and in databases section you can see here a lot of databases right well we can use test containers to deploy these databases as a docker image this is awesome right test container supports a lot of databases right a lot of models isn't it that's why test container is a very popular java library uh which we can use to directly use docker containers in jna test cases okay so this is quick overview of test containers now what we're going to do is we're going to quickly create a spring boot project and then we write the integration test using test containers well let's head over to star dot spring dot io this will brings up spring initializer and go ahead and select marvin project and then language java spring boot version 2.6.2 and then let's go and let's fill up the project metadata over here let's say google id net dot java guides dot spring boot well i'm going to give group name something like net.javage.springboard so you can give any group id that you want and here it backtite is nothing but our project name so let me give something like spring boot test containers [Music] demo okay so name is nothing but artifact and description lets you demo project for spring boot and test containers [Music] and package name let's keep net dot java dot spring boot okay and packaging let's keep jar as selected and java 11 you can choose java 17 or 8 as per the java installation on your machine and go to the dependencies section over here and here we're going to choose spring web dependency apart from that we are going to use spring data jp dependency we are going to develop a repository here so we're going to use spring data gpa dependency and we are going to use lombok library to reduce the boilerplate code and let's go and let's use mysql driver all right and then yeah that is pretty much so make sure that you have selected spring web spring data jpa lombok and mysql driver and then go ahead and click on generate over here so this will generate spring boot application as a zip file in a file system and go ahead and open in a folder and just extract it all right and let's open intj idea and let's import this project so i am going to open the intellij idea over here click on open and go to the folder where the application is extracted so i am going to go to the downloads folder over here and spring boot test containers demo select it click on open alright so you can see resolving dependencies of springboard test containers demo applications so mine will basically take couple of seconds to resolve all the dependencies let's wait couple of seconds well you can see here spring boot application is successfully imported in the integer idea now what we'll do will quickly create a packaging structure for our project so go ahead and right click new and then choose package let's give package name as entity within entity package we keep the jp entities and let's go and let's create one more package let's call it as a repository and again let's create one more package let's call it as controller [Music] all right next what we're gonna do is we're gonna configure mysql database details so go ahead and open application.properties file over here and just type the property spring dot data source dot url equals to jdbc colon mysql and localhost so i want to connect to the local mysql server that's why here localhost and the port 3306 and database let's say demo all right and we are going to disable the ssl so let's have a property ssl use ssl equal to false and let's configure you know username and password here spring dot data source dot username [Music] root in my case the username is root and similarly let's do it for password all right so make sure that you have to change username password as per the mysql you know server installation in your machine and let's go and let's configure hibernate dialet as well as detail auto hibernate property over here all right so look at here the hibernate dilate from mysql database and this is the detail auto property so this will create a table automatically okay great now what you're going to do is we're going to create a jp entity so go to the entity package over here right click new and then choose java class let's give a entity name something like student okay let's declare the fields something like private long id [Music] and then private string first name [Music] alright and similarly let's create one more field as a last name okay and let's go let's create one more field email perfect and let's annotate this class with add sector annotation to create a setter methods for these instance variables and let's also have a getter annotation so this is basically a longboard connotation to generate a getters method for these private instance variables okay now what do you want to do is we're gonna use at builder annotation to have a builder pattern for this student class and we can also use add you know all argument constructor to create parameterized constructor for this class let's have no argument constructed okay now we have created a class with get to certain methods builder pattern and constructors now let's make this class as a jp entity in order to do that let's go and let's use jpa annotations let's use add entity annotation and also use add table annotation to specify table details over here let's say the table name is students okay well here is a typo now what you're gonna do is we're gonna specify the primary key for this table so let's one let's use add id annotation and also specify the primary generation strategy so let's have a strategy something like identity generation type identity so this will have to increment the column in a table all right and let's go and let's configure the column name for these fields let's say add column annotation over here and just give name to the column something like first name okay and let me copy this and go ahead and similarly do it for last name so this is something like last underscore name okay let's change from first name to first underscore name all right we have created student jp entity now what you're gonna do is we're gonna create a gpa repository for student entity so go to the repository package right click new and choose java class and choose interface and let's give repository name something like student repository hit enter and let's go let's extend student repository interface from jpa a repository and look at a jpeg repository takes two arguments type of the entity and type up the primary key so in our case we are going to create an entity for student so go ahead and pass student as a first argument all right and second argument is the type of the primary key that is long okay and we no need to annotate this interface with add repository annotation because jpeg repository implementation class you know will take care of that now we have created student repository now let's one let's create a rest api which will call student repository methods so go to the controller package right click new and choose class let's view class name as student controller all right and let's annotate this class with add rest controller annotation to make this class as a spring game music controller which will able to handle the http request and let's also annotate this class with at the request mapping annotation to provide a base url for this cons you know controller let's say base url something like slash api and also mention students all right and let's quickly create one rest api over here before that let's inject student repository so we are not going to create a service layer because this is just a demo uh to showcase how we can use you know test containers for integration testing if you have a requirement to use the service layer for business logic then you can go ahead and create the service layer all right and let's one let's create a rest endpoint public which returns a student and let's call it as create student okay and just pass student object as a method argument and then simply return a student repository dot call save method to save the student object and now we have created a method right let's make this method as a rest api by calling i mean by using annotation that is add post mapping annotation it's pretty simple isn't it let's use add request body annotation all right and this will basically map http request to directly to the student object and let's go and let's annotate this method again with iterate response data annotation and we need to provide http status as created okay so this is the rest api to create the new resource so we have to specify http status as you know created all right just save it we have created a rest api you know to create a student all right great next let's go and let's create one more rest and point that is get all students rest and point let's create a method first public and then it returned a list of student and let's say get all students is the method name all right and just return call student repository and then call final method so this will return a list of students and go ahead and take this method with at get mapping annotation so that this method will handle http request okay this is pretty simple we have created get all students rest api all right okay so now we have created a base for integration testing we are going to basically write integration test for student controller okay great now it's time to create integration testing well go to the test package and here what we're gonna do is we're gonna write the integration test so we have already annotated this class with add spring boot test annotation well here add spring boot test annotation is very very useful for integration testing because add springboot test annotation will load a full application context full application context meaning it will load all the spring bins that is available in the springboot application okay so it will load full application context so that we can able to do the integration testing of different layers of the springboot application isn't it and this ad springboard test annotation provides you know different options to run the integration test cases for example it will provide the embedded server with you know random port to deploy uh this application and do the integration testing okay so ultimately this add spring boot test annotation will invoke internally the main entry point class okay and this main entry point class will deploy our springboot application in embedded tomcat server right now let's go and let's write the integration test case well just get rid of this code and write the jna test case over here public wide and let's give a indication test name something like basically we follow a bdd style okay given given student students okay we are going to save multiple students first in a given section and then comes when so basically now when we call the get all students you know api right and then this will return list of students list of students so this is typical naming convention that i follow to give name to the jne test cases so this is basically a given when then format okay so this is basically a bdd style behavior driven development style all right great now within this uh method we are going to write the logic so before that let's annotate this method with add test annotation and make sure that you choose add text annotation from you know junit framework now we divide this test into three parts given and then when and then in a given section we basically prepare the setup setup or the free condition okay and in event section we perform the action action meaning we perform the actual testing and in a then section we basically verify the output okay so in a given section basically we are going to create couple of students and will save those students in the database table and we know when section we are going to call a get all students rest api which will fetch all the students from the database and in a verify or in a then section we are going to verify the output so what i'm going to do is i'm going to create a list here and of type student okay and then let's call it as students and here i'm going to create a list of student objects off and then i'm going to create student object over here i'm going to use builder pattern perfect we have created two students object okay so first one is ramesh and second one is tony what is gonna save this student object to the database in order to do that we're going to first use our first inject student repository over here we're going to use add auto wired annotation to inject the student repository okay student repository and go ahead and use this student repository and call its method that is save all to save the bulk of student objects that's it so in a given section we have done the free condition that is we have saved a couple of student object into the database and in event section we are going to make a rest api call okay for that we're gonna use mock muc object so let's go and let's add our mock muc object so go ahead and use at a to add annotation over here and let's go and let's use mock muc object okay so in order to call the rest api or in order to do the integration testing of rest apis spring framework basically provides mock a music class which we can use to call the rest api and in order to enable this mock music class we're gonna use annotation that is add auto configure mock muc okay great now we are good to use mochi music class object we'll go to the event section again and then here simply call for form method and within a perform method we're gonna call mock muc request builders class it provides different methods like post get port to delete so we can use these methods to call the respective rest api so i'm going to call get all students rest api in this case so let's go ahead and call get method and then provide the rest api url here that is api students okay this will provide a list of student objects and what is the compilation here here it says unhandled exception so go ahead and you know throw the exception from this method and this proper method returns a result actions object right so go ahead and take the response of this method in a result actions object let's call it as a response now let's go and let's verify this response in the then section so go ahead and call the response object and then we're going to call and expect method to just verify the expected result with the actual result and this you know method expect a result matcher so just call its implementation that is mock music result matches and it has a method called status okay and this get all students api returns a status code okay right so we're gonna call okay method to check the http status okay isn't it great now we have verified the http status of the response next we're gonna verify the size of the list that we get in the response well here in a given section you can see we have saved two students object into the database and we are sure that this get students rest api returns those two students object from the database right now here what i'm gonna do is we're gonna call again and expect method all right and when again use mock muc result matches and this has a json path method and look at your jsonpath method expect expression and match these two parameters so go ahead and call this and here we're going to pass the jsonpath expression that is dollar dollar meant for a whole complete json structure okay and we can see that this decent structure size by using size method and here we are going to basically use a second parameter as core matches class from ham crust it provides ease method so we can use easy method to just check the expected result with the actual result okay in this case this is the expected and what is the you know actual so actual is the size of the students past students okay this is how basically we write the you know statement to verify the response of the rest api so here basically we are using jsonpath method to verify the json size with the actual size so here actual size we have given students.size because in a given section you can see we have saved two students object and we are sure that get our students method returns to student object right that is what we are verifying here was just simply verifying the size of the json that we got from the response isn't it so this is how we write the integration test to test get all students rest api now we are good to run the integration test case before that one more thing we want to do is we want to create a database in a mysql server because in application.properties file we have configured demo database right in order to connect our stream boot application with demo database we should create this demo database in a mysql server well let me go to the terminal and let me quickly connect to the mysql database so here i am basically using terminal you can use mysql workbench if you have mysql workbench and let me create a database create database demo perfect i have created demo database now we are good to run our integration test case now let's go and let's run the integration test case and let's see how this works and there we go the jna test case passed it means that the integration test case that we have written is working as expected and if you want to you know run this jna test case with a clean database then you can go ahead and change one property so let me show you good application.properties file and instead of update you can have a create drop value for this property so this will basically create and drop the table uh you know each and every january test case execution okay great now what we have done basically we have created integration test for one rest api that is get all students rest api now it's time to understand what is the problem with this integration test and what is the solution for this problem well the problem we can see here this integration test is depends on my sql database right and let's say in your spring boot application you may have a different external services instead of only you know database for example you may have rapid mq you may have kafka you may have you know cassandra couchdb right so our basically integration test cases depends on all these external services right and in order to solve this problem we can use test containers right so instead of you know installing all these external services we can simply use test containers to deploy the external service services as a docker container and we simply run our integration test cases isn't it now let's go and let's see how we can you know add test containers in our spring boot application and how we can use test containers to run our integration test cases well in order to add test containers in our spring boot application let's head over to the browser and let's go to the official website of test containers it is testcontainers.org and go to quick start here and junit for you quick start and here basically we need to grab the dependencies so go to marvin here and you can see these are the couple of dependencies we need to add okay and you can see here these are the jnet5 related dependencies jupiter api jupiter params jupiter engine and these are the jn85 dependencies are already provided by spring boot starter test dependency that's why we are not going to use these three dependencies and these are the two couple of dependencies that we are going to use okay just grab these two dependencies and you can see here this is the dependency that provides the integration of you know junit with test container all right so just grab these two dependencies grab meaning just copy these two dependencies and go to integer integer idea and go to pom.xml and just scroll down and go ahead and add these two dependencies okay and we need one more dependency so go to again the official documentation page and we are going to basically install mysql as a docker container right for that go to the module section over here databases and go to mysql module and we're going to use marvin dependency of this model so just copy this dependency and go to integer id again and just paste it here all right and save it and you can see here my main icon so go ahead and click on this to load the money changes so my menu will basically download all these newly added dependencies in order to confirm this what you can do you can go to the external libraries over here and you can confirm for example just scroll down and you can able to see here test containers dependencies are added okay it means that we have added test continuous support in our springboot application all right now we are good to use test containers well go back to the test class now let's go and let's use test container provided annotations to integrate j note 5 with test containers well we need to provide extension in order to integrate test containers in j.5 so in order to do that go ahead and annotate this class with at test containers annotation well add test containers annotation is basically annotation it internally provides an extension to integrate jnut file with test containers for example if you can dive into this annotation you can see this annotation internally uses you know extension it is test containers extension so this extension help us to integrate test containers with jnet5 okay great now we have integrated j with you know test containers let's go and let's create private field here that is we're going to create my sequel container instance here mysql container equal to mysql container and make sure that you should make this container object as a static so that this object will be shared between multiple test cases okay so if you don't declare this object as a static then what will happen this container will start and stop after each and every test methods and yeah so it will take a lot of time if it starts and stops you know before each and every test right that's why we just make this object as a static so that it can be shared between multiple test methods and again you can see mysql container so we are going to deploy mysql database in a docker container that's why we are using mysql container instance over here and this is deprecated because we need to pass a docker image name to this constructor and by default it will take a docker image with some version you can see 5.7.34 i guess this is you know old version that's why it is duplicated we have to manually specify the docker image name okay let me go ahead and let me pass the docker image name something like mysql dot latest well in order to check the docker image what you can do you can go to the browser and just search for docker hub docker hub all right just type docker hub and go to docker hub website and here just type mysql and just hit enter and go to official image and scroll down scroll down and you can see here supported tags and respect to docker files link and these are the docker image tags and you can choose the docker image as per your requirement you can specify the you know version or tag in the in my case i am going to use the latest okay you can see my sql color latest if you want to use 8 dot o then you can specify 8.0 so in this example let's keep mysql colon latest now what will happen basically when this instance will be created well basically test containers will full this docker image from the docker hub and it will deploy in a docker container that is awesome right we don't have to install mysql database in our local machine if we have a docker installed in our machine then we can simply use test containers to integrate the docker containers in a jnt test cases itself all right now this test container will pull this docker image from the docker hub and it will deploy in a docker container so that this integration test can test case can be executed with respect to the database which is deployed in a docker container isn't it and in order to make this instance uh you know life cycle methods to be managed by add test container we're gonna use at container annotation now once we annotate this object with add you know container annotation then add test containers annotation will manage the life cycle of this docker container all right lifecycle method meaning this will basically start the container and stop the container okay great now we have created mysql container this will load uh or it will fool the docker image from the docker hub and it will deploy in a docker container now what we're going to do is we're going to see what is the default you know database uh username password this mysql container uses behind the scene so in order to fetch the you know default username password and jdb url what we can do is we can put some css out over here and print some data so i'm going to print some data for example mysql container dot get database name and put again one more sis out here mysql container dot get password okay and one more sis out mysql container dot get username and let's have one more css out mysql container dot get jdbc url all right so i just want to show you what are the default you know database name password username jdbc url that this you know test container internally uses to manage this mysql database isn't it great now if we run our integration test case it will able to you know connect to the mysql database which is deployed in a docker container well before running these integration test cases with respect to test containers make sure that your docker you know a desktop is running in your machine for example i just started docker instance and you can able to see docker's desktop is running on my operating system all right now i'm good to run the integration test case so let me run the integration test and let's see how this works and look at here test container will basically you know pull this mysql latest uh docker image from the docker hub and it will deploy in a docker container all right so initially it will take some time but later on it won't take time because initially it need to set up other things right and you can able to see here test case passed it means that we have successfully executed integration test with respect to the mysql database which is deployed in a docker container and let me show you the default you know database name password user name and all those stuff right so go ahead and click on this journey test case and you can see here by default test container uses you know database name as a test password as a test username as a test and gdbc url okay so whenever test container you know full the docker image that is my sql docker image from the docker hub and it will deploy a docker container then by default it will use all these details okay by default the database name test username test password test okay and this is the default jdbc url all right great now what we can do is we can observe the problem with this code well in our springboot application we have only one integration class right and let's say in your spring boot application you create a multiple integration classes then you have to create a multiple instances of this mysql container class right so in order to avoid this problem what we can do is we can create one abstract class and we we can make this mysql container as a singleton so that other integration test classes can simply extend abstract class and can reuse this mysql container singleton instance all right so basically it is best practice to you know share this mysql container instance with all the integration test classes we don't have to create a separate mysql instance for each you know integration test classes okay now let's see how we can do that well if you can go to browser and you can just search for you know singleton uh test containers so basically in a documentation they have mentioned like singleton containers pattern so this is the important guys this is the pattern that we have to use to make you know this mysql container as a singleton so that other integration test cases can you know reuse it for example look at here the code snippet we need to create abstract class and we need to make this mysql container as a singleton by using static block and the rest of the integration test classes can simply extend this abstract class and can reuse this mysql container instance all right so we are going to use you know similar to this example so let's go and let's head over to the integer idea and let's create one abstract class so let me copy this class name because we are going to create same class name so i'm going to create a class let's name it as abstract container base test and here we are going to create a singleton instance right for that in case of creating a singleton object of the class we first make a field as a static all right this is a mysql container and let's you know have a naming convention for this this class object as i know my underscore sql underscore container and let's use a static block over here to create and initialize the object of this you know class mysql container equal to new mysql container and i'm going to pass docker image name then mysql colon latest perfect now we're going to start explicitly this container right so go ahead and call the start method if we start this container explicitly then we don't have to use you know the test containers annotation that is you can see we have annotated this class with add test containers annotation right we can simply remove this annotation because we are explicitly starting the mysql container instance all right and here we can simply remove this piece of code because this is not going to we are not going to use it because we have already created the instance in abstract class so again get rid of this system statements and here just extend the abstract class that is abstract containers based test class all right that's it and whenever you create integration test classes in your project then you can go ahead and simply extend this class and you can reuse this mysql container instance all right so let's go and let's run the integration test case and let's see how this works well i'm going to run this integration test case now so and there we go the test passed it means that we have you know successfully used singleton containers pattern uh to optimize this code okay we have basically made mysql container instance as a singleton so that it can be you know used in multiple integration test classes all right this is a best practice actually the test containers team suggest this approach okay great well let me recap what we have done in this crash course well we have basically understood a quick overview of you know test containers and then we have created spring boot project and then we have created a couple of rest apis and we have created entity repository and then we have created integration test with respect to the local mysql database and then we have seen what is the problem with using local mysql database and then we have added test containers as a solution and then we have integrated test containers in our springboot application and then we have you know used singleton contains pattern to optimize the code and finally we ran the integration test with respect to the test containers and yeah so we have successfully ran that integration test with respect to the mysql database which is deployed in a docker container all right we have understood you know pretty much about how to use test containers to perform integration testing in a springboot application all right great well if you want to learn more about testing spring boot application with generator and marquetto then i am going to suggest you my course that i have published on the udemy that is testing spring boot with you know jnet and mokito so in this course uh you can learn how to write the unit test cases and integration test cases for spring boot application using junit muketo asset j ham crust json path and test containers well basically you will learn how to write the integration test for a repository layer components service layer component and controller layer components and you will also learn how to write the integration test cases with respect to the local database with respect to the test containers all right you will learn a lot about testing spring boot application with lot of popular frameworks like jnet market to asset j hamcast jsonpath and test containers all right so just go ahead and enroll this course and damn sure that you will able to learn a lot about testing spring boot application and i have used industry standard approaches okay you can just go through these points and you can just go through the preview videos you can able to understand you know how i have organized this course okay great all right thanks for watching this crash course and yeah i will see you in next video

Channel: Java Guides

Views: 21,318

Keywords: spring boot testing, spring boot, spring framework, testing

Id: UT9pUo_6w4w

Length: 52min 10sec (3130 seconds)

Published: Mon Jan 17 2022