Forem: DmitryKotlyarenko

Reasons to Use Robot Framework for Test Automation

DmitryKotlyarenko — Fri, 17 Apr 2020 14:17:04 +0000

Software development companies automate the testing process to increase accuracy and speed, enabling them to deliver high-quality digital products on short notice.

Robot Framework is one of the most popular automated testing technologies. It is open-source and can be used on both user and programming interfaces, and it has strong community support. Experienced QA engineers value Robot for its extendibility and wide range of customization features.

With Robot, you can choose your preferred programming language. You can even use English words as keywords, which makes RF an easy-to-master option for beginners, since you don’t need much programming knowledge to start writing your first scripts.

This post lists the main reasons to use Robot Framework for automated testing.

Active Community

Learning something new is always easier when you have seasoned specialists to advise you about useful tools and industry best practices.

You can join RF communities on Stackoverflow, GitHub, and Slack to stay abreast of the latest updates, find questions and answers on virtually any topic related to RF’s launch and uses, as well as detailed tutorials and source code.
By reading case studies you can see how theoretic knowledge can be put into practice.
You can attend the RoboCon convention that is held annually in Helsinki. Try to take part in open-source RF development sprints and workshops.

Availability and Frequent Updates

You can acquire Robot Framework for free, along with all the libraries and extensions supplied by the community. But be sure to check contributors’ comments to avoid having to fix bugs resulting from low-quality code. You can also visit the official foundation website that supports FR’s development and the release of new versions.

Integrations

Depending on your project’s requirements, the testing environment can be customized with third-party libraries. Special libraries for UI testing, database testing, and HTTP request testing are available in the public domain. Expand your stack by trying a special Selenium library for RF that lets you use Selenium functionality when testing apps.

Documentation

RF’s documentation found on their official website is accurate, well-structured, and easy-to-read, so new users are able to quickly tap into the technology. Apart from textual instructions, it includes videos, demos and online courses.

Also, RF lets you create your own documentation. When building third-party libraries and extensions, contributors can document the process and outcomes in a unified format that the community can understand.

Custom Keywords

Teams using unique functionality or datasets not provided in the basic toolkit may need to script them using custom keywords. This can be done using Python or any other programming language that binds to Python.

Comprehensive and Understandable Test Reporting

Easy-to-read RF reports can be understood by anyone, including QA engineers, product owners, stakeholders, and other parties who lack programming knowledge. Each report explains the test’s purpose, features and verified data, along with other important details.

Reusable User Stories

User stories make user experience the center of attention when designing, developing, and testing apps. They can be reused by different teams to ensure consistency. Also, you’ll save loads of time by scripting tests at the development stage. Once the code is written, it can be verified with a ready-made autotest. All user stories can be kept in a catalog for use by product managers to write new stories.

That sums up the key advantages of Robot Framework. Use this cutting-edge technology to simplify and accelerate your QA processes.

Helpful Tips for Smooth Integration of New Projects

DmitryKotlyarenko — Mon, 23 Sep 2019 12:05:29 +0000

Project managers regularly have to accept projects from other project managers or companies. Typically, the transition time is limited to a couple of weeks or less. Whether this process goes smoothly depends on your experience, the development phase, as well as the management system in which the project was launched.

Prepare Yourself for Challenging Projects

It is easy to define the project’s purpose and specifics and quickly join the workflow if you already have similar projects in your portfolio and know the shortest pathways to their successful implementation. With no practical accomplishments, you should at least have theoretic knowledge and learn on your colleagues' experience.
The best way to familiarize yourself with the best practices in the industry and gain useful resources is to attend large-scale conferences, with both niche and adjacent subjects. At first glance, some topics discussed at such venues may seem irrelevant to your projects. However, the broad outlook will help you think outside the box and find unusual ways out of challenging situations.

Early Steps

Acquiring an unexpected project can be overwhelming for a newly appointed PM. The sheer abundance of new information, people, connections, and communications can make it challenging to understand all past and future tasks. But don’t worry, you just need some time to acclimatize to your new work environment. Adhering to a clear step-by-step strategy will definitely help:

