api_weather

Gain insights into unit testing Elixir applications with ExUnit, explore advanced integration and E2E testing, and master OTP, Phoenix frameworks, API testing, and platform-specific refactoring.

testingElixir.tar.gz

First Test

SoggyWaffle-mix test

chapter2-RealExternalDependency - soggy_waffle_test

Chapter3- GenServer-Example

chapter1-isolating code 

chapter1-dependencyinjection -fine

Ch4-testing-ecto-schemas-

Ch4-testing-ecto-schemas--mix deps

Ch4-testing-ecto-schemas--Database tmux 2 shell makeup

Ch4-testing-ecto-schemas--Database tmux 2 shell window

Ch4-testing-ecto-schemas--Database tmux 2 shell databasetest

Ch4-testing-ecto-schemas--Database tmux 2 shell databasetest-copy

Ch6-testingPhoenix-error test

chapter2-RealExternalDependency - soggy_waffle_test-copy

Chapter3- GenServer-Example-copy

Ch6-testingPhoenix-error test-copy

Ch6-testingPhoenix-error test-copy-lbr

ch7-property-based-testing

Ch6-testingPhoenix-error test-copy-check

Ch6-testingPhoenix-error test-copy-happytest

Chapter3-edit

chapter1_l2

chapter1_l6

chapter1_l7

chapter1_l10

chapter1_l13

chapter1_l14

chapter2_l3

chapter2_l4

chapter2_l6

chapter2_l7

chapter2_l9

chapter2_l14

chapter2_l15

chapter2_l16

Ch4-testing-ecto-schemas--mix deps-refactor

Ch4-testing-ecto-schemas--mix deps-shared

chapter3_l4

chapter3_l5

chapter3_l6

chapter4_l3

chapter4_l4

chapter4_l5

chapter4_l6

chapter4_l7

test

chapter4_l11

chapter4_l12

chapter4_l13

chapter5_l3

chapter5_l4

chapter5_l5

chapter5_l6

chapter6_l4

chapter6_l5

chapter6_l6

chapter6_l7

chapter6_l9

chapter6_l10

chapter6_l11

chapter4_l13-copy

chapter6_l3

Ch6-testingPhoenix-error test-copywithMix

ch7-property-based-testing-copy

ch7_Introducing_stream_data

ch7_Writing Properties

ch7_Shrinking

ch7_Strategies

ch7_ Smoke

Chapter3- GenServer-isolating

Chapter3- Controlling

Chapter3- GenServer1

chapter4_l10

chapter6_l3-copy

ch7_ Properties

Testing is an essential part of the software development life cycle. A good automated testing suite streamlines feedback, allowing rapid creation and tight control over specific application components.

This course is a comprehensive introduction to testing Elixir applications with ExUnit. You’ll start with a review of unit testing principles before diving into writing tests with the ExUnit. You’ll build a comprehensive suite of unit tests before moving on to more advanced testing, including integration, end-to-end, and property-baste testing. In addition to the core Elixir environment, you’ll also develop tests for OTP, the Phoenix web framework, including JSON APIs and Ecto schematics. You’ll also explore refactoring for different platforms, server rendering, and design strategies.

By the end of this course, you’ll be an expert in unit testing Elixir applications with ExUnit and ready to build robust, performant applications using Phoenix.

Ensuring Elixir Application Performance with Testing and ExUnit

# Which approach is best for testing external services?

We saw three possible approaches to testing third-party HTTP services:

- Making real requests
- Running a test server that mocks the service
- Recording real requests and replaying them 

As is often the case in our industry, there’s no definitive best approach among these. Each one fits some use cases better.

## Test server
Building a test server is the way to go if we want tight control over how the third-party API should behave. This lets us test different responses from the API and gives us flexibility. However, the trade-off is having to build the test server and keep it up to date with the real API.

## ExVCR 
If we want to mimic the API perfectly and use one of the supported HTTP clients, then ExVCR is a good alternative. The trade-off is that we have to keep cassettes up to date, but that’s something that we can only avoid by going with the real requests approach anyway. 

## Real requests 

If we can get away with making real requests to a service, then it’s often a good idea to do that. Many HTTP services provide sandbox environments specifically for testing or are **idempotent**, meaning that we can make requests without affecting the state of the service. Even in these cases, though, we might want to avoid the real requests approach if we don’t want to rely on an Internet connection in our tests.

>**Tip:** Relying on an Internet connection can also cause all sorts of weird problems if the connection is unstable. We’re fans of a workaround that gives us an excellent way to deal with this. We tag our tests that use the Internet as `@tag :requires_internet`. This way, if we don’t have a connection available, we can run `mix test --exclude requires_internet` and still run all the tests that don’t require the connection.

# Testing non-HTTP services

Most of the concepts we discussed apply to non-HTTP services as well. For example, if we’re talking with a service that exposes a binary protocol, we can build an interface (with a behavior) that specifies how to interact with the service. Then we can use dependency doubles to test components that talk to the service through the interface.

However, testing the actual interaction with a service that doesn’t expose an HTTP interface is more complex because fewer tools are available. If we want to build a test server, we’ll often have to implement that ourselves on lower-level protocols like TCP. If we want cassettes, we’ll have to implement all of the infrastructure needed for them ourselves because there isn’t an ExVCR counterpart for protocols other than HTTP.

Learn about which approach is best suitable for testing third-party HTTP services and how to test Non-HTTP Services.

Final Remarks on Testing External Services

Getting Started

Unit Tests

Integration and End-to-End Tests

Testing OTP

Testing Ecto Schemas

Testing Ecto Queries

Testing Phoenix

Property-Based Testing

Final Remarks on Testing External Services

Which approach is best for testing external services?