My Most Favorite iOS Automation Tools!

Automation! I am a huge huge fan of automation. Whether it’s Mobile or Desktop … whether you use open source technologies or in-house built frameworks. Does not really matter :) Being a big believer in automation as ultimate solution for “need for speed”, I love following 3 iOS automation tools.

I was super happy when Google open-sourced Earl-Grey! Let us look at that first...

EarlGrey: https://github.com/google/EarlGrey

Google has open sourced it, Internally Google has used this framework for some of it’s products like Youtube, Calendar or photos et al

This is a native iOS automation framework which enables you to write clear tests. This framework gets integrated with XCode’s test navigator to run your tests from XCode itself.

One of the key feature is it’s built-in synchronization mechanism. This mechanism makes your tests run fast and provides improved performance. The built-in synchronization makes the test scripts to wait for UI events to occur.  

Then features like Visibility checks, use like interactions enables framework to be more richer and scalable over any other framework.

This framework is very easy to set up, just follow the instructions accurately provided on GitHub.

UI Automation: http://tinyurl.com/gwj9ux3

This one is an instrument. The one you can use for automating your user interface tests through some written test-scripts. This is mostly utilized for functional testing and it is provided by Apple.

You write tests in Javascript which differs from Obj-C. Since not many folks using it and neither Apple keeps updating it, any problem occurs, you don’t get much help with automation.

We had tried using it in one of my previous companies for UI functional automation however looking at various difficulties we had switched to something better.

KeepItFunctional: https://github.com/kif-framework/KIF

This is an integration testing framework. It uses XCTest testing framework to write tests.

KIF is an open source by Square which allows you to write tests using Obj-C. KIF supports all functionalities like tap, swipe, drag, click etc etc The tests are usually executed against iPhone or iPad simulators and usually gets executed speedier.

KIF is easy to set-up, install it, turn on the Accessibility inspector and configure it. The KIFTestController is nothing but a test runner. And KIFTestScenarios stores all the steps to perform a test scenario.

KIF provides an ability to integrate with Jenkins. After every Dev-Check-In or Commit, you can have a smoke test suite, written using KIF, gets executed to ensure nothing obviously is broken. KIF allows you to support and configure continuous deployment for frequent launches of your commits.

Is Quality time-consuming entity?

Lets first look at….What’s Quality? Is it just identifying defects by expert test team? That’s not quality, that’s just a way to get your product to a viable condition so you can release to world. And I agree it could be time consuming process.

How can we avoid it.

For that let us first even understand what is the meaning of “achieve quality”. Quality has always been associated with business context. The product concept need to be discussed thoroughly. Chalk out any imperfection right that step than coming into development cycle.

At the development phase, let us adopt test-driven design concept. The more effective unit tests you have, the early you will identify imperfections/flaws. This will allow you to move faster rather than waiting for test team to come into picture and find defects.

Follow an agile/lean process. That means literally eliminate anything that’s not adding any value! Get rid of unnecessary meetings, and the documentations. Adapt to user acceptance and short stories. Also avoid what we “need in future” as requirements / UI keep ever changing then why to even waste time in “need for future”

Use an On-demand Cloud Infrastructure.  Cloud is everywhere and we all know what are the benefits of using the same. Maintenance hazard is first and foremost thing we can avoid with this model. Provides flexibility, ensure data integrity, increases efficiency et al

Set up Continuous Deployment. I totally understand getting continuous deployment could be time consuming if there are hurdles faced. However get it clear that it is one time investment but benefits are for life time! This gives you a flexibility to “Build frequently and launch frequently”. Basically it equips you to get a small piece of functionality or feature done with TDD approach and get it out.

Opt-In for Parallel Executions. You can set up multiple important platforms running at the same time. Have your tests seamlessly integrated to run against these multiple combinations (you care about and/or identified from Marketing analysis et al) simultaneously.