The primary task of the project manager is to build effective communication channels among all project participants. In the beginning, it may be unclear which team member is responsible for what, so be sure to immediately write down each member’s name, position and contact information.
Next, you should carry out an audit of the project to get an idea of its current state.
Think about what needs to be done for your team to successfully finish the project. Draft a BackLog (task registry).
Once you have a clear understanding of the project’s mode and timeframe, you need to establish effective reporting, notifying, revising, and testing processes.

Research the Project

Begin your in-depth research by collecting all available project-related documents. If some documentation is missing, it is worth drafting it on your own, at least in general terms, even if you don’t know all the details.
Pay attention to the description of the system, its structure, and features. This will help you understand the nuts and bolts of the project and decide which specialists are best suited to perform each task.
Gathering information on technical support, testing and production environments, and basic development approaches will also prove useful.
All this can be described in 5-10 pages. Use a wiki-like system so that all documentation is accessible to each team member, and not just the project manager.

Documentation

You can use different description sets and templates when drafting a list of project-related documents.
It is important to highlight the following features:

The main goals and objectives of the project overall, or its individual stages. The description does not have to be detailed, but it should provide enough information to help all team members understand the purpose of your project.
Business logic. If some business logic is implemented in the project, it is a good idea to provide a detailed description. A block diagram is particularly useful here for mapping out its characteristics.
Interaction systems of external and internal integrations. If your project has integrations, you should have descriptions for each of them. At the very least, you should know the purpose of integrations and have API documentation at hand.

Work Organization

If the team has been working efficiently on past projects, they probably have a streamlined system of actions and procedures in place. As long as things are running smoothly, there is no need for excessive oversight. However, be ready to step in and make changes if necessary to refine the workflow.
Before getting started, take time to determine which team members will be responsible for which tasks. It’s great if every team member is qualified to do all tasks, from development to testing and release. But to make the process flow smoothly, you need to impose some order.
While revising and planning, the project manager should pay attention to work methodology and completion. Also, be sure to specify the procedure for testing results.
When all tasks are in plain sight and every team member can learn the current state of the project at any time, it is much easier for the project manager to evaluate and make decisions about the work’s progress.
It is convenient to control projects in a task management system. Ordering the activities of backlog grooming and setting the right priorities can help you create a steady workflow.
In addition, if all tasks are carried out through a common project management system, it is much easier for the project manager to collect information for reporting on the project and its labor costs.

In Conclusion

When you accept a new project, take some time to identify its purpose, and to create effective communication channels among all participants. Obtain or develop documentation that describes the business goals of the project, its structure, architecture, and all possible requirements. Once work begins, continually audit the project and make necessary adjustments to the registry of tasks, working hours, and project reports.

Static Typing in a React Application

DmitryKotlyarenko — Fri, 16 Aug 2019 10:06:20 +0000

In 2016, TypeScript began to regain popularity. Developers have completely rewritten many popular technologies using this programming language and added static analysis tools to existing platforms. Using such a global process adds stability to the code base of thousands or even tens of thousands of projects.

Why did I choose React for app development? Today, this library undoubtedly dominates its competitors. The world’s largest developer community has formed around React. Every third SPA is written on this platform. Also, there are many great projects involving the use of React Native, a platform for iOS, UWP, and Android app development based on React.js.

The integration of two super-popular tools, TypeScript and React, offers great opportunities for app developers.

Examples

First, let's clarify what types we can use with React.
We will start with the basics and then add types to the Functional Component.

import * as React from 'react';

const HelloWorld: React.FunctionComponent<{
  name: string;
}> = ({ name = 'World' }) => {
  return <div>Hello, {props.name}</div>;
};

export default HelloWorld;

For the Functional Component (or Stateless Component), we must use a definition of the “React.FunctionComponent” type. We can also define types for the “Props” argument, i.e. fields that the parent passes to the component. In this case, “Props” can only contain a "name" field with the "string" type.

All this does not look complicated. What about class components?

import * as React from 'react';

interface State {
  name: string;
}

interface Props {}

class HelloWorld extends React.Component<Props, State> {
  state = {
    name: 'World'
  }

