DEV Community: samsha1

How you test your code?

samsha1 — Thu, 28 Mar 2019 17:02:21 +0000

Testing code is one of the most important part to understand your application and behavior of code.Every developer knows how painful bugs can be, especially in the production stage as it takes hours of hard work. Testing each scenario can be as good as believing yourself. You write and execute your code, without knowing how it behaves if some exception occurs or some validation violates, this may cause a problem in staging or production. So, running test case plays a vital role in SDLC. You give rich life and believe your code with eye closed, once your test coverage is at good level.

Today, we are going to write a simple test methods and run test code using tools like Xdebug and PHPUnit. PHPUnit is a programmer-oriented testing framework. This is the outstanding testing framework for writing Unit tests for PHP Web Applications. With the help of PHPUnit, we can direct test-driven improvement.

Let's install PHPUnit:

wget https://phar.phpunit.de/phpunit-7.5.phar
chmod +x phpunit-7.5.phar
sudo mv phpunit-7.5.phar /usr/bin/phpunit

There are several other way to insall phpunit. Find more here:phpunit.

Now, To get our Test Coverage full report we need to install Xdebug:

sudo apt install php-pear
pecl install xdebug
sudo apt-get install php-xdebug

Find More about Xdebug here: xdebug.

Without making further delay Let's dive into our simple test scenarios where we test whether an array is empty:

Create a folder UnitTest where we will include all testable files. In this folder, create a subfolder tests. Create a new file phpunit.xml in this subfolder and add following code.

The colors=”true” will show the results in highlighted colors and <directory>./UnitTestFiles/Test/</directory> will ask PHPUnit for the location of the files to be tested. The filter tag is used while discovering GUI based report with statistics analysis of our test coverages.

Basic Conventions to Write Unit Test Case

Following are some basic conventions and steps for writing tests with PHPUnit:

Test File names should have a suffix Test. For example, if First.php needs to be tested,the name of the test file name will be FirstTest.php
Similarly, If the class name is MyFirstClass than the test class name will be MyFirstClassTest.
Add test as the prefix for method names. For example, if the method name is getuser(), then in test class, it will become testgetuser(). You can also use @test annotation in document block to declare it as a testing method.
All testing methods are public
MyFirstClassTest class should be inherited from PHPUnit\Framework\TestCase.

These are the major ground rules for the PHP unit testing framework. The essential configurations and settings are all setup. It is now time to write the first test case.

Writing The First Unit Test Case in PHP

Create a file EmptyTest.php in UnitTest/tests. Add the following code to it.

Now, to run our test code inside terminal type: phpunit i.e. phpunit tests/EmptyTest.php.

Note: By running only phpunit, it defaults executes all test file inside UnitTest/tests directory because we have mentioned this directory in phpunit.xml above.

We will get our test failure because the value inside array is not empty. In my terminal I am getting:

F                                                                   1 / 1 (100%)

Time: 513 ms, Memory: 10.00MB

There was 1 failure:

1) EmptyTest::testFailure
Failed asserting that an array is empty.

/home/samrat/myproj/testcase/tests/EmptyTest.php:8

FAILURES!
Tests: 1, Assertions: 1, Failures: 1.

Let's pass our above test case and add one more scenario to test equals.

It gives an error when $expected is not equal to $actual. If $expected equals $actual then it returns true. Remember, the first argument is expected and the other is actual. The above test only passes if expected (0) is equal to (1). To pass above test case just replace 0 with 1 or 1 with 0. Now, run both testcase.

Our both test must pass:

PHPUnit 7.5.6 by Sebastian Bergmann and contributors.

Runtime:       PHP 7.3.1-1+ubuntu18.04.1+deb.sury.org+1 with Xdebug 2.7.0
Configuration: /home/samrat/myproj/UnitTest/phpunit.xml

..                                                                  2 / 2 (100%)

Time: 200 ms, Memory: 10.00MB

OK (2 tests, 2 assertions)

You can find more about assertion here: PHPUnit Assertion

Let’s look at another example in which a developer has created a code to parse the items received in json and validate it for the possible use case may be exception or for other validation rules.

Let's create app/item_parser.php file inside UnitTest directory

