Blog of PCBabu

Some discrete things

pcbabu — Fri, 26 Feb 2010 06:40:49 +0000

1. Input Data: In a dynamic web service, users always need register
him/herself to get some services. But all the information put by these
users are not valid or correct. There are some special types of inputs
which are strictly restricted to put in web based registration. This are
inputs like &#, 34 special character which are considered as free keyboard character such as !,~,&, etc and write space. It must also be checked that where a required field is kept blank or not. The maximum length also should be checked with capitals like ‘W’ which take more space than others.

2. Validation: Validation is a process of checking the validity of a
field value. Validation should be performed for each field. Basically
there are two types of validation procedure. These are:

a. Special validation: Validating fields like phone number.

b. Standard validation: Validating fields like email, name, date of birth
etc.

3. Error Message: As a part of validation procedure, it is necessary to
show error message to notice the user about errors. While designing a
software, a developer must consider a specific standard for the error
message which is user friendly and consitent throughtout the site.

4. Requirement Analysis: This is another important issue in software
testing. A tester should always have a practice to think like a client
which make the purpose of testing more effecient. This is why a testing team should go through the client’s requirement iteratively. In case of necessity, they must have the ability to propose enhancement.

5. Pagination: When a user needs to go through a list, it is always
convenient to use pagination to handle the list. In case of designing
pagination process, a developer must be concious about the facts like the design consistency, position of pagination and the wording which is used to make it easily understandable.

6. Search: Search operation is used to find important content in a site. There are different kinds of search techniques like simple search, single quote search and exact search. In simple or single quote search, all the words in the search textbox are searched individualy whereas in exact search the total search phrase is searched. The search string should be checked to see whether it is trimmed or not and whether it causes any kind of server crashes.

7. User Interface: It is always said that user interface is the most
important part in software development process because it is the only
thing which can convince the client at the first sight. So, to ensure a
good design of user interface, a developer should avoid problems like
unwanted space, overlapping error message, inefficient use of padding and lack of knowledge about design issues which vary browser to browser.

8. Use of HTML tag: Sometimes HTML tags can be given as input unintentionaly or erroniously. These inputs should be kept unchanged i.e; these should not be converted.

9. Common Error Page: Different types of error may occur when a user browses through a site. So, other than checking each and every page individually, a user can be notified about an error through a common error page. In this case, the developer also should be notified about the error through a special kind of mail which includes the error message, particular functions for which the error occurs, link of the page where the error occurs, name of the browser which faces this issue,IP address and date time.

10. Browser: The software should be designed in such a way so that a user can have the same output in different major browsers like IE6, IE7, Firefox and Safari.

11. Image: When an image needs to be shown in a website, the issues which must be tested are the size of the image, the title of the image which ultimately serves the purpose of tooltip for the image, the browser compatibility and distortion of image with change of monitor resolution.

12.Others: Some other facts also be checked to have an effective site apart from the above consideration. These include: Operation of button with both mouse and keyboard, browser compatible tool tip for button, consistent anchor color, redirection of pages and operation in case of internal and external links.

Test Case

pcbabu — Thu, 25 Feb 2010 06:38:42 +0000

Common test cases are: Input data, Validation, Error message, Requirement analysis, Pagination, Search, User Interface, Use of Html tag, Common error page, Browser, Image etc.

Input Data: Suppose we are testing a register page or any input field where user can give input. In these type of situation tester should give &#, XSS like alert (’XSS attack’); , special characters (free keyboard characters only i.e. ~`! @#$ %^&*()_+|{}:”?-=\ [];’,. /,), white space, max length data and blank input box to check it works fine or not. If the page allows the tester to submit then he/she also should test whether there is any server error, script alert, distortion of special character, data loss etc.

Validation: Tester should check validation for each field. For invalid data, user friendly message need to be shown.