Go for Usability Sessions. These are the best sessions. Having real users looking at your product and running through it, will help with finding UI issues/ simplification issues right away. So you can have your real users test it to identify exploratory defects. All of this can be done directly on Prod. You can always use A/B test mechanism.

Frequent Alpha-Beta Launches. You can start conducting alpha releases within your team itself or with little larger audience which constitutes product owners during development process. Alpha launch does not mean you have to have a viable and stable product. Once you are close to getting a stable product, you can opt in for beta launches. These sessions will help identify things way early to keep you moving faster!

From An Idea to Minimum Viable Product!

While working in Silicon Valley learnt about the concept of MVP Stands for Minimum Viable Product.

Let’s look at what MVP means:

In product development, MVP is described as getting minimum features developed just enough to get trusted customer feedback quickly.  This equips product members and various stakeholders to make quick decisions about their awesome idea or concept.

Usually various start-ups built MVP to know more about adaptability and revenue that their concept might generate.

Here’s how to go about achieving MVP to launch successfully and quickly:

Idea – Have an idea in mind... Just pen it down. Penning down your idea or concept would help you draw vision and audience base. It will help eliminate unknowns and uncertainties. This will also help you get align with focus.

Be Intelligent – Now you have vision, focus, and concept. What’s the next step? Figure out the problem. What pain-point you are trying to solve? Is this really needed? Should it really be built? Answer yourself to build the confidence! As the confidence, the positivity and the believe in idea will take you miles in the run…

Priority - Outlining relevant and important aspect for MVP is key.  As initial step, first identify what exactly you need out of features from your concept. Get it prioritized based on market analysis and trend.

Develop – Once you know what you want to reach users quicker, building the concept into actuality becomes a critical step. As you are building solution towards identified problem, in the process, you are learning too. Ensure to have metrics/analytics in place. As measurement and leanings will shape up your startup’s engine.

Cloud – With AWS, Google upcoming Cloud Solution, Micrsoft Cloud Solution…world is moving towards cloud and eventually scalability! However there are many cloud orgs which can help you pay for what you use model. These will help save tons of money providing sustainability and scalability.

YouTube – Yes Youtube! You might have heard that a video worth of million dollar words! J Youtube allows you to advertise with them. So instead of getting a heavy duty demo for your product or way too many pages to advertise, get a video built. Craft it carefully and message it smartly. Videos go viral now a days and it would be like mouth-publicity for your product to reach millions in no time…

Duration – As you need to get your idea quickly in market, you are short on time. In such cases focus on Mobile as thats the new and hot industry which will help you run your marathon and not a sprint. Focus on getting something out quickly on iOS and Android. You can put website/ support for all browsers et al to rest for now and build the mobile version first. Also buidling mobile version first help getting a web version up and running down the line.

Conclusion - Getting a Minimum viable product is key for your startup's success. Getting it tested by real end users helps you get feedback right away to modify or revisit the idea. 

JASMINE - A Unit Testing Framework

Any small or medium or large App does require unit tests to verify quality of the code during development stage itself. And this provides flexibility to easily change or modify code without worrying about breaking any regressions.

Before even getting into let’s understand BDD S/W development process.  BDD as it stands for behavior-driven development emerged from Test-driven development. BDD comprises of techniques and principles of TDD to provide ease on collaboration.

Jasmine, a JS unit test BDD framework, for validating JS functions. Jasmine does not have any dependency on DOM elements nor depends on any other JS unit test framework. This comes with it’s own syntax to write efficient tests.

Here’s you can get code for Jasnmine:

https://github.com/jasmine/jasmine

Jasmine provides flexibility either to use Ruby or Python. Once the setup is done as per above given instructions, you can start developing unit tests. It is advisable to develop your unit tests first and then write code.

Angular framework has written by keeping testability in mind. Jasmine whole-heartedly support any app built using Angular just like Mocha or qunit etc

You want to write a unit test for a simple mathematics equation

Sample code:

Describe (‘Maths, function () {

//necessary

it(‘should add two numbers accurately’, function() {});

it(‘should subtracts two numbers accurately’, function() {});

});