I've created a class called ItemsParser with static method called parse that takes one argument called response, received from json data. We have checked for different exceptions and returned parsed data as an array.

Let's add some exceptions class for above use cases inside same directory:

Now in the UnitTest/tests folder, create a new file called ItemsParserTest.php and add the following test code:

Run above test case, Our test case must pass. By, this we can assure ItemParser class is successfully instantiated.

As, we don't invoke real endpoint. Let's create a fake json data called one.json inside UnitTest/json and test with it.

Now Let's write another test method to ensure our data is actually parsed the way we expected it:

As, we created fake data, and send that data to ItemParser::parse() method. If we now run our test case we get the data as the way we expected.

PHPUnit 7.5.8 by Sebastian Bergmann and contributors.

Runtime:       PHP 7.2.15-0ubuntu0.18.04.1 with Xdebug 2.6.0
Configuration: /home/samrat/myproj/UnitTest/phpunit.xml

..                                                                  2 / 2 (100%)

Time: 377 ms, Memory: 10.00 MB

OK (2 tests, 2 assertions)

Actually, what we did is we send json data and decoupled it on our data only with label and value as key and returned only data that is required as an array.

Now, Let's test for the array keys we are getting:

From above code we can ensure that whether we are getting the key we expected i.e label and value.

What about the exceptions we added to our methods, whether they are working the way we wanted? Well I am not sure so let's test it.

Say, we have some json data with price in string:

How our code block response when we send price as string, well we must be sure our code handles such kind of exceptions.

expectException() method is to ensure whether expected exception is thrown by our code block. Run phpunit and check above code it must by the way!

Revise, the ItemParser.php file we have used number_format function to convert cent price into dollar.So, Let's write test to check whether our price has been successfully converted.

And These test can go on and on, wouldn't it be nice to get report or analyzer for our test case. To get total test coverage report would be great. So, we have written some test code and let's generate our test report and find out how much code did we really covered?

It's simple just type this in terminal: phpunit --coverage-html . In my case phpunit --coverage-html report/. You will get whole report in html format. By the way, we can generate in xml, php, text and many other formats. Just type: phpunit --help for more.

Above test coverage explains, our first example test coverage is 100% but ItemParserTest could be better and we only covered some part of our code so let's stick with 90%. I leave it up to you to make it 100%. Actually, 80% code coverage can be acceptable coverage in software world (heard somewhere).

We also get the report of where we can do better. Here's some other code coverage statistics:

Conclusion

This article explains a basic setup that help you in getting started with PHPUnit for PHP unit testing.

Hope you find this article helpful. Unit Testing is a vast topic. Here I have given you a brief introduction so that you can start writing your own tests. I would like to mention several changes in the latest version of PHPUnit. In the previous versions, the class extend with PHPUnit_Framework_TestCase. In the latest version, it extends with TestCase only. Please comment below if you have any question or suggestions.

You are awesome!

What's your first step while starting project?

samsha1 — Tue, 29 Jan 2019 03:56:05 +0000

Once, I am sure I always start by working in database design, step by step it gets vague. So, I just want to know is it the right first step?

Getting Started in CI/CD for Beginners

samsha1 — Sun, 13 Jan 2019 16:35:19 +0000

What is CI/CD?

CI/CD stands for Continuous Integration and Continuous Deployment. Continuous Integration means building your application continuously. Consider, a scenario where developer makes some changes in source code. Now Continuous Integration must be able to fetch that source code and prepare a Build.Build also involves compiling and validating your code, code review, Unit Testing and Integration Testing, also packaging your application.

After Continuous Integration we have Continuous Delivery. Until now your product is ready, tested and ready for delivery. Consider, a Continuous Integration tools like Jenkins which deploy into the test servers to perform a user acceptance testing and once this is done it will be deployed onto the prod server for release. If this step is done manually then it is called Continuous Delivery but yes if its done automatically then its Continuous Deployment.

Understanding the WorkFlow

First, Let's have simple Hello world project in our local machine and initialize git. Once done push our code to remote repository. Next, We will write simple Jenkins Job so that It will trigger and deploy our code to dev server.We will create two different aws instance for jenkins and dev. Remember, we will run jenkins application inside Docker Container so that we donot have to go through manual installation.

