Hi, we are AppUnite, we take care of the businesses from a tech perspective. We build products and teams around them enabling our clients to bring the difference to the world.

We believe in knowledge sharing and software as a tool to improve companies and peoples’ lives. We take lessons from our daily challenges and share that experience and knowledge to help you build better products. 

Let’s talk about products, businesses, and software development!

Testing is often an overlooked part of app development. Unit tests are the most trivial testing software you can implement in your project anytime. You only need the `flutter_test` package in your dev dependencies (it's added to every project by default).

Unit tests help to maintain your code, discover bugs quicker and ensure the quality of your code. They're also a key factor when working with legacy code.

## How to write unit tests

Let's say you have a simple method that calculates 6 * 7:

<Gist gist="mhnowak/074af15940a90db2b52b7fcec7c93e2d"/>

The test for it would look somehow like this:

<Gist gist="mhnowak/1ecf86149027399e2bf5e29f1daf390a"/>

Pretty simple, but in the real world, you'd have a class that calls some other method in its dependency and returns some data. More or less something like this:

<Gist gist="mhnowak/d9c36d99fc20d84dc5ba241e71e3d863"/>

First, we need to create an instance of our class, but we have one problem since it relies on `NetworkManager`. We could also create a `NetworkManager` class, but that's not a point of unit tests. When unit testing, you should always limit what you're testing to the very minimum, so you know what failed precisely.

With the help come mocks, which allow you to create simulated objects that imitate the behavior of real objects in controlled ways. You'll need to add `mocktail` to your packages. Then, create a mock class that you want to imitate, like the one below:

<Gist gist="mhnowak/ff8daeef65036daec06e7479b9973412"/>

Now you can use it in your tests:

<Gist gist="mhnowak/04cc5021a7ad484f089de2892f95f74e"/>

Let me explain what happens here. First, you create a mocked version of `NetworkManager`, then pass it to the class you want to test. Subsequently, you tell the `NetworkManager` what he needs to respond with when calling the `getData` method. Finally, you execute the function and compare the data.

There's also one cool thing that you can do with mocks. You can verify if the methods inside of them were called or not. It comes in handy once your method doesn't return anything (void method).

<Gist gist="mhnowak/20985a75b892dd75acc3935cd5a350c5"/>

Here we're verifying that the `getData` method was called once and that there were no more calls on our `mockNetworkManager`.

## Working with unit tests

Unit tests are a great way to keep your project together. Let's say you change one of the methods to do something else. For example, the `calculate` method now calculates different equations `3 * 7` - the tests won't pass now, and you will need to update them.

Why is this useful? This example asks you to double-check your changes, but let's see what happens if something changes in the `getParsedData` method. There are way more scenarios that can go wrong here. For example, you could call `getData` twice - the tests will fail.

You could also call another method from NetworkManager instead of using getData and the tests will also fail. You're notified about the changes and assured the changes are made for a reason.

## Useful methods

- `emitsInOrder` - helpful in testing streams or blocs

<Gist gist="mhnowak/7375edc744091e1bcead867b256c84b9"/>

- `expectLater` - works like `expect`, but completes when a matcher has finished matching
- `pumpEventQueue` - waits for an event loop to run 20 times (default), helpful when waiting for some async work to complete

<Gist gist="mhnowak/8282bac3f15fa424138dc66538dbfa77"/>




large_lewis-kang-ethe-ngugi-f5pTwLHCsAg-unsplash.jpg

medium_lewis-kang-ethe-ngugi-f5pTwLHCsAg-unsplash.jpg

small_lewis-kang-ethe-ngugi-f5pTwLHCsAg-unsplash.jpg

thumbnail_lewis-kang-ethe-ngugi-f5pTwLHCsAg-unsplash.jpg

lewis-kang-ethe-ngugi-f5pTwLHCsAg-unsplash.jpg

Testing  is often an overlooked part of app development. Unit tests are the most trivial testing software you can implement in your project anytime. Wanna learn how?


Flutter Unit Testing

From a mobile developer’s perspective, the world of fintech is exciting and constantly evolving. With increasing reliance on mobile banking and financial transactions, there are a number of opportunities for developers to create innovative and user-friendly applications. However, working in the fintech industry also comes with its own set of challenges.

## Security

One major challenge is the need to maintain strict security standards. Financial transactions involve sensitive information and any breach of security can have serious consequences for both the company and the users. This requires developers to constantly update their knowledge of security protocols and ensure that their code is secure and compliant. This can be achieved in a number of ways:

1. Implementing strong authentication and access control measures. It means that the application should require a user to use a secure password, as well as offer an option, or require to use two-factor authentication, which prevents unwanted access to their account.
2. Complying with relevant regulations. Developers have to be aware of and comply with regulations such as the PCI DSS (Payment Card Industry Data Security Standard), the GDPR (General Data Protection Regulation) and the FCA (Financial Conduct Authority).
3. Security testing. Developers should test their systems and code for security vulnerabilities and potential weaknesses. When found, developers should take steps to address any issues identified.
4. Encrypting sensitive data. Sensitive financial information such as credit card numbers and bank account details should be encrypted to protect against data breaches.
5. Keeping systems and software up-to-date. Developers should ensure that their systems and software are updated with the latest security updates to protect against known vulnerabilities and threats.

## How to deal with security challenges?

One way to deal with security is to work closely with security experts and stay up-to-date with the latest industry developments. Working with a team composed of developers with diverse skills and expertise can also help to tackle these challenges and create a more robust and secure application. At AppUnite, we foster a culture of learning. We are excited to learn and try new things, we use our curiosity to build a deep understanding of how things really work. When a team is curious, they are proactive. We value partnerships in business, so we form teams that have great product knowledge. We do not want to implement solutions blindly, we want to know that they make business and technological sense. Our job is to build teams, and products and help businesses that are built around them.

## The ever-changing industry

The need to keep up with the constantly changing landscape of the financial industry is another challenge. These changes are driven by a range of factors including technical innovations, regulatory changes and shifts in consumer behavior. With the emergence of new technologies, such as blockchain, and the increasing popularity of cryptocurrency, developers need to constantly learn and adapt to stay relevant in the industry. Coming from a financial background, I have experience in developing banking applications. When I jumped to a blockchain project, the rules of the game seemed familiar at first, yet, the new product required a rapid growth of knowledge in the crypto industry and, thus, hours of studying a new topic. This can be a daunting task, but it is also what makes working in fintech so exciting and rewarding.

## Regulations

The financial industry is heavily regulated and changes to regulatory requirements can have a significant impact on financial institutions and their operations, as well as their systems and applications. As people’s financial needs and preferences change over time, the change can lead to the development of new products and services and the need to adapt the current ones. 

## Be Agile

To be ready for possible changes and adaptations, our team at AppUnite chose to work agilely, emphasizing flexibility. It is designed to help teams quickly respond to changing requirements, often occurring in the development phase of a product lifespan.

## Why you should go native

In addition to facing these challenges, fintech also requires native mobile developers for a number of reasons. Native mobile development allows for more seamless and efficient user experience as it is specifically designed for the platform it is being developed for. This is particularly important in the fintech industry, where users expect a fast and reliable application for handling their finances. 

Native mobile development also allows for better integration with the device's hardware and software, allowing for more advanced features such as facial recognition for added security. At AppUnite, when working on a blockchain exchange platform, we leveraged these advantages by securing the product with biometric authentication and simplifying card payments by using Apple Pay and Google Pay. Implementing Apple Pay was particularly interesting, as it enables a shift in responsibility for fraudulent transactions from a merchant to a card issuer. 

There are also more platform-specific features, such as haptic feedback, which I have experimented with during my work on banking applications. I believe it makes an impression of an application being more responsive and improves user experience in an interesting way. This level of integration is not possible by using only cross-platform development technologies, making native mobile developers an essential part of the fintech industry. 

Native applications offer better performance, as they are designed specifically for a particular platform and are optimized to take advantage of the platform’s capabilities. 

Another advantage of native mobile applications can be improved user experience. Platform-specific features are used to provide a more seamless and intuitive user experience, they are designed to feel like a natural extension of the device. That being said, native applications are also easier to build, test, and maintain. Native technologies also enable developers to quickly adapt to new technological trends, as the newest features are always first available with native technologies.

## Summing up

Overall, the fintech industry presents exciting opportunities for mobile developers, but also comes with its own challenges. By staying up-to-date with the latest industry developments and working closely with security experts, developers can create innovative and secure applications that meet the needs of their users. The importance of native mobile developers in the fintech industry cannot be underestimated, as their expertise allows for a seamless and efficient user experience that is essential for the success of a financial application.



large_Zrzut ekranu 2023-01-16 o 10.23.37.png

medium_Zrzut ekranu 2023-01-16 o 10.23.37.png

small_Zrzut ekranu 2023-01-16 o 10.23.37.png

thumbnail_Zrzut ekranu 2023-01-16 o 10.23.37.png

Zrzut ekranu 2023-01-16 o 10.23.37.png

Unlock the potential of fintech with AppUnite's expert solutions. Our team has the knowledge and experience to tackle the challenges of security and industry changes, ensuring top-notch performance for your mobile financial needs.


Szymon Mrozek

The story of iOS CI at AppUnite (Part 2)

The story of iOS CI at AppUnite (Part 1)

How to test iOS apps with Combine, ReactiveSwift and RxSwift

How we spent 500 hours for writing tests and proved this to be a business value

How to keep dependencies up to date

IOS Open Source Hell

Building Dependencies on iOS with Carthage