describe() method describes test suite. It() describes spec.

For Angular’s simple controller you can write below unit test:

var myApp = angular.module('myApp',[]);  myApp.controller('GreetingController', ['$scope', function($scope) {   $scope.greeting = 'Hola!'; }]);

describe(‘GreetingsController Example’, function() {

var GreetingController,

scope;

beforeEach(inject(function ($rootScope, $controller) {

scope = $rootScope.$new();

.

.

.

.});

Now you have an example of basic unit test using Jasmine. You can run all your tests on every commit. These tests are very lightweight, and executes faster.

Achieving Continuous deployment makes it easy.

On Jenkins, you can install a command line with grunt plugin. Add the command line argument in your Jenkins config file.

You can see a sample output here:

All About World of Mobile!

Mobile in general is such niche area and glad that at LinkedIn, I am getting to explore as well as expand new horizon.

My team is focus on supporting Mobile native apps, hybrid app as well as mobile web software test cycles.

I may not be able to write more here but look forward to a blog from me on engineering.linkedin.com

Exploratory Testing - Innovative approach

Exploratory testing is an approach to software testing that is concisely described as simultaneous learning, test design and test execution. While the software is being tested, the tester learns things that together with experience and creativity generates new good tests to run. Exploratory testing is often thought of as a black box testing technique. Instead, those who have studied it consider it a test approach that can be applied to any test technique, at any stage in the development process. The key is not the test technique nor the item being tested or reviewed; the key is the cognitive engagement of the tester, and the tester's responsibility for managing his or her time. (Ref: Wikipedia)


In a resource crunch situation, especially, when the new features are coming in to huge extent, this innovative approach can make wonders! However appropriate planning, organizing and motivation is desirable to make this approach a success.


In short, the approach, involves, getting various stake holders like engineering team members, product managers, UX team members, customer field representatives together and perform an exploratory testing... on given feature or product. It could be simple web 2.0 product or it could be wireless device...does not matter.


As long as QA manager/lead outlines proper strategy....and a step by step representation of how to effectively perform exploratory testing or corner case testing... Once you have such step by step guide you can always give a preso to above stakeholders and get them up to speed with concept of exploratory testing. And you can pin point exact ways to make it effective and get best out of it!!


When I had conducted this approach, I had come up with 10 steps of effective ways.... think like an end user, act like an end user....relevant to the product that I wanted to get tested thoroughly,... Made sure to get buy in from VP/ Director initially by explaining them approach, impact and result! Rolled it out to engineering. Then got buy in from product manager(s). Rolled it out to them and then field representatives as they deal with customers and they know the issues or most common operations by customers.


Overall to avoid duplication of bugs, we have had everyone perform testing at the same time..no matter where they are located within USA :) And then set up IRC channel where constant communication of issues seen was going on to avoid duplication of bugs.


Result..we actually end up finding some of the corner case issues, high priority issues! We ended up adding almost 35+ test scenarios in our test repository and automating the same!!


This was very well received by my engineering team as well as product manager. Helped save a lot of QA time of performing black box - exploratory testing ..

Selenium wait()

Selenium wait() not defined ? What will happen ?

Selenium uses the browser to make requests and process the server response. In short, selenium asks for a page and server sends back the response.
The browser then constructs a DOM tree out of the response. Selenium then parses this DOM tree and looks for elements as per the test statements.

Short example
Step 1 --> @selenium.open("www.google.com")
Step 2 --> @selenium.wait()
Step 3--> @selenium.is_text_present("Google ...")

Here the request is Step 1.

Now assuming that the server is not loaded at all, the network latency is very minimal and the client machine has a very fast processor, the time from the first request to receiving the response will STILL be atleast a few miliseconds. So not considering the network latency and delayed response from the server, some time is definitely required for the browser to generate a DOM tree out of the response and then ready the page to be rendered.

If we do not allow for a wait period, however small it maybe due to ideal network and server load conditions, then selenium will jump from step 1 to step 3. At this point, the DOM tree is not ready and selenium will NOT find the text "Google ..." in the DOM tree. Thus, our test will fail.

For any test environments, the server response times could be large and selenium has to wait for the response to be completely consumed by the browser and build a DOM tree. Even if we were to make the test environments extremely fast and run at almost no load, there will be some amount of time required for DOM tree creation and parsing :)

Hence wait() is a basic required function for Selenium and can not be avoided :(

How to be innovative and how to keep yourself motivated

At work some times it could be possible that you end up working on certain project and may end up performing kinda similar tasks w/very little variations... So would that become monotonous ?

Do you think if it becomes monotonous..you may loose productivity to some extent and to help performing excellent at work, you need your motivation to be boost ?

Well, here is how I keep myself motivated - whether its work or cooking in kitchen. Coming from an Indian background, I almost end up preparing similar kinda breakfast with little variations...my family may get bored with same taste over and over again so I try to add different spices or motivate myself to try creative recipes for the same dish :) Well that truly helps!

I found below an interesting article published which helps self-motivation:
http://business.timesonline.co.uk/tol/business/management/article5883575.ece

JMeter or Selenium - Performance Testing of Web App

Some one recently asked me an interesting question "which tool better for performance testing for given web app - Selenium ? or any other open source ?"

Well here is my take

Find bugs - Static Analysis To Look For Bugs In Java code

Find Bugs - A static analysis tool to find logical error in given code snippet. Basically it helps find bugs in Java code. This comes as an Eclipse plug-in.

There is a way you can integrate Find bugs into the source control you are using for example Perforce.

This should be integrated on each and every development environment of developer's whether Eclipse or IntelliJ. As you go on writing code, this tool will immediately display errors which could cause eventually potential bugs with coding right away. So it saves time of developers handing over code to QA, QA performs testing and reporting back these bugs. Here is published material bu Find Bugs community as it was used @Google for product AdWords:

Published Material:Find Bugs Approach As Published

Methodology - Agile Testing Approach

What does Agile Means:

• Being Agile means creating an environment where change is embraced
• Changes in requirements, system knowledge, and /or organization are considered part of normal software development
• Agile is about focused collaboration between customers and developers
• The main goal is clean code that works, at a minimum investment

Why Agile: Reference: [AgileManifesto01] “Individuals and interactions over processes and tools Working software over comprehensive documentation. Customer collaboration over contract negotiation. Responding to change over following a plan. That is, while there is value in the items on. the right, we value the items on the left more”

 

When does Agile Makes sense:

• Rapidly develop and deliver software that
• meets business needs in the face of an
• unpredictable future
• Ability to change your mind
• Early availability of business value
• Option to cancel at any time yet still have value
• Handle uncertainty
• Visibility to & feedback from the customer 
  

When does Agile makes no sense:

• Uncertain and/or unstable success criteria
• Uncertain and/or unstable requirements
• Immediate access to business expertise
• High value in early release of partial functionality
• Project can be “self-contained”

  When does Less Agility makes sense:

• Knowable, stable project goals and requirements
• Like version 3 of a well-established application
• Customer can't absorb frequent releases
• High effort of data conversion, user training, …
• Team is too large, dispersed, or high turnover
• Poor team dynamics
• Lack of customer representation and/or poor
• customer relationship
• Dependence on external supplier's
• Long-term maintainability is important
• Life- or mission-critical products

There's more than one way to be Agile: 

• Extreme Programming
• Scrum
• Crystal
• Agile Modeling
• Dynamic Systems Development Method
• Feature-Driven Development
• Adaptive Software Development

Is Agile Appropriate:

• §Learning objective
• §Practice evaluating projects to see why they would or
• §wouldn’t be good candidates for agile development
• §Procedure
• §Read the Project Profiles in the Labs section
• §Discuss the projects in your groups
• §What characteristics of the projects make them good
• §candidates to be run as agile projects?
• §What characteristics make them not so good
• §candidates to be agile projects?
• §Extra Credit: Analyze your current project's 
  

Test A Little Code A Little:

• §You don’t need to write all the test cases first
  •1. You have to create of one test that the current code won’t pass
  •2. Write code to pass the test
  •3. Go back to step 1
• §If it is hard to write a test there may be a design issue
• §Each round of test & code includes refactoring of the previous code

Frequent Build and Test:

• §Completely build the product and run it through a series of tests to verify basic operation
• §“Daily build and smoke test”
• §“Continuous integration”
• §Works well with large volume projects
• §Lowering integration risk
• §Exposing big integration errors quickly
• §Tracking project progress
• §Extra effort/overhead

 How Frequent:

• §Not more than a couple of hours between builds
• §Build should take 10 minutes
• §Asynchronous builds most common
• §Check stuff in, the automatic build process
• §notices, sends out email of result
• §Synchronous builds give team a chance to reflect
• §Builds scheduled at certain times for all programmers

Multiple Builds:

• §Different builds accomplish different goals
• §Short, small builds on the test first approach
• §Overnight builds to test full integration
• §Weekly run more complete tests
• §Automation here is key
• §Agile sees this as a worthy area to spend
   

 Test Coverage Criteria:

• §How do I have confidence that my set of test cases is “good enough”?
• §Input and output domain coverage
• §Boundary value testing
• Decision (Branch) coverage

• Agile Testing good for Agile development projects;  can work on conventional projects too.
• Don’t implement Agile testing as a whole, but adapt its most valuable concepts
• Testers should be active members of the team.
• Testers often hesitate to speak up during team meetings, share ideas, interact with developers.
• Agile only works when there is lots of both formal and informal communication within a team.

Ongoing Conversation concept.

§With developers

§With CSRs

§Business Analysts.

Testers and developers are working together.

§Share office

§Testers assigned to help particular developers

§Test plan evolves  through a series of short “drop-in” meetings

§Benefits of pairing with developers:

     - developers gain insight into potential errors

     - testers gain insight into constraints and opportunities.

     - together can advance automated testing.

     - Grey box:  - understand relationship btw parts of the systems. 

                         - understand bugs:  what were the root causes?

                         - what needs to be retested?

                    

Test Status is reported via simple to read charts that answer specific question “What part of code can we stop worrying about?.”

Stand up reports.

Conversation with a customer is as important as with developers.

–Remember that customer are trying to figure out what they need, want and are getting, in large part, by trying out the  working code.

–Get feedback from CSRs -> create tests

–Participate in usability testing

Remember: “ …thinking does not take place inside our heads … Most of our mental activities need external resources.”

 

Keep in mind that sometimes design docs can be flawed.

Documents can’t be an adequate representation of the working code.

View them as:  interesting texts, partly fictional, often useful

Active communication is the key to a successful test plan

First, Waste No Time. Evaluate risky areas and test them first

     -  We gain an understanding of the product we're testing to the point where we can imagine what kinds of problems are more likely to happen and what problems would have more impact if they happened. Then we put most of our effort into testing for those problems. Agile Testing is concerned with uncovering the most important information as soon as possible.

Mission. What's more important? Writing test cases or doing testing?

     -  In Agile Testing we don't start with a task ("write test cases"), we start with a mission. Our mission may be "find important problems fast". If so, then writing test cases may not be the best approach to the test process. If, on the other hand, our mission is "please the FDA auditors", then we not only will have to write test cases, we'll have to write certain kinds of test cases and present them in a specifically approved format.  In our case it’s both.

 

Skills.

      -  Knowing the product lets you perform “out of the box” testing

Exploration.   

     -  Use exploratory testing. We prefer to let the next test we do be influenced by the last test we did. This is a good thing, because we're not imprisoned by pre-conceived notions about what we should test, but let ourselves develop better ideas as we go.

Teaming.   

     -  Agile Testers cheat. That is, they do things that our former elementary school teachers would consider cheating: we figure things out in advance where possible, we borrow other people's work, we use every resource and tool we can find. Example:  Pair testing: two heads, one computer. This idea has proven valuable in the practice of Extreme Programming, and it works for testing just as well. In our experience of normal testing, testers usually work quietly and alone, rather than hunting for bugs like a pack of rapid wolves. Again the message of this presentation is not  to try to adapt Agile testing as a whole, but extract and implement the most useful techniques of Agile testing.

Some of the stuff is being done already.

    -  Testers have stand up meetings

    -  Some Interaction with CSRs (manager, team leads)

What we don’t do yet:

    -  Closer interaction with developers.

    -  Closer interaction with CSRs. (primary testers)

    -  Robust testing, “out-of-the-box” thinking. (for primary testers)

    -  Grey box:  understanding of the system.

    -  Automation:  combine unit tests and our automation tests.

    - Testing in pairs. 

Increase quality of the product.  Find bugs faster.

Get more exposure for QA

Get better understanding of components.

Interact with developers more, which is always good.

Get better understanding of the working code.

Deliver marketable product earlier

 

Automated Testing:Hadnling/Managing ever changing UI - Use of CheckSum

Following post has a bug and an unanswered question - How would you handle dynamically updated web app. I do have some solution in my mind and just need to try it out before throwing as a post. So update soon.... ************

Firstly we need to understand what is Checksum. According to wikipedia:
A checksum or hash sum is a fixed-size datum computed from an arbitrary block of digital data for the purpose of detecting accidental errors that may have been introduced during its transmission or storage.

MD5 generated Checksum for a string is unique. And it will always give same checksum value as long as string does not change. Now selenium requests page we can use get_html_source to get back entire html source as a string. Then we can calculate checksums and we store it as our "html data or test data" and proceed with test.

Next time we run test we again get checksum and compare with the (existing) checksum that was recorded earlier.

Now there will be 2 scenarios ==>
1. Checksum is identical to recorded one which means there is no change in UI
2. Checksum do not match indicating change in UI.

If scenario 2) exists, then we can stop testing that particular page and send a report to QA that UI has changed for that particular page!!! At this point individual QA developers can visually inspect changes and verify by running test script meant for that particular page from there own laptops.