Let's Bring It To Life

Inside Local Machine

Step 1: Let's create simple Hello World Project written in php.

Step 2: Initialize git, commit and push your changes to remote repository.

Inside GitHub

Create a webhook so that jenkins jobs would trigger or look for changes whenever code is pushed to specified branch.

Go to Settings -> Webhooks -> Add Webhooks.

Payload URl:The URL is in the form $JENKINS_BASE_URL/github-webhook/ — for example: https://ci.example.com/jenkins/github-webhook/.

Content Type: application/json

Secret Key: Secret Key so that github can access jenkins.

Which events would you like to trigger this webhook? : Depends on events you prefer. I have just checked for pushed event i.e. job is triggered whenever something is pushed to github master branch. (For specific branch name you can mention it from jenkins).

Update Webhooks. That's it inside Github.

Inside Jenkins Instance

Step 1: ssh to your aws Jenkins instance

```

ssh -i




Step 2: Run update your packages.

sudo apt-get update




Step 3: Install docker

sudo apt-get install docker.io




Step 4: Add Docker to your user group and login again after exit

sudo usermod -aG docker ubuntu




Step 5: Let's pull docker image for jenkins:

docker pull jenkins/jenkins




Step 6: Type

docker images



to see pulled image from jenkins/jenkins repository

Step 7: Run Docker image:

docker run -d -p 8080:8080 --name




Step 8:Type

docker ps



to see running container.

Step 9: Once you setup jenkins inside docker. Try, accessing from browser


        ```
<instance public ip >:<external-port-number>

Note: Before accessing, open the add inbound rules in aws. choose security groups(launch-wizard). click Edit->Add Rules, set custom tcp rules and _external port range (my case 8080)_also http rule then save

Voila! you can then run jenkins, Install suggested plugin (default). Fill the required credential and set your first job set!

Step 1: create Freestyle Project.

Step 2: Add some Description and give the github repository url from where jenkins would fetch your project.

Remember, to setup webhook inside github. Go to settings->webhooks->add payload url i.e /github-webhook/

Step 3: Write some shell script to deploy your code inside dev-server.

To establish, a connection between jenkins and dev instance we need to add jenkins public key to dev authorized key.

In jenkins instance run ssh-keygen to generate the .pub key and copy public key from .ssh/ to dev ./ssh/authorized_keys.

instance = '13.232.89.159' 

ARCHIVE_FILENAME = cicd.zip

zip --symlinks -x *.git* -r $ARCHIVE_FILENAME . #compress all the files and create zip file

echo "--------Copying Files to remote dev server from jenkins ----------"

scp -o StrictHostKeyChecking=no index.tar.gz ubuntu@$instance:/home/ubuntu/

echo "--------Finished Copying----------"

echo "Entering to Dev Instance"

ssh -o StrictHostKeyChecking=no ubuntu@$instance '

  mv $ARCHIVE_FILENAME /var/www/html #move zip file from current directory to /var/www/html

  cd /var/www/html

  unzip $ARCHIVE_FILENAME

  rm -rf $ARCHIVE_FILENAME #remove the file once done

'

Once, the scripting part is done let's save and build our job. After successful job build we can access our deployment server from our browser and see the changes made.

This is just a simple example we have done, just to understand the workflow of CI/CD.

You are awesome!

event.stopPropagation()

samsha1 — Thu, 27 Sep 2018 17:07:23 +0000

Currently, I am learning react and came to know how useful event.stopPropagation() function can be.So, Let's dive in.

Let's create a simple functional component

deleteTask(){

    let tasks=this.state.tasks;
    tasks.splice(index,1);
    this.setState({
       tasks 
    })

}

const ToDoItem = (props) => {
    return (
        <li onClick={ ()=> { props.clickHandler(props.index)}}
            className={props.details.completed} ? 'completed' : ''>
           Some Text 
        <button onClick={ ()=>{props.deleteTask(props.index)}}>Delete</button>
        </li>

    )

}

Now, If you click Delete button the onClick event gets triggered on both li and button element.The point here is we only want to trigger button onClick event but not li. If the props (completed) is not defined in details props then we get console message as

Cannot read the property 'completed' of undefined

