하루에 5분씩만 투자해서 함께 공부해요~ 댓글은 개별 포스트 클릭하면 작성가능합니다~

Flutter 통합 테스트 - Provider, STT를 사용하는 앱을 테스트 해봅시다

플러터 통합 테스트

  • 안드로이드 네이티브 코드의 경우엔, 앱피움이라는 좋은 프레임워크가 존재합니다.
  • 그런데 플러터를 앱피움으로 테스트하려고 하면, 몇 가지 제약사항이 있더군요.
  • 하지만 실망할 필요가 없습니다! 플러터는 자체적으로 통합 테스트를 지원하거든요!

테스트를 해봅시다

  • 제가 일전에 소개했던 앱을 테스트 해 볼건데요. 여기 블로그로도 올렸었습니다.
  • 실제로 이번 테스트를 통해서 버그도 몇 개 고쳤습니다.
  • 이 앱의 특성상 테스트를 위해서 몇 가지 고려사항이 있는데요.
    • 프로바이더를 이용한 상태관리 패턴을 구현했다는 점
    • STT를 이용하기 때문에 테스트에서 문장이 음성으로 재생되어야 한다는 점
    • 위젯들이 애니메이션으로 타나난다는 점
광고를 클릭해주시면 블로그운영에 큰 힘이 됩니다.

테스트 소스코드

  • 주석을 통해 코드 설명을 대신 하겠습니다.
import 'package:string_similarity/string_similarity.dart';
import 'package:flutter/material.dart';
import 'package:flutter/semantics.dart';
import 'package:flutter_gemini/flutter_gemini.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:mysec/global_vars.dart';
import 'package:mysec/main.dart' as app;
import 'package:flutter_tts/flutter_tts.dart';
import 'package:mysec/slot_editor.dart';
import 'package:mysec/stt_tools.dart';
import 'package:provider/provider.dart';


// 타입에 의해서 값을 가져옵니다
String? getValueByType(WidgetTester tester) {
  final Finder itemFinder = find.byType(SlotEditor);
  final SlotEditorState state = tester.state(itemFinder);
  return state.selectedCategory;
}

/// ValueKey로 정의된 key 값을 조회해서 가져옵니다.
/// ex: const ValueKey('listen_button')
String getTextByKey(WidgetTester tester, String keyString) {
  final Finder itemFinder = find.byKey(ValueKey(keyString));
  final Text itemText = tester.widget<Text>(itemFinder);
  return itemText.data!;
}

// SemanticsLabel로 정의된 값을 조회해서 가져옵니다
String? getValueByLabel(WidgetTester tester, String label) {
  final Finder itemFinder = find.bySemanticsLabel(label);
  final SemanticsNode itemText = tester.getSemantics(itemFinder);
  return itemText.value;
}

// 문장 유사도 계산 함수
double calculateSimilarity(String str1, String str2) {
  final double distance = StringSimilarity.compareTwoStrings(str1, str2);
  final int maxLength = str1.length > str2.length ? str1.length : str2.length;
  if (maxLength == 0) {
    return 1.0; // 둘 다 빈 문자열이면 완전히 동일
  }
  final double similarity = 1.0 - (distance / maxLength);
  return similarity;
}

// 문장 유사도 기준치 판정 함수
bool isSimilarEnough(String str1, String str2, double threshold) {
  return calculateSimilarity(str1, str2) >= threshold;
}