Error message: Tester should consider two different things in case of error message. One is User Friendliness of error message and another is Error message standard. Error message should be user friendly. It should be in plain English. There shouldn’t be any engineering term as the user might be from any filed. Moreover the color, font and position of error message should be consistent throughout the site. The position of error message can be right or bottom of individual input box, top or bottom of the page, If error message includes full stop, then it need to follow in the whole site.

Requirement Analysis: A tester should consider the following things: A tester should think like client while testing. In each step of testing a tester should analyze the requirement. Sometime client doesn’t know himself what he/she wants in his/her site. So a tester should think what can be more beneficial for client and then tester can propose that enhancement to the client.

Pagination: Testing team should check whether the number of pagination of various components is throughout the site is consistent or not. Position of pagination should be same in entire application. It can be left, right or middle side of top or bottom of the page. But wherever it is for one page, it should be in the same place for every single page.

Search: Here a tester has to check several issues. These are:

Search pattern: Search should support simple search, single quote search and exact search.

Space trim: Space in search text box should be auto trimmed. But not all space. Only those spaces which are in front and at the last of texts.

Server error: Search should not crash for entering data like ‘Amy’s book’ or any alphanumeric data.

Search counter: Tester should check the search counter also. Sometimes search counter shows there are five results but actually there are not five outputs in the page.

User Interface: User Interface is one of the most important issues in testing. A tester should check if all the pages look fine in the browser like alignment, padding etc.

Use of Html tag: Tester should check also if user enters Html tag then after submission that tag shouldn’t convert. Suppose $’ is entered as user name from registration page. The registered user got confirmation mail where his name was converted to tag. Tester should test the reverse also. In any case, application will not convert the input data.

Common error page: There should be a common error page with user friendly message.

Browser: Another thing a tester must check is browser compatibility which means whether the site looks same in different browsers like IE 6.0, IE 7.0, Safari and Firefox.

Image: While testing image testing team should check: Uploaded image’s Height X Width need to be same as original image. Tool tip of image should represent image. Image and tool tip should be browser compatible. Changing monitor resolution will not distort the image.

Data recovery

pcbabu — Thu, 18 Feb 2010 06:16:06 +0000

Database Recovery: Data loss is one of the most common and critical issues. So we need to prevent it in order to maintain our database properly. Data can be lost as a result of many different problems: Hardware failures, Viruses, Incorrect use of UPDATE and DELETE statements, Software bugs, Disasters: such as fire or flood etc. In order to prevent data loss we can implement a recovery strategy for our database.

Full Database Backups: A very common backup strategy is to back up the whole database in a predefined time series like once each night. With such a backup strategy, it is possible to recover a database to the state it had when the last backup occurred. The main advantage of a full database backup is that it contains all the data needed to rebuild the entire database. But this advantage can also be a disadvantage. Consider a database where full database backups are performed each night. If you need to recover the database, you always have to use the backup from the previous night, resulting in the loss of a whole day’s work.

Incremental Backup: Normally full database backup is taken once in a day because normally it’s a costly and time consuming operation. Suppose we take full database backup at 12am every night. So if the crash takes place at 11pm then we will lose 23 hrs data transaction. So we take incremental backup in every one hour. It doesn’t take the full backup. Incremental backup takes only the backup of updated pages. So in this case we can lose highest 1 hr data transaction.

Transaction Log Backup: With the combination of full database backup and incremental backups, it is possible to take snapshots of the data and recover them. But in some situations, it is also desirable to have backups of all events that have occurred in a database, like a record of every single statement executed. With such functionality, it would be possible to recover the database to any state required. Transaction log backups provide this functionality. As its name suggests, the transaction log backup is a backup of transaction log entries and contains all transactions that have happened to the database.

Recovery Models: There are two types of recovery models: Simple Recovering and Full Recovering.

Simple Recovering: Recovery = Last Full Backup + Last Incremental Backup. The steps are:

1. Restore the last Full Backup.
2. Restore the last Incremental Backup.

Full Recovering: Recovery = Last Full Backup + Last Incremental Backup + Last Transaction log file.The steps are:

1. Take backup of current .ldf file.
2. Restore the Last Full Backup.
3. Restore the Last Incremental Backup.
4. Restore the Last Transaction log Backup.
5. Restore the backup that is taken from the current Transactional log file.

Database recovery is an important task of Database Administrator. There are several reasons, where database can be affected. To recover from any disaster, we need to use backup.

There are three types of backup – Full backup, Differential backup and Transaction log back up. Full Backup contains all the data needed to rebuild the database. So, if the database is large, then it can be time consuming, slow and needed large space to take full backup. So, We should take full backup at night or in off peak time in a regular interval.

When we restore the data from full backup, it will result a loss of work which is made after taking that backup. Here we need Differential backup. It stores only the data changes that have occurred since the last full database backup. So, we can take Differential backup in short time interval.

Transaction Log backup stores all the transaction log entries and all transactions that have happened to database. So, we can restore the data from a specific point of time even if the data files are destroyed.

Now, Recovery model; it is mainly of two types – simple and full. In simple recovery model, database is restored from full and differential backup. So, here some data can be lost after last differential back up. In full recovery model, we also use transaction log backup along with the last full and differential. So, here is no possibility of loosing any data.

ndIndexing and Stored Procedure: Two important techniques for faster query execution

pcbabu — Fri, 12 Feb 2010 05:35:55 +0000

When we search Google, how much time it requires? In most of the cases, we will find results in a fraction of seconds. But Google has one of the largest databases of the world. When we search on it, it has to execute query in its database. So, why its query processing is so faster? Basically Google and other large databases use some techniques for faster query processing. Indexing is one of the most important techniques.

In clustered indexing, the records are saved in physical cluster based on a column of that particular table. Not all the times data will be searched based on that column. Then we need non-clustered indexing. Here it contains a reference to records based on another column. For a table, there can only one clustered index but many non-clustered index. Not all the time, this non-clustered indexing will help us improving query performance. If we have a small size of database then obviously this logical index will be treated as an overhead. So, we have to use indexing based on the size and needs.

When same type of query is used so frequently, then another important technique is used; that is Stored Procedure. It is another technique which reduces network traffic and ensures reusability and security. Stored procedure is nothing but a precompiled query. It is very similar to functions. The main difference is that, functions can be used inside any SQL queries and it returns something to that query but, stored procedure is invoked by the Call statement and returns the result.

Yesterday, besides these two important things we explore many other issues like trigger, T-SQL, Function, Transaction. After a long Brainbench SQL exam & this long class, we can’t manage much time for practicing those. Hope, we will manage much time today and can practice those efficiently.

Database Design(2)

pcbabu — Wed, 10 Feb 2010 03:21:33 +0000

When we worked on database previously it was all about just creating design and establishing relation. But now i realize that it has to be done in a optimize way. In today’s session we are taught about detailed logical design, functional dependency, candidate key, super key, primary key, normalization etc.

If a field in a table depends on any other field than we represent it by X -> y in R(X,Y) where R is a relation and X and Y are fields of that table. It means if Y changes than X will also change. That’s how we define functional dependency.

Candidate keys are sets of super keys, which are candidates to be a primary key. primary key defines unique row in the table. primary key has to be something like that, every other attributes of that table have to depend on that primary key.

Normalization is applied to a database to make it more optimized, more manageable. First normal form(1NF) is applied to a table to make every field atomic, to reduce redundancy and to make it well manageable like optimize use of space. 2NF is applied to remove any kind of partial dependency. 3NF is used to remove any transitive dependency.

Now the question is, does applying normalization always helpful? Answer is no. There are two types of database. OLTP(Online Transaction Processing) and OLAP(Online Analytical Processing). Continuous transaction happens in OLTP. Example of this processing can be banking system where lots of update or insert operations happen. Here frequently data modification occurs. Applying normalization to this type of system is fruitful. But in OLAP system frequent read operations happen. So, to provide a optimize read operation, normalization shouldn’t be applied to this because ‘select’ operation will be slow because number of tables grow due to normalization.

Blackbox testing