This will ensure that any UI change is taken care of. Sometimes we may get false-positive changes, might be due to some text element or images which don't really affect our test scripts because none of form fields or link ids have changed. Hence local execution of the test by QA will be all that is needed to verify if the GUI has really changed to necessitate script changes or its a non-script breaking changes.

Furthermore --- checksum algorithm and parsing html source to traverse through DOM to find elements - update soon...

Automated Production Testing - Why does it raises eyebrows!

Every company has different rules and revenue impacts about production environment changes depending users input stream and business model.

AdWords is one of the most complex project I have ever worked on. AdWords involves huge complex calculations and collections of data and stats. It has various salient features and has a very heavy duty traffic of zillions ..trillions end users. These zillions..trillions end users are expected to perform various combination of actions and transactions. Testing such an application is in itself a challenge. Above all, even thinking about automating such an application was definitely complex and challenging!!

Certain aspects to take into consideration for automated production testing:

•  

JUnit

As requested posting a blog about Junit

What is Junit ?
Simple framework for writing and running automated tests. Includes useful abstractions for running tests including test cases, text fixtures and test suites.

package junit.samples;


import junit.frameworks.*;
import java.util.Vector;
import junit.extensions.*;


/**
* sample test for java.util.Vector
*/
public class VectorTest extends TestCase {
  protected Vector fEmpty;
  protected Vector fFull;


public VectorTest(String name) {
      super(name);
}
public static void main (String[] args) { 
      junit.textui.TestRunner.run (suite());
}
...
protected void setUp() {
  fEmpty = newVector();
  fFull = new Vector();
  fFull.addElement(new Integer(1));
  fFull.addElement(new Integer(2));
  fFull.addElement(new Integer(3));
}
public static Test suite() {
    return new TestSuite(VectorTest.class);
}
public void testCapacity() {
       int size= fFull.size();
       for (int i=0; i < 100; i++)
          fFull.addElement(new Integer(i));
       assertTrue(fFull.size() == 100+size);
}
public void testClone() {
   Vector clone =  (Vector)fFull.clone();
   assertTrue(clone.size() == fFull.size());
   assertTrue(clone.contains(new Integer(1)));
}
}
...