void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized(); // 통합 테스트 환경 초기화

  testWidgets('ListenAndResult', (WidgetTester tester) async {
    Gemini.init(apiKey: "");
    // Provider를 사용하기 때문에 아래와 같이 정의합니다.
    await tester.pumpWidget(MultiProvider(
      providers: [
        ChangeNotifierProvider<SttTools>(create: (_) => SttTools(),), // SttTools Provider 추가,
        ChangeNotifierProvider<GlobalVars>(create: (_) => GlobalVars()),
      ],
      child: const app.MyApp(), // 앱 시작
    ),);

    // 권한 지정 및 구글 로그인을 위한 시간을 벌기 위해서 10초를 기다립니다.
    await Future.delayed(const Duration(seconds: 10));

    final Finder listenButton = find.byKey(const ValueKey("listen_button"));
    await tester.tap(listenButton);
    /**
     * 위젯에 애니메이션이 들어가서 그런지, pumpAndSettle 함수가 작동하지 않았습니다.
     * 어쩔수 없이 약간의 시간차를 두고 TTS를 실행하기 위해서 0.5초를 기다립니다
     */
    await Future.delayed(const Duration(milliseconds: 500));

    /**
     *  TTS를 이용해서 문장을 읽겠습니다. SpeechRate 0.5이하에서 인식이 되고
     *  그 이상은 전혀 안되는 현상이 발생하였고, 0.5 이하에서도 주변 소음 상태에 따라서
     *  인식률이 떨어지는 경우가 있어서 안전하게 0.3으로 SpeechRate를 잡았습니다.
     */

    final FlutterTts flutterTts = FlutterTts();
    await flutterTts.setLanguage("ko-KR");
    await flutterTts.setSpeechRate(0.3);
    await flutterTts.setPitch(1.0);
    await flutterTts.setVolume(1.5);
    await flutterTts.speak("내일 오전 9시부터 30분동안 JP 카테고리에 선예매 관련 포스팅 추가");
    await flutterTts.awaitSpeakCompletion(true);

    // STT가 TTS 음성을 인식할 때 까지 대기
    await Future.delayed(const Duration(seconds: 15));

    final Finder nextButton = find.byKey(const ValueKey("next_step_button2"));
    await tester.tap(nextButton);

    // AI 에이전트와의 통신 시간을 위한 대기
    await Future.delayed(const Duration(seconds: 10));
    /// 화면이 넘어가고 나서 위젯이 배치될 때 까지 대기
    /// 아래 코드들에서 값들을 받아오지 못합니다
    await tester.pump(const Duration(seconds: 2));

    final String datePickerValue = getTextByKey(tester, "date_picker");
    final String time1PickerText = getTextByKey(tester, "time1_picker");
    final String time2PickerText = getTextByKey(tester, "time2_picker");
    final String? categoryPickerText = getValueByType(tester);
    final String? titleText = getValueByLabel(tester, "title_text");

    DateTime today = DateTime.now();
    DateTime tomorrow = today.add(const Duration(days: 1));
    String formattedDate = "${tomorrow.year}-${tomorrow.month.toString().padLeft(2, '0')}-${tomorrow.day.toString().padLeft(2, '0')}";

    expect(datePickerValue, formattedDate);
    expect(time1PickerText, '9:00 AM');
    expect(time2PickerText, '9:30 AM');
    expect(categoryPickerText, 'JP');
    // STT 인식률을 감안해서 50% 유사도 이상일 경우 테스트 통과처리
    expect(isSimilarEnough(titleText!, '선예매 관련 포스팅', 0.5), true);

  });
}

테스트 과정 설명

  • 처음에 테스트를 시도하면 설치 다이얼로그가 뜹니다. 테스트 실행해야 할 때 마다 매번 설치해야 하는게 귀찮은데, 안뜨게 할 방법은 없는것 같더라구요.
  • 각종 권한 설정 및 구글 로그인 다이얼로그도 뜹니다. 이것도 새로 설치하기 때문에 매번 뜹니다.
    • 권한설정
  • 이후로는 테스트가 진행됩니다. 동영상으로 확인하시죠.

라즈베리파이 피코에서 BLE로 스마트폰과 통신하기기

Why Not WIFI

  • 지난 시간에 라즈베리파이 피코를 아두이노 와이파이 모듈 처럼 사용하는 방법을 소개했었는데요.
  • 라우터가 없으면 통신이 어렵다는 최대의 단점이 있었습니다.
  • 이로 인해서 집에서 나가면 먼지 측정을 할 수가 없었습니다.
  • 결국 블루투스를 쓰게 되었는데요, 다행히도 제가 사용하는 라즈베리파이 피코 W는 BLE를 지원하더군요.
  • 이번에는 라즈베리파이 피코를 아두이노의 블루투스 모듈처럼 써보겠습니다.