This is because when we click button element, indirectly we are also triggering to li. As, li is parent element of button. li onClick event is triggered and there is no defined 'completed' inside props details. So, to get rid of this issue we can use event.stopPropagation().

const ToDoItem = (props) => {
    return (
        <li onClick={ ()=> { props.clickHandler(props.index)}}
            className={props.details.completed} ? 'completed' : ''>
           Some Text 
        <button onClick={ (evt)=>
            evt.stopPropagation();
            {props.deleteTask(props.index)}}>Delete</button>
        </li>

    )

}

Now, the event is not propagated to the parent element because of evt.stopPropagation(). So, we are free to go.

How it's like to refactor code, written by other developer?

samsha1 — Mon, 06 Aug 2018 16:32:24 +0000

Currently, I am working in Menuboard manager project written by some other developer. Now, the developer is out of contact. So, I am given the task to refactor his code and add some module. My question is How can one understand the flow of code without any code documentation and project goal??

Walk Through Docker

samsha1 — Sun, 05 Aug 2018 20:11:00 +0000

What is Docker?

Docker is the open platform for developers and system admins to build,ship and run distributed application on laptops,VM or cloud.Docker is widely used for operations to run multiple application in containerization form.For example: one container may have web server to run application and other container may handle mysql database that is used by web application. Source wiki

Where is docker used?

Docker can be used in many cases, these days the software packages are run virually with more efficient,fast and secured way. So, Why not Docker?

Let us move with simple example: Say, your friend want to share a project, which requires with latest golang version,mysql database and nginx web server....Now, to run this project manually what you need is to install same version of go system file,mysql and web server in your local machine. You also need to go through version configuration issue.

To get rid of this headache, let's docker our project.

First, write a simple docker file . create a filename Dockerfile in your root_project directory.

FROM amd64/golang:1.10.3
WORKDIR /go/src/app
COPY . .
RUN go get -u github.com/gorilla/mux
RUN go get github.com/pilu/fresh
RUN go get github.com/sirupsen/logrus 
CMD ["fresh"]

Let's dig into script that we created

FROM amd64/golang:1.10.3

pulls docker remote repo with go version go:1.10.3

WORKDIR /go/src/app

defines working directory inside docker container.

COPY . .

copies current working directory to /go/src/app inside docker container.

RUN go get -u github.com/gorilla/mux RUN go get github.com/pilu/fresh RUN go get github.com/sirupsen/logrus

installs different packages depends on your project. Here, I have installed /gorilla/mux that implements request router and dispatcher for matching incoming requests to their respective handler. /pilu/fresh is a command line tool that builds and (re)starts your web application everytime you save a code. Likewise, logrus is used to log the data of status.Remember, these packages are not mandatory and varies according to your requirement.

CMD ["fresh"]

CMD run once we successfully build and run our Dockerfile. If you want to run some command use CMD as simple as that. Here, I have use fresh command because when we docker run or project it automatically runs in command inside docker.

Once, our docker file is ready build your docker application

docker build -t docker-golang.

builds docker application where -t flag is the name given to built repository or image as simple as that.

once, you successfully built image. You are ready to run

docker run -d -p 8090:8090 -v $(pwd):/go/src/app  --env EXAMPLE_ENV_SETUP=test_value_env --name golang-env docker-golang

docker run command runs above created image,where:

-d //runs docker image in backgroud (optional)
-p is the port number to run the docker,left:right indicates the port to run outside and inside docker container.
-v //volume created that represents the direcory of file outside and inside docker repository
--env //enviroment value needed while running the project
--name //name of the container which makes easy to remember rather using container id 
--docker-golang //name of image or image id you created while building docker

After docker run in daemon mode, use

docker ps

to know the running instance inside docker.

Output:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
ed07831e976a        docker-icinga-env   "fresh"             About an hour ago   Up About an hour    0.0.0.0:8090->8090/tcp   golang-env

There you go, You have a running instance inside docker which you can access through browser localhost:8090

Now, Run the following command in the running container:

docker exec -it <runnning container name or id> /bin/bash

This will create a new Bash session in the container golang-env.This command will take you inside running command where you can check logs and do Whatever hell you like because You have a running instance. It's that easy