pcbabu — Sat, 28 Feb 2009 06:43:18 +0000

Black box testing is a process that focuses solely on the outputs generated in response to selected inputs and execution conditions ignoring the internal mechanism of a system or component. Black box testing includes the external design testing or visual testing and functionality testing. These are described below:

Visual testing: There are different types of visual testing. These can
figured out as follows:

1. Carefully checking left and right alignment of a page.

2. Removing all unwanted space. Specially spaces between grid and navigation button should be checked conciously.

3. Words describes the purpose and contents of a software. To make it more user friendly, the wording inside the software should be checked for several times.

4. Padding should be given around the text and image.

5. Text must be ensured to be looked alike by checking them under
different browser.

6. Position of different modules of a software must be tested in
browsers.

7. Full display of any UI element like page, frame, textbox etc should be assured.

Funcational testing: It is a process of checking out the functionality of an application as per functional design document(FDD) and user requirement specification. Test cases are prepared based on the FDD and user requirements and testing is done by the testing these test cases.

Various kinds of functional testing are stated below:

1. Input fields should be checked to see whether they takes more space than anticipated or overlapping other fields.

2. Sometimes maximum length may cause UI distortion. This must be checked carefully.

3. The page must be tested with different contents to see whether there is any kind of unwanted expansion or not.

4. The boundary value of an input field must be analyzed and then the field should be checked with the boundary value.

5. Stress testing is a way to check the normal operational capacity of a software. This must be ensured to varify how much load a software can take.

6. The server may crash due to some overloaded input field. This must be varified to assure that no crash of server will occur.

7. In some cases, name of a user may contain characters which are
considered as special characters. This special characters give ambiguous result. This must checked properly to avoid ambiguity.

8. SQL injection is a technique that exploits a security vulnerability
occuring in the database layer of an application. It occurs when user input is not filtered for escape characters and then passed into SQL statement. Proper varification should be ensured due to this fact.

9. After submitting test data, they should be reviewed to see whether they are kept intact inside the database.

10. Data loss must be stopped to ensure reliability. To do that maximum length of a field must be selected carefully.

11. Data flow must be tested according to the requirement.

12. If any kind of html tag is entered into the database, they must be saved wihthout any change.

13. Input fields must be checked by keeping them blank or entering white space.

System Analysis

pcbabu — Thu, 26 Feb 2009 06:41:57 +0000

A software development process always starts with a requirement provided by the client. And throughout the software development life cycle, it plays the key role behind the scene. But most of the cases it is found that these requirements creates a huge hindrance in the execution of the process. So, what are the issues behind this fact? After conducting a research, experts found the following reasons:

1. Incomplete requirement/ specification
2. Fast and continuous change in specification
3. Lack of user input to test requirement.

It is to be notable that both the client and the developers are equally responsible for the aforementioned problems. Sometimes the clients are not able to provide perfect specifications and sometimes the developers are unable to understand the requirements or implement the required functionality inefficiently. So, to overcome these troubles, priority must be given to understand the specifications and perform testing based on those given specs. So a software can be developed successfully if a developer or quality controller keeps the following issues in mind:

1. Understanding requirement: In the initial step of the software development, all the involved personalities should realize what are the feature the client wants to have and they should act according to that. Business logic projected by the system analyst, user interface and functions designed by the developers and test cases planned by the testers – all should follow the requirement throughout the process.

2. Clarification of requirement: Sometimes the client provides unclear, ambiguous and incorrect requirement. This erroneous requirement then should be traced, tracked and perfectly executed by all the members so that the software can “do that was required”.

3. Identifying problems perfectly: If the analyst faces any kind of problems like technological limitation, timing shortage, necessity of R&D or client’s feedback, he/she should raise these issues in the analysis phase.

4. Adopting requirement development life cycle: Requirement development life cycle includes elicitation i.e.; gathering requirement, specification and analysis and validation of those requirement which refers everyone understands and agrees on the requirement. Its very urgent to follow the cycle but most of the case it is avoided to save money, time and energy.