What is JUnitPerf ?
Collection of JUnit tests decorators used to measure the performance and scalability of functionality contained within existing JUnit tests. When ever performance and scalability requirements are critical, JUnit perf plays an pivotal role.

Supported JUnit test decorators:

Timed tests: Runs a test and measures elapsed time

Load tests: Runs a test with concurrent users and iterations

Threaded tests: Runs a test in separate thread

JUnitEE: This is an extension to Junit. It allows tests to be executed inside an application server. Hence tests run in production environment.

Code Coverage Tools:

Emma - I have used Emma as well as our own version of Clover in my previous company. One can find all information about Emma at emma.sourceforge.net

Clover is commercial, free to open source project. Here is an example image for a cal app:

Qualities of a good Engineering or Test Manager

I have been fortunate to be reporting to a quality Test managers in the past. Looking at my past experience as well as current experience of reporting to test manager or a director led me to write this blog:


According to me whether you are explicitly a test manager or QA manager at least you should have following qualities.

• Having domain expertise of the product that you are managing
• Technical knowledge about the technology or tools being used in an organization they are managing - if not expertise but some sort of knowledge
• Ability to have an healthy/productive technical discussion with reporters
• Ability to provide career guidance, recognize skill set, assign appropriate role
• Test manager should not under estimate reporters or co-workers
• Should have execellent knowledge of software development process
• Should always promote a positive atmosphere in the team
• Must promote teamwork to increase productivity
• Must maintain enthusiasm of team
• Must have preventive approach to the problems
• Must be able to promote cooperation between software, test, and QA engineers
• Should have the ability to promote improvements in QA processes
• Should have people judgement skills for hiring and keeping skilled personnel
• Should be able to organize meetings and keep them focused
• Good communication skills to communicate well with technical & non-technical people, engineers, managers and as well as with customers.
• Ability to say ‘no’ to other leads / managers when quality is insufficient or QA processes are not being adhered.