BLE in RPI PICO

  • 이제 마이크로 파이썬에서 BLE를 어떻게 써야하는지 찾아보겠습니다.
  • 위에서 제시된 예제를 이해하기 위해서 몇 가지 개념을 설명하고자 합니다.
    • central : 중앙처리 장치 입니다. 이번 포스팅의 상황에서는 스마트폰이 이에 해당합니다.
    • peripheral : 단말장치를 의미합니다. 라즈베리파이 피코가 이에 해당합니다.
    • advertising : 단말장치가 중앙처리 장치에게 존재를 알리는 행위입니다.

BLE 소스코드

  • 사실상 위에서 찾아낸 예제 코드를 그대로 가져왔습니다.
from micropython import const
import struct
import bluetooth
import time

_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)

_ADV_MAX_PAYLOAD = const(31)

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

_UART_UUID = bluetooth.UUID("10000001-1000-1000-1000-100000000000")
_UART_TX = (
    bluetooth.UUID("10000003-1000-1000-1000-100000000000"),
    _FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
    bluetooth.UUID("10000002-1000-1000-1000-100000000000"),
    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)

def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
    payload = bytearray()

    def _append(adv_type, value):
        nonlocal payload
        payload += struct.pack("BB", len(value) + 1, adv_type) + value

    _append(
        _ADV_TYPE_FLAGS,
        struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
    )

    if name:
        _append(_ADV_TYPE_NAME, name)

    if services:
        for uuid in services:
            b = bytes(uuid)
            if len(b) == 2:
                _append(_ADV_TYPE_UUID16_COMPLETE, b)
            elif len(b) == 4:
                _append(_ADV_TYPE_UUID32_COMPLETE, b)
            elif len(b) == 16:
                _append(_ADV_TYPE_UUID128_COMPLETE, b)

    # See org.bluetooth.characteristic.gap.appearance.xml
    if appearance:
        _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))

    if len(payload) > _ADV_MAX_PAYLOAD:
        raise ValueError("advertising payload too large")

    return payload


def decode_field(payload, adv_type):
    i = 0
    result = []
    while i + 1 < len(payload):
        if payload[i + 1] == adv_type:
            result.append(payload[i + 2 : i + payload[i] + 1])
        i += 1 + payload[i]
    return result


def decode_name(payload):
    n = decode_field(payload, _ADV_TYPE_NAME)
    return str(n[0], "utf-8") if n else ""


def decode_services(payload):
    services = []
    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
        services.append(bluetooth.UUID(u))
    return services

class BLESimplePeripheral:
    def __init__(self, ble, name="dust"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        ((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))
        self._connections = set()
        self._write_callback = None
        self._payload = advertising_payload(name=name, services=[_UART_UUID])
        self._advertise()

    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("New connection", conn_handle)
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Disconnected", conn_handle)
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            if value_handle == self._handle_rx and self._write_callback:
                self._write_callback(value)

    def send(self, data):
        for conn_handle in self._connections:
            self._ble.gatts_notify(conn_handle, self._handle_tx, data)

    def is_connected(self):
        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):
        self._write_callback = callback

기존 소스코드 변경

  • Wifi 모듈처럼 사용하던 코드를 BLE 모듈로 바꿔 보겠습니다.
  • 비교를 위해서 Wifi 를 위해서 사용하던 함수는 남겨놨습니다.
import utime
import rp2 
from rp2 import PIO, asm_pio
from machine import UART, Pin
import network
import time
import urequests as requests
import uasyncio
import ujson
import umqtt.simple
import ble
from ble import BLESimplePeripheral, bluetooth


dust_value = 0

mqtt_broker_ip = "###.###.###.###"
client_id = "XXX"
ssid = ''
password = ''

uart = UART(0,9600)

def send_message_mqtt(client, value):
    print("Publish Mqtt Message")
    msg = ujson.dumps({'device_id': client_id, 'value': value})
    #msg = "Device: %s, Temp: %d, Hum: %d" % (client_id,h,t)
    try:
        client.publish("pico/dust_log", msg)
    except OSError as e:
        print(e)
    