5. Iterative requirement Analysis: Requirement should be anaylized time to time on way to develop a software. Although, it is problematic to reevaluate the validation process as the software is being built incrementally now-a-days, iterative analysis is considered very important.

6. Thinking like client: The quality assurance team of a company should be able to think widely about the software so that it can provide more facilities to the client by proposing better way.

7. Recording all communication: The communication which is held during the development phase must be tracked.

8. Tracking iteration of validation process: It is necessary to keep record of the validation process as the requirement is continually checked an reevaluated.

Software Testing

pcbabu — Wed, 25 Feb 2009 06:36:06 +0000

There are different software testing methods where black box testing and white box testing are more common. In white box testing test case are created based on the internal structure of the project. Actually the testing team has to have programming knowledge for this type of testing. White box testing check whether the code is written in well structure, whether it is optimized and whether it follows the programming convention. In black box testing tester checks the external perspective. It can be functional or design perspective. Actually this test performs like a client. Tester uses it in client’s way.

In Jaxara, when a task is created it has some status. When a new task created it has a status ‘New’. When it goes to the development it has the status ‘In progress’. When the development has done it gets the status ‘Fixed’. After fixed status it goes to the QC team. If QA team sees it fulfill the requirements then the status is ‘Closed’, otherwise it gets the status ‘Reopen’. Then it will again go to the programmer and gets the status ‘In progress’.

Functionality testing: In this testing tester checks whether the project fulfill the requirements and whether the functions are working properly as the client’s need. Tester will not consider the UI properties here if client particularly hasn’t said so.

Security testing: In security testing tester checks for any flaws that can get in the way of security.

Compatibility testing: Tester checks whether the application runs correctly and same in different platforms. Like in case of website tester must check whether it is cross browser compatible.

Usability testing: It tests how conveniently a user can use the system. The tester may suggest some issues to make it more suitable for the user if it doesn’t conflict with the client’s requirements.

Comparison testing: In comparison testing tester checks the application with the some other application. Like client requirements is make an application which will have the functionality of his/her previous project or he/she may say that his website has to be like some other site, say yahoo.com. In these cases the tester must compare his work with the other one.

Some common problems in software developments are-

Requirements: Requirements should be thoroughly understandable. Often because of not understanding the requirements a lot of problem occurs.
Schedule: Because of tight schedule there may remain lots of bugs in the application. Programmers may not get the time which he is supposed to get in that particular task because of mismanagement in the scheduling.
Futurities: Client may add new requirements in middle of the development. It can be fully new requirement or can be enhancement of the current requirements.
Miscommunication: There may be miscommunication between the clients and the manager or between manager and programmers. So, they may not understand the requirements clearly.

Design consideration of SQA:

The following things should be considered by SQA in case of designing-

Compatibility: It should be working properly in different platform.
Extensibility: There should be a scope to add different feature.
Fault tolerance: The tester give some different data to see whether it react differently.
Robustness: Test up to the failure point.
User friendliness: He should check whether it can be done in a way that it becomes more user friendly.
Maintainability: The software should be easily maintained.

Now here comes the topic-types of testing. There are basically two types of testing like:

1. Black box testing: In black box testing a software is considered as a black box and only the functionality of the software are checked. Although this type of testing is faster and simple, it has no relation to the internal programs of a software which left many issues untouched.

2. White box testing: Comparing to black box testing,in white box testing a tester has access to the internal data structure and algorithms. As a result, through white box testing the probability of getting optimized code increases.

Other than these above kind of testing, a quality assurance team also follows the types of testing stated below:

1. Acceptance testing: This type of testing ensures whether client’s requirement and company standard are fulfilled or not.

2. Unit testing: In this type of testing, the software goes under an investigation by dividing the software into different modules.

3. Functionality testing: Its a process through which only the functionality of a software are checked.

4. Security Testing: Security issues like unauthorized access are checked through this process.

5. Compatibility testing: It means to check how compatible a software with a hardware, operating system etc.