  setName(name: string) {
    this.setState({ name });
  }

  redner() {
    return (
      <React.Fragment>
        <h1>Hello, {this.state.name}</h1>
        <input value={this.state.name} onChange={(e) => this.setName(e.target.value)} />
      </React.Fragment>
    );
  }
}

In the example with "class", we created two interfaces: Props and State. With their help, we determined the signatures of incoming props (empty) and the signature of the component's state, as in the example with Functional Components.
We can also add default props values.

import * as React from 'react';

interface Props {
  name?: string;
}

export default class HelloWorld extends React.Component<Props> {
  static defaultProps: Props = {
    name: 'World'
  };

  render () {
    return <h1>Hello, {this.props.name}</h1>;
  }
}

That's all! Our little React application is already strictly typed at the level of parameters and state values of the component.

Let's consider the advantages:

we can see all type mismatches at the compilation stage;
a properly configured editor will help us avoid mistakes (even at the development stage) by simply highlighting the discrepancies between signatures or data types;
we have documentation on interfaces and type definitions.

Enum in Parameters

Enum is an enumerated data type. If we add this type to a variable or interface field, then the value of this field or variable will be equal to specific values in Enum.
For example:

import * as React from 'react';

enum Colors {
  RED,
  BLUE,
  GREEN
}

const ColorResult: React.FunctionComponent<{
  color: Colors;
}> = ({ color = Colors.Red }) => {
  return <div>Your color is {props.color}</div>;
};

export default ColorResult;

In the already familiar Functional Component, we can show the color selected by the user. In the "enum Colors" type, we should specify all possible color options that can be transmitted to the component. If the TypeScript compiler finds a type mismatch, it will display an error alert.

Strict Redux

Today, we still have many applications running on Redux. TypeScript can improve them.

import * as React from 'react';

const initialState = { name: 'World' };
type HelloWorldStateProps = Readonly<typeof initialState>;

interface Action {
    type: string;
  name?: string;
}

const worldNameReducer = (
    state: HelloWorldStateProps = initialState,
    action: Action
): HelloWorldStateProps => {
    switch (action.type) {
        case "SET":
            return { name: action.name };
        case "CLEAR":
            return { name: initialState.name };
        default:
            return state;
    }
};

const set = (name): Action => ({ type: "SET", name });
const clear = (): Action => ({ type: "CLEAR" });

const store = createStore(
    combineReducers({
        world: worldNameReducer
    })
);

type StateProps = ReturnType<typeof mapStateToProps>;
type DispatchProps = typeof mapDispatchToProps;

interface AppProps extends StateProps, DispatchProps {}
interface AppState extends StateProps {}

class App extends React.Component<AppProps, AppState> {
  state = {
    name: initialState.name
  }

  setName(name: string) {
    this.setState({ name });
  }

    render() {
        const { set, clear, name } = this.props;
        return (
            <div>
                <h1>Hello, {name}</h1>
        <input value={this.state.name} onChange={(e) => this.setName(e.target.value)} />

        <button onClick={() => set(this.state.name)}>Save Name</button>
        <button onClick={() => clear()}>Clear</button>
            </div>
        );
    }
}

const mapStateToProps = ({ world }: { world: HelloWorldStateProps }) => ({
    name: world.name,
});

const mapDispatchToProps = { set, clear };

const AppContainer = connect(
    mapStateToProps,
    mapDispatchToProps
)(App);

render(
    <Provider store={store}>
        <AppContainer />
    </Provider>,
    document.getElementById("root")
);

In this example, I added types to several app levels at once. First of all, I worked with reducers. A reducer accepts "Action" on input and should return objects corresponding to the "HelloWorldStateProps" type. Given the great number of reducers in an average application, this is a very useful innovation. Every action has a strict "Action" signature.

The next level of typing is a component. I have applied type inheritance to AppProps and AppState. Why should I write more if data types with such signatures are already available? With this approach, it is much easier to maintain the system. If some elements are changed, all the heirs will change as well.

Conclusion

TypeScript is a really useful language running on top of JavaScript. In conjunction with React, it provides truly impressive programming practices for Frontend applications.