def wlan_connect():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password)

    # Setup onboard LED
    onboard_led = Pin('LED', Pin.OUT)  # Adjust the pin number if necessary

    # Initial connection attempt
    max_attempts = 10
    attempts = 0
    connected = False  # Flag to track connection status

    while not wlan.isconnected() and attempts < max_attempts:
        onboard_led.toggle()  # Blink LED while trying to connect
        time.sleep(1)
        attempts += 1
        
    if wlan.isconnected():
        print(f"Connected to {ssid} successfully!")
        print("Network Config:", wlan.ifconfig())
        onboard_led.value(1)  # Keep LED on when connected
        connected = True
    else:
        print("Failed to connect to WiFi.")
        onboard_led.value(0)  # Turn off LED if initial connection fails
    return [wlan, connected]

def mqtt_connect():
    print("Try Mqtt Connect")
    client = umqtt.simple.MQTTClient(client_id = client_id, server = mqtt_broker_ip, port = #####)
    client.connect()
    return client


def wlan_main():
    wret = wlan_connect()
    wlan = wret[0]
    connected = wret[1]
    client = 0
    utime.sleep(3)
    try:
        client = mqtt_connect()
    except OSError as e:
        print(f"Error: %s" % e)
    print("Mqtt Connect Done")
    
    utime.sleep(1)
    
    while True:
        if uart.any():
            dust_value = uart.readline()
            if dust_value:
                try:
                    dust_value = float(dust_value.decode().strip())
                    print(dust_value)
                except ValueError:
                    print("Invalid data:", dust_value)
                
        
        if wlan.isconnected() and not connected:
            print("Reconnected to WiFi.")
            onboard_led.value(1)  # Keep LED on when connected
            print("Network Config:", wlan.ifconfig())
            connected = True
        elif not wlan.isconnected() and connected:
            print("Disconnected from WiFi.")
            connected = False

        if not connected:
            print("Wlan Not Connected")
            onboard_led.toggle()  # Blink LED if disconnected
        else:
            if client == 0:
                print("MQTT is not connected")
            else:
                send_message_mqtt(client, dust_value)
            #message = "?m=2&h=%d&t=%d" % (humidity, temperature)
            #await send_message(message)     
        utime.sleep(2)

# 여기서부터 새로 바뀐 내용입니다    

def ble_connect():
    my_ble = bluetooth.BLE()
    p = BLESimplePeripheral(my_ble)

    def on_rx(v):
        print("RX", v)

    p.on_write(on_rx)
    return p


def ble_main():
    global dust_value
    ble_conn = 0
    onboard_led = Pin('LED', Pin.OUT)  # Adjust the pin number if necessary
    try:
        ble_conn = ble_connect()
        if ble_conn != 0 and ble_conn.is_connected():
            print("Connected as BLE.")
            onboard_led.value(1)  
            conncted = True
    except Exception as e:
        print("Ble Connection Error: %s" % e)
        
    utime.sleep(1)
    connected = False
    
    while True:
        if uart.any():
            dust_value = uart.readline()
            if dust_value:
                try:
                    dust_value = float(dust_value.decode().strip())
                    print(dust_value)
                except ValueError:
                    print("Invalid data:", dust_value)
                
        
        if  ble_conn != 0 and ble_conn.is_connected() and not connected:
            print("Connected as BLE.")
            onboard_led.value(1)  # Keep LED on when connected            
            connected = True
        elif not ble_conn.is_connected() and connected:
            print("Disconnected as BLE.")
            connected = False

        if not connected:
            print("BLE Not Connected")
            onboard_led.toggle()  # Blink LED if disconnected
        else:
            # Central(스마트폰)에서 별도 계산을 하지 않을거기 때문에 여기서 먼지값을 계산해서 보냅니다            
            last_value = int((0.173 * ((dust_value / 1024.0) * 5.0 - 0.622)) * 1000)
            data = str(last_value) + ""
            print("TX", data)
            ble_conn.send(data)
            #message = "?m=2&h=%d&t=%d" % (humidity, temperature)
            #await send_message(message)     
        utime.sleep(2)

#main()
ble_main()

측정결과

  • 측정 결과는 스마트폰에 BLE scanner 앱을 설치해서 확인할 수 있습니다.
    • 결과
  • 그런데 이번에도 전력이 너무 적게 사용해서 보조배터리가 거부(?)하는 문제가 발생하네요.
  • 지난번에 아두이노 + 먼지센서 + 피코(wlan 모듈사용) 조합으로 80mA ~ 100mA를 사용했는데, 이번에는 60mA ~ 80mA를 사용하게 됩니다.
  • 부족한 20mA를 추가하기 위해서 쓸데 없는 전력사용을 해야하는 아이러니한 상황이 펼쳐지고 말았네요.
  • 실제로 결과물을 어떻게 사용했는지는, 아래 영상에서 시청할 수 있습니다~

라즈베리파이 피코를 아두이노 와이파이 모듈 처럼 사용하기

미세먼지 측정하기

  • 저희집 고양이 호박이 화장실 모래의 미세먼지를 측정한 적이 있습니다.
  • 결과가 너무 충격적이어서 뚜껑없는 개방형 화장실로 바꿔줬었지요.
  • 그런데 겨울에 환기를 적게 하다보니, 모래 먼지가 방에 퍼져서 목이 너무 아픈거에요.
  • 그래서 먼지가 덜 나온다는 카사바 모래로 화장실 모래를 바꿔줬습니다.
  • 바꾼 모래도 먼지를 측정해 봐야겠죠?

측정 결과를 무선통신으로 보낼 수 없을까?

  • 이전에는 측정 결과를 USB 라인을 통해서 보냈습니다.
  • 그러다보니까 측정할 수 있는 공간에 한계가 생기더군요.
  • 그래서 이번에는 와이파이로 통신할 수 있는 라즈베리파이 피코에 먼지센서를 연결해 보려고 했어요.
  • 그런데 안타깝게도 3.3V 기반 ADC를 사용하는 피코에서는 값을 얻기가 어렵더군요.
  • 그래서 아두이노를 사용하되, 라즈베리파이 피코를 와이파이 모듈처럼 써서 측정값을 보내봤습니다.
    • 회로연결
  • 방법은 간단합니다, 아두이노의 시리얼핀(Tx,Rx)를 라즈베리파이 피코의 시리얼핀에 붙였어요.
  • 그런 다음 피코에서는 받아지는 값을 그대로 mqtt를 이용해서 서버로 보내기만 하도록 프로그래밍 했습니다.

보조배터리가 꺼지는 문제 해결

  • 그런데 보조배터리에 아두이노와 피코를 각각 연결하니까 1분 정도 있다가 전원이 꺼져버리는 문제가 발생하더군요.
  • 아무래도 보조배터리에 내장된 미세전류 차단 기준에 걸린것 같았습니다. 대략 60mA ~ 80mA가 그 기준값인 듯 한데요…
  • 아두이노도 피코도 따로사용할 때는 저 값보다 낮은 전류를 사용합니다.
  • 그런데 보조배터리에 있는 2개의 USB 단자에서 동시에 사용하는 전류량의 합을 기준으로 차단하는게 아니라, 둘 중에 최대값을 기준으로 차단하는 것 같아요.
  • 이로인해서 어쩔수 없이 USB 허브를 하나 투입했습니다. 이러니까 하나의 USB 단자로 약 80mA ~ 100mA를 사용하게 됩니다.
    • USB허브
  • 이제는 미세 전류 차단으로 인해 전원이 꺼지지 않고 꾸준히 동작하네요.

측정결과

  • 측정 결과는 PC에서 아래와 같이 받아보게 되었구요.
    • 결과
  • 무선으로 전송되니까 여기저기 옮겨다니면서 측정할 수 있게 되어서 좋네요.
  • 관련 에피소드는 아래 영상에서 시청할 수 있습니다~