Basically it all can be divided in top 5 points:


Creativity:You can never solve a problem on the level on which it was created. Discovery of new ideas or concepts. A good manager should be able to welcome/encourage new ideas or concepts. Be able to discuss pros and cons of such new idea or concept. Say for example, exploratory testing by various stakeholders or integrating guiceberry with junit3 or use of testng instead of junit3.


Leadership Skills: Leadership, a critical management skill, is the ability to motivate a group of people toward a common goal. These items will help you develop your skills as a leader.

• Talking out loud
• Having a positive attitude
• Able to be change the perspective
• Effective convincing skills to deal with various stakeholders
• Able to recognize skill sets and assigning tasks

Organization Skills:Practicing good organizational skills helps you to be prepared for your day-to-day responsibilities. Organizing your home, school or office will help you to work more efficiently, in whatever tasks you wish to accomplish.

• Significance: Good organizational skills are significant because they help you to function better in everyday activities, from getting dressed in the morning to remembering appointments and meeting deadlines.
• Function: Being organized helps you to know what is expected of each day and to be prepared to meet those expectations. For example, creating a list of things you need prior to going to the store will make you a more effective manager of both your time and your money.
• Considerations: Consider the importance of being organized if you are in school and have to be responsible for assignments, if you have to keep appointments for your job or if you are running a household.
• Warning:Avoid overwhelming yourself with maintaining organization. It is often easy to be just as overwhelmed as you try to keep up with your new skills, as it is to be unorganized and cluttered. Ease your way into new organizational habits.
• Benefits:Good organizational skills will help you to finish tasks you begin. Focusing on completing a goal in an organized manner will enable you to eliminate things that may otherwise cause a distraction.