6. Comparison testing: The software should check with similar others.

7. Integration testing: This testing is performed to ensure that the combined modules of a software can execute perfectly.

Although the all these types of testing can be considered as a part of the black box testing, it is necessary to go through all these testing steps to ensure better performance of a software.

Apart from these above topics, we learnt about the work flow of Jaxara i,e,; about the steps a software goes through to get its final look. Another thing that, I think, should be mentioned now. We have written about the “Engagement Team” tomorrow. This team has been abolished and now the tasks of the team are performed by experienced persons of the company.

Common problems in Software Development

pcbabu — Tue, 24 Feb 2009 16:35:01 +0000

Common problems in Software Development:

1) Requirements:

Requirements must be thoroughly understandable and it is the most important aspect of software development. If any requirement creates some confusion then clarification about this requirement is very much necessary. Otherwise, the system may be failed to fulfill the client’s expectation. The most important thing related to this matter is that all the guys who are related to the project must think like client that is thilient.

2) Schedule:

It is another factor which can create problems for the software development. It is a big factor with respect to today’s competitive world. Every phase must follow the schedule as deadline of the project is very important.

3) Inadequate Testing:

It is somehow related with the previous one because when the time limit is very short the whole testing procedure is ignored as deadline is so important here.

4) Futurities:

It can be come in two ways. These are:

a) New: If some completely new requirements come for the project.

b) Enhancements: Enhancement to the one existing requirement.

5) Miscommunications:

It is the burning problem of software development as miscommunication among the team members of a project can create a hazardous situation. Everyone must give special attention to this.

Design considerations of SQA:

1) Compatibility: It was discussed in my previous post that is cross browser compatibility.

2) Extensibility: The software must be built in this process so that any extension can be added later and it is necessary for flexibility.

3) Fault Tolerance: Sometimes it is found that by scripting one can go to the server page and there is no option to back to the original site. It can be avoided by creating another error page where all the navigation is available just like other pages of the sites.

4) Maintainability: It can be built in this way so that it can be maintained easily.

5) Reliability: It refers to the fulfillment of conditions that are exactly required.

6) Re usability: It can save time and as well as cost effective as same module of code is built in this way so that it can be reused.

7) Robustness: Though it is done very often if the client requires. Here the software is checked to its failure point.

8) Security: It is also important issue to ensure the security and it is discussed in my earlier post.

9) User friendliness: Every system must be user friendly that is easy to use for the client.

10 Steps for tuning data access in SQL server

pcbabu — Tue, 24 Feb 2009 06:31:02 +0000

1. Make sure that, indexing is properly done in the database (All tables have primary keys, and, tables has appropriate non-clustered indexes on columns which

A. Are used as search criteria fields
B. Are used to join other tables
C. Are used as foreign key fields
D. Have low selectivity
E. Are used in the ORDER BY clause

–While creating indexes, create appropriate “Covering indexes” involving frequently accessed fields

–Use “SQL server management studio” to view the query execution plan and identify the scopes for improvement in the SQLs

–Use “SQL server tuning advisor” to get help from SQL server in creating indexes.

2. Consider moving your SQL’s from application to Stored Procedures/Views if there is any

3. Re-factor the SQL’s used in Stored procedures/Views/Triggers and apply the best practices to write optimized queries

4. Consider using the “Full text search” feature to perform search on textual columns.

5. Re-build indexes if fragmentation occurs.

6. Create “Indexed Views” with expensive select queries that internally saves result sets on queries

7. Consider refactoring your table design and apply De-normalizations to improve select operations.

8. Consider creating different “User defined file groups” and use these based upon

A. Frequency of table access
B. Read/write nature of tables
C. Types of objects (Tables/Index)

9. Consider creating “History tables” that contains archived read only data where select operations will be applied. Use SQL server Maintenance feature to populate those history tables.

10.Consider partitioning big fat tables into different file groups so that the table spans across different files and SQL server engine can concurrently access the table data.

Optimization is fun!