Knowledge: Having domain expertise of the product or project is as important as being skill-full about the technologies or tools used - whether its a bugs tool or test case management tool. A good test manager will always be aware and be proactive about learning new technologies that are being used within his organization. For example test case management tool or bugs tool. Its essential to have a thourough knowledge about such tools which are used in day to day activities by entire QA organization. In terms of finding metrics or planning upcoming release cycle, these both tools play key role in providing visualization of various metrics like bug count, bug history, trends and patterns - which are looked upon by various stakeholders.


Innovation, Motivation, Enthusiasm: Extremely important. A good test manager should be able to motivate various members within his organization either by appreciating there work or making them responsible to take over a challenging project, where team member not only get an opportunity to prove himself (visibility) but also gets an opportunity to learn something new.
In my past company I was involved in developing a SDK which can be used to develop dashboard(s) or gadgets to provide various metrics. It gave me an opportunity to prove myself, huge huge visibility, learn new techs like GWT, Gviz!!!!
Another aspect could be innovation! Being innovative, being a pioneer of say a process or a framework!! In my past company I was involved in help automating release process. Understanding release process not just related to my own project but also to learnt it across various projects within same organization and then gathering requirements from various teams, stakeholders, outlining in terms of priority, presenting to higher authorities. And then designing which tech or lang to used to build, what are commonalities across board etc. After that comes actual implementation. 
Enthusiasm - Being enthu about work you are actually performing and also be able to create equal amount of enthusiasm across board withing team members is as critical as motivation. If you do not feel enthu about your work then its very hard to keep team motivated! Without the enthusiasm to support their activities, it is extremely doubtful that the QA and Testing function will be successful. Doubt and negativity will only reinforce a perception that the QA and testing activities are not as value-added as programming activities and are a drain on schedule and budget.  Enthusiasm is rare, however. Most employees want to do a good job, but they feel under appreciated. Generally, bad management is blamed for unmotivated workers, but often, good management can still provide unenthusiastic workers. So, what's the secret?
If your own employees aren't acting motivated or aren't acting enthusiastic, then it's time to get your own "act" in gear. You can fire up your workforce in three acts: 
Act enthusiastic. Act grateful. Act happy.
Psychologists tell us that the best way to change our feelings about what we're doing is to change the way we think of our feelings. The brain tells the body how to feel and the body acts accordingly. We can direct our own feelings and our outlook on life. Writing in Out of Work? Get Into Business!, I wrote about expectations and how they can change the outcome of future events


Team Member:
Working on teams can be rewarding, but at times it can be difficult and downright frustrating. If there are poor communicators on your team, you may often feel left in the dark, confused or misunderstood. To create a successful team, effective communication methods are necessary for both team members and leaders. To have an effective team or be able to build team spirit, following norms usually been followed or enforced by a good test or quality manager.

• Team members as coworkers: all team members are equal; every team member's opinion will be thoughtfully considered; each team member will keep all commitments by the agreed upon due date; each team member agrees to constantly assess whether team members are honoring their commitment to the team norms.
• Team member communication: team members will speak respectfully to each other; will not talk down to each other; will positively recognize and thank each other for team contributions.
• Team member interaction in meetings: team members will listen without interrupting; hold no side or competing conversations; follow the rules for effective meetings; attend the meeting on time; always work from an agenda; minutes will be recorded at each meeting; end meetings on time.
• Team organization and function: leadership will rotate monthly; the team management sponsor will attend the meeting, at least, monthly.
• Team communication with other employees including managers: team members will make certain they have agreement on what and when to communicate; complaints about team members will be addressed first in the team.
• Team problem solving, conflict resolution, and decision making: team members will make decisions by consensus, but majority will rule if timely consensus is not reached; conflicts will be resolved directly with the persons in conflict